brighterscript 1.0.0-alpha.14 → 1.0.0-alpha.17

package/dist/parser/Parser.js

@@ -12,11 +12,12 @@ const Logger_1 = require("../Logger");
 const reflection_1 = require("../astUtils/reflection");
 const visitors_1 = require("../astUtils/visitors");
 const creators_1 = require("../astUtils/creators");
-const SymbolTable_1 = require("../SymbolTable");
+const Cache_1 = require("../Cache");
 const DynamicType_1 = require("../types/DynamicType");
-const ObjectType_1 = require("../types/ObjectType");
 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() {
         /**
@@ -211,25 +212,46 @@ class Parser {
             this.synchronize();
         }
     }
+    /**
+     * Try to get an identifier. If not found, add diagnostic and return undefined
+     */
+    tryIdentifier(...additionalTokenKinds) {
+        const identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
+        if (identifier) {
+            // force the name into an identifier so the AST makes some sense
+            identifier.kind = TokenKind_1.TokenKind.Identifier;
+            return identifier;
+        }
+    }
     identifier(...additionalTokenKinds) {
         const identifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...additionalTokenKinds);
         // force the name into an identifier so the AST makes some sense
         identifier.kind = TokenKind_1.TokenKind.Identifier;
         return identifier;
     }
+    enumMemberStatement() {
+        const tokens = {};
+        let value;
+        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)) {
+            tokens.equal = this.advance();
+            value = this.expression();
+        }
+        return new Statement_1.EnumMemberStatement(tokens, value);
+    }
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
      */
     interfaceFieldStatement() {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
         let asToken = this.consumeToken(TokenKind_1.TokenKind.As);
-        let typeToken = this.typeToken();
-        const type = util_1.util.tokenToBscType(typeToken);
-        if (!type) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+        let typeExpr = this.typeExpression();
+        if (!typeExpr.isValidType()) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
             throw this.lastDiagnosticAsError();
         }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type);
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpr);
     }
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
@@ -241,17 +263,16 @@ class Parser {
         const params = [];
         const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
         let asToken = null;
-        let returnTypeToken = null;
+        let returnTypeExpr;
         if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
-            returnTypeToken = this.typeToken();
-            const returnType = util_1.util.tokenToBscType(returnTypeToken);
-            if (!returnType) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeToken.text)), { range: returnTypeToken.range }));
+            returnTypeExpr = this.typeExpression();
+            if (!returnTypeExpr.isValidType(this.options.mode)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeExpr.getText())), { range: returnTypeExpr.range }));
                 throw this.lastDiagnosticAsError();
             }
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken));
+        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpr);
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
@@ -313,6 +334,57 @@ class Parser {
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
     }
+    enumDeclaration() {
+        this.warnIfNotBrighterScriptMode('enum declarations');
+        const parentAnnotations = this.enterAnnotationBlock();
+        const tokens = {};
+        const body = [];
+        tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        tokens.name = this.tryIdentifier();
+        this.consumeStatementSeparators();
+        //gather up all members
+        while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
+            try {
+                let decl;
+                //collect leading annotations
+                if (this.check(TokenKind_1.TokenKind.At)) {
+                    this.annotationExpression();
+                }
+                //members
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.enumMemberStatement();
+                    //comments
+                }
+                else if (this.check(TokenKind_1.TokenKind.Comment)) {
+                    decl = this.commentStatement();
+                }
+                if (decl) {
+                    this.consumePendingAnnotations(decl);
+                    body.push(decl);
+                }
+                else {
+                    //we didn't find a declaration...flag tokens until next line
+                    this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+                }
+            }
+            catch (e) {
+                //throw out any failed members and move on to the next line
+                this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
+            }
+            //ensure statement separator
+            this.consumeStatementSeparators();
+            //break out of this loop if we encountered the `EndEnum` token
+            if (this.check(TokenKind_1.TokenKind.EndEnum)) {
+                break;
+            }
+        }
+        //consume the final `end interface` token
+        tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        const result = new Statement_1.EnumStatement(tokens, body, this.currentNamespaceName);
+        this._references.enumStatements.push(result);
+        this.exitAnnotationBlock(parentAnnotations);
+        return result;
+    }
     /**
      * A BrighterScript class declaration
      */
