optimze: reduce allocations

Author: link-duan

ast.go

@@ -94,18 +94,18 @@ type baseNode struct {
 	end   Pos
 }
 
-func (e *baseNode) Start() Pos {
+func (e baseNode) Start() Pos {
 	return e.start
 }
 
-func (e *baseNode) End() Pos {
+func (e baseNode) End() Pos {
 	return e.end
 }
 
-func (e *baseNode) cannotBeImplemented() {}
+func (e baseNode) cannotBeImplemented() {}
 
-func newBaseNode(start, end Pos) *baseNode {
-	return &baseNode{
+func newBaseNode(start, end Pos) baseNode {
+	return baseNode{
 		start: start,
 		end:   end,
 	}
@@ -119,14 +119,14 @@ var _ Node = (*IdentExpr)(nil)
 var _ Node = (*RangeExpr)(nil)
 
 type FunCallExpr struct {
-	*baseNode
+	baseNode
 	Name       *Token // Function name token
 	ParanOpen  *Token
 	Arguments  []Node // Arguments can be any expression type
 	ParanClose *Token
 }
 
-func (f *FunCallExpr) String() string {
+func (f FunCallExpr) String() string {
 	var sb strings.Builder
 	sb.WriteString("FunCallExpr(Name: ")
 	sb.WriteString(f.Name.Raw)
@@ -142,7 +142,7 @@ func (f *FunCallExpr) String() string {
 }
 
 type BinaryExpr struct {
-	*baseNode
+	baseNode
 	Left     Node   // Left operand
 	Operator *Token // Operator token (e.g., +, -, *, /)
 	Right    Node   // Right operand
@@ -153,53 +153,53 @@ func (b *BinaryExpr) String() string {
 }
 
 type UnaryExpr struct {
-	*baseNode
+	baseNode
 	Operator *Token // Operator token (e.g., !, -)
 	Operand  Node   // Operand expression
 }
 
-func (u *UnaryExpr) String() string {
+func (u UnaryExpr) String() string {
 	return fmt.Sprintf("UnaryExpr(Operator: %s, Operand: %s)", u.Operator.Raw, u.Operand)
 }
 
 type LiteralExpr struct {
-	*baseNode
+	baseNode
 	Value *Token // Token representing the literal value (e.g., number, string, boolean)
 }
 
-func (l *LiteralExpr) String() string {
+func (l LiteralExpr) String() string {
 	return fmt.Sprintf("LiteralExpr(Value: %s)", l.Value.Raw)
 }
 
 type IdentExpr struct {
-	*baseNode
+	baseNode
 	Name *Token
 }
 
-func (i *IdentExpr) String() string {
+func (i IdentExpr) String() string {
 	return fmt.Sprintf("IdentExpr(Name: %s)", i.Name.Raw)
 }
 
 type ParenthesizedExpr struct {
-	*baseNode
+	baseNode
 	ParenOpen  *Token // The opening parenthesis
 	Inner      Node   // The expression inside the parentheses
 	ParenClose *Token // The closing parenthesis
 }
 
-func (p *ParenthesizedExpr) String() string {
+func (p ParenthesizedExpr) String() string {
 	return fmt.Sprintf("ParenthesizedExpr(Inner: %s)", p.Inner)
 }
 
 type RangeExpr struct {
-	*baseNode
+	baseNode
 
 	Begin  Node     // Start of the range (e.g., A1, A, 1)
 	Colons []*Token // Colon tokens (e.g., : between A1 and B2)
 	Ends   []Node   // End of the range (e.g., B2, B, 2)
 }
 
-func (r *RangeExpr) String() string {
+func (r RangeExpr) String() string {
 	var sb strings.Builder
 	sb.WriteString("RangeExpr(")
 	sb.WriteString(r.Begin.String())
@@ -212,26 +212,26 @@ func (r *RangeExpr) String() string {
 }
 
 type CellExpr struct {
-	*baseNode
+	baseNode
 	Ident       *Token // The cell identifier (e.g., A1, B2)
 	Row         int    // starts from 0. -1 indicates a full column reference (e.g., A:A)
 	Col         int    // starts from 0. -1 indicates a full row reference (e.g., 1:1)
 	RowAbsolute bool   // true if the row is absolute (e.g., $1, $2)
 	ColAbsolute bool   // true if the column is absolute (e.g., $A, $B)
 }
 
-func (c *CellExpr) String() string {
+func (c CellExpr) String() string {
 	return fmt.Sprintf("CellExpr(%s)", c.Ident.Raw)
 }
 
 type ArrayExpr struct {
-	*baseNode
+	baseNode
 	BraceOpen  *Token   // The opening brace token {
 	Elements   [][]Node // [row][column] of expressions
 	BraceClose *Token   // The closing brace token }
 }
 
-func (a *ArrayExpr) String() string {
+func (a ArrayExpr) String() string {
 	var sb strings.Builder
 	sb.WriteString("ArrayExpr(")
 	for i, row := range a.Elements {

lexer.go

@@ -10,11 +10,20 @@ var keywords = map[string]TokenType{
 	"FALSE": BoolLiteral,
 }
 
+type tokenState struct {
+	tokenType     TokenType
+	tokenStartPos Pos
+	tokenEndPos   Pos
+	tokenStart    int // start offset
+	tokenEnd      int // end offset
+}
+
 type lexer struct {
 	src    []rune
 	pos    Pos
 	offset int
 	ch     rune
+	tokenState
 }
 
 func newLexer(src string) *lexer {

parser.go

@@ -210,14 +210,14 @@ func (p *Parser) negation() (Node, error) {
 		if err != nil {
 			return nil, err
 		}
-		if lit, ok := right.(*LiteralExpr); ok && lit.Value.Type == Number {
+		if lit, ok := right.(LiteralExpr); ok && lit.Value.Type == Number {
 			if isDigit([]rune(lit.Value.Raw)[0]) { // combine '-' / '+' with number literal
 				lit.start = op.Start                   // Adjust start position to the operator
 				lit.Value.Raw = op.Raw + lit.Value.Raw // Prepend the operator to the literal value
 				return lit, nil
 			}
 		}
-		return &UnaryExpr{
+		return UnaryExpr{
 			baseNode: newBaseNode(op.Start, op.End),
 			Operator: op,
 			Operand:  right,
@@ -240,7 +240,7 @@ func (p *Parser) implicitIntersection() (Node, error) {
 		if err != nil {
 			return nil, err
 		}
-		return &UnaryExpr{
+		return UnaryExpr{
 			baseNode: newBaseNode(start, operand.End()),
 			Operator: op,
 			Operand:  operand,
@@ -280,7 +280,7 @@ func (p *Parser) rangeExpr() (Node, error) {
 			}
 			ends = append(ends, right)
 		}
-		return &RangeExpr{
+		return RangeExpr{
 			baseNode: newBaseNode(begin.Start(), ends[len(ends)-1].End()),
 			Begin:    begin,
 			Colons:   colons,
@@ -290,31 +290,31 @@ func (p *Parser) rangeExpr() (Node, error) {
 	return left, nil
 }
 
-func (p *Parser) tryConvertToCellExpr(node Node) (*CellExpr, error) {
-	if node, ok := node.(*CellExpr); ok {
+func (p *Parser) tryConvertToCellExpr(node Node) (Node, error) {
+	if node, ok := node.(CellExpr); ok {
 		return node, nil // Already a CellExpr, no conversion needed
 	}
-	if node, ok := node.(*IdentExpr); ok {
+	if node, ok := node.(IdentExpr); ok {
 		col := colNameToIndex(node.Name.Raw)
 		if col < 0 {
 			return nil, newParseError(node.Start(), "expected a cell reference: %s", node.Name.Raw)
 		}
-		return &CellExpr{
+		return CellExpr{
 			baseNode: newBaseNode(node.Start(), node.End()),
 			Ident:    node.Name,
 			Row:      -1, // -1 indicates a full column reference
 			Col:      col,
 		}, nil
 	}
-	if node, ok := node.(*LiteralExpr); ok {
+	if node, ok := node.(LiteralExpr); ok {
 		if node.Value.Type != Number {
 			return nil, newParseError(node.Start(), "expected a row reference, got %s", node.Value.Raw)
 		}
 		row, err := strconv.Atoi(node.Value.Raw)
 		if err != nil {
 			return nil, newParseError(node.Start(), "invalid row reference: %s", err.Error())
 		}
-		return &CellExpr{
+		return CellExpr{
 			baseNode: newBaseNode(node.Start(), node.End()),
 			Ident:    node.Value,
 			Row:      row - 1, // Convert to zero-based index
@@ -346,7 +346,7 @@ func (p *Parser) primary() (Node, error) {
 		if err := p.advance(); err != nil { // consume the token
 			return nil, err
 		}
-		return &LiteralExpr{
+		return LiteralExpr{
 			baseNode: newBaseNode(tk.Start, tk.End),
 			Value:    tk,
 		}, nil
@@ -361,7 +361,7 @@ func (p *Parser) primary() (Node, error) {
 		if err := p.advance(); err != nil { // consume the token
 			return nil, err
 		}
-		return &IdentExpr{
+		return IdentExpr{
 			baseNode: newBaseNode(tk.Start, tk.End),
 			Name:     tk,
 		}, nil
@@ -374,7 +374,7 @@ func (p *Parser) primary() (Node, error) {
 		if err := p.advance(); err != nil { // consume the token
 			return nil, err
 		}
-		return &CellExpr{
+		return CellExpr{
 			baseNode:    newBaseNode(tk.Start, tk.End),
 			Ident:       tk,
 			Row:         result.row,
@@ -390,7 +390,7 @@ func (p *Parser) primary() (Node, error) {
 		if err := p.advance(); err != nil { // consume the token
 			return nil, err
 		}
-		return &CellExpr{
+		return CellExpr{
 			baseNode:    newBaseNode(tk.Start, tk.End),
 			Ident:       tk,
 			Row:         row - 1,
@@ -406,7 +406,7 @@ func (p *Parser) primary() (Node, error) {
 		if err := p.advance(); err != nil { // consume the token
 			return nil, err
 		}
-		return &CellExpr{
+		return CellExpr{
 			baseNode:    newBaseNode(tk.Start, tk.End),
 			Ident:       tk,
 			Row:         -1, // -1 indicates a full column reference
@@ -474,7 +474,7 @@ func (p *Parser) arrayExpr() (Node, error) {
 	if err := p.advance(); err != nil { // consume the '}' token
 		return nil, err
 	}
-	return &ArrayExpr{
+	return ArrayExpr{
 		baseNode:   newBaseNode(braceOpen.Start, braceClose.End),
 		BraceOpen:  braceOpen,
 		Elements:   values,
@@ -526,7 +526,7 @@ func (p *Parser) functionCall() (Node, error) {
 	if err := p.advance(); err != nil { // consume the ')' token
 		return nil, err
 	}
-	return &FunCallExpr{
+	return FunCallExpr{
 		baseNode:   newBaseNode(name.Start, paranClose.End),
 		Name:       name,
 		ParanOpen:  paranOpen,
@@ -556,7 +556,7 @@ func (p *Parser) parenthesized() (Node, error) {
 	if err := p.advance(); err != nil { // consume the ')' token
 		return nil, err
 	}
-	return &ParenthesizedExpr{
+	return ParenthesizedExpr{
 		baseNode:   newBaseNode(start, end),
 		ParenOpen:  parenOpen,
 		Inner:      expr,