brighterscript 0.70.3 → 0.70.4

package/dist/parser/Parser.d.ts

@@ -1,5 +1,5 @@
 import type { Token } from '../lexer/Token';
-import { AssignmentStatement, Body, ClassStatement, ConstStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement } from './Statement';
+import { AssignmentStatement, Body, ClassStatement, ConstStatement, EnumStatement, FunctionStatement, ImportStatement, InterfaceStatement, LibraryStatement, NamespaceStatement, TypeStatement } from './Statement';
 import { AnnotationExpression, FunctionExpression, NewExpression } from './Expression';
 import type { Diagnostic } from 'vscode-languageserver';
 import type { Logger } from '../logging';
@@ -118,6 +118,7 @@ export declare class Parser {
     private assignment;
     private checkLibrary;
     private checkAlias;
+    private checkTypeStatement;
     private statement;
     private whileStatement;
     private exitWhile;
@@ -146,6 +147,7 @@ export declare class Parser {
     private typecastStatement;
     private aliasStatement;
     private annotationExpression;
+    private typeStatement;
     private ternaryExpression;
     private nullCoalescingExpression;
     private regexLiteralExpression;
@@ -228,6 +230,9 @@ export declare class Parser {
      * Will allow v1 type syntax (typed arrays, union types), but there is no validation on types used this way
      */
     private typeToken;
+    private inlineInterface;
+    private groupedTypeExpression;
+    private typedFunctionType;
     private primary;
     private arrayLiteral;
     private aaLiteral;
@@ -359,6 +364,7 @@ export declare class References {
     importStatements: ImportStatement[];
     libraryStatements: LibraryStatement[];
     namespaceStatements: NamespaceStatement[];
+    typeStatements: TypeStatement[];
     newExpressions: NewExpression[];
     propertyHints: Record<string, string>;
 }

package/dist/parser/Parser.js

@@ -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):
@@ -2523,6 +2681,9 @@ class Parser {
             },
             IncrementStatement: e => {
                 this._references.expressions.add(e);
+            },
+            TypeStatement: (s) => {
+                this._references.typeStatements.push(s);
             }
         }), {
             walkMode: visitors_1.WalkMode.visitAllRecursive
@@ -2564,6 +2725,7 @@ class References {
         this.importStatements = [];
         this.libraryStatements = [];
         this.namespaceStatements = [];
+        this.typeStatements = [];
         this.newExpressions = [];
         this.propertyHints = {};
     }