brighterscript 0.52.1 → 0.53.0

package/dist/parser/Parser.js

@@ -5,6 +5,7 @@ const Token_1 = require("../lexer/Token");
 const Lexer_1 = require("../lexer/Lexer");
 const TokenKind_1 = require("../lexer/TokenKind");
 const Statement_1 = require("./Statement");
+const Statement_2 = require("./Statement");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
 const util_1 = require("../util");
 const Expression_1 = require("./Expression");
@@ -13,6 +14,8 @@ const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
 const Cache_1 = require("../Cache");
+const SymbolTable_1 = require("../SymbolTable");
+const DynamicType_1 = require("../types/DynamicType");
 class Parser {
     constructor() {
         /**
@@ -22,7 +25,11 @@ class Parser {
         /**
          * The list of statements for the parsed file
          */
-        this.ast = new Statement_1.Body([]);
+        this.ast = new Statement_2.Body([]);
+        /**
+         * The top-level symbol table for this file. Things like top-level namespaces, non-namespaced classes, enums, interfaces, and functions beling here.
+         */
+        this.symbolTable = new SymbolTable_1.SymbolTable();
         this._references = new References();
         this.globalTerminators = [];
         /**
@@ -33,6 +40,10 @@ class Parser {
     get statements() {
         return this.ast.statements;
     }
+    get currentSymbolTable() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : (_c = this.currentNamespace) === null || _c === void 0 ? void 0 : _c.symbolTable) !== null && _d !== void 0 ? _d : this.symbolTable;
+    }
     /**
      * References for significant statements/expressions in the parser.
      * These are initially extracted during parse-time to improve performance, but will also be dynamically regenerated if need be.
@@ -68,6 +79,10 @@ class Parser {
             }
         }
     }
+    get currentNamespaceName() {
+        var _a;
+        return (_a = this.currentNamespace) === null || _a === void 0 ? void 0 : _a.nameExpression;
+    }
     /**
      * Get the currently active global terminators
      */
@@ -79,22 +94,22 @@ class Parser {
      * Static wrapper around creating a new parser and parsing a list of tokens
      */
     static parse(toParse, options) {
-        let tokens;
-        if (typeof toParse === 'string') {
-            tokens = Lexer_1.Lexer.scan(toParse).tokens;
-        }
-        else {
-            tokens = toParse;
-        }
-        return new Parser().parse(tokens, options);
+        return new Parser().parse(toParse, options);
     }
     /**
      * Parses an array of `Token`s into an abstract syntax tree
      * @param toParse the array of tokens to parse. May not contain any whitespace tokens
      * @returns the same instance of the parser which contains the diagnostics and statements
      */
-    parse(tokens, options) {
+    parse(toParse, options) {
         var _a;
+        let tokens;
+        if (typeof toParse === 'string') {
+            tokens = Lexer_1.Lexer.scan(toParse).tokens;
+        }
+        else {
+            tokens = toParse;
+        }
         this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : new Logger_1.Logger();
         this.tokens = tokens;
         this.options = this.sanitizeParseOptions(options);
@@ -112,7 +127,7 @@ class Parser {
     }
     body() {
         const parentAnnotations = this.enterAnnotationBlock();
-        let body = new Statement_1.Body([]);
+        let body = new Statement_2.Body([]);
         if (this.tokens.length > 0) {
             this.consumeStatementSeparators(true);
             try {
@@ -178,6 +193,9 @@ class Parser {
             if (this.checkLibrary()) {
                 return this.libraryStatement();
             }
+            if (this.check(TokenKind_1.TokenKind.Const)) {
+                return this.constDeclaration();
+            }
             if (this.check(TokenKind_1.TokenKind.At) && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
                 return this.annotationExpression();
             }
@@ -216,7 +234,7 @@ class Parser {
         return identifier;
     }
     enumMemberStatement() {
-        const statement = new Statement_1.EnumMemberStatement({});
+        const statement = new Statement_2.EnumMemberStatement({});
         statement.tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         //look for `= SOME_EXPRESSION`
         if (this.check(TokenKind_1.TokenKind.Equal)) {
@@ -237,7 +255,7 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
             throw this.lastDiagnosticAsError();
         }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type);
+        return new Statement_2.InterfaceFieldStatement(name, asToken, typeToken, type);
     }
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
@@ -259,7 +277,7 @@ class Parser {
                 throw this.lastDiagnosticAsError();
             }
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken));
+        return new Statement_2.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken));
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
@@ -316,13 +334,13 @@ class Parser {
         }
         //consume the final `end interface` token
         const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
-        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
+        const statement = new Statement_2.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
         this._references.interfaceStatements.push(statement);
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
     enumDeclaration() {
-        const result = new Statement_1.EnumStatement({}, [], this.currentNamespaceName);
+        const result = new Statement_2.EnumStatement({}, [], this.currentNamespaceName);
         this.warnIfNotBrighterScriptMode('enum declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
@@ -366,6 +384,9 @@ class Parser {
         }
         //consume the final `end interface` token
         result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        if (result.name) {
+            this.currentSymbolTable.addSymbol(result.tokens.name.text, result.tokens.name.range, DynamicType_1.DynamicType.instance);
+        }
         this._references.enumStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -414,9 +435,11 @@ class Parser {
                     if (overrideKeyword && funcDeclaration.name.text.toLowerCase() === 'new') {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { range: overrideKeyword.range }));
                     }
-                    decl = new Statement_1.MethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
+                    decl = new Statement_2.MethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
                     //refer to this statement as parent of the expression
                     functionStatement.func.functionStatement = decl;
+                    //add the `super` symbol to class methods
+                    funcDeclaration.func.symbolTable.addSymbol('super', undefined, DynamicType_1.DynamicType.instance);
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -446,7 +469,10 @@ class Parser {
         if (endingKeyword.kind !== TokenKind_1.TokenKind.EndClass) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('class')), { range: endingKeyword.range }));
         }
-        const result = new Statement_1.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName, this.currentNamespaceName);
+        const result = new Statement_2.ClassStatement(classKeyword, className, body, endingKeyword, extendsKeyword, parentClassName, this.currentNamespaceName);
+        if (className) {
+            this.currentSymbolTable.addSymbol(className.text, className.range, DynamicType_1.DynamicType.instance);
+        }
         this._references.classStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -471,9 +497,9 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue);