@@ -360,6 +432,8 @@ class Parser {
                     decl = new Statement_1.ClassMethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
                     //refer to this statement as parent of the expression
                     functionStatement.func.functionStatement = decl;
+                    //cache the range property so that plugins can't affect it
+                    decl.cacheRange();
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -400,13 +474,13 @@ class Parser {
     classFieldDeclaration(accessModifier) {
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldType;
+        let fieldTypeExpr;
         //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
-            fieldType = this.typeToken();
+            fieldTypeExpr = this.typeExpression();
             //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType, true, this.currentNamespaceName)) {
+            if (!fieldTypeExpr.isValidType(this.options.mode)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
             }
         }
@@ -417,7 +491,7 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue, this.currentNamespaceName);
+        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldTypeExpr, equal, initialValue, this.currentNamespaceName);
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, forClassMethod = false) {
         var _a, _b, _c, _d;
@@ -467,7 +541,7 @@ class Parser {
             }
             let params = [];
             let asToken;
-            let typeToken;
+            let typeExpr;
             if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
                     if (params.length >= Expression_1.CallExpression.MaximumArguments) {
@@ -479,9 +553,9 @@ class Parser {
             let rightParen = this.advance();
             if (this.check(TokenKind_1.TokenKind.As)) {
                 asToken = this.advance();
-                typeToken = this.typeToken();
-                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
+                typeExpr = this.typeExpression();
+                if (!typeExpr.isValidType(this.options.mode)) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeExpr.getText()) !== null && _a !== void 0 ? _a : '')), { range: typeExpr.range }));
                 }
             }
             params.reduce((haveFoundOptional, param) => {
@@ -493,7 +567,7 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken, //return type
+            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);
             //if there is a parent function, register this function with the parent
             if (this.currentFunctionExpression) {
@@ -537,12 +611,16 @@ class Parser {
             }
             func.callExpressions = this.callExpressions;
             if (isAnonymous) {
+                //cache the range property so that plugins can't affect it
+                func.cacheRange();
                 return func;
             }
             else {
                 let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
                 func.functionStatement = result;
                 this._references.functionStatements.push(result);
+                //cache the range property so that plugins can't affect it
+                result.cacheRange();
                 return result;
             }
         }
@@ -558,7 +636,7 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         const name = this.identifier(...TokenKind_1.AllowedLocalIdentifiers);
-        let typeToken;
+        let typeExpr;
         let defaultValue;
         let equalsToken;
         // parse argument default value
@@ -570,26 +648,26 @@ class Parser {
         let asToken = null;
         if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
-            typeToken = this.typeToken();
-            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+            typeExpr = this.typeExpression();
+            if (!typeExpr.isValidType(this.options.mode)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
                 throw this.lastDiagnosticAsError();
             }
         }
-        let type;
-        if (typeToken) {
-            type = util_1.util.tokenToBscType(typeToken, true, this.currentNamespaceName);
+        let typeInContext;
+        if (typeExpr) {
+            typeInContext = typeExpr.type;
         }
         else if (defaultValue) {
-            type = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
-            if ((0, reflection_1.isInvalidType)(type)) {
-                type = new DynamicType_1.DynamicType();
+            typeInContext = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
+            if ((0, reflection_1.isInvalidType)(typeInContext)) {
+                typeInContext = new DynamicType_1.DynamicType();
             }
         }
         else {
-            type = new DynamicType_1.DynamicType();
+            typeInContext = new DynamicType_1.DynamicType();
         }
-        return new Expression_1.FunctionParameterExpression(name, type, equalsToken, defaultValue, asToken, typeToken, this.currentNamespaceName);
+        return new Expression_1.FunctionParameterExpression(name, typeInContext, equalsToken, defaultValue, asToken, typeExpr, this.currentNamespaceName);
     }
     assignment() {
         let name = this.identifier(...this.allowedLocalIdentifiers);
@@ -709,6 +787,9 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.Namespace)) {
             return this.namespaceStatement();
         }
+        if (this.check(TokenKind_1.TokenKind.Enum)) {
+            return this.enumDeclaration();
+        }
         // TODO: support multi-statements
         return this.setStatement();
     }
@@ -780,6 +861,12 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
+        let itemType = new DynamicType_1.DynamicType();
+        const targetType = getBscTypeFromExpression(target, this.currentFunctionExpression);
+        if ((0, reflection_1.isArrayType)(targetType)) {
+            itemType = targetType.getDefaultType();
+        }
+        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
         this.consumeStatementSeparators();
         let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
