brighterscript 0.41.2 → 1.0.0-alpha.12

package/dist/parser/Parser.spec.js

@@ -8,8 +8,18 @@ const Parser_1 = require("./Parser");
 const Statement_1 = require("./Statement");
 const vscode_languageserver_1 = require("vscode-languageserver");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
-const astUtils_1 = require("../astUtils");
+const reflection_1 = require("../astUtils/reflection");
 const testHelpers_spec_1 = require("../testHelpers.spec");
+const VoidType_1 = require("../types/VoidType");
+const FunctionType_1 = require("../types/FunctionType");
+const StringType_1 = require("../types/StringType");
+const CustomType_1 = require("../types/CustomType");
+const IntegerType_1 = require("../types/IntegerType");
+const ObjectType_1 = require("../types/ObjectType");
+const SymbolTable_1 = require("../SymbolTable");
+const DynamicType_1 = require("../types/DynamicType");
+const util_1 = require("../util");
+const LazyType_1 = require("../types/LazyType");
 describe('parser', () => {
     it('emits empty object when empty token list is provided', () => {
         (0, chai_1.expect)(Parser_1.Parser.parse([])).to.deep.include({
@@ -18,6 +28,56 @@ describe('parser', () => {
         });
     });
     describe('findReferences', () => {
+        it('recomputes localVars', () => {
+            const parser = Parser_1.Parser.parse(`
+                sub main(herd)
+                    for each zombie in herd
+                        isAlive = false
+                    end for
+                    for i = 0 to 10 step 1
+                        j = i
+                    end for
+                    humansAreAlive = false
+                end sub
+            `);
+            (0, chai_1.expect)(parser.references.functionExpressions[0].symbolTable.getOwnSymbols().map(x => x.name).sort()).to.eql([
+                'herd',
+                'humansAreAlive',
+                'i',
+                'isAlive',
+                'j',
+                'zombie'
+            ]);
+            parser.invalidateReferences();
+            (0, chai_1.expect)(parser.references.functionExpressions[0].symbolTable.getOwnSymbols().map(x => x.name).sort()).to.eql([
+                'herd',
+                'humansAreAlive',
+                'i',
+                'isAlive',
+                'j',
+                'zombie'
+            ]);
+        });
+        it('assigns localVars to correct function expression bucket', () => {
+            const parser = Parser_1.Parser.parse(`
+                sub main()
+                    outerName = "bob"
+                    speak = sub()
+                        innerName = "innerBob"
+                    end sub
+                    age = 12
+                end sub
+            `);
+            parser.invalidateReferences();
+            (0, chai_1.expect)(parser.references.functionExpressions[0].symbolTable.getOwnSymbols().map(x => x.name)).to.eql([
+                'outerName',
+                'speak',
+                'age'
+            ]);
+            (0, chai_1.expect)(parser.references.functionExpressions[1].symbolTable.getOwnSymbols().map(x => x.name)).to.eql([
+                'innerName'
+            ]);
+        });
         it('gets called if references are missing', () => {
             const parser = Parser_1.Parser.parse(`
                 sub main()
@@ -197,6 +257,41 @@ describe('parser', () => {
                 `);
                 (0, chai_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('namespace').message);
             });
+            it('declares a symbol table for the namespace', () => {
+                let parser = parse(`
+                    namespace Name.Space
+                        function funcInt() as integer
+                           return 3
+                        end function
+
+                        function funcStr() as string
+                           return "hello"
+                        end function
+                    end namespace
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_1.expect)(parser.ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
+                const namespaceStmt = parser.ast.statements[0];
+                (0, chai_1.expect)(namespaceStmt.symbolTable).to.be.instanceof(SymbolTable_1.SymbolTable);
+                (0, chai_1.expect)(namespaceStmt.symbolTable.getSymbolType('funcInt').toString()).to.equal('function funcInt() as integer');
+                (0, chai_1.expect)(namespaceStmt.symbolTable.getSymbolType('funcStr')).to.be.instanceof(FunctionType_1.FunctionType);
+                const strFunctionType = namespaceStmt.symbolTable.getSymbolType('funcStr');
+                (0, chai_1.expect)(strFunctionType.returnType.toString()).to.equal('string');
+            });
+            it('adds a fully qualified name of a function in a namespace to the parsers symbol table', () => {
+                let parser = parse(`
+                    namespace Name.Space
+                        function funcInt() as integer
+                           return 3
+                        end function
+
+                        function funcStr() as string
+                           return "hello"
+                        end function
+                    end namespace
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_1.expect)(parser.symbolTable.getSymbolType('Name.Space.funcInt')).to.be.instanceof(FunctionType_1.FunctionType);
+                (0, chai_1.expect)(parser.symbolTable.getSymbolType('Name.Space.funcStr')).to.be.instanceof(FunctionType_1.FunctionType);
+            });
         });
         it('supports << operator', () => {
             var _a;
@@ -451,19 +546,19 @@ describe('parser', () => {
                 let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
                 (0, chai_1.expect)(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
                 let fnSmt = statements[0];
-                if ((0, astUtils_1.isFunctionStatement)(fnSmt)) {
+                if ((0, reflection_1.isFunctionStatement)(fnSmt)) {
                     let ifStmt = fnSmt.func.body.statements[0];
-                    if ((0, astUtils_1.isIfStatement)(ifStmt)) {
+                    if ((0, reflection_1.isIfStatement)(ifStmt)) {
                         expectCommentWithText(ifStmt.thenBranch.statements[0], `'comment 1`);
                         expectCommentWithText(ifStmt.thenBranch.statements[1], `'comment 2`);
                         expectCommentWithText(ifStmt.thenBranch.statements[3], `'comment 3`);
                         let elseIfBranch = ifStmt.elseBranch;
-                        if ((0, astUtils_1.isIfStatement)(elseIfBranch)) {
+                        if ((0, reflection_1.isIfStatement)(elseIfBranch)) {
                             expectCommentWithText(elseIfBranch.thenBranch.statements[0], `'comment 4`);
                             expectCommentWithText(elseIfBranch.thenBranch.statements[1], `'comment 5`);
                             expectCommentWithText(elseIfBranch.thenBranch.statements[3], `'comment 6`);
                             let elseBranch = elseIfBranch.elseBranch;
-                            if ((0, astUtils_1.isBlock)(elseBranch)) {
+                            if ((0, reflection_1.isBlock)(elseBranch)) {
                                 expectCommentWithText(elseBranch.statements[0], `'comment 7`);
                                 expectCommentWithText(elseBranch.statements[1], `'comment 8`);
                                 expectCommentWithText(elseBranch.statements[3], `'comment 9`);
@@ -605,7 +700,7 @@ describe('parser', () => {
             (0, chai_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.eql(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('import statements').message);
             (0, chai_1.expect)(statements[0]).to.be.instanceof(Statement_1.ImportStatement);
         });
-        it('catchs missing file path', () => {
+        it('catches missing file path', () => {
             var _a;
             let { statements, diagnostics } = parse(`
                 import
@@ -949,6 +1044,308 @@ describe('parser', () => {
             (0, chai_1.expect)(fn.annotations[0].getArguments()).to.deep.equal([-100]);
         });
     });
+    describe('getBscTypeFromExpression', () => {
+        it('computes void type for sub with no return type', () => {
+            const parser = parse(`
+                sub main()
+                    getMessage = sub()
+                        print "hello"
+                    end sub
+                end sub
+            `);
+            const func = parser.ast.statements[0].func;
+            const type = (0, Parser_1.getBscTypeFromExpression)(func.body.statements[0].value, func);
+            (0, chai_1.expect)(type.returnType).to.be.instanceof(VoidType_1.VoidType);
+        });
+        it('computes return type for sub with explicit return type', () => {
+            const parser = parse(`
+                sub main()
+                    getMessage = sub() as string
+                        return "hello"
+                    end sub
+                end sub
+            `);
+            const func = parser.ast.statements[0].func;
+            const type = (0, Parser_1.getBscTypeFromExpression)(func.body.statements[0].value, func);
+            (0, chai_1.expect)(type.returnType).to.be.instanceof(StringType_1.StringType);
+        });
+        it('supports sub with custom return type', () => {
+            const parser = parse(`
+                sub main()
+                    getPerson = sub() as Person
+                        return new Person()
+                    end sub
+                end sub
+
+                class Person
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            const func = parser.ast.statements[0].func;
+            const type = (0, Parser_1.getBscTypeFromExpression)(func.body.statements[0].value, func);
+            // Return type is LazyType, because "Person" is not fully known yet
+            (0, chai_1.expect)(type.returnType).to.be.instanceof(LazyType_1.LazyType);
+        });
+    });
+    describe('symbolTable', () => {
+        it('stores the types', () => {
+            const parser = parse(`
+                sub main()
+                    someNum = 123
+                    someString = "hello world"
+                    someObj = {foo: "bar"}
+                    someCustom = new CustomKlass()
+                end sub
+
+                class CustomKlass
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            const mainSymbolTable = parser.references.functionExpressions[0].symbolTable;
+            (0, chai_1.expect)(mainSymbolTable.getSymbolType('someNum')).to.be.instanceof(IntegerType_1.IntegerType);
+            (0, chai_1.expect)(mainSymbolTable.getSymbolType('someString')).to.be.instanceof(StringType_1.StringType);
+            (0, chai_1.expect)(mainSymbolTable.getSymbolType('someObj')).to.be.instanceof(ObjectType_1.ObjectType);
+            (0, chai_1.expect)(mainSymbolTable.getSymbolType('someCustom')).to.be.instanceof(CustomType_1.CustomType);
+        });
+        it('stores typed parameters in functions', () => {
+            const parser = parse(`
+                sub someFunc(param1 as string, param2 as integer)
+                    temp = param2
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            const someFuncSymbolTable = parser.references.functionExpressions[0].symbolTable;
+            (0, chai_1.expect)(someFuncSymbolTable.getSymbolType('param1')).to.be.instanceof(StringType_1.StringType);
+            (0, chai_1.expect)(someFuncSymbolTable.getSymbolType('param2')).to.be.instanceof(IntegerType_1.IntegerType);
+            (0, chai_1.expect)(someFuncSymbolTable.getSymbolType('temp')).to.be.instanceof(IntegerType_1.IntegerType);
+        });
+        it('properly defers typing lazy types', () => {
+            const parser = parse(`
+                sub someFunc()
+                    temp = foo()
+                end sub
+
+                function foo() as string
+                    return "foo"
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            const someFuncSymbolTable = parser.references.functionExpressions[0].symbolTable;
+            (0, chai_1.expect)((0, reflection_1.isLazyType)(someFuncSymbolTable.getSymbol('temp')[0].type)).to.be.true;
+            (0, chai_1.expect)(someFuncSymbolTable.getSymbolType('temp').toTypeString()).to.eq('string');
+        });
+        it('does not know about symbols declared in parent functions', () => {
+            const parser = parse(`
+                sub main()
+                    count = 0
+                    addOne = sub()
+                        oldVal = count
+                    end sub
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            const addOneSymbolTable = parser.references.functionExpressions[0].childFunctionExpressions[0].symbolTable;
+            (0, chai_1.expect)((0, reflection_1.isUninitializedType)(addOneSymbolTable.getSymbolType('oldVal'))).to.be.true;
+        });
+        it('finds params', () => {
+            const parser = parse(`
+                sub alert(p1, p2 as string, p3 = 1)
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+            (0, testHelpers_spec_1.expectSymbolTableEquals)(parser.references.functionExpressions[0].symbolTable, [
+                ['p1', new DynamicType_1.DynamicType(), util_1.default.createRange(1, 26, 1, 28)],
+                ['p2', new StringType_1.StringType(), util_1.default.createRange(1, 30, 1, 32)],
+                ['p3', new IntegerType_1.IntegerType(), util_1.default.createRange(1, 44, 1, 46)]
+            ]);
+        });
+        describe('loops', () => {
+            it('stores the loop variable in a for loop', () => {
+                const parser = parse(`
+                sub main()
+                    for i = 0 to 10 step 10
+                      print i
+                    end for
+                end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+                const currentSymbolTable = parser.references.functionExpressions[0].symbolTable;
+                (0, chai_1.expect)(currentSymbolTable.getSymbolType('i').toString()).to.eq('integer');
+            });
+            it('stores the loop variable in a for each loop', () => {
+                const parser = parse(`
+                sub doLoop(someData)
+                    for each datum in someData
+                      print datum
+                    end for
+                end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(parser.diagnostics);
+                const currentSymbolTable = parser.references.functionExpressions[0].symbolTable;
+                (0, chai_1.expect)(currentSymbolTable.getSymbolType('datum').toString()).to.eq('dynamic');
+            });
+        });
+    });
+    describe('tokenChain', () => {
+        it('can find a chain of tokens', () => {
+            const parser = parse(`
+            sub someFunc()
+                print m.field.childField
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const childFieldToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 38));
+            const tokenChain = parser.getTokenChain(childFieldToken).chain;
+            const tokenChainTokens = tokenChain.map(tcm => tcm.token);
+            (0, chai_1.expect)(tokenChain.length).to.equal(3);
+            (0, chai_1.expect)(tokenChainTokens.map(token => token.text)).to.eql(['m', 'field', 'childField']);
+            (0, chai_1.expect)(tokenChain.map(tcm => tcm.usage)).to.eql([Parser_1.TokenUsage.Direct, Parser_1.TokenUsage.Direct, Parser_1.TokenUsage.Direct]);
+        });
+        it('can find a chain of tokens with function call with no args in the middle', () => {
+            const parser = parse(`
+            sub someFunc()
+                print var.field.funcCall().childField
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const childFieldToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 49));
+            const tokenChain = parser.getTokenChain(childFieldToken).chain;
+            const tokenChainTokens = tokenChain.map(tcm => tcm.token);
+            (0, chai_1.expect)(tokenChain.length).to.equal(4);
+            (0, chai_1.expect)(tokenChainTokens.map(token => token.text)).to.eql(['var', 'field', 'funcCall', 'childField']);
+            (0, chai_1.expect)(tokenChain[2].usage).to.eql(Parser_1.TokenUsage.Call);
+        });
+        it('can find a chain of tokens with function call with multiple args in the middle', () => {
+            const parser = parse(`
+            sub someFunc()
+                print var.field.funcCall(1, "string", {key: value}).childField
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const childFieldToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 75));
+            const tokenChain = parser.getTokenChain(childFieldToken).chain;
+            const tokenChainTokens = tokenChain.map(tcm => tcm.token);
+            (0, chai_1.expect)(tokenChain.length).to.equal(4);
+            (0, chai_1.expect)(tokenChainTokens.map(token => token.text)).to.eql(['var', 'field', 'funcCall', 'childField']);
+            (0, chai_1.expect)(tokenChain[2].usage).to.eql(Parser_1.TokenUsage.Call);
+        });
+        it('can find a chain of tokens with function call with function call inside', () => {
+            const parser = parse(`
+            sub someFunc()
+                print var.field.funcCall(a(), b(), otherFunc2(c(), {d: func3(e)})).childField
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const childFieldToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 90));
+            const tokenChain = parser.getTokenChain(childFieldToken).chain;
+            const tokenChainTokens = tokenChain.map(tcm => tcm.token);
+            (0, chai_1.expect)(tokenChain.length).to.equal(4);
+            (0, chai_1.expect)(tokenChainTokens.map(token => token.text)).to.eql(['var', 'field', 'funcCall', 'childField']);
+            (0, chai_1.expect)(tokenChain[2].usage).to.eql(Parser_1.TokenUsage.Call);
+        });
+        it('can find a chain of tokens with array references inside', () => {
+            const parser = parse(`
+            sub someFunc()
+                print var.field.myArray[0].childField
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const childFieldToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 50));
+            const tokenChain = parser.getTokenChain(childFieldToken).chain;
+            const tokenChainTokens = tokenChain.map(tcm => tcm.token);
+            (0, chai_1.expect)(tokenChain.length).to.equal(4);
+            (0, chai_1.expect)(tokenChainTokens.map(token => token.text)).to.eql(['var', 'field', 'myArray', 'childField']);
+            (0, chai_1.expect)(tokenChain[2].usage).to.eql(Parser_1.TokenUsage.ArrayReference);
+        });
+        it('includes unknown when an expression in brackets is part of the chain', () => {
+            const parser = parse(`
+            sub someFunc()
+                print (1 + 1).toStr()
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const toStrToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 34));
+            const tokenChainResponse = parser.getTokenChain(toStrToken);
+            (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.true;
+        });
+        it('includes unknown when an expression in double brackets is part of the chain', () => {
+            const parser = parse(`
+            sub someFunc()
+                print ((2 + 1)*3).toStr()
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const toStrToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 38));
+            const tokenChainResponse = parser.getTokenChain(toStrToken);
+            (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.true;
+        });
+        it('includes unknown when a complicated expression in brackets is part of the chain', () => {
+            const parser = parse(`
+            sub someFunc(currentDate, lastUpdate)
+                print (INT((currentDate.asSeconds() - lastUpdate) / 86400)).toStr()
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const toStrToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 81));
+            const tokenChainResponse = parser.getTokenChain(toStrToken);
+            (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.true;
+        });
+    });
+    it('includes unknown when property is referenced via brackets', () => {
+        const parser = parse(`
+            sub someFunc()
+                complexObj = {prop: "hello", subObj: {prop: "foo", grandChildObj:{prop:"bar"}}}
+                print complexObj.subObj.prop
+                print complexObj["subObj"].prop
+                print complexObj["subObj"]["grandChildObj"].prop
+            end sub
+            `, Parser_1.ParseMode.BrighterScript);
+        const propAsChainToken = parser.getTokenAt(vscode_languageserver_1.Position.create(3, 44)); // complexObj.subObj.prop
+        const propAsAsBracketToken = parser.getTokenAt(vscode_languageserver_1.Position.create(4, 47)); // complexObj["subObj"].prop
+        const propAsAsDoubleBracketToken = parser.getTokenAt(vscode_languageserver_1.Position.create(5, 64)); // complexObj["subObj"]["grandChildObj"].prop
+        let tokenChainResponse = parser.getTokenChain(propAsChainToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['complexObj', 'subObj', 'prop']);
+        tokenChainResponse = parser.getTokenChain(propAsAsBracketToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain[0].usage).to.eql(Parser_1.TokenUsage.ArrayReference);
+        tokenChainResponse = parser.getTokenChain(propAsAsDoubleBracketToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.true;
+    });
+    it('allows token kinds from AllowedLocalIdentifiers as start of a chain', () => {
+        const parser = parse(`
+            sub testLocalIdentifiers(override, string, float)
+                override.someProp.someFunc()
+                string.someProp.someFunc()
+                float.someProp.someFunc()
+            end sub
+            `, Parser_1.ParseMode.BrightScript);
+        const overrideFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 40)); // override.someProp.someFunc()
+        const stringFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(3, 40)); // string.someProp.someFunc()
+        const floatFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(4, 38)); // float.someProp.someFunc()
+        let tokenChainResponse = parser.getTokenChain(overrideFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['override', 'someProp', 'someFunc']);
+        tokenChainResponse = parser.getTokenChain(stringFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['string', 'someProp', 'someFunc']);
+        tokenChainResponse = parser.getTokenChain(floatFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['float', 'someProp', 'someFunc']);
+    });
+    it('allows token kinds from AllowedProperties in middle of a chain', () => {
+        const parser = parse(`
+            sub testAllowedProperties(someObj)
+                someObj.override.someFunc()
+                someObj.string.someFunc()
+                someObj.float.someFunc()
+            end sub
+            `, Parser_1.ParseMode.BrightScript);
+        const overrideFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(2, 36)); // someObj.override.someFunc()
+        const stringFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(3, 36)); // someObj.string.someFunc()
+        const floatFuncToken = parser.getTokenAt(vscode_languageserver_1.Position.create(4, 36)); // someObj.float.someFunc()
+        let tokenChainResponse = parser.getTokenChain(overrideFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['someObj', 'override', 'someFunc']);
+        tokenChainResponse = parser.getTokenChain(stringFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['someObj', 'string', 'someFunc']);
+        tokenChainResponse = parser.getTokenChain(floatFuncToken);
+        (0, chai_1.expect)(tokenChainResponse.includesUnknowableTokenType).to.be.false;
+        (0, chai_1.expect)(tokenChainResponse.chain.map(tcm => tcm.token).map(token => token.text)).to.eql(['someObj', 'float', 'someFunc']);
+    });
 });
 function parse(text, mode) {
     let { tokens } = lexer_1.Lexer.scan(text);
@@ -966,7 +1363,7 @@ function rangeToArray(range) {
 }
 exports.rangeToArray = rangeToArray;
 function expectCommentWithText(stat, text) {
-    if ((0, astUtils_1.isCommentStatement)(stat)) {
+    if ((0, reflection_1.isCommentStatement)(stat)) {
         (0, chai_1.expect)(stat.text).to.equal(text);
     }
     else {