+        return new Statement_2.FieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue);
     }
-    functionDeclaration(isAnonymous, checkIdentifier = true) {
+    functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
         var _a;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
@@ -547,11 +573,21 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken, this.currentFunctionExpression, this.currentNamespaceName);
+            leftParen, rightParen, asToken, typeToken, this.currentFunctionExpression, this.currentNamespaceName, this.currentSymbolTable);
+            if (!func.symbolTable.hasSymbol('m')) {
+                func.symbolTable.addSymbol('m', undefined, DynamicType_1.DynamicType.instance);
+            }
             //if there is a parent function, register this function with the parent
             if (this.currentFunctionExpression) {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
             }
+            // add the function to the relevant symbol tables
+            if (!onlyCallableAsMember && name) {
+                const funcType = func.getFunctionType();
+                funcType.setName(name.text);
+                // add the function as declared to the current symbol table
+                this.currentSymbolTable.addSymbol(name.text, name.range, funcType);
+            }
             this._references.functionExpressions.push(func);
             let previousFunctionExpression = this.currentFunctionExpression;
             this.currentFunctionExpression = func;
@@ -580,7 +616,7 @@ class Parser {
                 return func;
             }
             else {
-                let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
+                let result = new Statement_2.FunctionStatement(name, func, this.currentNamespaceName);
                 func.functionStatement = result;
                 this._references.functionStatements.push(result);
                 return result;
@@ -628,14 +664,17 @@ class Parser {
         let value = this.expression();
         let result;
         if (operator.kind === TokenKind_1.TokenKind.Equal) {
-            result = new Statement_1.AssignmentStatement(operator, name, value, this.currentFunctionExpression);
+            result = new Statement_2.AssignmentStatement(operator, name, value, this.currentFunctionExpression);
         }
         else {
-            result = new Statement_1.AssignmentStatement(operator, name, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
+            const nameExpression = new Expression_1.VariableExpression(name, this.currentNamespaceName);
+            result = new Statement_2.AssignmentStatement(operator, name, new Expression_1.BinaryExpression(nameExpression, operator, value), this.currentFunctionExpression);
+            this.addExpressionsToReferences(nameExpression);
             //remove the right-hand-side expression from this assignment operator, and replace with the full assignment expression
             this._references.expressions.delete(value);
             this._references.expressions.add(result);
         }
+        this.currentSymbolTable.addSymbol(name.text, name.range, DynamicType_1.DynamicType.instance);
         this._references.assignmentStatements.push(result);
         return result;
     }
@@ -755,11 +794,11 @@ class Parser {
         else {
             endWhile = this.advance();
         }
-        return new Statement_1.WhileStatement({ while: whileKeyword, endWhile: endWhile }, condition, whileBlock);
+        return new Statement_2.WhileStatement({ while: whileKeyword, endWhile: endWhile }, condition, whileBlock);
     }
     exitWhile() {
         let keyword = this.advance();
-        return new Statement_1.ExitWhileStatement({ exitWhile: keyword });
+        return new Statement_2.ExitWhileStatement({ exitWhile: keyword });
     }
     forStatement() {
         const forToken = this.advance();
@@ -790,7 +829,7 @@ class Parser {
         }
         // WARNING: BrightScript doesn't delete the loop initial value after a for/to loop! It just
         // stays around in scope with whatever value it was when the loop exited.
-        return new Statement_1.ForStatement(forToken, initializer, toToken, finalValue, body, endForToken, stepToken, incrementExpression);
+        return new Statement_2.ForStatement(forToken, initializer, toToken, finalValue, body, endForToken, stepToken, incrementExpression);
     }
     forEachStatement() {
         let forEach = this.advance();
@@ -808,6 +847,7 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
+        this.currentSymbolTable.addSymbol(name.text, name.range, DynamicType_1.DynamicType.instance);
         this.consumeStatementSeparators();
         let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
@@ -815,7 +855,7 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        return new Statement_1.ForEachStatement({
+        return new Statement_2.ForEachStatement({
             forEach: forEach,
             in: maybeIn,
             endFor: endFor
@@ -823,14 +863,14 @@ class Parser {
     }
     exitFor() {
         let keyword = this.advance();
-        return new Statement_1.ExitForStatement({ exitFor: keyword });
+        return new Statement_2.ExitForStatement({ exitFor: keyword });
     }
     commentStatement() {
         //if this comment is on the same line as the previous statement,
         //then this comment should be treated as a single-line comment
         let prev = this.previous();
         if ((prev === null || prev === void 0 ? void 0 : prev.range.end.line) === this.peek().range.start.line) {
-            return new Statement_1.CommentStatement([this.advance()]);
+            return new Statement_2.CommentStatement([this.advance()]);
         }
         else {
             let comments = [this.advance()];
@@ -838,7 +878,7 @@ class Parser {
                 this.advance();
                 comments.push(this.advance());
             }
-            return new Statement_1.CommentStatement(comments);
+            return new Statement_2.CommentStatement(comments);
         }
     }
     namespaceStatement() {
@@ -850,12 +890,13 @@ class Parser {
         this.namespaceAndFunctionDepth++;
         let name = this.getNamespacedVariableNameExpression();
         //set the current namespace name
-        this.currentNamespaceName = name;
+        let result = new Statement_2.NamespaceStatement(keyword, name, null, null, this.currentSymbolTable);
+        this.currentNamespace = result;
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
         //unset the current namespace name
-        this.currentNamespaceName = undefined;
+        this.currentNamespace = undefined;
         let endKeyword;
         if (this.check(TokenKind_1.TokenKind.EndNamespace)) {
             endKeyword = this.advance();
@@ -865,8 +906,14 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { range: keyword.range }));
         }
         this.namespaceAndFunctionDepth--;
-        let result = new Statement_1.NamespaceStatement(keyword, name, body, endKeyword);
+        result.body = body;
+        result.endKeyword = endKeyword;
         this._references.namespaceStatements.push(result);
+        //cache the range property so that plugins can't affect it
+        result.cacheRange();
+        if (result.name) {
+            this.symbolTable.addSymbol(result.name.split('.')[0], result.nameExpression.range, DynamicType_1.DynamicType.instance);
+        }
         return result;
     }
     /**
@@ -919,8 +966,24 @@ class Parser {
         }
         return result;
     }
+    constDeclaration() {
+        const constToken = this.advance();
+        const nameToken = this.identifier();
+        const equalToken = this.consumeToken(TokenKind_1.TokenKind.Equal);
+        const expression = this.expression();
+        const statement = new Statement_1.ConstStatement({
+            const: constToken,
+            name: nameToken,
+            equals: equalToken
+        }, expression, this.currentNamespaceName);
+        if (nameToken) {
+            this.currentSymbolTable.addSymbol(nameToken.text, nameToken.range, DynamicType_1.DynamicType.instance);
+        }
+        this._references.constStatements.push(statement);
+        return statement;
+    }
     libraryStatement() {
-        let libStatement = new Statement_1.LibraryStatement({
+        let libStatement = new Statement_2.LibraryStatement({
             library: this.advance(),
             //grab the next token only if it's a string
             filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('library'), TokenKind_1.TokenKind.StringLiteral)
@@ -930,7 +993,7 @@ class Parser {
     }
     importStatement() {
         this.warnIfNotBrighterScriptMode('import statements');
-        let importStatement = new Statement_1.ImportStatement(this.advance(), 
+        let importStatement = new Statement_2.ImportStatement(this.advance(), 
         //grab the next token only if it's a string
         this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral));
         this._references.importStatements.push(importStatement);
@@ -1057,7 +1120,7 @@ class Parser {
     }
     tryCatchStatement() {
         const tryToken = this.advance();
-        const statement = new Statement_1.TryCatchStatement({ try: tryToken });
+        const statement = new Statement_2.TryCatchStatement({ try: tryToken });
         //ensure statement separator
         this.consumeStatementSeparators();
         statement.tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
@@ -1070,7 +1133,7 @@ class Parser {
             }
             return statement;
         }
-        const catchStmt = new Statement_1.CatchStatement({ catch: this.advance() });
+        const catchStmt = new Statement_2.CatchStatement({ catch: this.advance() });
         statement.catchStatement = catchStmt;
         const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         if (exceptionVarToken) {
@@ -1087,6 +1150,9 @@ class Parser {
         else {
             statement.tokens.endTry = this.advance();
         }
+        if (exceptionVarToken) {
+            this.currentSymbolTable.addSymbol(exceptionVarToken.text, exceptionVarToken.range, DynamicType_1.DynamicType.instance);
+        }
         return statement;
     }
     throwStatement() {
@@ -1098,7 +1164,7 @@ class Parser {
         else {
             expression = this.expression();
         }
-        return new Statement_1.ThrowStatement(throwToken, expression);
+        return new Statement_2.ThrowStatement(throwToken, expression);
     }
     dimStatement() {
         const dim = this.advance();
@@ -1129,7 +1195,7 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingExpressionsInDimStatement()), { range: this.peek().range }));
         }
         let rightSquareBracket = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingRightSquareBracketAfterDimIdentifier(), TokenKind_1.TokenKind.RightSquareBracket);
-        return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
+        return new Statement_2.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
     }
     ifStatement() {
         // colon before `if` is usually not allowed, unless it's after `then`
@@ -1235,7 +1301,7 @@ class Parser {
                 }
             }
         }
-        return new Statement_1.IfStatement({
+        return new Statement_2.IfStatement({
             if: ifToken,
             then: thenToken,
             endIf: endIfToken,
@@ -1311,7 +1377,7 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(colon.text)), { range: colon.range }));
             }
         }
-        return new Statement_1.Block(statements, startingRange);
+        return new Statement_2.Block(statements, startingRange);
     }
     expressionStatement(expr) {
         let expressionStart = this.peek();
@@ -1325,12 +1391,12 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incrementDecrementOperatorsAreNotAllowedAsResultOfFunctionCall()), { range: expressionStart.range }));
                 throw this.lastDiagnosticAsError();
             }
-            const result = new Statement_1.IncrementStatement(expr, operator);
+            const result = new Statement_2.IncrementStatement(expr, operator);
             this._references.expressions.add(result);
             return result;
         }
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
-            return new Statement_1.ExpressionStatement(expr);
+            return new Statement_2.ExpressionStatement(expr);
         }
         //at this point, it's probably an error. However, we recover a little more gracefully by creating an assignment
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
@@ -1350,12 +1416,12 @@ class Parser {
             let right = this.expression();
             // Create a dotted or indexed "set" based on the left-hand side's type
             if ((0, reflection_1.isIndexedGetExpression)(left)) {
-                return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
+                return new Statement_2.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                return new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
+                return new Statement_2.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
                     ? right
                     : new Expression_1.BinaryExpression(left, operator, right));
             }
@@ -1388,7 +1454,7 @@ class Parser {
         if ((0, Token_1.isToken)(last)) {
             // TODO: error, expected value
         }
-        return new Statement_1.PrintStatement({ print: printKeyword }, values);
+        return new Statement_2.PrintStatement({ print: printKeyword }, values);
     }
     /**
      * Parses a return statement with an optional return value.
@@ -1397,10 +1463,10 @@ class Parser {
     returnStatement() {
         let tokens = { return: this.previous() };
         if (this.checkEndOfStatement()) {
-            return new Statement_1.ReturnStatement(tokens);
+            return new Statement_2.ReturnStatement(tokens);
         }
         let toReturn = this.check(TokenKind_1.TokenKind.Else) ? undefined : this.expression();
-        return new Statement_1.ReturnStatement(tokens, toReturn);
+        return new Statement_2.ReturnStatement(tokens, toReturn);
     }
     /**
      * Parses a `label` statement
@@ -1417,7 +1483,7 @@ class Parser {
             this.current -= 2;
             throw new CancelStatementError();
         }
-        return new Statement_1.LabelStatement(tokens);
+        return new Statement_2.LabelStatement(tokens);
     }
     /**
      * Parses a `goto` statement
@@ -1428,7 +1494,7 @@ class Parser {
             goto: this.advance(),
             label: this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLabelIdentifierAfterGotoKeyword(), TokenKind_1.TokenKind.Identifier)
         };
-        return new Statement_1.GotoStatement(tokens);
+        return new Statement_2.GotoStatement(tokens);
     }
     /**
      * Parses an `end` statement
@@ -1436,7 +1502,7 @@ class Parser {
      */
     endStatement() {
         let endTokens = { end: this.advance() };
-        return new Statement_1.EndStatement(endTokens);
+        return new Statement_2.EndStatement(endTokens);
     }
     /**
      * Parses a `stop` statement
@@ -1444,7 +1510,7 @@ class Parser {
      */
     stopStatement() {
         let tokens = { stop: this.advance() };
-        return new Statement_1.StopStatement(tokens);
+        return new Statement_2.StopStatement(tokens);
     }
     /**
      * Parses a block, looking for a specific terminating TokenKind to denote completion.
@@ -1496,7 +1562,7 @@ class Parser {
             }
         }
         this.exitAnnotationBlock(parentAnnotations);
-        return new Statement_1.Block(statements, startingToken.range);
+        return new Statement_2.Block(statements, startingToken.range);
     }
     /**
      * Attach pending annotations to the provided statement,
@@ -1554,6 +1620,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.And, TokenKind_1.TokenKind.Or)) {
             let operator = this.previous();
             let right = this.relational();
+            this.addExpressionsToReferences(expr, right);
             expr = new Expression_1.BinaryExpression(expr, operator, right);
         }
         return expr;
@@ -1563,16 +1630,25 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.Equal, TokenKind_1.TokenKind.LessGreater, TokenKind_1.TokenKind.Greater, TokenKind_1.TokenKind.GreaterEqual, TokenKind_1.TokenKind.Less, TokenKind_1.TokenKind.LessEqual)) {
             let operator = this.previous();
             let right = this.additive();
+            this.addExpressionsToReferences(expr, right);
             expr = new Expression_1.BinaryExpression(expr, operator, right);
         }
         return expr;
     }
+    addExpressionsToReferences(...expressions) {
+        for (const expression of expressions) {
+            if (!(0, reflection_1.isBinaryExpression)(expression)) {
+                this.references.expressions.add(expression);
+            }
+        }
+    }
     // TODO: bitshift
     additive() {
         let expr = this.multiplicative();
         while (this.matchAny(TokenKind_1.TokenKind.Plus, TokenKind_1.TokenKind.Minus)) {
             let operator = this.previous();
             let right = this.multiplicative();
+            this.addExpressionsToReferences(expr, right);
             expr = new Expression_1.BinaryExpression(expr, operator, right);
         }
         return expr;
@@ -1582,6 +1658,7 @@ class Parser {
         while (this.matchAny(TokenKind_1.TokenKind.Forwardslash, TokenKind_1.TokenKind.Backslash, TokenKind_1.TokenKind.Star, TokenKind_1.TokenKind.Mod, TokenKind_1.TokenKind.LeftShift, TokenKind_1.TokenKind.RightShift)) {
             let operator = this.previous();
             let right = this.exponential();
+            this.addExpressionsToReferences(expr, right);
             expr = new Expression_1.BinaryExpression(expr, operator, right);
         }
         return expr;
@@ -1591,6 +1668,7 @@ class Parser {
         while (this.match(TokenKind_1.TokenKind.Caret)) {
             let operator = this.previous();
             let right = this.prefixUnary();
+            this.addExpressionsToReferences(expr, right);
             expr = new Expression_1.BinaryExpression(expr, operator, right);
         }
         return expr;
@@ -1775,7 +1853,7 @@ class Parser {
             case this.check(TokenKind_1.TokenKind.RegexLiteral):
                 return this.regexLiteralExpression();
             case this.check(TokenKind_1.TokenKind.Comment):
-                return new Statement_1.CommentStatement([this.advance()]);
+                return new Statement_2.CommentStatement([this.advance()]);
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
                 if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -1793,7 +1871,7 @@ class Parser {
         let openingSquare = this.previous();
         //add any comment found right after the opening square
         if (this.check(TokenKind_1.TokenKind.Comment)) {
-            elements.push(new Statement_1.CommentStatement([this.advance()]));
+            elements.push(new Statement_2.CommentStatement([this.advance()]));
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
@@ -1802,7 +1880,7 @@ class Parser {
             while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
                 if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
                     let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
-                    elements.push(new Statement_1.CommentStatement([comment]));
+                    elements.push(new Statement_2.CommentStatement([comment]));
                 }
                 while (this.match(TokenKind_1.TokenKind.Newline)) {
                 }
@@ -1845,7 +1923,7 @@ class Parser {
             let lastAAMember;
             if (this.check(TokenKind_1.TokenKind.Comment)) {
                 lastAAMember = null;
-                members.push(new Statement_1.CommentStatement([this.advance()]));
+                members.push(new Statement_2.CommentStatement([this.advance()]));
             }
             else {
                 let k = key();
@@ -1861,7 +1939,7 @@ class Parser {
                 //check for comment at the end of the current line
                 if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
                     let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                    members.push(new Statement_1.CommentStatement([token]));
+                    members.push(new Statement_2.CommentStatement([token]));
                 }
                 else {
                     this.consumeStatementSeparators(true);
@@ -1869,7 +1947,7 @@ class Parser {
                     if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
                         let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
                         lastAAMember = null;
-                        members.push(new Statement_1.CommentStatement([token]));
+                        members.push(new Statement_2.CommentStatement([token]));
                         continue;
                     }
                     if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
@@ -2165,6 +2243,19 @@ class Parser {
                     }
                 }
             },
+            BinaryExpression: (e, parent) => {
+                //walk the chain of binary expressions and add each one to the list of expressions
+                const expressions = [e];
+                let expression;
+                while ((expression = expressions.pop())) {
+                    if ((0, reflection_1.isBinaryExpression)(expression)) {
+                        expressions.push(expression.left, expression.right);
+                    }
+                    else {
+                        this._references.expressions.add(expression);
+                    }
+                }
+            },
             ArrayLiteralExpression: e => {
                 for (const element of e.elements) {
                     //keep everything except comments
@@ -2182,6 +2273,9 @@ class Parser {
             EnumStatement: e => {
                 this._references.enumStatements.push(e);
             },
+            ConstStatement: s => {
+                this._references.constStatements.push(s);
+            },
             UnaryExpression: e => {
                 this._references.expressions.add(e);
             },
@@ -2210,6 +2304,7 @@ class References {
         this.functionStatements = [];
         this.interfaceStatements = [];
         this.enumStatements = [];
+        this.constStatements = [];
         /**
          * A collection of full expressions. This excludes intermediary expressions.
          *
@@ -2219,6 +2314,9 @@ class References {
          *
          * Example 2:
          * `name.space.doSomething(a.b.c)` will result in 2 entries in this list. the `CallExpression` for `doSomething`, and the `.c` DottedGetExpression.
+         *
+         * Example 3:
+         * `value = SomeEnum.value > 2 or SomeEnum.otherValue < 10` will result in 4 entries. `SomeEnum.value`, `2`, `SomeEnum.otherValue`, `10`
          */
         this.expressions = new Set();
         this.importStatements = [];
@@ -2266,6 +2364,15 @@ class References {
             return result;
         });
     }
+    get constStatementLookup() {
+        return this.cache.getOrAdd('consts', () => {
+            const result = new Map();
+            for (const stmt of this.constStatements) {
+                result.set(stmt.fullName.toLowerCase(), stmt);
+            }
+            return result;
+        });
+    }
 }
 exports.References = References;
 class CancelStatementError extends Error {