tova 0.3.5 → 0.3.6

package/src/lsp/server.js

@@ -145,7 +145,7 @@ class TovaLanguageServer {
       capabilities: {
         textDocumentSync: {
           openClose: true,
-          change: 1, // Full content sync
+          change: 2, // Incremental sync — receive only changed ranges
           save: { includeText: true },
         },
         completionProvider: {
@@ -183,11 +183,56 @@ class TovaLanguageServer {
 
   _onDidChange(params) {
     const { uri, version } = params.textDocument;
-    const text = params.contentChanges[0]?.text;
-    if (text !== undefined) {
-      this._documents.set(uri, { text, version });
-      this._validateDocument(uri, text);
+    const changes = params.contentChanges;
+    if (!changes || changes.length === 0) return;
+
+    const doc = this._documents.get(uri);
+    if (!doc) return;
+
+    let text = doc.text;
+
+    for (const change of changes) {
+      if (change.range) {
+        // Incremental sync: apply range edit
+        text = this._applyEdit(text, change.range, change.text);
+      } else {
+        // Full sync fallback (e.g., if client sends full text)
+        text = change.text;
+      }
     }
+
+    this._documents.set(uri, { text, version });
+    this._debouncedValidate(uri, text);
+  }
+
+  // Apply a single incremental text edit to the document
+  _applyEdit(text, range, newText) {
+    const startOffset = this._positionToOffset(text, range.start);
+    const endOffset = this._positionToOffset(text, range.end);
+    return text.slice(0, startOffset) + newText + text.slice(endOffset);
+  }
+
+  // Convert { line, character } position to byte offset in text
+  _positionToOffset(text, pos) {
+    let line = 0;
+    let offset = 0;
+    while (line < pos.line && offset < text.length) {
+      if (text[offset] === '\n') line++;
+      offset++;
+    }
+    return offset + pos.character;
+  }
+
+  _debouncedValidate(uri, text) {
+    if (!this._validateTimers) this._validateTimers = new Map();
+    const existing = this._validateTimers.get(uri);
+    if (existing) clearTimeout(existing);
+    this._validateTimers.set(uri, setTimeout(() => {
+      this._validateTimers.delete(uri);
+      // Re-read latest text in case more changes arrived
+      const doc = this._documents.get(uri);
+      if (doc) this._validateDocument(uri, doc.text);
+    }, 200));
   }
 
   _onDidClose(params) {
@@ -222,6 +267,8 @@ class TovaLanguageServer {
       // LSP always runs with strict: true for better diagnostics
       const analyzer = new Analyzer(ast, filename, { strict: true });
       const result = analyzer.analyze();
+      // Build sorted scope index for O(log n) position lookups
+      analyzer.globalScope.buildIndex();
       const { warnings } = result;
       const typeRegistry = TypeRegistry.fromAnalyzer(analyzer);
 
@@ -296,6 +343,7 @@ class TovaLanguageServer {
         try {
           const analyzer = new Analyzer(partialAST, filename, { tolerant: true, strict: true });
           const result = analyzer.analyze();
+          analyzer.globalScope.buildIndex();
           const typeRegistry = TypeRegistry.fromAnalyzer(analyzer);
           this._diagnosticsCache.set(uri, { ast: partialAST, analyzer, text, typeRegistry });
           for (const w of result.warnings) {
@@ -1555,7 +1603,7 @@ class TovaLanguageServer {
     });
   }
 
-  // ─── References ─────────────────────────────────────────
+  // ─── References (scope-aware) ───────────────────────────
 
   _onReferences(msg) {
     const { position, textDocument } = msg.params;
@@ -1566,15 +1614,90 @@ class TovaLanguageServer {
     const word = this._getWordAt(line, position.character);
     if (!word) return this._respond(msg.id, []);
 
+    const cached = this._diagnosticsCache.get(textDocument.uri);
+    if (!cached || !cached.analyzer || !cached.analyzer.globalScope) {
+      // Fallback to naive text search if no scope info
+      return this._naiveReferences(msg.id, textDocument.uri, doc.text, word);
+    }
+
+    // Find the scope at cursor and walk up to find the defining scope
+    const cursorLine = position.line + 1;
+    const cursorCol = position.character + 1;
+    const cursorScope = cached.analyzer.globalScope.findScopeAtPosition(cursorLine, cursorCol);
+    if (!cursorScope) {
+      return this._naiveReferences(msg.id, textDocument.uri, doc.text, word);
+    }
+
+    let definingScope = null;
+    let scope = cursorScope;
+    while (scope) {
+      if (scope.symbols && scope.symbols.has(word)) {
+        definingScope = scope;
+        break;
+      }
+      scope = scope.parent;
+    }
+
+    if (!definingScope) {
+      return this._naiveReferences(msg.id, textDocument.uri, doc.text, word);
+    }
+
+    // Collect locations: for each text occurrence, check if it resolves to the same scope
     const locations = [];
     const docLines = doc.text.split('\n');
-    const wordRegex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const wordRegex = new RegExp('\\b' + escaped + '\\b', 'g');
+
+    for (let i = 0; i < docLines.length; i++) {
+      let match;
+      while ((match = wordRegex.exec(docLines[i])) !== null) {
+        const matchLine = i + 1;
+        const matchCol = match.index + 1;
+        const matchScope = cached.analyzer.globalScope.findScopeAtPosition(matchLine, matchCol);
+        if (!matchScope) continue;
+
+        // Walk up from matchScope to see if the name resolves to definingScope
+        let resolvedScope = null;
+        let s = matchScope;
+        while (s) {
+          if (s.symbols && s.symbols.has(word)) {
+            resolvedScope = s;
+            break;
+          }
+          s = s.parent;
+        }
+
+        if (resolvedScope === definingScope) {
+          locations.push({
+            uri: textDocument.uri,
+            range: {
+              start: { line: i, character: match.index },
+              end: { line: i, character: match.index + word.length },
+            },
+          });
+        }
+      }
+    }
+
+    // Fallback if scope-aware search found nothing (e.g. positional info gaps)
+    if (locations.length === 0) {
+      return this._naiveReferences(msg.id, textDocument.uri, doc.text, word);
+    }
+
+    this._respond(msg.id, locations);
+  }
+
+  _naiveReferences(id, uri, text, word) {
+    const locations = [];
+    const docLines = text.split('\n');
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const wordRegex = new RegExp('\\b' + escaped + '\\b', 'g');
 
     for (let i = 0; i < docLines.length; i++) {
       let match;
       while ((match = wordRegex.exec(docLines[i])) !== null) {
         locations.push({
-          uri: textDocument.uri,
+          uri: uri,
           range: {
             start: { line: i, character: match.index },
             end: { line: i, character: match.index + word.length },
@@ -1583,7 +1706,7 @@ class TovaLanguageServer {
       }
     }
 
-    this._respond(msg.id, locations);
+    this._respond(id, locations);
   }
 
   // ─── Workspace Symbol ──────────────────────────────────
@@ -1869,6 +1992,19 @@ class TovaLanguageServer {
   }
 }
 
-// Start the server
-const server = new TovaLanguageServer();
-server.start();
+export { TovaLanguageServer };
+
+// Auto-start when imported (for `tova lsp` command).
+// Use startServer() export for explicit control.
+export function startServer() {
+  const server = new TovaLanguageServer();
+  server.start();
+  return server;
+}
+
+// Start automatically — callers that only want the class import should
+// use dynamic import with test-aware filtering or call startServer() explicitly
+const _autoStart = globalThis.__TOVA_LSP_NO_AUTOSTART !== true;
+if (_autoStart) {
+  startServer();
+}

package/src/parser/ast.js

@@ -77,7 +77,7 @@ export class LetDestructure {
 }
 
 export class FunctionDeclaration {
-  constructor(name, params, body, returnType, loc, isAsync = false, typeParams = []) {
+  constructor(name, params, body, returnType, loc, isAsync = false, typeParams = [], decorators = []) {
     this.type = 'FunctionDeclaration';
     this.name = name;
     this.typeParams = typeParams; // Array of type parameter names (generics)
@@ -85,6 +85,7 @@ export class FunctionDeclaration {
     this.body = body;         // BlockStatement or Expression (implicit return)
     this.returnType = returnType; // optional type annotation
     this.isAsync = isAsync;
+    this.decorators = decorators; // Array of { name, args } for @decorator syntax
     this.loc = loc;
   }
 }

package/src/parser/client-parser.js

@@ -293,6 +293,13 @@ export function installClientParser(ParserClass) {
         suffix = this.expect(TokenType.IDENTIFIER, "Expected name after ':'").value;
       }
       name = `${name}:${suffix}`;
+      // Consume event modifiers: on:click.stop.prevent
+      if (name.startsWith('on:') && this.check(TokenType.DOT)) {
+        while (this.match(TokenType.DOT)) {
+          const mod = this.expect(TokenType.IDENTIFIER, "Expected modifier name after '.'").value;
+          name += `.${mod}`;
+        }
+      }
     }
 
     if (!this.match(TokenType.ASSIGN)) {
@@ -402,17 +409,17 @@ export function installClientParser(ParserClass) {
         if (!this.match(TokenType.COMMA)) break;
       }
       this.expect(TokenType.RBRACKET, "Expected ']' in destructuring pattern");
-      variable = `[${elements.join(', ')}]`;
+      variable = new AST.ArrayPattern(elements, l);
     } else if (this.check(TokenType.LBRACE)) {
       // Object destructuring: {name, age}
       this.advance(); // consume {
       const props = [];
       while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-        props.push(this.expect(TokenType.IDENTIFIER, "Expected property name in object pattern").value);
+        props.push({ key: this.expect(TokenType.IDENTIFIER, "Expected property name in object pattern").value });
         if (!this.match(TokenType.COMMA)) break;
       }
       this.expect(TokenType.RBRACE, "Expected '}' in destructuring pattern");
-      variable = `{${props.join(', ')}}`;
+      variable = new AST.ObjectPattern(props, l);
     } else {
       variable = this.expect(TokenType.IDENTIFIER, "Expected loop variable").value;
     }

package/src/parser/parser.js

@@ -5,35 +5,25 @@ 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 ───────────────────────────────────────────────
@@ -49,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) {
@@ -250,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
@@ -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
+]);