func genInteger(node *ast.IntegerLiteral, b *bytes.Buffer) string {
	tmp := freshTemp()
	write(b, "Int %s = Int(%s);\n", tmp, string(node.Token.Lit))
	return tmp
}

func genString(node *ast.StringLiteral, b *bytes.Buffer) string {
	tmp := freshTemp()
	str := string(node.Token.Lit)
	str = strings.Replace(str, `\`, "\\", -1)

	write(b, "String %s = String(%s);\n", tmp, str)
	return tmp
}

func genBoolean(node *ast.Boolean, b *bytes.Buffer) string {
	if node.Value {
		return "Bool(\"true\")"
	} else {
		return "Bool(\"false\")"
	}
	return ""
}

func genIdentifier(node *ast.Identifier, b *bytes.Buffer) string {
	return node.Value
}

func genInfixExpression(node *ast.InfixExpression, b *bytes.Buffer) string {
	left := gen(node.Left, b)
	right := gen(node.Right, b)
	kind := node.Type

	tmp := freshTemp()
	methods := map[string]string{"+": PLUS, "-": MINUS, "==": EQUAL, "<": LT, ">": GT, "*": TIMES, "/": DIVIDE, "or": OR, "and": AND}

	method, _ := GetMethod(kind, methods[node.Operator])
	write(b, "%s %s = %s.%s(%s);\n", method.Return, tmp, left, methods[node.Operator], right)
	return tmp
}

func genFunctionCall(node *ast.FunctionCall, b *bytes.Buffer) string {
	var sig Signature
	args := make([]string, len(node.Args))
	// store expression tmp vars
	for i, arg := range node.Args {
		res := gen(arg, b)
		args[i] = res
	}

	tmp := freshTemp()
	if IsBuiltin(node.Name) {
		sig, ok := GetMethod(node.Type, node.Name)
		if !ok {
			panic("no builtin function")
		}

		write(b, "%s %s = %s.%s(", sig.Return, tmp, args[0], node.Name)
	} else {
		sig, _ = GetFunctionSignature(node.Name)
		write(b, "%s %s = %s(", sig.Return, tmp, node.Name)
		for i, arg := range args {
			write(b, arg)
			if i != len(args)-1 {
				write(b, ",")
			}
		}
	}

	write(b, ");")
	return tmp
}