brighterscript 1.0.0-alpha.17 → 1.0.0-alpha.18

package/dist/parser/Parser.js

@@ -187,7 +187,7 @@ class Parser {
     declaration() {
         try {
             if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-                return this.functionDeclaration(false);
+                return this.functionStatement({ hasName: true, hasBody: true, hasEnd: true });
             }
             if (this.checkLibrary()) {
                 return this.libraryStatement();
@@ -241,44 +241,29 @@ class Parser {
         return new Statement_1.EnumMemberStatement(tokens, value);
     }
     /**
-     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration`
+     * Create a new InterfaceFieldStatement. This should only be called from within `interfaceDeclaration`
      */
     interfaceFieldStatement() {
         const name = this.identifier(...TokenKind_1.AllowedProperties);
-        let asToken = this.consumeToken(TokenKind_1.TokenKind.As);
-        let typeExpr = this.typeExpression();
-        if (!typeExpr.isValidType()) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
-            throw this.lastDiagnosticAsError();
-        }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpr);
-    }
-    /**
-     * Create a new InterfaceMethodStatement. This should only be called from within `interfaceDeclaration()`
-     */
-    interfaceMethodStatement() {
-        const functionType = this.advance();
-        const name = this.identifier(...TokenKind_1.AllowedProperties);
-        const leftParen = this.consumeToken(TokenKind_1.TokenKind.LeftParen);
-        const params = [];
-        const rightParen = this.consumeToken(TokenKind_1.TokenKind.RightParen);
-        let asToken = null;
-        let returnTypeExpr;
+        let asToken;
+        let typeExpr;
+        //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.advance();
-            returnTypeExpr = this.typeExpression();
-            if (!returnTypeExpr.isValidType(this.options.mode)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeExpr.getText())), { range: returnTypeExpr.range }));
-                throw this.lastDiagnosticAsError();
+            asToken = this.consumeToken(TokenKind_1.TokenKind.As);
+            typeExpr = this.typeExpression();
+            //no field type specified
+            if (!typeExpr.isValidType()) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
             }
         }
-        return new Statement_1.InterfaceMethodStatement(functionType, name, leftParen, params, rightParen, asToken, returnTypeExpr);
+        return new Statement_1.InterfaceFieldStatement(name, asToken, typeExpr, this.currentNamespaceName);
     }
     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(...this.allowedLocalIdentifiers);
+        //get the interface name
+        let nameToken = this.tryConsume(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('interface'), TokenKind_1.TokenKind.Identifier, ...this.allowedLocalIdentifiers);
         let extendsToken;
         let parentInterfaceName;
         if (this.peek().text.toLowerCase() === 'extends') {
@@ -290,6 +275,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)) {
@@ -301,7 +290,15 @@ class Parser {
                     //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();
+                    const functionStatement = this.functionStatement({
+                        hasName: true,
+                        hasBody: false,
+                        hasEnd: false,
+                        onlyCallableAsMember: true
+                    });
+                    decl = new Statement_1.InterfaceMethodStatement(functionStatement.name, functionStatement.func);
+                    //refer to this statement as parent of the expression
+                    functionStatement.func.functionStatement = decl;
                     //comments
                 }
                 else if (this.check(TokenKind_1.TokenKind.Comment)) {
@@ -311,10 +308,6 @@ class Parser {
                     this.consumePendingAnnotations(decl);
                     body.push(decl);
                 }
-                else {
-                    //we didn't find a declaration...flag tokens until next line
-                    this.flagUntil(TokenKind_1.TokenKind.Newline, TokenKind_1.TokenKind.Colon, TokenKind_1.TokenKind.Eof);
-                }
             }
             catch (e) {
                 //throw out any failed members and move on to the next line
@@ -322,14 +315,13 @@ 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);
-        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endInterfaceToken, this.currentNamespaceName);
+        let endingKeyword = this.advance();
+        if (endingKeyword.kind !== TokenKind_1.TokenKind.EndInterface) {
+            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('interface')), { range: endingKeyword.range }));
+        }
+        const statement = new Statement_1.InterfaceStatement(interfaceToken, nameToken, extendsToken, parentInterfaceName, body, endingKeyword, this.currentNamespaceName);
         this._references.interfaceStatements.push(statement);
         this.exitAnnotationBlock(parentAnnotations);
         return statement;
