brighterscript 0.66.0-alpha.1 → 0.66.0-alpha.11

package/dist/parser/Parser.js

@@ -240,10 +240,14 @@ class Parser {
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
      */
-    interfaceFieldStatement() {
+    interfaceFieldStatement(optionalKeyword) {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
-        const [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpression);
+        let asToken;
+        let typeExpression;
+        if (this.check(TokenKind_1.TokenKind.As)) {
+            [asToken, typeExpression] = this.consumeAsTokenAndTypeExpression();
+        }
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpression, optionalKeyword);
     }
     consumeAsTokenAndTypeExpression() {
         let asToken = this.consumeToken(TokenKind_1.TokenKind.As);
@@ -255,6 +259,9 @@ class Parser {
                 //consume the statement separator
                 this.consumeStatementSeparators();
             }
+            else if (this.peek().kind !== TokenKind_1.TokenKind.Identifier && !this.checkAny(...TokenKind_1.DeclarableTypes, ...TokenKind_1.AllowedTypeIdentifiers)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text)), { range: asToken.range }));
+            }
             else {
                 typeExpression = this.typeExpression();
             }
@@ -264,11 +271,19 @@ class Parser {
     /**
      * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
      */
-    interfaceMethodStatement() {
+    interfaceMethodStatement(optionalKeyword) {
         const functionType = this.advance();
         const name = this.identifier(...TokenKind_1.AllowedProperties);
-        const leftParen = this.consumeToken(TokenKind_1.TokenKind.LeftParen);
-        const params = [];
+        const leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedToken(TokenKind_1.TokenKind.LeftParen), TokenKind_1.TokenKind.LeftParen);
+        let params = [];
+        if (!this.check(TokenKind_1.TokenKind.RightParen)) {
+            do {
+                if (params.length >= Expression_1.CallExpression.MaximumArguments) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(params.length, Expression_1.CallExpression.MaximumArguments)), { range: this.peek().range }));
+                }
+                params.push(this.functionParameter());
+            } while (this.match(TokenKind_1.TokenKind.Comma));
+        }
         const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
         // let asToken = null as Token;
         // let returnTypeExpression: TypeExpression;
