brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.28

package/dist/parser/Parser.js

@@ -11,7 +11,6 @@ const Expression_1 = require("./Expression");
 const Logger_1 = require("../Logger");
 const reflection_1 = require("../astUtils/reflection");
 const creators_1 = require("../astUtils/creators");
-const SymbolTable_1 = require("../SymbolTable");
 class Parser {
     constructor() {
         /**
@@ -28,6 +27,13 @@ class Parser {
          */
         this.callExpressions = [];
     }
+    get eofToken() {
+        var _a;
+        const lastToken = (_a = this.tokens) === null || _a === void 0 ? void 0 : _a[this.tokens.length - 1];
+        if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.kind) === TokenKind_1.TokenKind.Eof) {
+            return lastToken;
+        }
+    }
     get statements() {
         return this.ast.statements;
     }
@@ -57,16 +63,17 @@ class Parser {
      */
     parse(toParse, options) {
         var _a;
+        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : new Logger_1.Logger();
+        options = this.sanitizeParseOptions(options);
+        this.options = options;
         let tokens;
         if (typeof toParse === 'string') {
-            tokens = Lexer_1.Lexer.scan(toParse).tokens;
+            tokens = Lexer_1.Lexer.scan(toParse, { trackLocations: options.trackLocations }).tokens;
         }
         else {
             tokens = toParse;
         }
-        this.logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : new Logger_1.Logger();
         this.tokens = tokens;
-        this.options = this.sanitizeParseOptions(options);
         this.allowedLocalIdentifiers = [
             ...TokenKind_1.AllowedLocalIdentifiers,
             //when in plain brightscript mode, the BrighterScript source literals can be used as regular variables
@@ -115,7 +122,11 @@ class Parser {
         return body;
     }
     sanitizeParseOptions(options) {
-        return Object.assign({ mode: 'brightscript' }, (options || {}));
+        var _a, _b;
+        options !== null && options !== void 0 ? options : (options = {});
+        (_a = options.mode) !== null && _a !== void 0 ? _a : (options.mode = ParseMode.BrightScript);
+        (_b = options.trackLocations) !== null && _b !== void 0 ? _b : (options.trackLocations = true);
+        return options;
     }
     /**
      * Determine if the parser is currently parsing tokens at the root level.
@@ -155,9 +166,6 @@ class Parser {
             if (this.check(TokenKind_1.TokenKind.At) && this.checkNext(TokenKind_1.TokenKind.Identifier)) {
                 return this.annotationExpression();
             }
-            if (this.check(TokenKind_1.TokenKind.Comment)) {
-                return this.commentStatement();
-            }
             //catch certain global terminators to prevent unnecessary lookahead (i.e. like `end namespace`, no need to continue)
             if (this.checkAny(...this.peekGlobalTerminators())) {
                 return;
@@ -190,13 +198,15 @@ class Parser {
         return identifier;
     }
     enumMemberStatement() {
-        const statement = new Statement_1.EnumMemberStatement({});
-        statement.tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        const name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+        let equalsToken;
+        let value;
         //look for `= SOME_EXPRESSION`
         if (this.check(TokenKind_1.TokenKind.Equal)) {
-            statement.tokens.equals = this.advance();
-            statement.value = this.expression();
+            equalsToken = this.advance();
+            value = this.expression();
         }
+        const statement = new Statement_1.EnumMemberStatement({ name: name, equals: equalsToken, value: value });
         return statement;
     }
     /**
@@ -290,6 +300,10 @@ class Parser {
         let body = [];
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
+                //break out of this loop if we encountered the `EndInterface` token not followed by `as`
+                if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
+                    break;
+                }
                 let decl;
                 //collect leading annotations
                 if (this.check(TokenKind_1.TokenKind.At)) {
@@ -309,10 +323,6 @@ class Parser {
                 }
                 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)) {
-                    decl = this.commentStatement();
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
@@ -329,10 +339,6 @@ class Parser {
             }
             //ensure statement separator
             this.consumeStatementSeparators();
-            //break out of this loop if we encountered the `EndInterface` token not followed by `as`
-            if (this.check(TokenKind_1.TokenKind.EndInterface) && !this.checkNext(TokenKind_1.TokenKind.As)) {
-                break;
-            }
         }
         //consume the final `end interface` token
         const endInterfaceToken = this.consumeToken(TokenKind_1.TokenKind.EndInterface);
@@ -348,12 +354,12 @@ class Parser {
         return statement;
     }
     enumDeclaration() {
-        const result = new Statement_1.EnumStatement({ name: {}, body: [] });
+        const enumToken = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        const nameToken = this.tryIdentifier(...this.allowedLocalIdentifiers);
         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(...this.allowedLocalIdentifiers);
         this.consumeStatementSeparators();
+        const body = [];
         //gather up all members
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
             try {
@@ -365,14 +371,10 @@ class Parser {
                 //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);
-                    result.body.push(decl);
+                    body.push(decl);
                 }
                 else {
                     //we didn't find a declaration...flag tokens until next line
@@ -391,7 +393,13 @@ class Parser {
             }
         }
         //consume the final `end interface` token
-        result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        const endEnumToken = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        const result = new Statement_1.EnumStatement({
+            enum: enumToken,
+            name: nameToken,
+            body: body,
+            endEnum: endEnumToken
+        });
         this.exitAnnotationBlock(parentAnnotations);
         return result;
     }
@@ -448,8 +456,6 @@ class Parser {
                         func: funcDeclaration.func,
                         override: overrideKeyword
                     });
-                    //refer to this statement as parent of the expression
-                    funcDeclaration.func.functionStatement = decl;
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -458,10 +464,6 @@ class Parser {
                     if (overrideKeyword) {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.classFieldCannotBeOverridden()), { range: overrideKeyword.range }));
                     }
-                    //comments
-                }
-                else if (this.check(TokenKind_1.TokenKind.Comment)) {
-                    decl = this.commentStatement();
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
@@ -542,7 +544,6 @@ class Parser {
         });
     }
     functionDeclaration(isAnonymous, checkIdentifier = true, onlyCallableAsMember = false) {
-        var _a;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
@@ -610,46 +611,38 @@ class Parser {
                 return haveFoundOptional || !!param.defaultValue;
             }, false);
             this.consumeStatementSeparators(true);
+            //support ending the function with `end sub` OR `end function`
+            let body = this.block();
+            //if the parser was unable to produce a block, make an empty one so the AST makes some sense...
+            // consume 'end sub' or 'end function'
+            const endFunctionType = this.advance();
+            let expectedEndKind = isSub ? TokenKind_1.TokenKind.EndSub : TokenKind_1.TokenKind.EndFunction;
+            //if `function` is ended with `end sub`, or `sub` is ended with `end function`, then
+            //add an error but don't hard-fail so the AST can continue more gracefully
+            if (endFunctionType.kind !== expectedEndKind) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, endFunctionType.text)), { range: endFunctionType.range }));
+            }
+            if (!body) {
+                body = new Statement_1.Block({
+                    statements: [],
+                    startingRange: util_1.util.createBoundingRange(functionType, name, leftParen, ...params, rightParen, asToken, typeExpression, endFunctionType)
+                });
+            }
             let func = new Expression_1.FunctionExpression({
                 parameters: params,
-                body: undefined,
+                body: body,
                 functionType: functionType,
-                endFunctionType: undefined,
+                endFunctionType: endFunctionType,
                 leftParen: leftParen,
                 rightParen: rightParen,
                 as: asToken,
                 returnTypeExpression: typeExpression
             });
-            //support ending the function with `end sub` OR `end function`
-            func.body = this.block();
-            //if the parser was unable to produce a block, make an empty one so the AST makes some sense...
-            if (!func.body) {
-                func.body = new Statement_1.Block({
-                    statements: [],
-                    startingRange: util_1.util.createRangeFromPositions(func.range.start, func.range.start)
-                });
-            }
-            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();
-            }
-            // consume 'end sub' or 'end function'
-            func.tokens.endFunctionType = this.advance();
-            let expectedEndKind = isSub ? TokenKind_1.TokenKind.EndSub : TokenKind_1.TokenKind.EndFunction;
-            //if `function` is ended with `end sub`, or `sub` is ended with `end function`, then
-            //add an error but don't hard-fail so the AST can continue more gracefully
-            if (func.tokens.endFunctionType.kind !== expectedEndKind) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, func.tokens.endFunctionType.text)), { range: func.tokens.endFunctionType.range }));
-            }
-            func.callExpressions = this.callExpressions;
             if (isAnonymous) {
                 return func;
             }
             else {
                 let result = new Statement_1.FunctionStatement({ name: name, func: func });
-                func.symbolTable.name += `: '${name === null || name === void 0 ? void 0 : name.text}'`;
-                func.functionStatement = result;
                 return result;
             }
         }
@@ -926,6 +919,7 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedInAfterForEach(name.text)), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
+        maybeIn.kind = TokenKind_1.TokenKind.In;
         let target = this.expression();
         if (!target) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
@@ -951,29 +945,12 @@ class Parser {
         let keyword = this.advance();
         return new Statement_1.ExitForStatement({ exitFor: keyword });
     }
-    commentStatement() {
-        //if this comment is on the same line as the previous statement,
-        //then this comment should be treated as a single-line comment
-        let prev = this.previous();
-        if ((prev === null || prev === void 0 ? void 0 : prev.range.end.line) === this.peek().range.start.line) {
-            return new Statement_1.CommentStatement({ comments: [this.advance()] });
-        }
-        else {
-            let comments = [this.advance()];
-            while (this.check(TokenKind_1.TokenKind.Newline) && this.checkNext(TokenKind_1.TokenKind.Comment)) {
-                this.advance();
-                comments.push(this.advance());
-            }
-            return new Statement_1.CommentStatement({ comments: comments });
-        }
-    }
     namespaceStatement() {
         this.warnIfNotBrighterScriptMode('namespace');
         let keyword = this.advance();
         this.namespaceAndFunctionDepth++;
         let name = this.identifyingExpression();
         //set the current namespace name
-        let result = new Statement_1.NamespaceStatement({ namespace: keyword, nameExpression: name, body: null });
         this.globalTerminators.push([TokenKind_1.TokenKind.EndNamespace]);
         let body = this.body();
         this.globalTerminators.pop();
@@ -986,8 +963,12 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace')), { range: keyword.range }));
         }
         this.namespaceAndFunctionDepth--;
-        result.body = body;
-        result.tokens.endNamespace = endKeyword;
+        let result = new Statement_1.NamespaceStatement({
+            namespace: keyword,
+            nameExpression: name,
+            body: body,
+            endNamespace: endKeyword
+        });
         //cache the range property so that plugins can't affect it
         result.cacheRange();
         result.body.symbolTable.name += `: namespace '${result.name}'`;
@@ -1071,7 +1052,7 @@ class Parser {
         let importStatement = new Statement_1.ImportStatement({
             import: this.advance(),
             //grab the next token only if it's a string
-            filePath: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral)
+            path: this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import'), TokenKind_1.TokenKind.StringLiteral)
         });
         return importStatement;
     }
@@ -1217,36 +1198,43 @@ class Parser {
     }
     tryCatchStatement() {
         const tryToken = this.advance();
-        const statement = new Statement_1.TryCatchStatement({ try: tryToken });
+        let endTryToken;
+        let catchStmt;
         //ensure statement separator
         this.consumeStatementSeparators();
-        statement.tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
+        let tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
         const peek = this.peek();
         if (peek.kind !== TokenKind_1.TokenKind.Catch) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedCatchBlockInTryCatch()), { range: this.peek().range }));
-            //gracefully handle end-try
-            if (peek.kind === TokenKind_1.TokenKind.EndTry) {
-                statement.tokens.endTry = this.advance();
-            }
-            return statement;
         }
-        const catchStmt = new Statement_1.CatchStatement({ catch: this.advance() });
-        statement.catchStatement = catchStmt;
-        const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
-        if (exceptionVarToken) {
-            // force it into an identifier so the AST makes some sense
-            exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
-            catchStmt.tokens.exceptionVariable = exceptionVarToken;
+        else {
+            const catchToken = this.advance();
+            const exceptionVarToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.missingExceptionVarToFollowCatch(), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
+            if (exceptionVarToken) {
+                // force it into an identifier so the AST makes some sense
+                exceptionVarToken.kind = TokenKind_1.TokenKind.Identifier;
+            }
+            //ensure statement sepatator
+            this.consumeStatementSeparators();
+            const catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
+            catchStmt = new Statement_1.CatchStatement({
+                catch: catchToken,
+                exceptionVariable: exceptionVarToken,
+                catchBranch: catchBranch
+            });
         }
-        //ensure statement sepatator
-        this.consumeStatementSeparators();
-        catchStmt.catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
         if (this.peek().kind !== TokenKind_1.TokenKind.EndTry) {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedEndTryToTerminateTryCatch()), { range: this.peek().range }));
         }
         else {
-            statement.tokens.endTry = this.advance();
+            endTryToken = this.advance();
         }
+        const statement = new Statement_1.TryCatchStatement({
+            try: tryToken,
+            tryBranch: tryBranch,
+            catchStatement: catchStmt,
+            endTry: endTryToken
+        });
         return statement;
     }
     throwStatement() {
@@ -2077,8 +2065,6 @@ class Parser {
                 return this.anonymousFunction();
             case this.check(TokenKind_1.TokenKind.RegexLiteral):
                 return this.regexLiteralExpression();
-            case this.check(TokenKind_1.TokenKind.Comment):
-                return new Statement_1.CommentStatement({ comments: [this.advance()] });
             default:
                 //if we found an expected terminator, don't throw a diagnostic...just return undefined
                 if (this.checkAny(...this.peekGlobalTerminators())) {
@@ -2094,10 +2080,6 @@ class Parser {
     arrayLiteral() {
         let elements = [];
         let openingSquare = this.previous();
-        //add any comment found right after the opening square
-        if (this.check(TokenKind_1.TokenKind.Comment)) {
-            elements.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
-        }
         while (this.match(TokenKind_1.TokenKind.Newline)) {
         }
         let closingSquare;
@@ -2105,10 +2087,6 @@ class Parser {
             try {
                 elements.push(this.expression());
                 while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Comment)) {
-                    if (this.checkPrevious(TokenKind_1.TokenKind.Comment) || this.check(TokenKind_1.TokenKind.Comment)) {
-                        let comment = this.check(TokenKind_1.TokenKind.Comment) ? this.advance() : this.previous();
-                        elements.push(new Statement_1.CommentStatement({ comments: [comment] }));
-                    }
                     while (this.match(TokenKind_1.TokenKind.Newline)) {
                     }
                     if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
@@ -2156,11 +2134,23 @@ class Parser {
         if (!this.match(TokenKind_1.TokenKind.RightCurlyBrace)) {
             let lastAAMember;
             try {
-                if (this.check(TokenKind_1.TokenKind.Comment)) {
-                    lastAAMember = null;
-                    members.push(new Statement_1.CommentStatement({ comments: [this.advance()] }));
-                }
-                else {
+                let k = key();
+                let expr = this.expression();
+                lastAAMember = new Expression_1.AAMemberExpression({
+                    key: k.keyToken,
+                    colon: k.colonToken,
+                    value: expr
+                });
+                members.push(lastAAMember);
+                while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
+                    // collect comma at end of expression
+                    if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
+                        lastAAMember.tokens.comma = this.previous();
+                    }
+                    this.consumeStatementSeparators(true);
+                    if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
+                        break;
+                    }
                     let k = key();
                     let expr = this.expression();
                     lastAAMember = new Expression_1.AAMemberExpression({
@@ -2170,38 +2160,6 @@ class Parser {
                     });
                     members.push(lastAAMember);
                 }
-                while (this.matchAny(TokenKind_1.TokenKind.Comma, TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Comment)) {
-                    // collect comma at end of expression
-                    if (lastAAMember && this.checkPrevious(TokenKind_1.TokenKind.Comma)) {
-                        lastAAMember.tokens.comma = this.previous();
-                    }
-                    //check for comment at the end of the current line
-                    if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
-                        let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                        members.push(new Statement_1.CommentStatement({ comments: [token] }));
-                    }
-                    else {
-                        this.consumeStatementSeparators(true);
-                        //check for a comment on its own line
-                        if (this.check(TokenKind_1.TokenKind.Comment) || this.checkPrevious(TokenKind_1.TokenKind.Comment)) {
-                            let token = this.checkPrevious(TokenKind_1.TokenKind.Comment) ? this.previous() : this.advance();
-                            lastAAMember = null;
-                            members.push(new Statement_1.CommentStatement({ comments: [token] }));
-                            continue;
-                        }
-                        if (this.check(TokenKind_1.TokenKind.RightCurlyBrace)) {
-                            break;
-                        }
-                        let k = key();
-                        let expr = this.expression();
-                        lastAAMember = new Expression_1.AAMemberExpression({
-                            key: k.keyToken,
-                            colon: k.colonToken,
-                            value: expr
-                        });
-                        members.push(lastAAMember);
-                    }
-                }
             }
             catch (error) {
                 this.rethrowNonDiagnosticError(error);
@@ -2353,7 +2311,8 @@ class Parser {
         return tokenKinds.includes(nextKind);
     }
     isAtEnd() {
-        return this.peek().kind === TokenKind_1.TokenKind.Eof;
+        const peekToken = this.peek();
+        return !peekToken || peekToken.kind === TokenKind_1.TokenKind.Eof;
     }
     peekNext() {
         if (this.isAtEnd()) {