@@ -787,12 +874,6 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        let itemType = new DynamicType_1.DynamicType();
-        const targetType = getBscTypeFromExpression(target, this.currentFunctionExpression);
-        if ((0, reflection_1.isArrayType)(targetType)) {
-            itemType = targetType.getDefaultType();
-        }
-        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
         return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
     }
     exitFor() {
@@ -843,6 +924,8 @@ class Parser {
         result.body = body;
         result.endKeyword = endKeyword;
         this._references.namespaceStatements.push(result);
+        //cache the range property so that plugins can't affect it
+        result.cacheRange();
         return result;
     }
     /**
@@ -854,7 +937,8 @@ class Parser {
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
             firstIdentifier.kind = TokenKind_1.TokenKind.Identifier;
-            expr = new Expression_1.VariableExpression(firstIdentifier, null);
+            const varExpr = new Expression_1.VariableExpression(firstIdentifier, null);
+            expr = varExpr;
             //consume multiple dot identifiers (i.e. `Name.Space.Can.Have.Many.Parts`)
             while (this.check(TokenKind_1.TokenKind.Dot)) {
                 let dot = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.Dot);
@@ -924,6 +1008,8 @@ class Parser {
             let leftParen = this.advance();
             annotation.call = this.finishCall(leftParen, annotation, false);
         }
+        //cache the range property so that plugins can't affect it
+        annotation.cacheRange();
         return annotation;
     }
     ternaryExpression(test) {
@@ -1328,12 +1414,10 @@ class Parser {
             if ((0, reflection_1.isIndexedGetExpression)(left)) {
                 return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
                     ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
+                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare, operator);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right));
+                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal ? right : new Expression_1.BinaryExpression(left, operator, right), left.dot, operator);
                 this._references.dottedSetStatements.push(dottedSetStmt);
                 return dottedSetStmt;
             }
@@ -1687,9 +1771,6 @@ class Parser {
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
-        if ((0, reflection_1.isVariableExpression)(callee)) {
-            callee.isCalled = true;
-        }
         let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
         if (addToCallExpressionList) {
             this.callExpressions.push(expression);
@@ -1701,7 +1782,7 @@ class Parser {
      * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
      * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
      */
-    typeToken() {
+    typeExpression() {
         let typeToken;
         if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
             // Token is a built in type
@@ -1722,18 +1803,23 @@ class Parser {
             // just get whatever's next
             typeToken = this.advance();
         }
-        if (typeToken && this.options.mode === ParseMode.BrighterScript) {
+        //TODO: to support InterfaceTypeLiterals - (eg. `{name as string; age as integer}`), check if "typeToken" is a curly bracket, and do something else
+        let typeExpr = new Expression_1.TypeExpression({ type: typeToken }, this.currentNamespaceName);
+        if (this.options.mode === ParseMode.BrighterScript) {
             // Check if it is an array - that is, if it has `[]` after the type
-            // eg. `string[]` or `SomeKlass[]`
-            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
-                this.advance();
+            // eg. `string[]` or `SomeKlass[]` or `float[][][]`
+            while (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                const leftBracket = this.advance();
                 if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
                     const rightBracket = this.advance();
-                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeToken.text + '[]', util_1.util.getRange(typeToken, rightBracket));
+                    typeExpr = new Expression_1.ArrayTypeExpression([typeExpr], { leftBracket: leftBracket, rightBracket: rightBracket }, this.currentNamespaceName);
+                }
+                else {
+                    break;
                 }
             }
         }
-        return typeToken;
+        return typeExpr;
     }
     primary() {
         switch (true) {
@@ -2369,6 +2455,9 @@ class Parser {
             DottedSetStatement: e => {
                 this.addPropertyHints(e.name);
             },
+            EnumStatement: e => {
+                this._references.enumStatements.push(e);
+            },
             UnaryExpression: e => {
                 this._references.expressions.add(e);
             },
@@ -2405,6 +2494,7 @@ var ParseMode;
 })(ParseMode = exports.ParseMode || (exports.ParseMode = {}));
 class References {
     constructor() {
+        this.cache = new Cache_1.Cache();
         this.assignmentStatements = [];
         this.classStatements = [];
         this.dottedSetStatements = [];
@@ -2412,6 +2502,7 @@ class References {
         this.functionExpressions = [];
         this.functionStatements = [];
         this.interfaceStatements = [];
+        this.enumStatements = [];
         /**
          * A collection of full expressions. This excludes intermediary expressions.
          *
@@ -2459,6 +2550,15 @@ class References {
         }
         return this._interfaceStatementLookup;
     }
+    get enumStatementLookup() {
+        return this.cache.getOrAdd('enums', () => {
+            const result = new Map();
+            for (const stmt of this.enumStatements) {
+                result.set(stmt.fullName.toLowerCase(), stmt);
+            }
+            return result;
+        });
+    }
 }
 exports.References = References;
 var TokenUsage;
@@ -2490,7 +2590,7 @@ function getBscTypeFromExpression(expression, functionExpression) {
             //Associative array literal
         }
         else if ((0, reflection_1.isAALiteralExpression)(expression)) {
-            return new ObjectType_1.ObjectType(expression.memberTable);
+            return new ObjectType_1.ObjectType('object', expression.memberTable);
             //Array literal
         }
         else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {