brighterscript 0.70.3 → 0.71.0

package/dist/parser/Parser.js

@@ -66,7 +66,7 @@ class Parser {
         }
         else {
             for (const member of item.elements) {
-                if (!(0, reflection_1.isCommentStatement)(member)) {
+                if (!(0, reflection_1.isCommentStatement)(member) && (0, reflection_1.isAAMemberExpression)(member) && member.keyToken) {
                     const name = member.keyToken.text;
                     if (!name.startsWith('"')) {
                         this._references.propertyHints[name.toLowerCase()] = name;
@@ -743,6 +743,22 @@ class Parser {
             return false;
         }
     }
+    checkTypeStatement() {
+        let isTypeToken = this.check(TokenKind_1.TokenKind.Type);
+        //if we are at the top level, any line that starts with "type" should be considered a type statement
+        if (this.isAtRootLevel() && isTypeToken) {
+            return true;
+            //not at root level, type statements are all invalid here, but try to detect if the tokens look
+            //like a type statement (and let the type function handle emitting the diagnostics)
+        }
+        else if (isTypeToken && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
+            return true;
+            //definitely not a type statement
+        }
+        else {
+            return false;
+        }
+    }
     statement() {
         if (this.checkLibrary()) {
             return this.libraryStatement();
@@ -756,6 +772,9 @@ class Parser {
         if (this.checkAlias()) {
             return this.aliasStatement();
         }
+        if (this.checkTypeStatement()) {
+            return this.typeStatement();
+        }
         if (this.check(TokenKind_1.TokenKind.Stop)) {
             return this.stopStatement();
         }
@@ -919,6 +938,11 @@ class Parser {
     forEachStatement() {
         let forEach = this.advance();
         let name = this.advance();
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            this.warnIfNotBrighterScriptMode('typed for each item');
+            this.advance(); // get 'as'
+            this.typeToken(); // get type
+        }
         let maybeIn = this.peek();
         if (this.check(TokenKind_1.TokenKind.Identifier) && maybeIn.text.toLowerCase() === 'in') {
             this.advance();
@@ -1126,6 +1150,21 @@ class Parser {
         }
         return annotation;
     }
+    typeStatement() {
+        this.warnIfNotBrighterScriptMode('type statements');
+        const typeToken = this.advance();
+        const name = this.identifier(...this.allowedLocalIdentifiers);
+        const equals = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.Equal), TokenKind_1.TokenKind.Equal);
+        let value = this.typeToken();
+        let typeStmt = new Statement_1.TypeStatement({
+            type: typeToken,
+            name: name,
+            equals: equals,
+            value: value
+        });
+        this._references.typeStatements.push(typeStmt);
+        return typeStmt;
+    }
     ternaryExpression(test) {
         this.warnIfNotBrighterScriptMode('ternary operator');
         if (!test) {
@@ -1507,6 +1546,24 @@ class Parser {
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
             return new Statement_1.ExpressionStatement(expr);
         }
+        //you're not allowed to do dottedGet or XmlAttrGet after a function call
+        if ((0, reflection_1.isDottedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Property')), { range: util_1.util.createBoundingRange(expr.dot, expr.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement(expr);
+            //you're not allowed to do indexedGet expressions after a function call
+        }
+        else if ((0, reflection_1.isIndexedGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('Index')), { range: util_1.util.createBoundingRange(expr.openingSquare, expr.index, expr.closingSquare) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.ExpressionStatement(expr);
+            //you're not allowed to do XmlAttrGet after a function call
+        }
+        else if ((0, reflection_1.isXmlAttributeGetExpression)(expr)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.propAccessNotPermittedAfterFunctionCallInExpressionStatement('XML attribute')), { range: util_1.util.createBoundingRange(expr.at, expr.name) }));
+            //we can recover gracefully here even though it's invalid syntax
+            return new Statement_1.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 }));
         throw this.lastDiagnosticAsError();
@@ -1974,20 +2031,35 @@ class Parser {
      */
     typeToken(ignoreDiagnostics = false) {
         let typeToken;
-        let lookForUnions = true;
-        let isAUnion = false;
+        let lookForCompounds = true;
+        let isACompound = false;
         let resultToken;
-        while (lookForUnions) {
-            lookForUnions = false;
-            if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
+        while (lookForCompounds) {
+            lookForCompounds = false;
+            const isTypedFunction = this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkNext(TokenKind_1.TokenKind.LeftParen);
+            if (this.checkAny(...TokenKind_1.DeclarableTypes) && !isTypedFunction) {
                 // 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(ignoreDiagnostics);
-                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                    if (this.check(TokenKind_1.TokenKind.LeftCurlyBrace)) {
+                        // could be an inline interface
+                        typeToken = this.inlineInterface();
+                    }
+                    else if (this.check(TokenKind_1.TokenKind.LeftParen)) {
+                        // could be an inline interface
+                        typeToken = this.groupedTypeExpression();
+                    }
+                    else if (isTypedFunction) {
+                        //typed function type
+                        typeToken = this.typedFunctionType();
+                    }
+                    else {
+                        // see if we can get a namespaced identifer
+                        const qualifiedType = this.getNamespacedVariableNameExpression(ignoreDiagnostics);
+                        typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, qualifiedType.getName(this.options.mode), qualifiedType.range);
+                    }
                 }
                 catch (_a) {
                     //could not get an identifier - just get whatever's next
@@ -2000,26 +2072,112 @@ class Parser {
             }
             resultToken = resultToken !== null && resultToken !== void 0 ? resultToken : typeToken;
             if (resultToken && this.options.mode === ParseMode.BrighterScript) {
-                // check for brackets
+                // check for brackets for typed arrays
                 while (this.check(TokenKind_1.TokenKind.LeftSquareBracket) && this.peekNext().kind === TokenKind_1.TokenKind.RightSquareBracket) {
                     const leftBracket = this.advance();
                     const rightBracket = this.advance();
                     typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeToken.text + leftBracket.text + rightBracket.text, util_1.util.createBoundingRange(typeToken, leftBracket, rightBracket));
                     resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, typeToken.range);
                 }
-                if (this.check(TokenKind_1.TokenKind.Or)) {
-                    lookForUnions = true;
+                if (this.checkAny(TokenKind_1.TokenKind.Or, TokenKind_1.TokenKind.And)) {
+                    lookForCompounds = true;
                     let orToken = this.advance();
                     resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(resultToken, typeToken, orToken));
-                    isAUnion = true;
+                    isACompound = true;
                 }
             }
         }
-        if (isAUnion) {
+        if (isACompound) {
             resultToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(resultToken, typeToken));
         }
         return resultToken;
     }
+    inlineInterface() {
+        const openToken = this.advance();
+        const memberTokens = [];
+        memberTokens.push(openToken);
+        while (this.matchAny(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) { }
+        while (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral, TokenKind_1.TokenKind.Optional)) {
+            let optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
+            if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral)) {
+                if (this.check(TokenKind_1.TokenKind.As)) {
+                    if (this.checkAnyNext(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Newline)) {
+                        // as <EOL>
+                        // `as` is the field name
+                    }
+                    else if (this.checkNext(TokenKind_1.TokenKind.As)) {
+                        //  as as ____
+                        // first `as` is the field name
+                    }
+                    else if (optionalKeyword) {
+                        // optional as ____
+                        // optional is the field name, `as` starts type
+                        // rewind current token
+                        optionalKeyword = null;
+                        this.current--;
+                    }
+                }
+            }
+            else {
+                // no name after `optional` ... optional is the name
+                // rewind current token
+                optionalKeyword = null;
+                this.current--;
+            }
+            if (optionalKeyword) {
+                memberTokens.push(optionalKeyword);
+            }
+            if (!this.checkAny(TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers, TokenKind_1.TokenKind.StringLiteral)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { range: this.peek().range }));
+                throw this.lastDiagnosticAsError();
+            }
+            if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties, TokenKind_1.TokenKind.StringLiteral)) {
+                this.advance();
+            }
+            else {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { range: this.peek().range }));
+                throw this.lastDiagnosticAsError();
+            }
+            if (this.check(TokenKind_1.TokenKind.As)) {
+                memberTokens.push(this.advance()); // as
+                memberTokens.push(this.typeToken()); // type
+            }
+            while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) { }
+        }
+        if (!this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text)), { range: this.peek().range }));
+            throw this.lastDiagnosticAsError();
+        }
+        const closeToken = this.advance();
+        memberTokens.push(closeToken);
+        const completeInlineInterfaceToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(...memberTokens));
+        return completeInlineInterfaceToken;
+    }
+    groupedTypeExpression() {
+        const leftParen = this.advance();
+        const typeToken = this.typeToken();
+        const rightParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.RightParen), TokenKind_1.TokenKind.RightParen);
+        return (0, creators_1.createToken)(TokenKind_1.TokenKind.Dynamic, null, util_1.util.createBoundingRange(leftParen, typeToken, rightParen));
+    }
+    typedFunctionType() {
+        const funcOrSub = this.advance();
+        const leftParen = this.advance();
+        let params = [];
+        if (!this.check(TokenKind_1.TokenKind.RightParen)) {
+            do {
+                params.push(this.functionParameter());
+            } while (this.match(TokenKind_1.TokenKind.Comma));
+        }
+        const rightParen = this.advance();
+        let asToken;
+        let returnType;
+        if ((this.check(TokenKind_1.TokenKind.As))) {
+            // this is a function type with a return type, e.g. `function(string) as void`
+            asToken = this.advance();
+            returnType = this.typeToken();
+        }
+        return (0, creators_1.createToken)(TokenKind_1.TokenKind.Function, null, util_1.util.createBoundingRange(funcOrSub, leftParen, rightParen, asToken, returnType));
+    }
     primary() {
         switch (true) {
             case this.matchAny(TokenKind_1.TokenKind.False, TokenKind_1.TokenKind.True, TokenKind_1.TokenKind.Invalid, TokenKind_1.TokenKind.IntegerLiteral, TokenKind_1.TokenKind.LongIntegerLiteral, TokenKind_1.TokenKind.FloatLiteral, TokenKind_1.TokenKind.DoubleLiteral, TokenKind_1.TokenKind.StringLiteral):
@@ -2108,12 +2266,22 @@ class Parser {
         let openingBrace = this.previous();
         let members = [];
         let key = () => {
+            var _a;
             let result = {
-                colonToken: null,
+                colon: null,
                 keyToken: null,
+                key: null,
+                leftBracket: null,
+                rightBracket: null,
                 range: null
             };
-            if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                // Computed key: [expr]
+                result.leftBracket = this.advance();
+                result.key = this.expression();
+                result.rightBracket = this.tryConsumeToken(TokenKind_1.TokenKind.RightSquareBracket);
+            }
+            else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
                 result.keyToken = this.identifier(...TokenKind_1.AllowedProperties);
             }
             else if (this.check(TokenKind_1.TokenKind.StringLiteral)) {
@@ -2123,8 +2291,8 @@ class Parser {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedAAKey()), { range: this.peek().range }));
                 throw this.lastDiagnosticAsError();
             }
-            result.colonToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
-            result.range = util_1.util.getRange(result.keyToken, result.colonToken);
+            result.colon = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedColonBetweenAAKeyAndvalue(), TokenKind_1.TokenKind.Colon);
+            result.range = util_1.util.getRange((_a = result.keyToken) !== null && _a !== void 0 ? _a : result.leftBracket, result.colon);
             return result;
         };
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
@@ -2139,7 +2307,9 @@ class Parser {
                 else {
                     let k = key();
                     let expr = this.expression();
-                    lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                    lastAAMember = k.key
+                        ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                        : new Expression_1.AAMemberExpression(k.keyToken, k.colon, expr);
                     members.push(lastAAMember);
                 }
                 while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
@@ -2166,7 +2336,9 @@ class Parser {
                         }
                         let k = key();
                         let expr = this.expression();
-                        lastAAMember = new Expression_1.AAMemberExpression(k.keyToken, k.colonToken, expr);
+                        lastAAMember = k.key
+                            ? new Expression_1.AAIndexedMemberExpression({ leftBracket: k.leftBracket, key: k.key, rightBracket: k.rightBracket, colon: k.colon, value: expr })
+                            : new Expression_1.AAMemberExpression(k.keyToken, k.colon, expr);
                         members.push(lastAAMember);
                     }
                 }
@@ -2483,6 +2655,10 @@ class Parser {
                     if ((0, reflection_1.isAAMemberExpression)(member)) {
                         this._references.expressions.add(member.value);
                     }
+                    else if ((0, reflection_1.isAAIndexedMemberExpression)(member)) {
+                        this._references.expressions.add(member.value);
+                        this._references.expressions.add(member.key);
+                    }
                 }
             },
             BinaryExpression: (e, parent) => {
@@ -2523,6 +2699,9 @@ class Parser {
             },
             IncrementStatement: e => {
                 this._references.expressions.add(e);
+            },
+            TypeStatement: (s) => {
+                this._references.typeStatements.push(s);
             }
         }), {
             walkMode: visitors_1.WalkMode.visitAllRecursive
@@ -2564,6 +2743,7 @@ class References {
         this.importStatements = [];
         this.libraryStatements = [];
         this.namespaceStatements = [];
+        this.typeStatements = [];
         this.newExpressions = [];
         this.propertyHints = {};
     }