@@ -422,14 +414,12 @@ class Parser {
                 }
                 //methods (function/sub keyword OR identifier followed by opening paren)
                 if (this.checkAny(TokenKind_1.TokenKind.Function, TokenKind_1.TokenKind.Sub) || (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties) && this.checkNext(TokenKind_1.TokenKind.LeftParen))) {
-                    const funcDeclaration = this.functionDeclaration(false, false, true);
-                    //remove this function from the lists because it's not a callable
-                    const functionStatement = this._references.functionStatements.pop();
+                    const functionStatement = this.functionStatement({ hasName: true, hasBody: true, hasEnd: true, onlyCallableAsMember: true });
                     //if we have an overrides keyword AND this method is called 'new', that's not allowed
-                    if (overrideKeyword && funcDeclaration.name.text.toLowerCase() === 'new') {
+                    if (overrideKeyword && functionStatement.name.text.toLowerCase() === 'new') {
                         this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseOverrideKeywordOnConstructorFunction()), { range: overrideKeyword.range }));
                     }
-                    decl = new Statement_1.ClassMethodStatement(accessModifier, funcDeclaration.name, funcDeclaration.func, overrideKeyword);
+                    decl = new Statement_1.ClassMethodStatement(accessModifier, functionStatement.name, functionStatement.func, overrideKeyword);
                     //refer to this statement as parent of the expression
                     functionStatement.func.functionStatement = decl;
                     //cache the range property so that plugins can't affect it
@@ -493,20 +483,32 @@ class Parser {
         }
         return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldTypeExpr, equal, initialValue, this.currentNamespaceName);
     }
-    functionDeclaration(isAnonymous, checkIdentifier = true, forClassMethod = false) {
+    functionStatement(options) {
+        options.hasName = true;
+        const funcResult = this.functionDeclaration(options);
+        if (funcResult) {
+            let result = new Statement_1.FunctionStatement(funcResult.name, funcResult.functionExpression, this.currentNamespaceName);
+            funcResult.functionExpression.functionStatement = result;
+            if (!options.onlyCallableAsMember) {
+                this._references.functionStatements.push(result);
+            }
+            return result;
+        }
+    }
+    functionDeclaration(options = {}) {
         var _a, _b, _c, _d;
         let previousCallExpressions = this.callExpressions;
         this.callExpressions = [];
         try {
             //track depth to help certain statements need to know if they are contained within a function body
             this.namespaceAndFunctionDepth++;
-            let functionType;
+            let functionKeyword;
             if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-                functionType = this.advance();
+                functionKeyword = this.advance();
             }
             else {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.missingCallableKeyword()), { range: this.peek().range }));
-                functionType = {
+                functionKeyword = {
                     isReserved: true,
                     kind: TokenKind_1.TokenKind.Function,
                     text: 'function',
@@ -518,24 +520,24 @@ class Parser {
                     leadingWhitespace: ''
                 };
             }
-            let isSub = (functionType === null || functionType === void 0 ? void 0 : functionType.kind) === TokenKind_1.TokenKind.Sub;
-            let functionTypeText = isSub ? 'sub' : 'function';
+            let isSub = (functionKeyword === null || functionKeyword === void 0 ? void 0 : functionKeyword.kind) === TokenKind_1.TokenKind.Sub;
+            let functionKeywordText = isSub ? 'sub' : 'function';
             let name;
             let leftParen;
-            if (isAnonymous) {
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionTypeText), TokenKind_1.TokenKind.LeftParen);
+            if (!options.hasName) {
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallable(functionKeywordText), TokenKind_1.TokenKind.LeftParen);
             }
             else {
-                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionTypeText), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
-                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionTypeText), TokenKind_1.TokenKind.LeftParen);
+                name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedNameAfterCallableKeyword(functionKeywordText), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
+                leftParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedLeftParenAfterCallableName(functionKeywordText), TokenKind_1.TokenKind.LeftParen);
                 //prevent functions from ending with type designators
                 let lastChar = name.text[name.text.length - 1];
                 if (['$', '%', '!', '#', '&'].includes(lastChar)) {
                     //don't throw this error; let the parser continue
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionNameCannotEndWithTypeDesignator(functionTypeText, name.text, lastChar)), { range: name.range }));
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionNameCannotEndWithTypeDesignator(functionKeywordText, name.text, lastChar)), { range: name.range }));
                 }
-                //flag functions with keywords for names (only for standard functions)
-                if (checkIdentifier && TokenKind_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
+                //flag functions with keywords for names (only for standard functions - not for class methods)
+                if (!options.onlyCallableAsMember && TokenKind_1.DisallowedFunctionIdentifiersText.has(name.text.toLowerCase())) {
                     this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier(name.text)), { range: name.range }));
                 }
             }
@@ -564,9 +566,12 @@ class Parser {
                 }
                 return haveFoundOptional || !!param.defaultValue;
             }, false);
-            this.consumeStatementSeparators(true);
+            if (options.hasEnd && options.hasBody) {
+                // do not go to next statement - we don't care about any other statement
+                this.consumeStatementSeparators(true);
+            }
             let func = new Expression_1.FunctionExpression(params, undefined, //body
-            functionType, undefined, //ending keyword
+            functionKeyword, undefined, //ending keyword
             leftParen, rightParen, asToken, typeExpr, //return type
             this.currentFunctionExpression, this.currentNamespaceName, (_c = (_b = this.currentNamespace) === null || _b === void 0 ? void 0 : _b.symbolTable) !== null && _c !== void 0 ? _c : this.symbolTable);
             //if there is a parent function, register this function with the parent
@@ -574,7 +579,7 @@ class Parser {
                 this.currentFunctionExpression.childFunctionExpressions.push(func);
             }
             // add the function to the relevant symbol tables
-            if (!isAnonymous && !forClassMethod) {
+            if (!options.onlyCallableAsMember && name) {
                 const funcType = func.getFunctionType();
                 funcType.setName(name.text);
                 // add the function as declared to the current namespace's table
@@ -587,42 +592,35 @@ class Parser {
                 this.currentSymbolTable.addSymbol(fullyQualifiedName, name.range, funcType);
             }
             this._references.functionExpressions.push(func);
-            let previousFunctionExpression = this.currentFunctionExpression;
-            this.currentFunctionExpression = func;
-            //make sure to restore the currentFunctionExpression even if the body block fails to parse
-            try {
-                //support ending the function with `end sub` OR `end function`
-                func.body = this.block();
-            }
-            finally {
-                this.currentFunctionExpression = previousFunctionExpression;
-            }
-            if (!func.body) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionTypeText)), { range: this.peek().range }));
-                throw this.lastDiagnosticAsError();
+            if (options.hasBody) {
+                let previousFunctionExpression = this.currentFunctionExpression;
+                this.currentFunctionExpression = func;
+                //make sure to restore the currentFunctionExpression even if the body block fails to parse
+                try {
+                    //support ending the function with `end sub` OR `end function`
+                    func.body = this.block();
+                }
+                finally {
+                    this.currentFunctionExpression = previousFunctionExpression;
+                }
+                if (!func.body) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callableBlockMissingEndKeyword(functionKeywordText)), { range: this.peek().range }));
+                    throw this.lastDiagnosticAsError();
+                }
             }
-            // consume 'end sub' or 'end function'
-            func.end = 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.end.kind !== expectedEndKind) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionTypeText, func.end.text)), { range: this.peek().range }));
+            if (options.hasEnd) {
+                // consume 'end sub' or 'end function'
+                func.end = 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.end.kind !== expectedEndKind) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchedEndCallableKeyword(functionKeywordText, func.end.text)), { range: this.peek().range }));
+                }
             }
             func.callExpressions = this.callExpressions;
