brighterscript 1.0.0-alpha.22 → 1.0.0-alpha.24

package/dist/parser/Parser.js

@@ -13,10 +13,10 @@ 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");
 const ArrayType_1 = require("../types/ArrayType");
 const helpers_1 = require("../types/helpers");
-const SymbolTable_1 = require("../SymbolTable");
 const ObjectType_1 = require("../types/ObjectType");
 class Parser {
     constructor() {
@@ -28,7 +28,10 @@ class Parser {
          * The list of statements for the parsed file
          */
         this.ast = new Statement_1.Body([]);
-        this.symbolTable = new SymbolTable_1.SymbolTable();
+        /**
+         * 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(undefined, `File Parser`);
         this._references = new References();
         this.globalTerminators = [];
         /**
@@ -40,8 +43,8 @@ class Parser {
         return this.ast.statements;
     }
     get currentSymbolTable() {
-        var _a, _b;
-        return (_b = (_a = this.currentFunctionExpression) === null || _a === void 0 ? void 0 : _a.symbolTable) !== null && _b !== void 0 ? _b : this.symbolTable;
+        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.
@@ -93,22 +96,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);
@@ -126,7 +129,7 @@ class Parser {
     }
     body() {
         const parentAnnotations = this.enterAnnotationBlock();
-        let body = new Statement_1.Body([]);
+        let body = new Statement_1.Body([], this.symbolTable);
         if (this.tokens.length > 0) {
             this.consumeStatementSeparators(true);
             try {
@@ -192,6 +195,9 @@ class Parser {
             if (this.checkLibrary()) {
                 return this.libraryStatement();
             }
+            if (this.check(TokenKind_1.TokenKind.Const) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers)) {
+                return this.constDeclaration();
+            }
             if (this.check(TokenKind_1.TokenKind.At) && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
                 return this.annotationExpression();
             }
@@ -495,11 +501,20 @@ class Parser {
             if (!options.onlyCallableAsMember) {
                 this._references.functionStatements.push(result);
             }
+            // Add the transpiled name for namespace functions
+            // to consider an edge case when defining namespaces in .bs files
+            // and using them in .brs files.
+            if (result.func.namespaceName) {
+                const transpiledNamespaceFunctionName = result.getName(ParseMode.BrightScript);
+                const funcType = result.func.getFunctionType();
+                funcType.setName(transpiledNamespaceFunctionName);
+                this.symbolTable.addSymbol(transpiledNamespaceFunctionName, result.name.range, funcType);
+            }
             return result;
         }
     }
     functionDeclaration(options = {}) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -573,10 +588,12 @@ class Parser {
                 // do not go to next statement - we don't care about any other statement
                 this.consumeStatementSeparators(true);
             }
+            // Can Not use the current function expression symbol table for a function expression inside of itself
+            const funcExprParentSymbolTable = (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable;
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionKeyword, undefined, //ending keyword
             leftParen, rightParen, asToken, typeExpr, //return type
-            this.currentFunctionExpression, this.currentNamespaceName, (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable);
+            this.currentFunctionExpression, this.currentNamespaceName, funcExprParentSymbolTable);
             //if there is a parent function, register this function with the parent
             if (this.currentFunctionExpression) {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
@@ -585,14 +602,8 @@ class Parser {
             if (!options.onlyCallableAsMember && name) {
                 const funcType = func.getFunctionType();
                 funcType.setName(name.text);
-                // add the function as declared to the current namespace's table
-                (_d = this.currentNamespace) === null || _d === void 0 ? void 0 : _d.symbolTable.addSymbol(name.text, name.range, funcType);
-                let fullyQualifiedName = name.text;
-                if (this.currentNamespaceName) {
-                    // add the "namespaced" name of this function to the parent symbol table
-                    fullyQualifiedName = this.currentNamespaceName.getName(ParseMode.BrighterScript) + '.' + name.text;
-                }
-                this.currentSymbolTable.addSymbol(fullyQualifiedName, name.range, funcType);
+                // add the function as declared to the current symbol table
+                this.currentSymbolTable.addSymbol(name.text, name.range, funcType);
             }
             this._references.functionExpressions.push(func);
             if (options.hasBody) {
@@ -683,9 +694,13 @@ class Parser {
             result = new Statement_1.AssignmentStatement(name, operator, value, this.currentFunctionExpression);
         }
         else {
-            result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(new Expression_1.VariableExpression(name, this.currentNamespaceName), operator, value), this.currentFunctionExpression);
-            //remove the right-hand-side expression from this assignment operator, and replace with the full assignment expression
-            this._references.expressions.delete(value);
+            const nameExpression = new Expression_1.VariableExpression(name, this.currentNamespaceName);
+            result = new Statement_1.AssignmentStatement(name, operator, new Expression_1.BinaryExpression(nameExpression, operator, value), this.currentFunctionExpression);
+            this.addExpressionsToReferences(nameExpression);
+            if ((0, reflection_1.isBinaryExpression)(value)) {
+                //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._references.assignmentStatements.push(result);
@@ -927,6 +942,9 @@ class Parser {
         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;
     }
     /**
@@ -979,6 +997,23 @@ class Parser {
         }
         return result;
     }
+    constDeclaration() {
+        this.warnIfNotBrighterScriptMode('const declaration');
+        const constToken = this.advance();
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
+        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, getBscTypeFromExpression(expression));
+        }
+        this._references.constStatements.push(statement);
+        return statement;
+    }
     libraryStatement() {
         let libStatement = new Statement_1.LibraryStatement({
             library: this.advance(),
@@ -1149,6 +1184,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() {
@@ -1191,6 +1229,9 @@ 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);
+        if (identifier) {
+            this.currentSymbolTable.addSymbol(identifier.text, identifier.range, new ArrayType_1.ArrayType(DynamicType_1.DynamicType.instance));
+        }
         return new Statement_1.DimStatement(dim, identifier, leftSquareBracket, expressions, rightSquareBracket);
     }
     ifStatement() {
@@ -1396,6 +1437,8 @@ class Parser {
         }
         //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 }));
+        // we can also add this expression to the references, for type checking purposes
+        this._references.expressions.add(expr);
         throw this.lastDiagnosticAsError();
     }
     setStatement() {
@@ -1618,6 +1661,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;
@@ -1627,16 +1671,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;
@@ -1646,6 +1699,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;
@@ -1655,6 +1709,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;
@@ -1907,7 +1962,7 @@ class Parser {
                 range: null
             };
             if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
-                result.keyToken = this.advance();
+                result.keyToken = this.identifier(...TokenKind_1.AllowedProperties);
             }
             else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
                 result.keyToken = this.advance();
@@ -2276,9 +2331,10 @@ class Parser {
                 currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
             }
         }
+        const isLiteral = (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.StringLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.IntegerLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.FloatLiteral || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.Boolean;
         // We will not be able to decipher the token type if it was in brackets
         // e.g (someVar+otherVar).toStr() -- we don't bother trying to decipher what "(someVar+otherVar)" is
-        let isUnknown = (lastTokenWasLeftBracket && (lastTokenHadLeadingWhitespace || !this.isAcceptableChainToken(currentToken)));
+        let isUnknown = isLiteral || (lastTokenWasLeftBracket && (lastTokenHadLeadingWhitespace || !this.isAcceptableChainToken(currentToken)));
         const tokenWithIndex = { token: currentToken, index: currentTokenIndex, tokenTypeIsNotKnowable: isUnknown, hasBrackets: hasBrackets };
         return tokenWithIndex;
     }
@@ -2298,7 +2354,7 @@ class Parser {
             currentToken = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.token;
             currentTokenIndex = previousTokenResult === null || previousTokenResult === void 0 ? void 0 : previousTokenResult.index;
         }
-        if ((currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.Dot) {
+        if ((currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.Dot || (currentToken === null || currentToken === void 0 ? void 0 : currentToken.kind) === TokenKind_1.TokenKind.QuestionDot) {
             previousTokenResult = this.getPreviousTokenFromIndex(currentTokenIndex);
             currentToken = previousTokenResult.token;
             currentTokenIndex = previousTokenResult.index;
@@ -2478,6 +2534,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
@@ -2495,6 +2564,9 @@ class Parser {
             EnumStatement: e => {
                 this._references.enumStatements.push(e);
             },
+            ConstStatement: s => {
+                this._references.constStatements.push(s);
+            },
             UnaryExpression: e => {
                 this._references.expressions.add(e);
             },
@@ -2505,6 +2577,9 @@ class Parser {
             walkMode: visitors_1.WalkMode.visitAllRecursive
         });
     }
+    getContainingExpression(currentToken) {
+        return [...this.references.expressions].find((cs) => util_1.util.rangeContainsRange(cs.range, currentToken.range));
+    }
     getContainingClass(currentToken) {
         return this.references.classStatements.find((cs) => util_1.util.rangeContains(cs.range, currentToken.range.start));
     }
@@ -2540,6 +2615,7 @@ class References {
         this.functionStatements = [];
         this.interfaceStatements = [];
         this.enumStatements = [];
+        this.constStatements = [];
         /**
          * A collection of full expressions. This excludes intermediary expressions.
          *
@@ -2549,6 +2625,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 = [];
@@ -2596,6 +2675,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;
 var TokenUsage;
@@ -2637,23 +2725,25 @@ function getBscTypeFromExpression(expression, functionExpression) {
             return new ArrayType_1.ArrayType(...innerTypes);
             //function call
         }
-        else if ((0, reflection_1.isNewExpression)(expression)) {
-            return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression);
-            //Function call
-        }
-        else if ((0, reflection_1.isCallExpression)(expression)) {
-            return (0, helpers_1.getTypeFromCallExpression)(expression, functionExpression);
-        }
-        else if ((0, reflection_1.isVariableExpression)(expression)) {
-            return (0, helpers_1.getTypeFromVariableExpression)(expression, functionExpression);
-        }
-        else if ((0, reflection_1.isDottedGetExpression)(expression)) {
-            return (0, helpers_1.getTypeFromDottedGetExpression)(expression, functionExpression);
-        }
-        else if ((0, reflection_1.isIndexedGetExpression)(expression)) {
-            const source = getBscTypeFromExpression(expression.obj, functionExpression);
-            if ((0, reflection_1.isArrayType)(source)) {
-                return source.getDefaultType();
+        else if (functionExpression) {
+            // These are more precise, and can't be determined without knowing the function expression you're in
+            if ((0, reflection_1.isNewExpression)(expression)) {
+                return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression);
+            }
+            else if ((0, reflection_1.isCallExpression)(expression)) {
+                return (0, helpers_1.getTypeFromCallExpression)(expression, functionExpression);
+            }
+            else if ((0, reflection_1.isVariableExpression)(expression)) {
+                return (0, helpers_1.getTypeFromVariableExpression)(expression, functionExpression);
+            }
+            else if ((0, reflection_1.isDottedGetExpression)(expression)) {
+                return (0, helpers_1.getTypeFromDottedGetExpression)(expression, functionExpression);
+            }
+            else if ((0, reflection_1.isIndexedGetExpression)(expression)) {
+                const source = getBscTypeFromExpression(expression.obj, functionExpression);
+                if ((0, reflection_1.isArrayType)(source)) {
+                    return source.getDefaultType();
+                }
             }
         }
     }
@@ -2661,7 +2751,7 @@ function getBscTypeFromExpression(expression, functionExpression) {
         //do nothing. Just return dynamic
     }
     //fallback to dynamic
-    return new DynamicType_1.DynamicType();
+    return DynamicType_1.DynamicType.instance;
 }
 exports.getBscTypeFromExpression = getBscTypeFromExpression;
 //# sourceMappingURL=Parser.js.map