@@ -277,13 +292,13 @@ class Parser {
         if (this.check(TokenKind_1.TokenKind.As)) {
             [asToken, returnTypeExpression] = this.consumeAsTokenAndTypeExpression();
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpression);
+        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpression, optionalKeyword);
     }
     interfaceDeclaration() {
         this.warnIfNotBrighterScriptMode('interface declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         const interfaceToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Interface), TokenKind_1.TokenKind.Interface);
-        const nameToken = this.identifier();
+        const nameToken = this.identifier(...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
@@ -305,13 +320,20 @@ class Parser {
                 if (this.check(TokenKind_1.TokenKind.At)) {
                     this.annotationExpression();
                 }
+                const optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
                 //fields
-                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_1.TokenKind.As)) {
+                if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkAnyNext(TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                    decl = this.interfaceFieldStatement(optionalKeyword);
+                    //field with name = 'optional'
+                }
+                else if (optionalKeyword && this.checkAny(TokenKind_1.TokenKind.As, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
+                    //rewind one place, so that 'optional' is the field name
+                    this.current--;
                     decl = this.interfaceFieldStatement();
                     //methods (function/sub keyword followed by opening paren)
                 }
-                else if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
-                    decl = this.interfaceMethodStatement();
+                else if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) && this.checkAnyNext(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+                    decl = this.interfaceMethodStatement(optionalKeyword);
                     //comments
                 }
                 else if (this.check(TokenKind_1.TokenKind.Comment)) {
@@ -349,7 +371,7 @@ class Parser {
         this.warnIfNotBrighterScriptMode('enum declarations');
         const parentAnnotations = this.enterAnnotationBlock();
         result.tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
-        result.tokens.name = this.tryIdentifier();
+        result.tokens.name = this.tryIdentifier(...this.allowedLocalIdentifiers);
         this.consumeStatementSeparators();
         //gather up all members
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
@@ -480,6 +502,32 @@ class Parser {
         return result;
     }
     fieldDeclaration(accessModifier) {
+        let optionalKeyword = this.consumeTokenIf(TokenKind_1.TokenKind.Optional);
+        if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
+            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--;
+        }
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
         let fieldTypeExpression;
@@ -494,7 +542,7 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldTypeExpression, equal, initialValue);
+        return new Statement_1.FieldStatement(accessModifier, name, asToken, fieldTypeExpression, equal, initialValue, optionalKeyword);
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
         var _a;
@@ -518,7 +566,8 @@ class Parser {
                         start: this.peek().range.start,
                         end: this.peek().range.start
                     },
-                    leadingWhitespace: ''
+                    leadingWhitespace: '',
+                    leadingTrivia: []
                 };
             }
             let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === TokenKind_1.TokenKind.Sub;
@@ -1363,9 +1412,9 @@ class Parser {
         if ((0, reflection_1.isCallExpression)(expr) || (0, reflection_1.isCallfuncExpression)(expr)) {
             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
+        //at this point, it's probably an error. However, we recover a little more gracefully by creating an inclosing ExpressionStatement
         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression()), { range: expressionStart.range }));
-        throw this.lastDiagnosticAsError();
+        return new Statement_1.ExpressionStatement(expr);
     }
     setStatement() {
         /**
@@ -1394,6 +1443,7 @@ class Parser {
         return this.expressionStatement(expr);
     }
     printStatement() {
+        var _a;
         let printKeyword = this.advance();
         let values = [];
         while (!this.checkEndOfStatement()) {
@@ -1412,7 +1462,8 @@ class Parser {
         }
         //print statements can be empty, so look for empty print conditions
         if (!values.length) {
-            let emptyStringLiteral = (0, creators_1.createStringLiteral)('');
+            const endOfStatementRange = util_1.util.createRangeFromPositions(printKeyword.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
+            let emptyStringLiteral = (0, creators_1.createStringLiteral)('', endOfStatementRange);
             values.push(emptyStringLiteral);
         }
         let last = values[values.length - 1];
@@ -1569,6 +1620,7 @@ class Parser {
         if (findTypeCast) {
             do {
                 if (this.check(TokenKind_1.TokenKind.As)) {
+                    this.warnIfNotBrighterScriptMode('type cast');
                     // Check if this expression is wrapped in any type casts
                     // allows for multiple casts:
                     // myVal = foo() as dynamic as string
@@ -1667,10 +1719,18 @@ class Parser {
     }
     prefixUnary() {
         const nextKind = this.peek().kind;
-        if (nextKind === TokenKind_1.TokenKind.Not || nextKind === TokenKind_1.TokenKind.Minus) {
+        if (nextKind === TokenKind_1.TokenKind.Not) {
             this.current++; //advance
             let operator = this.previous();
-            let right = this.prefixUnary();
+            let right = this.relational();
+            return new Expression_1.UnaryExpression(operator, right);
+        }
+        else if (nextKind === TokenKind_1.TokenKind.Minus || nextKind === TokenKind_1.TokenKind.Plus) {
+            this.current++; //advance
+            let operator = this.previous();
+            let right = nextKind === TokenKind_1.TokenKind.Not
+                ? this.boolean()
+                : this.prefixUnary();
             return new Expression_1.UnaryExpression(operator, right);
         }
         return this.call();
@@ -1692,10 +1752,18 @@ class Parser {
         return new Expression_1.IndexedGetExpression(expr, index, openingSquare, closingSquare, questionDotToken);
     }
     newExpression() {
+        var _a;
         this.warnIfNotBrighterScriptMode(`using 'new' keyword to construct a class`);
         let newToken = this.advance();
         let nameExpr = this.identifyingExpression();
-        let leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
+        let leftParen = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken(this.peek().text), TokenKind_1.TokenKind.LeftParen, TokenKind_1.TokenKind.QuestionLeftParen);
+        if (!leftParen) {
+            // new expression without a following call expression
+            // wrap the name in an expression
+            const endOfStatementRange = util_1.util.createRangeFromPositions(newToken.range.end, (_a = this.peek()) === null || _a === void 0 ? void 0 : _a.range.end);
+            const exprStmt = nameExpr !== null && nameExpr !== void 0 ? nameExpr : (0, creators_1.createStringLiteral)('', endOfStatementRange);
+            return new Statement_1.ExpressionStatement(exprStmt);
+        }
         let call = this.finishCall(leftParen, nameExpr);
         //pop the call from the  callExpressions list because this is technically something else
         this.callExpressions.pop();
@@ -1810,7 +1878,9 @@ class Parser {
         const changedTokens = [];
         try {
             let expr = this.getTypeExpressionPart(changedTokens);
-            while (this.matchAny(TokenKind_1.TokenKind.Or)) {
+            while (this.options.mode === ParseMode.BrighterScript && this.matchAny(TokenKind_1.TokenKind.Or)) {
+                // If we're in Brighterscript mode, allow union types with "or" between types
+                // TODO: Handle Union types in parens? eg. "(string or integer)"
                 let operator = this.previous();
                 let right = this.getTypeExpressionPart(changedTokens);
                 if (right) {
@@ -1832,6 +1902,13 @@ class Parser {
             throw error;
         }
     }
+    /**
+     * Gets a single "part" of a type of a potential Union type
+     * Note: this does not NEED to be part of a union type, but the logic is the same
+     *
+     * @param changedTokens an array that is modified with any tokens that have been changed from their default kind to identifiers - eg. when a keyword is used as type
+     * @returns an expression that was successfully parsed
+     */
     getTypeExpressionPart(changedTokens) {
         let expr;
         if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
@@ -1850,6 +1927,25 @@ class Parser {
                 this._references.expressions.add(expr);
             }
         }
+        //Check if it has square brackets, thus making it an array
+        if (expr && this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+            if (this.options.mode === ParseMode.BrightScript) {
+                // typed arrays not allowed in Brightscript
+                this.warnIfNotBrighterScriptMode('typed arrays');
+                return expr;
+            }
+            // Check if it is an array - that is, if it has `[]` after the type
+            // eg. `string[]` or `SomeKlass[]`
+            // This is while loop, so it supports multidimensional arrays (eg. integer[][])
+            while (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                const leftBracket = this.advance();
+                if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
+                    const rightBracket = this.advance();
+                    expr = new Expression_1.TypedArrayExpression(expr, leftBracket, rightBracket);
+                    this._references.expressions.add(expr);
+                }
+            }
+        }
         return expr;
     }
     primary() {