brighterscript 1.0.0-alpha.15 → 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();
@@ -230,56 +230,40 @@ 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 tokens = {};
+        let value;
+        tokens.name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         //look for `= SOME_EXPRESSION`
         if (this.check(TokenKind_1.TokenKind.Equal)) {
-            statement.tokens.equal = this.advance();
-            statement.value = this.expression();
+            tokens.equal = this.advance();
+            value = this.expression();
         }
-        return statement;
+        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 typeToken = this.typeToken();
-        const type = util_1.util.tokenToBscType(typeToken);
-        if (!type) {
-            this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
-            throw this.lastDiagnosticAsError();
-        }
-        return new Statement_1.InterfaceFieldStatement(name, asToken, typeToken, type);
-    }
-    /**
-     * 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 returnTypeToken = null;
+        let asToken;
+        let typeExpr;
+        //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
-            asToken = this.advance();
-            returnTypeToken = this.typeToken();
-            const returnType = util_1.util.tokenToBscType(returnTypeToken);
-            if (!returnType) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, returnTypeToken.text)), { range: returnTypeToken.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, returnTypeToken, util_1.util.tokenToBscType(returnTypeToken));
+        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') {
@@ -291,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)) {
@@ -302,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)) {
@@ -312,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
@@ -323,24 +315,24 @@ 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;
     }
     enumDeclaration() {
-        const result = new Statement_1.EnumStatement({}, [], this.currentNamespaceName);
         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();
+        const tokens = {};
+        const body = [];
+        tokens.enum = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedKeyword(TokenKind_1.TokenKind.Enum), TokenKind_1.TokenKind.Enum);
+        tokens.name = this.tryIdentifier();
         this.consumeStatementSeparators();
         //gather up all members
         while (this.checkAny(TokenKind_1.TokenKind.Comment, TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.At, ...TokenKind_1.AllowedProperties)) {
@@ -360,7 +352,7 @@ class Parser {
                 }
                 if (decl) {
                     this.consumePendingAnnotations(decl);
-                    result.body.push(decl);
+                    body.push(decl);
                 }
                 else {
                     //we didn't find a declaration...flag tokens until next line
@@ -379,7 +371,8 @@ class Parser {
             }
         }
         //consume the final `end interface` token
-        result.tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        tokens.endEnum = this.consumeToken(TokenKind_1.TokenKind.EndEnum);
+        const result = new Statement_1.EnumStatement(tokens, body, this.currentNamespaceName);
         this._references.enumStatements.push(result);
         this.exitAnnotationBlock(parentAnnotations);
         return result;
@@ -421,16 +414,16 @@ 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
+                    decl.cacheRange();
                     //fields
                 }
                 else if (this.checkAny(TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties)) {
@@ -471,13 +464,13 @@ class Parser {
     classFieldDeclaration(accessModifier) {
         let name = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedClassFieldIdentifier(), TokenKind_1.TokenKind.Identifier, ...TokenKind_1.AllowedProperties);
         let asToken;
-        let fieldType;
+        let fieldTypeExpr;
         //look for `as SOME_TYPE`
         if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
-            fieldType = this.typeToken();
+            fieldTypeExpr = this.typeExpression();
             //no field type specified
-            if (!util_1.util.tokenToBscType(fieldType, true, this.currentNamespaceName)) {
+            if (!fieldTypeExpr.isValidType(this.options.mode)) {
                 this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedValidTypeToFollowAsKeyword()), { range: this.peek().range }));
             }
         }
@@ -488,22 +481,34 @@ class Parser {
             equal = this.advance();
             initialValue = this.expression();
         }
-        return new Statement_1.ClassFieldStatement(accessModifier, name, asToken, fieldType, equal, initialValue, this.currentNamespaceName);
+        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',
@@ -515,30 +520,30 @@ 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 }));
                 }
             }
             let params = [];
             let asToken;
-            let typeToken;
+            let typeExpr;
             if (!this.check(TokenKind_1.TokenKind.RightParen)) {
                 do {
                     if (params.length >= Expression_1.CallExpression.MaximumArguments) {
@@ -550,9 +555,9 @@ class Parser {
             let rightParen = this.advance();
             if (this.check(TokenKind_1.TokenKind.As)) {
                 asToken = this.advance();
-                typeToken = this.typeToken();
-                if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
-                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeToken.text) !== null && _a !== void 0 ? _a : '')), { range: typeToken.range }));
+                typeExpr = this.typeExpression();
+                if (!typeExpr.isValidType(this.options.mode)) {
+                    this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidFunctionReturnType((_a = typeExpr.getText()) !== null && _a !== void 0 ? _a : '')), { range: typeExpr.range }));
                 }
             }
             params.reduce((haveFoundOptional, param) => {
@@ -561,17 +566,20 @@ 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
-            leftParen, rightParen, asToken, typeToken, //return type
+            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
             if (this.currentFunctionExpression) {
                 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
@@ -584,38 +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) {
-                return func;
-            }
-            else {
-                let result = new Statement_1.FunctionStatement(name, func, this.currentNamespaceName);
-                func.functionStatement = result;
-                this._references.functionStatements.push(result);
-                return result;
-            }
+            func.cacheRange();
+            return { name: name, functionExpression: func };
         }
         finally {
             this.namespaceAndFunctionDepth--;
@@ -629,7 +634,7 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         const name = this.identifier(...TokenKind_1.AllowedLocalIdentifiers);
-        let typeToken;
+        let typeExpr;
         let defaultValue;
         let equalsToken;
         // parse argument default value
@@ -641,26 +646,26 @@ class Parser {
         let asToken = null;
         if (this.check(TokenKind_1.TokenKind.As)) {
             asToken = this.advance();
-            typeToken = this.typeToken();
-            if (!util_1.util.tokenToBscType(typeToken, this.options.mode === ParseMode.BrighterScript, this.currentNamespaceName)) {
-                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeToken.text)), { range: typeToken.range }));
+            typeExpr = this.typeExpression();
+            if (!typeExpr.isValidType(this.options.mode)) {
+                this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionParameterTypeIsInvalid(name.text, typeExpr.getText())), { range: typeExpr.range }));
                 throw this.lastDiagnosticAsError();
             }
         }
-        let type;
-        if (typeToken) {
-            type = util_1.util.tokenToBscType(typeToken, true, this.currentNamespaceName);
+        let typeInContext;
+        if (typeExpr) {
+            typeInContext = typeExpr.type;
         }
         else if (defaultValue) {
-            type = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
-            if ((0, reflection_1.isInvalidType)(type)) {
-                type = new DynamicType_1.DynamicType();
+            typeInContext = getBscTypeFromExpression(defaultValue, this.currentFunctionExpression);
+            if ((0, reflection_1.isInvalidType)(typeInContext)) {
+                typeInContext = new DynamicType_1.DynamicType();
             }
         }
         else {
-            type = new DynamicType_1.DynamicType();
+            typeInContext = new DynamicType_1.DynamicType();
         }
-        return new Expression_1.FunctionParameterExpression(name, type, equalsToken, defaultValue, asToken, typeToken, this.currentNamespaceName);
+        return new Expression_1.FunctionParameterExpression(name, typeInContext, equalsToken, defaultValue, asToken, typeExpr, this.currentNamespaceName);
     }
     assignment() {
         let name = this.identifier(...this.allowedLocalIdentifiers);
@@ -854,6 +859,12 @@ class Parser {
             this.diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExpressionAfterForEachIn()), { range: this.peek().range }));
             throw this.lastDiagnosticAsError();
         }
+        let itemType = new DynamicType_1.DynamicType();
+        const targetType = getBscTypeFromExpression(target, this.currentFunctionExpression);
+        if ((0, reflection_1.isArrayType)(targetType)) {
+            itemType = targetType.getDefaultType();
+        }
+        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
         this.consumeStatementSeparators();
         let body = this.block(TokenKind_1.TokenKind.EndFor, TokenKind_1.TokenKind.Next);
         if (!body) {
@@ -861,12 +872,6 @@ class Parser {
             throw this.lastDiagnosticAsError();
         }
         let endFor = this.advance();
-        let itemType = new DynamicType_1.DynamicType();
-        const targetType = getBscTypeFromExpression(target, this.currentFunctionExpression);
-        if ((0, reflection_1.isArrayType)(targetType)) {
-            itemType = targetType.getDefaultType();
-        }
-        this.currentSymbolTable.addSymbol(name.text, name.range, itemType);
         return new Statement_1.ForEachStatement(forEach, name, maybeIn, target, body, endFor);
     }
     exitFor() {
@@ -917,6 +922,8 @@ class Parser {
         result.body = body;
         result.endKeyword = endKeyword;
         this._references.namespaceStatements.push(result);
+        //cache the range property so that plugins can't affect it
+        result.cacheRange();
         return result;
     }
     /**
@@ -999,6 +1006,8 @@ class Parser {
             let leftParen = this.advance();
             annotation.call = this.finishCall(leftParen, annotation, false);
         }
+        //cache the range property so that plugins can't affect it
+        annotation.cacheRange();
         return annotation;
     }
     ternaryExpression(test) {
@@ -1107,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);
@@ -1116,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;
     }
@@ -1403,12 +1411,10 @@ class Parser {
             if ((0, reflection_1.isIndexedGetExpression)(left)) {
                 return new Statement_1.IndexedSetStatement(left.obj, left.index, operator.kind === TokenKind_1.TokenKind.Equal
                     ? right
-                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare);
+                    : new Expression_1.BinaryExpression(left, operator, right), left.openingSquare, left.closingSquare, operator);
             }
             else if ((0, reflection_1.isDottedGetExpression)(left)) {
-                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal
-                    ? right
-                    : new Expression_1.BinaryExpression(left, operator, right));
+                const dottedSetStmt = new Statement_1.DottedSetStatement(left.obj, left.name, operator.kind === TokenKind_1.TokenKind.Equal ? right : new Expression_1.BinaryExpression(left, operator, right), left.dot, operator);
                 this._references.dottedSetStatements.push(dottedSetStmt);
                 return dottedSetStmt;
             }
@@ -1584,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);
@@ -1762,9 +1768,6 @@ class Parser {
         }
         while (this.match(TokenKind_1.TokenKind.Newline)) { }
         const closingParen = this.consume(DiagnosticMessages_1.DiagnosticMessages.expectedRightParenAfterFunctionCallArguments(), TokenKind_1.TokenKind.RightParen);
-        if ((0, reflection_1.isVariableExpression)(callee)) {
-            callee.isCalled = true;
-        }
         let expression = new Expression_1.CallExpression(callee, openingParen, closingParen, args, this.currentNamespaceName);
         if (addToCallExpressionList) {
             this.callExpressions.push(expression);
@@ -1776,7 +1779,7 @@ class Parser {
      * Allows for built-in types (double, string, etc.) or namespaced custom types in Brighterscript mode
      * Will  return a token of whatever is next to be parsed (unless `advanceIfUnknown` is false, in which case undefined will be returned instead
      */
