brighterscript 0.65.1 → 0.66.0-alpha.0

package/dist/parser/Parser.js

@@ -242,14 +242,24 @@ class Parser {
      */
     interfaceFieldStatement() {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
+        const [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpression);
+    }
+    consumeAsTokenAndTypeExpression() {
         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 }));
-            throw this.lastDiagnosticAsError();
+        let typeExpression;
+        if (asToken) {
+            //if there's nothing after the `as`, add a diagnostic and continue
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+                //consume the statement separator
+                this.consumeStatementSeparators();
+            }
+            else {
+                typeExpression = this.typeExpression();
+            }
         }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type);
+        return [asToken, typeExpression];
     }
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
@@ -260,18 +270,14 @@ class Parser {
         const leftParen = this.consumeToken(TokenKind_1.TokenKind.LeftParen);
         const params = [];
         const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
-        let asToken = null;
-        let returnTypeToken = null;
+        // let asToken = null as Token;
+        // let returnTypeExpression: TypeExpression;
+        let asToken;
+        let returnTypeExpression;
         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 }));
-                throw this.lastDiagnosticAsError();
-            }
+            [asToken, returnTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        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, returnTypeExpression);
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
@@ -282,7 +288,12 @@ class Parser {
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsToken = this.advance();
-            parentInterfaceName = this.getNamespacedVariableNameExpression();
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsToken.text)), { range: extendsToken.range }));
+            }
+            else {
+                parentInterfaceName = this.typeExpression();
+            }
         }
         this.consumeStatementSeparators();
         //gather up all interface members (Fields, Methods)
@@ -396,7 +407,12 @@ class Parser {
         //see if the class inherits from parent
         if (this.peek().text.toLowerCase() === 'extends') {
             extendsKeyword = this.advance();
-            parentClassName = this.getNamespacedVariableNameExpression();
+            if (this.checkEndOfStatement()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(extendsKeyword.text)), { range: extendsKeyword.range }));
+            }
+            else {
+                parentClassName = this.typeExpression();
+            }
         }
         //ensure statement separator
         this.consumeStatementSeparators();
@@ -466,15 +482,10 @@ class Parser {
     fieldDeclaration(accessModifier) {
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldType;
+        let fieldTypeExpression;
         //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.advance();
-            fieldType = this.typeToken();
-            //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
-            }
+            [asToken, fieldTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
         let initialValue;
         let equal;
@@ -483,10 +494,10 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue);
+        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldTypeExpression, equal, initialValue);
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
-        var _a, _b;
+        var _a;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -533,7 +544,7 @@ class Parser {
             }
             let params = [];
             let asToken;
