tova 0.3.4 → 0.3.6

package/src/parser/parser.js

@@ -1,37 +1,29 @@
 import { TokenType } from '../lexer/tokens.js';
 import * as AST from './ast.js';
+import { installServerParser } from './server-parser.js';
+import { installClientParser } from './client-parser.js';
 
 export class Parser {
   static MAX_EXPRESSION_DEPTH = 200;
+  static COMPARISON_OPS = null; // initialized after class definition
 
   constructor(tokens, filename = '<stdin>') {
-    this.tokens = tokens;
+    // Pre-filter: build array of significant tokens for O(1) peek
+    const significant = [];
+    const docs = [];
+    for (const t of tokens) {
+      const type = t.type;
+      if (type === TokenType.NEWLINE || type === TokenType.SEMICOLON) continue;
+      if (type === TokenType.DOCSTRING) { docs.push(t); continue; }
+      significant.push(t);
+    }
+    this.tokens = significant;
+    this._eof = significant[significant.length - 1]; // cache EOF for hot-path methods
     this.filename = filename;
     this.pos = 0;
     this.errors = [];
     this._expressionDepth = 0;
-    this.docstrings = this.extractDocstrings(tokens);
-    this._skipInsignificant();
-  }
-
-  _isInsignificant(type) {
-    return type === TokenType.NEWLINE || type === TokenType.DOCSTRING || type === TokenType.SEMICOLON;
-  }
-
-  _skipInsignificant() {
-    while (this.pos < this.tokens.length && this._isInsignificant(this.tokens[this.pos].type)) {
-      this.pos++;
-    }
-  }
-
-  extractDocstrings(tokens) {
-    const docs = [];
-    for (const t of tokens) {
-      if (t.type === TokenType.DOCSTRING) {
-        docs.push(t);
-      }
-    }
-    return docs;
+    this.docstrings = docs;
   }
 
   // ─── Helpers ───────────────────────────────────────────────
@@ -47,28 +39,16 @@ export class Parser {
   }
 
   current() {
-    return this.tokens[this.pos] || this.tokens[this.tokens.length - 1];
+    return this.tokens[this.pos] || this._eof;
   }
 
   peek(offset = 0) {
-    // Fast path: offset 0 is just the current position (always significant after skip)
-    if (offset === 0) return this.tokens[this.pos] || this.tokens[this.tokens.length - 1];
-    // General path: skip over insignificant tokens
-    let count = 0;
-    for (let idx = this.pos + 1; idx < this.tokens.length; idx++) {
-      if (!this._isInsignificant(this.tokens[idx].type)) {
-        count++;
-        if (count === offset) return this.tokens[idx];
-      }
-    }
-    return this.tokens[this.tokens.length - 1];
+    const idx = this.pos + offset;
+    return idx < this.tokens.length ? this.tokens[idx] : this._eof;
   }
 
   advance() {
-    const tok = this.current();
-    this.pos++;
-    this._skipInsignificant();
-    return tok;
+    return this.tokens[this.pos++] || this._eof;
   }
 
   check(type) {
@@ -248,8 +228,8 @@ export class Parser {
   }
 
   _attachDocstrings(program) {
-    // Build a map of docstring line ranges from raw tokens
-    const docTokens = this.tokens.filter(t => t.type === TokenType.DOCSTRING);
+    // Use pre-extracted docstring tokens
+    const docTokens = this.docstrings;
     if (docTokens.length === 0) return;
 
     // Group consecutive docstring lines
@@ -295,14 +275,12 @@ export class Parser {
   parseTopLevel() {
     if (this.check(TokenType.SERVER)) {
       if (!Parser.prototype._serverParserInstalled) {
-        const { installServerParser } = import.meta.require('./server-parser.js');
         installServerParser(Parser);
       }
       return this.parseServerBlock();
     }
     if (this.check(TokenType.CLIENT)) {
       if (!Parser.prototype._clientParserInstalled) {
-        const { installClientParser } = import.meta.require('./client-parser.js');
         installClientParser(Parser);
       }
       return this.parseClientBlock();
@@ -563,6 +541,7 @@ export class Parser {
       this.advance(); // consume async
       return this.parseForStatement(null, true);
     }
+    if (this.check(TokenType.AT)) return this.parseDecoratedDeclaration();
     if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FN) return this.parseAsyncFunctionDeclaration();
     if (this.check(TokenType.FN) && (this.peek(1).type === TokenType.IDENTIFIER || this._isContextualKeywordToken(this.peek(1)))) return this.parseFunctionDeclaration();
     if (this.check(TokenType.TYPE)) return this.parseTypeDeclaration();
@@ -723,7 +702,35 @@ export class Parser {
     return new AST.ExternDeclaration(name, params, returnType, l, isAsync);
   }
 
-  parseFunctionDeclaration() {
+  parseDecoratedDeclaration() {
+    const decorators = [];
+    while (this.check(TokenType.AT)) {
+      this.advance(); // consume @
+      const decName = this.expect(TokenType.IDENTIFIER, "Expected decorator name after '@'").value;
+      let decArgs = [];
+      if (this.check(TokenType.LPAREN)) {
+        this.advance(); // consume (
+        while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
+          decArgs.push(this.parseExpression());
+          if (!this.match(TokenType.COMMA)) break;
+        }
+        this.expect(TokenType.RPAREN, "Expected ')' after decorator arguments");
+      }
+      decorators.push({ name: decName, args: decArgs });
+    }
+    // After decorators, expect fn or async fn
+    if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FN) {
+      const node = this.parseAsyncFunctionDeclaration(decorators);
+      return node;
+    }
+    if (this.check(TokenType.FN)) {
+      const node = this.parseFunctionDeclaration(decorators);
+      return node;
+    }
+    this.error("Expected 'fn' or 'async fn' after decorator");
+  }
+
+  parseFunctionDeclaration(decorators = []) {
     const l = this.loc();
     this.expect(TokenType.FN);
     let name;
@@ -754,10 +761,10 @@ export class Parser {
     }
 
     const body = this.parseBlock();
-    return new AST.FunctionDeclaration(name, params, body, returnType, l, false, typeParams);
+    return new AST.FunctionDeclaration(name, params, body, returnType, l, false, typeParams, decorators);
   }
 
-  parseAsyncFunctionDeclaration() {
+  parseAsyncFunctionDeclaration(decorators = []) {
     const l = this.loc();
     this.expect(TokenType.ASYNC);
     this.expect(TokenType.FN);
@@ -789,7 +796,7 @@ export class Parser {
     }
 
     const body = this.parseBlock();
-    return new AST.FunctionDeclaration(name, params, body, returnType, l, true, typeParams);
+    return new AST.FunctionDeclaration(name, params, body, returnType, l, true, typeParams, decorators);
   }
 
   parseBreakStatement() {
@@ -1495,10 +1502,10 @@ export class Parser {
   // ─── Expressions (precedence climbing) ────────────────────
 
   parseExpression() {
-    if (++this._expressionDepth > Parser.MAX_EXPRESSION_DEPTH) {
-      this._expressionDepth--;
+    if (this._expressionDepth >= Parser.MAX_EXPRESSION_DEPTH) {
       this.error('Expression nested too deeply (max ' + Parser.MAX_EXPRESSION_DEPTH + ' levels)');
     }
+    this._expressionDepth++;
     try {
       return this.parsePipe();
     } finally {
@@ -1578,9 +1585,7 @@ export class Parser {
     let left = this.parseMembership();
 
     // Check for chained comparisons: a < b < c
-    const compOps = [TokenType.LESS, TokenType.LESS_EQUAL, TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.EQUAL, TokenType.NOT_EQUAL];
-
-    if (compOps.some(op => this.check(op))) {
+    if (Parser.COMPARISON_OPS.has(this.current().type)) {
       // Don't parse < as comparison if it looks like JSX
       if (this.check(TokenType.LESS) && this._looksLikeJSX()) {
         return left;
@@ -1589,9 +1594,8 @@ export class Parser {
       const operands = [left];
       const operators = [];
 
-      while (true) {
-        const op = this.match(...compOps);
-        if (!op) break;
+      while (Parser.COMPARISON_OPS.has(this.current().type)) {
+        const op = this.advance();
         operators.push(op.value);
         operands.push(this.parseMembership());
       }
@@ -1885,117 +1889,100 @@ export class Parser {
 
   parsePrimary() {
     const l = this.loc();
+    const tokenType = this.current().type;
 
-    // Number
-    if (this.check(TokenType.NUMBER)) {
-      return new AST.NumberLiteral(this.advance().value, l);
-    }
+    switch (tokenType) {
+      case TokenType.NUMBER:
+        return new AST.NumberLiteral(this.advance().value, l);
 
-    // String
-    if (this.check(TokenType.STRING) || this.check(TokenType.STRING_TEMPLATE)) {
-      return this.parseStringLiteral();
-    }
-
-    // Regex literal
-    if (this.check(TokenType.REGEX)) {
-      const token = this.advance();
-      return new AST.RegexLiteral(token.value.pattern, token.value.flags, l);
-    }
+      case TokenType.STRING:
+      case TokenType.STRING_TEMPLATE:
+        return this.parseStringLiteral();
 
-    // Boolean
-    if (this.check(TokenType.TRUE)) {
-      this.advance();
-      return new AST.BooleanLiteral(true, l);
-    }
-    if (this.check(TokenType.FALSE)) {
-      this.advance();
-      return new AST.BooleanLiteral(false, l);
-    }
+      case TokenType.REGEX: {
+        const token = this.advance();
+        return new AST.RegexLiteral(token.value.pattern, token.value.flags, l);
+      }
 
-    // Nil
-    if (this.check(TokenType.NIL)) {
-      this.advance();
-      return new AST.NilLiteral(l);
-    }
+      case TokenType.TRUE:
+        this.advance();
+        return new AST.BooleanLiteral(true, l);
 
-    // Match expression
-    if (this.check(TokenType.MATCH)) {
-      return this.parseMatchExpression();
-    }
+      case TokenType.FALSE:
+        this.advance();
+        return new AST.BooleanLiteral(false, l);
 
-    // If expression (in expression position): if cond { a } else { b }
-    if (this.check(TokenType.IF)) {
-      return this.parseIfExpression();
-    }
+      case TokenType.NIL:
+        this.advance();
+        return new AST.NilLiteral(l);
 
-    // Async lambda: async fn(params) body
-    if (this.check(TokenType.ASYNC) && this.peek(1).type === TokenType.FN) {
-      return this.parseAsyncLambda();
-    }
+      case TokenType.MATCH:
+        return this.parseMatchExpression();
 
-    // Lambda: fn(params) body  or  params => body
-    if (this.check(TokenType.FN) && this.peek(1).type === TokenType.LPAREN) {
-      return this.parseLambda();
-    }
+      case TokenType.IF:
+        return this.parseIfExpression();
 
-    // Arrow lambda: x => expr  or  (x, y) => expr
-    // We'll handle this in the identifier/paren case
+      case TokenType.ASYNC:
+        if (this.peek(1).type === TokenType.FN) {
+          return this.parseAsyncLambda();
+        }
+        break;
 
-    // Array literal or list comprehension
-    if (this.check(TokenType.LBRACKET)) {
-      return this.parseArrayOrComprehension();
-    }
+      case TokenType.FN:
+        if (this.peek(1).type === TokenType.LPAREN) {
+          return this.parseLambda();
+        }
+        break;
+
+      case TokenType.LBRACKET:
+        return this.parseArrayOrComprehension();
+
+      case TokenType.LBRACE:
+        return this.parseObjectOrDictComprehension();
+
+      case TokenType.DOT:
+        // Column expression: .column (for table operations)
+        if (this.peek(1).type === TokenType.IDENTIFIER) {
+          this.advance(); // consume .
+          const name = this.advance().value; // consume identifier
+          // Check for column assignment: .col = expr (used in derive)
+          if (this.check(TokenType.ASSIGN)) {
+            this.advance(); // consume =
+            const expr = this.parseExpression();
+            return new AST.ColumnAssignment(name, expr, l);
+          }
+          return new AST.ColumnExpression(name, l);
+        }
+        break;
 
-    // Object literal or dict comprehension
-    if (this.check(TokenType.LBRACE)) {
-      return this.parseObjectOrDictComprehension();
-    }
+      case TokenType.LPAREN:
+        return this.parseParenOrArrowLambda();
 
-    // Column expression: .column (for table operations)
-    // Appears at expression-start when DOT followed by IDENTIFIER
-    // but NOT when preceded by an expression (which would be member access)
-    if (this.check(TokenType.DOT) && this.peek(1).type === TokenType.IDENTIFIER) {
-      // Check this isn't inside a method pipe (|> .method) — that's handled in parsePipe
-      // Column expressions appear in function arguments and assignments
-      this.advance(); // consume .
-      const name = this.advance().value; // consume identifier
+      case TokenType.SERVER:
+      case TokenType.CLIENT:
+      case TokenType.SHARED:
+      case TokenType.DERIVE:
+        return new AST.Identifier(this.advance().value, l);
 
-      // Check for column assignment: .col = expr (used in derive)
-      if (this.check(TokenType.ASSIGN)) {
-        this.advance(); // consume =
-        const expr = this.parseExpression();
-        return new AST.ColumnAssignment(name, expr, l);
+      case TokenType.IDENTIFIER: {
+        const name = this.advance().value;
+        // Check for arrow lambda: x => expr or x -> expr
+        if (this.check(TokenType.ARROW) || this.check(TokenType.THIN_ARROW)) {
+          this.advance();
+          const body = this.parseExpression();
+          return new AST.LambdaExpression(
+            [new AST.Parameter(name, null, null, l)],
+            body,
+            l
+          );
+        }
+        return new AST.Identifier(name, l);
       }
-
-      return new AST.ColumnExpression(name, l);
-    }
-
-    // Parenthesized expression or arrow lambda
-    if (this.check(TokenType.LPAREN)) {
-      return this.parseParenOrArrowLambda();
-    }
-
-    // Keywords that can appear as identifiers in expression position
-    if (this.check(TokenType.SERVER) || this.check(TokenType.CLIENT) || this.check(TokenType.SHARED) || this.check(TokenType.DERIVE) ||
-        this._isContextualKeyword()) {
-      const name = this.advance().value;
-      return new AST.Identifier(name, l);
     }
 
-    // Identifier (or arrow lambda: x => expr)
-    if (this.check(TokenType.IDENTIFIER)) {
-      const name = this.advance().value;
-      // Check for arrow lambda: x => expr or x -> expr
-      if (this.check(TokenType.ARROW) || this.check(TokenType.THIN_ARROW)) {
-        this.advance();
-        const body = this.parseExpression();
-        return new AST.LambdaExpression(
-          [new AST.Parameter(name, null, null, l)],
-          body,
-          l
-        );
-      }
-      return new AST.Identifier(name, l);
+    // Contextual keywords that can appear as identifiers in expression position
+    if (this._isContextualKeyword()) {
+      return new AST.Identifier(this.advance().value, l);
     }
 
     this.error(`Unexpected token: ${this.current().type}`);
@@ -2486,3 +2473,10 @@ export class Parser {
     return node;
   }
 }
+
+// Initialize static Set after class definition (depends on TokenType)
+Parser.COMPARISON_OPS = new Set([
+  TokenType.LESS, TokenType.LESS_EQUAL,
+  TokenType.GREATER, TokenType.GREATER_EQUAL,
+  TokenType.EQUAL, TokenType.NOT_EQUAL
+]);