perf(parser): reduce range bookkeeping overhead

Author: AntonPieper

lib/parser.js

@@ -82,6 +82,30 @@ export class ASTNode {
     this.args = args
   }
 
+  static infix(input, pos, op, left, right) {
+    return new ASTNode(input, pos, left.#meta.start, right.#meta.end, op, [left, right])
+  }
+
+  static ternary(input, pos, op, expression, consequent, alternate) {
+    return new ASTNode(input, pos, expression.#meta.start, alternate.#meta.end, op, [
+      expression,
+      consequent,
+      alternate
+    ])
+  }
+
+  static unary(input, pos, op, arg) {
+    return new ASTNode(input, pos, pos, arg.#meta.end, op, arg)
+  }
+
+  static access(input, pos, op, left, right, end) {
+    return new ASTNode(input, pos, left.#meta.start, end, op, [left, right])
+  }
+
+  static receiverCallStart(args) {
+    return args[1].#meta.start
+  }
+
   clone(op, args) {
     const meta = this.#meta
     return new ASTNode(meta.input, meta.pos, meta.start, meta.end, op, args)
@@ -195,7 +219,6 @@ class Lexer {
   length
 
   tokenPos
-  tokenEnd
   tokenType
   tokenValue
 
@@ -206,9 +229,8 @@ class Lexer {
     return input
   }
 
-  token(pos, type, value, end = this.pos) {
+  token(pos, type, value) {
     this.tokenPos = pos
-    this.tokenEnd = end
     this.tokenType = type
     this.tokenValue = value
     return this
@@ -595,7 +617,6 @@ export class Parser {
 
   type = null
   pos = null
-  end = null
 
   constructor(limits, registry) {
     this.limits = limits
@@ -617,10 +638,33 @@ export class Parser {
     return node
   }
 
+  #infixNode(pos, op, left, right) {
+    const node = ASTNode.infix(this.input, pos, op, left, right)
+    if (!this.astNodesRemaining--) this.#limitExceeded('maxAstNodes', pos)
+    return node
+  }
+
+  #ternaryNode(pos, expression, consequent, alternate) {
+    const node = ASTNode.ternary(this.input, pos, OPS.ternary, expression, consequent, alternate)
+    if (!this.astNodesRemaining--) this.#limitExceeded('maxAstNodes', pos)
+    return node
+  }
+
+  #unaryNode(pos, op, arg) {
+    const node = ASTNode.unary(this.input, pos, op, arg)
+    if (!this.astNodesRemaining--) this.#limitExceeded('maxAstNodes', pos)
+    return node
+  }
+
+  #accessNode(pos, op, left, right, end) {
+    const node = ASTNode.access(this.input, pos, op, left, right, end)
+    if (!this.astNodesRemaining--) this.#limitExceeded('maxAstNodes', pos)
+    return node
+  }
+
   #advanceToken(returnValue = this.pos) {
     const l = this.lexer.nextToken()
     this.pos = l.tokenPos
-    this.end = l.tokenEnd
     this.type = l.tokenType
     return returnValue
   }
@@ -636,7 +680,7 @@ export class Parser {
     throw parseError(
       'expected_token',
       `Expected ${TOKEN_BY_NUMBER[expectedType]}, got ${TOKEN_BY_NUMBER[this.type]}`,
-      {pos: this.pos, start: this.pos, end: this.end, input: this.input}
+      {pos: this.pos, start: this.pos, end: this.lexer.pos, input: this.input}
     )
   }
 
@@ -660,13 +704,16 @@ export class Parser {
     throw parseError('unexpected_character', `Unexpected character: '${this.input[this.lexer.pos - 1]}'`, {
       pos: this.pos,
       start: this.pos,
-      end: this.end,
+      end: this.lexer.pos,
       input: this.input
     })
   }
 
-  #expandMacro(pos, op, args, start = pos, end = start) {
+  #expandMacro(pos, op, args, start, end) {
     const [methodName, receiver, fnArgs] = op === OPS.rcall ? args : [args[0], null, args[1]]
+    if (start === undefined && op === OPS.rcall) start = ASTNode.receiverCallStart(args)
+    if (start === undefined) start = pos
+    if (end === undefined) end = start
     const decl = this.registry.findMacro(methodName, !!receiver, fnArgs.length)
     const ast = this.#node(pos, op, args, start, end)
     if (!decl) return ast
@@ -686,7 +733,7 @@ export class Parser {
     this.consume(TOKEN.COLON)
     const alternate = this.parseExpression()
     this.maxDepthRemaining++
-    return this.#node(questionPos, OPS.ternary, [expr, consequent, alternate], expr.start, alternate.end)
+    return this.#ternaryNode(questionPos, expr, consequent, alternate)
   }
 
   // LogicalOr ::= LogicalAnd ('||' LogicalAnd)*
@@ -695,7 +742,7 @@ export class Parser {
     while (this.match(TOKEN.OR)) {
       const opPos = this.#advanceToken()
       const right = this.parseLogicalAnd()
-      expr = this.#node(opPos, OPS['||'], [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, OPS['||'], expr, right)
     }
     return expr
   }
@@ -706,7 +753,7 @@ export class Parser {
     while (this.match(TOKEN.AND)) {
       const opPos = this.#advanceToken()
       const right = this.parseEquality()
-      expr = this.#node(opPos, OPS['&&'], [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, OPS['&&'], expr, right)
     }
     return expr
   }
@@ -718,7 +765,7 @@ export class Parser {
       const op = OP_FOR_TOKEN[this.type]
       const opPos = this.#advanceToken()
       const right = this.parseRelational()
-      expr = this.#node(opPos, op, [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, op, expr, right)
     }
     return expr
   }
@@ -736,7 +783,7 @@ export class Parser {
       const op = OP_FOR_TOKEN[this.type]
       const opPos = this.#advanceToken()
       const right = this.parseAdditive()
-      expr = this.#node(opPos, op, [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, op, expr, right)
     }
     return expr
   }
@@ -748,7 +795,7 @@ export class Parser {
       const op = OP_FOR_TOKEN[this.type]
       const opPos = this.#advanceToken()
       const right = this.parseMultiplicative()
-      expr = this.#node(opPos, op, [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, op, expr, right)
     }
     return expr
   }