-            let typeToken;
+            let typeExpression;
             if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
                     if (params.length >= Expression_1.CallExpression.MaximumArguments) {
@@ -544,11 +555,7 @@ 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.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
-                }
+                [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
             }
             params.reduce((haveFoundOptional, param) => {
                 if (haveFoundOptional && !param.defaultValue) {
@@ -559,12 +566,7 @@ class Parser {
             this.consumeStatementSeparators(true);
             let func = new Expression_1.FunctionExpression(params, undefined, //body
             functionType, undefined, //ending keyword
-            leftParen, rightParen, asToken, typeToken);
-            // add the function to the relevant symbol tables
-            if (!onlyCallableAsMember && name) {
-                const funcType = func.getFunctionType();
-                funcType.setName(name.text);
-            }
+            leftParen, rightParen, asToken, typeExpression);
             this._references.functionExpressions.push(func);
             //support ending the function with `end sub` OR `end function`
             func.body = this.block();
@@ -572,7 +574,7 @@ class Parser {
             if (!func.body) {
                 func.body = new Statement_1.Block([], util_1.util.createRangeFromPositions(func.range.start, func.range.start));
             }
-            func.body.symbolTable = new SymbolTable_1.SymbolTable(`Block: Function '${(_b = name === null || name === void 0 ? void 0 : name.text) !== null && _b !== void 0 ? _b : ''}'`, () => func.getSymbolTable());
+            func.body.symbolTable = new SymbolTable_1.SymbolTable(`Block: Function '${(_a = name === null || name === void 0 ? void 0 : name.text) !== null && _a !== void 0 ? _a : ''}'`, () => func.getSymbolTable());
             if (!func.body) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionTypeText)), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
@@ -611,22 +613,19 @@ class Parser {
         let name = this.advance();
         // force the name into an identifier so the AST makes some sense
         name.kind = TokenKind_1.TokenKind.Identifier;
-        let typeToken;
+        let typeExpression;
         let defaultValue;
+        let equalToken;
         // parse argument default value
-        if (this.match(TokenKind_1.TokenKind.Equal)) {
+        if ((equalToken = this.consumeTokenIf(TokenKind_1.TokenKind.Equal))) {
             // it seems any expression is allowed here -- including ones that operate on other arguments!
-            defaultValue = this.expression();
+            defaultValue = this.expression(false);
         }
         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.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
-            }
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        return new Expression_1.FunctionParameterExpression(name, typeToken, defaultValue, asToken);
+        return new Expression_1.FunctionParameterExpression(name, equalToken, defaultValue, asToken, typeExpression);
     }
     assignment() {
         let name = this.advance();
@@ -863,7 +862,7 @@ class Parser {
         this.warnIfNotBrighterScriptMode('namespace');
         let keyword = this.advance();
         this.namespaceAndFunctionDepth++;
-        let name = this.getNamespacedVariableNameExpression();
+        let name = this.identifyingExpression();
         //set the current namespace name
         let result = new Statement_1.NamespaceStatement(keyword, name, null, null);
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
@@ -889,8 +888,9 @@ class Parser {
     /**
      * Get an expression with identifiers separated by periods. Useful for namespaces and class extends
      */
-    getNamespacedVariableNameExpression() {
-        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+    identifyingExpression(allowedTokenKinds) {
+        allowedTokenKinds = allowedTokenKinds !== null && allowedTokenKinds !== void 0 ? allowedTokenKinds : this.allowedLocalIdentifiers;
+        let firstIdentifier = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(this.previous().text), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds);
         let expr;
         if (firstIdentifier) {
             // force it into an identifier so the AST makes some sense
@@ -903,7 +903,7 @@ class Parser {
                 if (!dot) {
                     break;
                 }
-                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, ...TokenKind_1.AllowedProperties);
+                let identifier = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier(), TokenKind_1.TokenKind.Identifier, ...allowedTokenKinds, ...TokenKind_1.AllowedProperties);
                 if (!identifier) {
                     break;
                 }
@@ -912,7 +912,7 @@ class Parser {
                 expr = new Expression_1.DottedGetExpression(expr, identifier, dot);
             }
         }
-        return new Expression_1.NamespacedVariableNameExpression(expr);
+        return expr;
     }
     /**
      * Add an 'unexpected token' diagnostic for any token found between current and the first stopToken found.
@@ -1562,8 +1562,26 @@ class Parser {
         }
         this.pendingAnnotations = parentAnnotations;
     }
-    expression() {
-        const expression = this.anonymousFunction();
+    expression(findTypeCast = true) {
+        let expression = this.anonymousFunction();
+        let asToken;
+        let typeExpression;
+        if (findTypeCast) {
+            do {
+                if (this.check(TokenKind_1.TokenKind.As)) {
+                    // Check if this expression is wrapped in any type casts
+                    // allows for multiple casts:
+                    // myVal = foo() as dynamic as string
+                    [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+                    if (asToken && typeExpression) {
+                        expression = new Expression_1.TypeCastExpression(expression, asToken, typeExpression);
+                    }
+                }
+                else {
+                    break;
+                }
+            } while (asToken && typeExpression);
+        }
         this._references.expressions.add(expression);
         return expression;
     }
@@ -1676,7 +1694,7 @@ class Parser {
     newExpression() {
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
-        let nameExpr = this.getNamespacedVariableNameExpression();
+        let nameExpr = this.identifyingExpression();
         let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
         let call = this.finishCall(leftParen, nameExpr);
         //pop the call from the  callExpressions list because this is technically something else
@@ -1786,32 +1804,53 @@ class Parser {
         return expression;
     }
     /**
-     * Tries to get the next token as a type
-     * 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
+     * Creates a TypeExpression, which wraps standard ASTNodes that represent a BscType
      */
-    typeToken() {
-        let typeToken;
-        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
-            // Token is a built in type
-            typeToken = this.advance();
-        }
-        else if (this.options.mode === ParseMode.BrighterScript) {
-            try {
-                // see if we can get a namespaced identifer
-                const qualifiedType = this.getNamespacedVariableNameExpression();
-                typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+    typeExpression() {
+        const changedTokens = [];
+        try {
+            let expr = this.getTypeExpressionPart(changedTokens);
+            while (this.matchAny(TokenKind_1.TokenKind.Or)) {
+                let operator = this.previous();
+                let right = this.getTypeExpressionPart(changedTokens);
+                if (right) {
+                    expr = new Expression_1.BinaryExpression(expr, operator, right);
+                }
+                else {
+                    break;
+                }
             }
-            catch (_a) {
-                //could not get an identifier - just get whatever's next
-                typeToken = this.advance();
+            if (expr) {
+                return new Expression_1.TypeExpression(expr);
             }
         }
+        catch (error) {
+            // Something went wrong - reset the kind to what it was previously
+            for (const changedToken of changedTokens) {
+                changedToken.token.kind = changedToken.oldKind;
+            }
+            throw error;
+        }
+    }
+    getTypeExpressionPart(changedTokens) {
+        let expr;
+        if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+            // if this is just a type, just use directly
+            expr = new Expression_1.VariableExpression(this.advance());
+        }
         else {
-            // just get whatever's next
-            typeToken = this.advance();
+            if (this.checkAny(...TokenKind_1.AllowedTypeIdentifiers)) {
+                // Since the next token is allowed as a type identifier, change the kind
+                let nextToken = this.peek();
+                changedTokens.push({ token: nextToken, oldKind: nextToken.kind });
+                nextToken.kind = TokenKind_1.TokenKind.Identifier;
+            }
+            expr = this.identifyingExpression(TokenKind_1.AllowedTypeIdentifiers);
+            if (expr) {
+                this._references.expressions.add(expr);
+            }
         }
-        return typeToken;
+        return expr;
     }
     primary() {
         switch (true) {
@@ -2028,6 +2067,14 @@ class Parser {
             throw error;
         }
     }
+    /**
+     * Consume next token IF it matches the specified kind. Otherwise, do nothing and return undefined
+     */
+    consumeTokenIf(tokenKind) {
+        if (this.match(tokenKind)) {
+            return this.previous();
+        }
+    }
     consumeToken(tokenKind) {
         return this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(tokenKind), tokenKind);
     }
@@ -2219,7 +2266,7 @@ class Parser {
             ClassStatement: s => {
                 this._references.classStatements.push(s);
             },
-            ClassFieldStatement: s => {
+            FieldStatement: s => {
                 if (s.initialValue) {
                     this._references.expressions.add(s.initialValue);
                 }