Implemented an abstract syntax tree

src/build/expression/Expression.go

@@ -8,22 +8,22 @@ import (
 
 // Expression is a binary tree with an operator on each node.
 type Expression struct {
-	Token      token.Token
 	Parent     *Expression
 	Children   []*Expression
-	Precedence int
+	Token      token.Token
+	Precedence int8
 }
 
 // New creates a new expression.
 func New() *Expression {
-	return pool.Get().(*Expression)
+	return &Expression{}
 }
 
 // NewLeaf creates a new leaf node.
 func NewLeaf(t token.Token) *Expression {
-	expr := New()
-	expr.Token = t
-	return expr
+	return &Expression{
+		Token: t,
+	}
 }
 
 // AddChild adds a child to the expression.
@@ -32,17 +32,16 @@ func (expr *Expression) AddChild(child *Expression) {
 	child.Parent = expr
 }
 
-// Close puts the expression back into the memory pool.
-func (expr *Expression) Close() {
+// Reset resets all values to the default.
+func (expr *Expression) Reset() {
 	for _, child := range expr.Children {
-		child.Close()
+		child.Reset()
 	}
 
 	expr.Token.Reset()
 	expr.Parent = nil
 	expr.Children = expr.Children[:0]
 	expr.Precedence = 0
-	pool.Put(expr)
 }
 
 // EachLeaf iterates through all leaves in the tree.