@@ -760,7 +807,7 @@ export class Parser {
       const op = OP_FOR_TOKEN[this.type]
       const opPos = this.#advanceToken()
       const right = this.parseUnary()
-      expr = this.#node(opPos, op, [expr, right], expr.start, right.end)
+      expr = this.#infixNode(opPos, op, expr, right)
     }
     return expr
   }
@@ -770,12 +817,12 @@ export class Parser {
     if (this.type === TOKEN.NOT) {
       const pos = this.#advanceToken()
       const arg = this.parseUnary()
-      return this.#node(pos, OPS.unaryNot, arg, pos, arg.end)
+      return this.#unaryNode(pos, OPS.unaryNot, arg)
     }
     if (this.type === TOKEN.MINUS) {
       const pos = this.#advanceToken()
       const arg = this.parseUnary()
-      return this.#node(pos, OPS.unaryMinus, arg, pos, arg.end)
+      return this.#unaryNode(pos, OPS.unaryMinus, arg)
     }
     return this.parsePostfix()
   }
@@ -796,15 +843,15 @@ export class Parser {
 
         const propertyValue = this.value
         const propertyPos = this.pos
-        const propertyEnd = this.end
+        const propertyEnd = this.lexer.pos
         this.consume(TOKEN.IDENTIFIER)
         if (op === OPS.fieldAccess && this.match(TOKEN.LPAREN) && this.#advanceToken()) {
           const args = this.parseArgumentList()
-          const closeEnd = this.end
+          const closeEnd = this.lexer.pos
           this.consume(TOKEN.RPAREN)
-          expr = this.#expandMacro(propertyPos, OPS.rcall, [propertyValue, expr, args], expr.start, closeEnd)
+          expr = this.#expandMacro(propertyPos, OPS.rcall, [propertyValue, expr, args], undefined, closeEnd)
         } else {
-          expr = this.#node(propertyPos, op, [expr, propertyValue], expr.start, propertyEnd)
+          expr = this.#accessNode(propertyPos, op, expr, propertyValue, propertyEnd)
         }
         continue
       }
@@ -819,9 +866,9 @@ export class Parser {
             : OPS.bracketAccess
 
         const index = this.parseExpression()
-        const closeEnd = this.end
+        const closeEnd = this.lexer.pos
         this.consume(TOKEN.RBRACKET)
-        expr = this.#node(bracket, op, [expr, index], expr.start, closeEnd)
+        expr = this.#accessNode(bracket, op, expr, index, closeEnd)
         continue
       }
       break
@@ -852,19 +899,19 @@ export class Parser {
     throw parseError('unexpected_token', `Unexpected token: ${TOKEN_BY_NUMBER[this.type]}`, {
       pos: this.pos,
       start: this.pos,
-      end: this.end,
+      end: this.lexer.pos,
       input: this.input
     })
   }
 
   #consumeLiteral() {
-    return this.#advanceToken(this.#node(this.pos, OPS.value, this.value, this.pos, this.end))
+    return this.#advanceToken(this.#node(this.pos, OPS.value, this.value, this.pos, this.lexer.pos))
   }
 
   #parseIdentifierPrimary() {
     const value = this.value
     const pos = this.pos
-    const end = this.end
+    const end = this.lexer.pos
     this.consume(TOKEN.IDENTIFIER)
     if (RESERVED.has(value)) {
       throw parseError('reserved_identifier', `Reserved identifier: ${value}`, {
@@ -878,7 +925,7 @@ export class Parser {
     if (!this.match(TOKEN.LPAREN)) return this.#node(pos, OPS.id, value, pos, end)
     this.#advanceToken()
     const args = this.parseArgumentList()
-    const closeEnd = this.end
+    const closeEnd = this.lexer.pos
     this.consume(TOKEN.RPAREN)
     return this.#expandMacro(pos, OPS.call, [value, args], pos, closeEnd)
   }
@@ -906,7 +953,7 @@ export class Parser {
       }
     }
 
-    const closeEnd = this.end
+    const closeEnd = this.lexer.pos
     this.consume(TOKEN.RBRACKET)
     return this.#node(token, OPS.list, elements, token, closeEnd)
   }
@@ -927,7 +974,7 @@ export class Parser {
       }
     }
 
-    const closeEnd = this.end
+    const closeEnd = this.lexer.pos
     this.consume(TOKEN.RBRACE)
     return this.#node(token, OPS.map, props, token, closeEnd)
   }