-    typeToken() {
+    typeExpression() {
         let typeToken;
         if (this.checkAny(...TokenKind_1.DeclarableTypes)) {
             // Token is a built in type
@@ -1797,18 +1800,23 @@ class Parser {
             // just get whatever's next
             typeToken = this.advance();
         }
-        if (typeToken && this.options.mode === ParseMode.BrighterScript) {
+        //TODO: to support InterfaceTypeLiterals - (eg. `{name as string; age as integer}`), check if "typeToken" is a curly bracket, and do something else
+        let typeExpr = new Expression_1.TypeExpression({ type: typeToken }, this.currentNamespaceName);
+        if (this.options.mode === ParseMode.BrighterScript) {
             // Check if it is an array - that is, if it has `[]` after the type
-            // eg. `string[]` or `SomeKlass[]`
-            if (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
-                this.advance();
+            // eg. `string[]` or `SomeKlass[]` or `float[][][]`
+            while (this.check(TokenKind_1.TokenKind.LeftSquareBracket)) {
+                const leftBracket = this.advance();
                 if (this.check(TokenKind_1.TokenKind.RightSquareBracket)) {
                     const rightBracket = this.advance();
-                    typeToken = (0, creators_1.createToken)(TokenKind_1.TokenKind.Identifier, typeToken.text + '[]', util_1.util.getRange(typeToken, rightBracket));
+                    typeExpr = new Expression_1.ArrayTypeExpression([typeExpr], { leftBracket: leftBracket, rightBracket: rightBracket }, this.currentNamespaceName);
+                }
+                else {
+                    break;
                 }
             }
         }
-        return typeToken;
+        return typeExpr;
     }
     primary() {
         switch (true) {
@@ -2389,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);
             },
@@ -2402,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);
                 }
             },
@@ -2534,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;
@@ -2579,7 +2590,7 @@ function getBscTypeFromExpression(expression, functionExpression) {
             //Associative array literal
         }
         else if ((0, reflection_1.isAALiteralExpression)(expression)) {
-            return new ObjectType_1.ObjectType(expression.memberTable);
+            return new ObjectType_1.ObjectType('object', expression.memberTable);
             //Array literal
         }
         else if ((0, reflection_1.isArrayLiteralExpression)(expression)) {
@@ -2590,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)) {