-            if (isAnonymous) {
-                //cache the range property so that plugins can't affect it
-                func.cacheRange();
-                return func;
-            }
-            else {
-                let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
-                func.functionStatement = result;
-                this._references.functionStatements.push(result);
-                //cache the range property so that plugins can't affect it
-                result.cacheRange();
-                return result;
-            }
+            func.cacheRange();
+            return { name: name, functionExpression: func };
         }
         finally {
             this.namespaceAndFunctionDepth--;
@@ -1118,7 +1116,7 @@ class Parser {
     }
     tryCatchStatement() {
         const tryToken = this.advance();
-        const statement = new Statement_1.TryCatchStatement(tryToken);
+        const statement = new Statement_1.TryCatchStatement({ try: tryToken });
         //ensure statement separator
         this.consumeStatementSeparators();
         statement.tryBranch = this.block(TokenKind_1.TokenKind.Catch, TokenKind_1.TokenKind.EndTry);
@@ -1127,27 +1125,26 @@ class Parser {
             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.endTryToken = this.advance();
+                statement.tokens.endTry = this.advance();
             }
             return statement;
         }
-        else {
-            statement.catchToken = this.advance();
-        }
+        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;
-            statement.exceptionVariable = exceptionVarToken;
+            catchStmt.exceptionVariable = exceptionVarToken;
         }
         //ensure statement sepatator
         this.consumeStatementSeparators();
-        statement.catchBranch = this.block(TokenKind_1.TokenKind.EndTry);
+        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.endTryToken = this.advance();
+            statement.tokens.endTry = this.advance();
         }
         return statement;
     }
@@ -1593,7 +1590,7 @@ class Parser {
     }
     anonymousFunction() {
         if (this.checkAny(TokenKind_1.TokenKind.Sub, TokenKind_1.TokenKind.Function)) {
-            const func = this.functionDeclaration(true);
+            const func = this.functionDeclaration({ hasName: false, hasBody: true, hasEnd: true }).functionExpression;
             //if there's an open paren after this, this is an IIFE
             if (this.check(TokenKind_1.TokenKind.LeftParen)) {
                 return this.finishCall(this.advance(), func);
@@ -2400,6 +2397,9 @@ class Parser {
                     this._references.expressions.add(s.initialValue);
                 }
             },
+            InterfaceStatement: s => {
+                this._references.interfaceStatements.push(s);
+            },
             NamespaceStatement: s => {
                 this._references.namespaceStatements.push(s);
             },
@@ -2413,7 +2413,7 @@ class Parser {
                 this._references.libraryStatements.push(s);
             },
             FunctionExpression: (expression, parent) => {
-                if (!(0, reflection_1.isClassMethodStatement)(parent)) {
+                if (!(0, reflection_1.isClassMethodStatement)(parent) && !(0, reflection_1.isInterfaceMethodStatement)(parent)) {
                     this._references.functionExpressions.push(expression);
                 }
             },
@@ -2545,7 +2545,7 @@ class References {
         if (!this._interfaceStatementLookup) {
             this._interfaceStatementLookup = new Map();
             for (const stmt of this.interfaceStatements) {
-                this._interfaceStatementLookup.set(stmt.fullName.toLowerCase(), stmt);
+                this._interfaceStatementLookup.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
             }
         }
         return this._interfaceStatementLookup;
@@ -2601,7 +2601,7 @@ function getBscTypeFromExpression(expression, functionExpression) {
             //function call
         }
         else if ((0, reflection_1.isNewExpression)(expression)) {
-            return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression); // new CustomType(expression.className.getName(ParseMode.BrighterScript));
+            return (0, helpers_1.getTypeFromNewExpression)(expression, functionExpression);
             //Function call
         }
         else if ((0, reflection_1.isCallExpression)(expression)) {