brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/parser/Parser.spec.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failStatementType = exports.rangeToArray = void 0;
-const chai_1 = require("chai");
-const lexer_1 = require("../lexer");
+exports.failStatementType = exports.rangeToArray = exports.parse = void 0;
+const chai_config_spec_1 = require("../chai-config.spec");
+const Lexer_1 = require("../lexer/Lexer");
+const TokenKind_1 = require("../lexer/TokenKind");
 const Expression_1 = require("./Expression");
 const Parser_1 = require("./Parser");
 const Statement_1 = require("./Statement");
@@ -10,96 +11,19 @@ const vscode_languageserver_1 = require("vscode-languageserver");
 const DiagnosticMessages_1 = require("../DiagnosticMessages");
 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 visitors_1 = require("../astUtils/visitors");
 const IntegerType_1 = require("../types/IntegerType");
-const ObjectType_1 = require("../types/ObjectType");
-const LazyType_1 = require("../types/LazyType");
-const SymbolTable_1 = require("../SymbolTable");
-const DynamicType_1 = require("../types/DynamicType");
+const FloatType_1 = require("../types/FloatType");
+const StringType_1 = require("../types/StringType");
+const types_1 = require("../types");
 const util_1 = require("../util");
+const InlineInterfaceType_1 = require("../types/InlineInterfaceType");
 describe('parser', () => {
     it('emits empty object when empty token list is provided', () => {
-        chai_1.expect(Parser_1.Parser.parse([])).to.deep.include({
-            statements: [],
-            diagnostics: []
-        });
-    });
-    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
-            `);
-            chai_1.expect(parser.references.functionExpressions[0].symbolTable.ownSymbols.map(x => x.name).sort()).to.eql([
-                'herd',
-                'humansAreAlive',
-                'i',
-                'isAlive',
-                'j',
-                'zombie'
-            ]);
-            parser.invalidateReferences();
-            chai_1.expect(parser.references.functionExpressions[0].symbolTable.ownSymbols.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();
-            chai_1.expect(parser.references.functionExpressions[0].symbolTable.ownSymbols.map(x => x.name)).to.eql([
-                'outerName',
-                'speak',
-                'age'
-            ]);
-            chai_1.expect(parser.references.functionExpressions[1].symbolTable.ownSymbols.map(x => x.name)).to.eql([
-                'innerName'
-            ]);
-        });
-        it('gets called if references are missing', () => {
-            const parser = Parser_1.Parser.parse(`
-                sub main()
-                end sub
-
-                sub UnusedFunction()
-                end sub
-            `);
-            chai_1.expect(parser.references.functionStatements.map(x => x.name.text)).to.eql([
-                'main',
-                'UnusedFunction'
-            ]);
-            //simulate a tree-shaking plugin by removing the `UnusedFunction`
-            parser.ast.statements.splice(1);
-            //tell the parser we modified the AST and need to regenerate references
-            parser.invalidateReferences();
-            chai_1.expect(parser['_references']).not.to.exist;
-            //calling `references` automatically regenerates the references
-            chai_1.expect(parser.references.functionStatements.map(x => x.name.text)).to.eql([
-                'main'
-            ]);
-        });
+        let { ast, diagnostics } = Parser_1.Parser.parse([]);
+        (0, chai_config_spec_1.expect)((0, reflection_1.isBody)(ast)).to.be.true;
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.empty;
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.empty;
     });
     describe('callfunc operator', () => {
         it('is not allowed in brightscript mode', () => {
@@ -109,7 +33,7 @@ describe('parser', () => {
                     node@.doSomething(1, 2)
                 end sub
             `, Parser_1.ParseMode.BrightScript);
-            chai_1.expect((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('callfunc operator').message);
+            (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('callfunc operator').message);
         });
         it('does not cause parse errors', () => {
             var _a, _b, _c, _d, _e;
@@ -118,17 +42,118 @@ describe('parser', () => {
                     node@.doSomething(1, 2)
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect((_e = (_d = (_c = (_b = parser.statements[0]) === null || _b === void 0 ? void 0 : _b.func) === null || _c === void 0 ? void 0 : _c.body) === null || _d === void 0 ? void 0 : _d.statements[0]) === null || _e === void 0 ? void 0 : _e.expression).to.be.instanceof(Expression_1.CallfuncExpression);
+            (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)((_e = (_d = (_c = (_b = parser.ast.statements[0]) === null || _b === void 0 ? void 0 : _b.func) === null || _c === void 0 ? void 0 : _c.body) === null || _d === void 0 ? void 0 : _d.statements[0]) === null || _e === void 0 ? void 0 : _e.expression).to.be.instanceof(Expression_1.CallfuncExpression);
+        });
+    });
+    it('flags function names with invalid characters', () => {
+        const { diagnostics } = Parser_1.Parser.parse(`
+            function alpha$() : end function
+            function beta%() : end function
+            function charlie!() : end function
+            function delta#() : end function
+            function echo&() : end function
+        `);
+        (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+            DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier('alpha$', '$'),
+            DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier('beta%', '%'),
+            DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier('charlie!', '!'),
+            DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier('delta#', '#'),
+            DiagnosticMessages_1.DiagnosticMessages.invalidIdentifier('echo&', '&')
+        ]);
+    });
+    describe('optional chaining operator', () => {
+        function getExpression(text, options) {
+            const parser = parse(text, options === null || options === void 0 ? void 0 : options.parseMode);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+            const expressions = parser.ast.findChildren(reflection_1.isExpression);
+            if (options === null || options === void 0 ? void 0 : options.matcher) {
+                return expressions.find(options.matcher);
+            }
+            else {
+                return expressions[0];
+            }
+        }
+        it('works for ?.', () => {
+            const expression = getExpression(`value = person?.name`);
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.DottedGetExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.dot.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
+        });
+        it('works for ?[', () => {
+            const expression = getExpression(`value = person?["name"]`, { matcher: reflection_1.isIndexedGetExpression });
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.IndexedGetExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingSquare.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftSquare);
+            (0, chai_config_spec_1.expect)(expression.tokens.questionDot).not.to.exist;
+        });
+        it('works for ?.[', () => {
+            var _a;
+            const expression = getExpression(`value = person?.["name"]`, { matcher: reflection_1.isIndexedGetExpression });
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.IndexedGetExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingSquare.kind).to.eql(TokenKind_1.TokenKind.LeftSquareBracket);
+            (0, chai_config_spec_1.expect)((_a = expression.tokens.questionDot) === null || _a === void 0 ? void 0 : _a.kind).to.eql(TokenKind_1.TokenKind.QuestionDot);
+        });
+        it('works for ?@', () => {
+            const expression = getExpression(`value = someXml?@someAttr`);
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.XmlAttributeGetExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.at.kind).to.eql(TokenKind_1.TokenKind.QuestionAt);
+        });
+        it('works for ?(', () => {
+            const expression = getExpression(`value = person.getName?()`);
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.CallExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+        });
+        it('works for print statements using question mark', () => {
+            const { ast } = parse(`
+                ?[1]
+                ?(1+1)
+            `);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceOf(Statement_1.PrintStatement);
+            (0, chai_config_spec_1.expect)(ast.statements[1]).to.be.instanceOf(Statement_1.PrintStatement);
+        });
+        //TODO enable this once we properly parse IIFEs
+        it.skip('works for ?( in anonymous function', () => {
+            const expression = getExpression(`thing = (function() : end function)?()`);
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.CallExpression);
+            (0, chai_config_spec_1.expect)(expression.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+        });
+        it('works for ?( in new call', () => {
+            const expression = getExpression(`thing = new Person?()`, { parseMode: Parser_1.ParseMode.BrighterScript });
+            (0, chai_config_spec_1.expect)(expression).to.be.instanceOf(Expression_1.NewExpression);
+            (0, chai_config_spec_1.expect)(expression.call.tokens.openingParen.kind).to.eql(TokenKind_1.TokenKind.QuestionLeftParen);
+        });
+        it('distinguishes between optional chaining and ternary expression', () => {
+            const parser = parse(`
+                sub main()
+                    name = person?["name"]
+                    isTrue = true
+                    key = isTrue ? ["name"] : ["age"]
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const assignmentStatements = parser.ast.findChildren(reflection_1.isAssignmentStatement);
+            (0, chai_config_spec_1.expect)(assignmentStatements[0].value).is.instanceof(Expression_1.IndexedGetExpression);
+            (0, chai_config_spec_1.expect)(assignmentStatements[2].value).is.instanceof(Expression_1.TernaryExpression);
+        });
+        it('distinguishes between optional chaining and ternary expression', () => {
+            const parser = parse(`
+                sub main()
+                    'optional chain. the lack of whitespace between ? and [ matters
+                    key = isTrue ?["name"] : getDefault()
+                    'ternary
+                    key = isTrue ? ["name"] : getDefault()
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const assignmentStatements = parser.ast.findChildren(reflection_1.isAssignmentStatement);
+            (0, chai_config_spec_1.expect)(assignmentStatements[0].value).is.instanceof(Expression_1.IndexedGetExpression);
+            (0, chai_config_spec_1.expect)(assignmentStatements[1].value).is.instanceof(Expression_1.TernaryExpression);
         });
     });
     describe('diagnostic locations', () => {
         it('tracks basic diagnostic locations', () => {
-            chai_1.expect(parse(`
+            (0, chai_config_spec_1.expect)(parse(`
                 sub main()
                     call()a
                 end sub
-            `).diagnostics.map(x => rangeToArray(x.range))).to.eql([
+            `).diagnostics.map(x => rangeToArray(x.location.range))).to.eql([
                 [2, 26, 2, 27],
                 [2, 27, 2, 28]
             ]);
@@ -140,8 +165,8 @@ describe('parser', () => {
                     return "6c5cdf1"
                 end functionasdf
             `).diagnostics;
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist.and.to.eql(DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression().message);
-            chai_1.expect((_b = diagnostics[0]) === null || _b === void 0 ? void 0 : _b.range).to.eql(vscode_languageserver_1.Range.create(3, 20, 3, 32));
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist.and.to.eql(DiagnosticMessages_1.DiagnosticMessages.expectedStatement().message);
+            (0, chai_config_spec_1.expect)((_b = diagnostics[0]) === null || _b === void 0 ? void 0 : _b.location.range).to.eql(vscode_languageserver_1.Range.create(3, 20, 3, 32));
         });
     });
     describe('parse', () => {
@@ -154,7 +179,7 @@ describe('parser', () => {
                     end function()
                 end sub
             `);
-            testHelpers_spec_1.expectZeroDiagnostics(parser);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
         });
         it('supports grouped iife in assignment', () => {
             const parser = parse(`
@@ -165,7 +190,7 @@ describe('parser', () => {
                     end function)()
                 end sub
             `);
-            testHelpers_spec_1.expectZeroDiagnostics(parser);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
         });
         it('supports returning iife call', () => {
             const parser = parse(`
@@ -174,45 +199,143 @@ describe('parser', () => {
                     end sub)()
                 end sub
             `);
-            testHelpers_spec_1.expectZeroDiagnostics(parser);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
         });
         it('supports using "interface" as parameter name', () => {
             var _a;
-            chai_1.expect((_a = parse(`
+            (0, chai_config_spec_1.expect)((_a = parse(`
                 sub main(interface as object)
                 end sub
             `, Parser_1.ParseMode.BrighterScript).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
         });
+        it('does not scrap the entire function when encountering unknown parameter type', () => {
+            const parser = parse(`
+                sub test(param1 as unknownType)
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            // type validation happens at scope validation, not at the parser
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(parser.ast.statements[0])).to.be.true;
+        });
+        it('does not scrap the entire function when encountering unknown parameter type in brightscript mode', () => {
+            const parser = parse(`
+                sub test(param1 as unknownType)
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            // type validation happens at scope validation, not at the parser
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser, DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types'));
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(parser.ast.statements[0])).to.be.true;
+        });
+        it('adds diagnostics when missing end for statements', () => {
+            let parser = parse(`
+                sub test1(x)
+                    for each item in x
+                        print item
+                 end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop('for each')
+            ]);
+            parser = parse(`
+                sub test2()
+                    for i = 0 to 10
+                        print i
+                 end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedEndForOrNextToTerminateForLoop('for')
+            ]);
+            parser = parse(`
+                sub test3(x )
+                    for each item in x
+                        print item
+                    next
+
+                    for i = 0 to 10
+                        print i
+                    next ' next works the same as "end for"
+                 end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+        });
+        it('does not allow return type as invalid', () => {
+            let parser = parse(`
+                function test(x) as invalid
+                    return invalid
+                 end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('as').message
+            ]);
+        });
+        it('does not allow param type as invalid', () => {
+            let parser = parse(`
+                function test(x as invalid)
+                    return invalid
+                 end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('as').message
+            ]);
+        });
+        it('validates when theres a fraction hex', () => {
+            let parser = parse(`
+                function test()
+                    x = &HFF.01234
+                    return x
+                end function
+            `);
+            (0, testHelpers_spec_1.expectDiagnostics)(parser, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedStatement(),
+                DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon()
+            ]);
+        });
+        it('allows print statement with hex followed by dot <number>', () => {
+            let parser = parse(`
+                function test()
+                    print  &HFF.01234
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+        });
         describe('namespace', () => {
-            it('catches namespaces declared not at root level', () => {
-                var _a;
-                chai_1.expect((_a = parse(`
-                    sub main()
-                        namespace Name.Space
+            it('allows namespaces declared inside other namespaces', () => {
+                const parser = parse(`
+                    namespace Level1
+                        namespace Level2.Level3
+                            sub main()
+                            end sub
                         end namespace
-                    end sub
-                `, Parser_1.ParseMode.BrighterScript).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtRootLevel('namespace').message);
+                    end namespace
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+                // We expect these names to be "as given" in this context, because we aren't evaluating a full program.
+                const namespaceStatements = parser.ast.findChildren(reflection_1.isNamespaceStatement);
+                (0, chai_config_spec_1.expect)(namespaceStatements.map(statement => statement.getName(Parser_1.ParseMode.BrighterScript))).to.have.deep.members([
+                    'Level1.Level2.Level3',
+                    'Level1'
+                ]);
             });
             it('parses empty namespace', () => {
                 var _a;
-                let { statements, diagnostics } = parse(`
+                let { ast, diagnostics } = parse(`
                         namespace Name.Space
                         end namespace
                     `, Parser_1.ParseMode.BrighterScript);
-                chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-                chai_1.expect(statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+                (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
             });
             it('includes body', () => {
                 var _a;
-                let { statements, diagnostics } = parse(`
+                let { ast, diagnostics } = parse(`
                         namespace Name.Space
                             sub main()
                             end sub
                         end namespace
                     `, Parser_1.ParseMode.BrighterScript);
-                chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-                chai_1.expect(statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
-                chai_1.expect(statements[0].body.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+                (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
+                (0, chai_config_spec_1.expect)(ast.statements[0].body.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
             });
             it('supports comments and newlines', () => {
                 var _a;
@@ -228,7 +351,7 @@ describe('parser', () => {
                             'comment
                         end namespace 'comment
                     `, Parser_1.ParseMode.BrighterScript);
-                chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
             });
             it('catches missing name', () => {
                 var _a;
@@ -236,7 +359,7 @@ describe('parser', () => {
                         namespace
                         end namespace
                     `, Parser_1.ParseMode.BrighterScript);
-                chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifierAfterKeyword('namespace').message);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('namespace').message);
             });
             it('recovers after missing `end namespace`', () => {
                 var _a, _b, _c;
@@ -245,9 +368,9 @@ describe('parser', () => {
                         sub main()
                         end sub
                 `, Parser_1.ParseMode.BrighterScript);
-                chai_1.expect(parser.ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
-                chai_1.expect((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace').message);
-                chai_1.expect((_c = (_b = parser.ast.statements[0]) === null || _b === void 0 ? void 0 : _b.body) === null || _c === void 0 ? void 0 : _c.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+                (0, chai_config_spec_1.expect)(parser.ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
+                (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.couldNotFindMatchingEndKeyword('namespace').message);
+                (0, chai_config_spec_1.expect)((_c = (_b = parser.ast.statements[0]) === null || _b === void 0 ? void 0 : _b.body) === null || _c === void 0 ? void 0 : _c.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
             });
             it('adds diagnostic when encountering namespace in brightscript mode', () => {
                 var _a;
@@ -255,47 +378,12 @@ describe('parser', () => {
                     namespace Name.Space
                     end namespace
                 `);
-                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);
-                chai_1.expect(parser.ast.statements[0]).to.be.instanceof(Statement_1.NamespaceStatement);
-                const namespaceStmt = parser.ast.statements[0];
-                chai_1.expect(namespaceStmt.symbolTable).to.be.instanceof(SymbolTable_1.SymbolTable);
-                chai_1.expect(namespaceStmt.symbolTable.getSymbolType('funcInt').toString()).to.equal('function funcInt() as integer');
-                chai_1.expect(namespaceStmt.symbolTable.getSymbolType('funcStr')).to.be.instanceof(FunctionType_1.FunctionType);
-                const strFunctionType = namespaceStmt.symbolTable.getSymbolType('funcStr');
-                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);
-                chai_1.expect(parser.symbolTable.getSymbolType('Name.Space.funcInt')).to.be.instanceof(FunctionType_1.FunctionType);
-                chai_1.expect(parser.symbolTable.getSymbolType('Name.Space.funcStr')).to.be.instanceof(FunctionType_1.FunctionType);
+                (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('namespace').message);
             });
         });
         it('supports << operator', () => {
             var _a;
-            chai_1.expect((_a = parse(`
+            (0, chai_config_spec_1.expect)((_a = parse(`
                 sub main()
                     print ((r << 24) + (g << 16) + (b << 8) + a)
                 end sub
@@ -303,7 +391,7 @@ describe('parser', () => {
         });
         it('supports >> operator', () => {
             var _a;
-            chai_1.expect((_a = parse(`
+            (0, chai_config_spec_1.expect)((_a = parse(`
                 sub main()
                     print ((r >> 24) + (g >> 16) + (b >> 8) + a)
                 end sub
@@ -311,7 +399,7 @@ describe('parser', () => {
         });
         it('allows global function names with same as token to be called', () => {
             var _a;
-            chai_1.expect((_a = parse(`
+            (0, chai_config_spec_1.expect)((_a = parse(`
                 sub main()
                     print string(123)
                 end sub
@@ -325,18 +413,18 @@ describe('parser', () => {
                     age = personXml.firstChild@age
                 end sub
             `);
-            chai_1.expect((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
-            let statements = parser.statements[0].func.body.statements;
-            let first = statements[0].value;
-            chai_1.expect(first).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
-            chai_1.expect(first.name.text).to.equal('firstName');
-            chai_1.expect(first.at.text).to.equal('@');
-            chai_1.expect(first.obj.name.text).to.equal('personXml');
-            let second = statements[1].value;
-            chai_1.expect(second).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
-            chai_1.expect(second.name.text).to.equal('age');
-            chai_1.expect(second.at.text).to.equal('@');
-            chai_1.expect(second.obj.name.text).to.equal('firstChild');
+            (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
+            let assignments = parser.ast.statements[0].func.body.statements;
+            let first = assignments[0].value;
+            (0, chai_config_spec_1.expect)(first).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
+            (0, chai_config_spec_1.expect)(first.tokens.name.text).to.equal('firstName');
+            (0, chai_config_spec_1.expect)(first.tokens.at.text).to.equal('@');
+            (0, chai_config_spec_1.expect)(first.obj.tokens.name.text).to.equal('personXml');
+            let second = assignments[1].value;
+            (0, chai_config_spec_1.expect)(second).to.be.instanceof(Expression_1.XmlAttributeGetExpression);
+            (0, chai_config_spec_1.expect)(second.tokens.name.text).to.equal('age');
+            (0, chai_config_spec_1.expect)(second.tokens.at.text).to.equal('@');
+            (0, chai_config_spec_1.expect)(second.obj.tokens.name.text).to.equal('firstChild');
         });
         it('does not allow chaining of @ symbols', () => {
             let parser = parse(`
@@ -345,58 +433,58 @@ describe('parser', () => {
                     name = personXml@name@age@shoeSize
                 end sub
             `);
-            chai_1.expect(parser.diagnostics).not.to.be.empty;
+            (0, chai_config_spec_1.expect)(parser.diagnostics).not.to.be.empty;
         });
         it('unknown function type does not invalidate rest of function', () => {
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 function log() as UNKNOWN_TYPE
                 end function
             `, Parser_1.ParseMode.BrightScript);
-            chai_1.expect(diagnostics.length).to.be.greaterThan(0);
-            chai_1.expect(statements[0]).to.exist;
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types').message); // type validation happens at scope validation step
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.exist;
         });
         it('unknown function type is not a problem in Brighterscript mode', () => {
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 function log() as UNKNOWN_TYPE
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect(diagnostics.length).to.equal(0);
-            chai_1.expect(statements[0]).to.exist;
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.exist;
         });
         it('allows namespaced function type in Brighterscript mode', () => {
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 function log() as SOME_NAMESPACE.UNKNOWN_TYPE
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect(diagnostics.length).to.equal(0);
-            chai_1.expect(statements[0]).to.exist;
+            (0, chai_config_spec_1.expect)(diagnostics.length).to.equal(0);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.exist;
         });
         it('allows custom parameter types in BrighterscriptMode', () => {
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 sub foo(value as UNKNOWN_TYPE)
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect(diagnostics.length).to.equal(0);
-            chai_1.expect(statements[0]).to.exist;
+            (0, chai_config_spec_1.expect)(diagnostics.length).to.equal(0);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.exist;
         });
-        it('does not allow custom parameter types in Brightscript Mode', () => {
+        it('does cause diagnostics when custom parameter types are used in Brightscript Mode', () => {
             let { diagnostics } = parse(`
                 sub foo(value as UNKNOWN_TYPE)
                 end sub
             `, Parser_1.ParseMode.BrightScript);
-            chai_1.expect(diagnostics.length).not.to.equal(0);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types').message);
         });
         it('allows custom namespaced parameter types in BrighterscriptMode', () => {
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 sub foo(value as SOME_NAMESPACE.UNKNOWN_TYPE)
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect(diagnostics.length).to.equal(0);
-            chai_1.expect(statements[0]).to.exist;
+            (0, chai_config_spec_1.expect)(diagnostics.length).to.equal(0);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.exist;
         });
         it('works with conditionals', () => {
             var _a;
-            chai_1.expect((_a = parse(`
+            (0, chai_config_spec_1.expect)((_a = parse(`
                 function printNumber()
                     if true then
                         print 1
@@ -408,11 +496,11 @@ describe('parser', () => {
         });
         it('supports single-line if statements', () => {
             var _a;
-            chai_1.expect((_a = parse(`If true Then print "error" : Stop`).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
+            (0, chai_config_spec_1.expect)((_a = parse(`If true Then print "error" : Stop`).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
         });
         it('works with excess newlines', () => {
             var _a;
-            let { tokens } = lexer_1.Lexer.scan('function boolToNumber() as string\n\n' +
+            let { tokens } = Lexer_1.Lexer.scan('function boolToNumber() as string\n\n' +
                 '   if true then\n\n' +
                 '       print 1\n\n' +
                 '   elseif true then\n\n' +
@@ -421,112 +509,230 @@ describe('parser', () => {
                 '       print 1\n\n' +
                 '   end if\n\n' +
                 'end function\n\n');
-            chai_1.expect((_a = Parser_1.Parser.parse(tokens).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
+            (0, chai_config_spec_1.expect)((_a = Parser_1.Parser.parse(tokens).diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.not.exist;
         });
         it('does not invalidate entire file when line ends with a period', () => {
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 sub main()
                     person.a
                 end sub
 
             `);
             let { diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(1, 'Error count should be 0');
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1, 'Error count should be 0');
         });
-        it.skip('allows printing object with trailing period', () => {
-            let { tokens } = lexer_1.Lexer.scan(`print a.`);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            let printStatement = statements[0];
-            chai_1.expect(diagnostics).to.be.empty;
-            chai_1.expect(printStatement).to.be.instanceof(Statement_1.PrintStatement);
-            chai_1.expect(printStatement.expressions[0]).to.be.instanceof(Expression_1.DottedGetExpression);
+        it('allows printing object with trailing period', () => {
+            let { tokens } = Lexer_1.Lexer.scan(`print a.`);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            let printStatement = ast.statements[0];
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier());
+            (0, chai_config_spec_1.expect)(printStatement).to.be.instanceof(Statement_1.PrintStatement);
+            (0, chai_config_spec_1.expect)(printStatement.expressions[0]).to.be.instanceof(Expression_1.VariableExpression);
+        });
+        it('allows printing object with trailing period with multiple dotted gets', () => {
+            let { tokens } = Lexer_1.Lexer.scan(`print a.b.`);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            let printStatement = ast.statements[0];
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier());
+            (0, chai_config_spec_1.expect)(printStatement).to.be.instanceof(Statement_1.PrintStatement);
+            (0, chai_config_spec_1.expect)(printStatement.expressions[0]).to.be.instanceof(Expression_1.DottedGetExpression);
+        });
+        describe('incomplete statements in the ast', () => {
+            it('adds variable expressions to the ast', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function a()
+                        NameA.
+                    end function
+
+                    namespace NameA
+                        sub noop()
+                        end sub
+                    end namespace
+                `);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedStatement());
+                let stmt = ast.statements[0].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
+                (0, chai_config_spec_1.expect)((0, reflection_1.isVariableExpression)((stmt).expression)).to.be.true;
+                (0, chai_config_spec_1.expect)(stmt.expression.tokens.name.text).to.equal('NameA');
+            });
+            it('adds unended call statements', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function a()
+                        lcase(
+                    end function
+                `);
+                let { ast } = Parser_1.Parser.parse(tokens);
+                let stmt = ast.statements[0].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
+                (0, chai_config_spec_1.expect)((0, reflection_1.isCallExpression)((stmt).expression)).to.be.true;
+                (0, chai_config_spec_1.expect)(stmt.expression.callee.tokens.name.text).to.equal('lcase');
+            });
+            it('adds unended indexed get statements', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function a()
+                        nums[
+                    end function
+
+                    const nums = [1, 2, 3]
+                `);
+                let { ast } = Parser_1.Parser.parse(tokens);
+                let stmt = ast.statements[0].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
+                (0, chai_config_spec_1.expect)((0, reflection_1.isIndexedGetExpression)((stmt).expression)).to.be.true;
+                (0, chai_config_spec_1.expect)(stmt.expression.obj.tokens.name.text).to.equal('nums');
+            });
+            it('adds dotted gets', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function foo(a as KlassA)
+                        a.b.
+                    end function
+
+                    class KlassA
+                        b as KlassB
+                    end class
+
+                    class KlassB
+                        sub noop()
+                        end sub
+                    end class
+                `);
+                let { ast } = Parser_1.Parser.parse(tokens);
+                let stmt = ast.statements[0].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
+                (0, chai_config_spec_1.expect)((0, reflection_1.isDottedGetExpression)((stmt).expression)).to.be.true;
+                (0, chai_config_spec_1.expect)(stmt.expression.obj.tokens.name.text).to.equal('a');
+                (0, chai_config_spec_1.expect)(stmt.expression.tokens.name.text).to.equal('b');
+            });
+            it('adds function statement with missing type after as', () => {
+                var _a;
+                let parser = parse(`
+                    sub foo(thing as  )
+                        print thing
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+                (0, chai_config_spec_1.expect)(parser.ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            });
+            it('adds binary expressions to the ast', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function a(x, y)
+                        1 or 2
+                        x * y
+                        x + y
+                        x - y
+                    end function
+                `);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedStatement());
+                for (const stmt of ast.statements[0].func.body.statements) {
+                    (0, chai_config_spec_1.expect)((0, reflection_1.isExpressionStatement)(stmt)).to.be.true;
+                    (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)((stmt).expression)).to.be.true;
+                }
+            });
+            it('adds callfunc expressions', () => {
+                var _a;
+                let parser = parse(`
+                    sub foo(thing)
+                        thing@.
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+                let body = parser.ast.statements[0].func.body;
+                let callFunc = body.findChild(reflection_1.isCallfuncExpression);
+                (0, chai_config_spec_1.expect)(callFunc).to.exist;
+            });
+            it('adds if statements', () => {
+                var _a;
+                let parser = parse(`
+                    sub foo(thing)
+                        if thing.
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+                let body = parser.ast.statements[0].func.body;
+                let ifStmt = body.findChild(reflection_1.isIfStatement);
+                (0, chai_config_spec_1.expect)(ifStmt).to.exist;
+            });
         });
         describe('comments', () => {
-            it('combines multi-line comments', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+            it('does not include comments', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
                     'line 1
                     'line 2
                     'line 3
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
-                chai_1.expect(statements[0].text).to.equal(`'line 1\n'line 2\n'line 3`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.equal(0);
             });
-            it('does not combile comments separated by newlines', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+            it('does matter if comments separated by newlines', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
                     'line 1
 
                     'line 2
 
                     'line 3
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
-                chai_1.expect(statements).to.be.lengthOf(3);
-                chai_1.expect(statements[0].text).to.equal(`'line 1`);
-                chai_1.expect(statements[1].text).to.equal(`'line 2`);
-                chai_1.expect(statements[2].text).to.equal(`'line 3`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+                (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(0);
             });
             it('works after print statement', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     sub main()
                         print "hi" 'comment 1
                     end sub
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
-                chai_1.expect(statements[0].func.body.statements[1].text).to.equal(`'comment 1`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+                (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements.length).to.equal(1);
             });
-            it('declaration-level', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+            it('declaration-level should be set as leading trivia', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
                     'comment 1
                     function a()
                     end function
                     'comment 2
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
-                chai_1.expect(statements[0].text).to.equal(`'comment 1`);
-                chai_1.expect(statements[2].text).to.equal(`'comment 2`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
+                (0, chai_config_spec_1.expect)(ast.statements[0].leadingTrivia[2].text).to.equal(`'comment 1`);
             });
             it('works in aa literal as its own statement', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     obj = {
                         "name": true,
                         'comment
                     }
                 `);
                 let { diagnostics } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Error count should be 0');
             });
             it('parses after function call', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     sub Main()
                         name = "Hello"
                         DoSomething(name) 'comment 1
                     end sub
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
-                chai_1.expect(statements[0].func.body.statements[2].text).to.equal(`'comment 1`);
+                let { diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
             });
             it('function', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     function a() 'comment 1
                         'comment 2
                         num = 1
                         'comment 3
                     end function 'comment 4
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
-                chai_1.expect(statements[0].func.body.statements[0].text).to.equal(`'comment 1`);
-                chai_1.expect(statements[0].func.body.statements[1].text).to.equal(`'comment 2`);
-                chai_1.expect(statements[0].func.body.statements[3].text).to.equal(`'comment 3`);
-                chai_1.expect(statements[1].text).to.equal(`'comment 4`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
+                (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements[0].leadingTrivia.filter(x => x.kind === TokenKind_1.TokenKind.Comment).map(x => x.text)).members([`'comment 1`, `'comment 2`]);
             });
             it('if statement`', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     function a()
                         if true then 'comment 1
                             'comment 2
@@ -543,25 +749,19 @@ describe('parser', () => {
                         end if 'comment 10
                     end function
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
-                let fnSmt = statements[0];
-                if (reflection_1.isFunctionStatement(fnSmt)) {
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Should have zero diagnostics');
+                let fnSmt = ast.statements[0];
+                if ((0, reflection_1.isFunctionStatement)(fnSmt)) {
                     let ifStmt = fnSmt.func.body.statements[0];
-                    if (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`);
+                    if ((0, reflection_1.isIfStatement)(ifStmt)) {
+                        expectCommentWithText(ifStmt.thenBranch.statements[0], `'comment 1\n'comment 2`);
                         let elseIfBranch = ifStmt.elseBranch;
-                        if (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`);
+                        if ((0, reflection_1.isIfStatement)(elseIfBranch)) {
+                            expectCommentWithText(elseIfBranch.thenBranch.statements[0], `'comment 4\n'comment 5`);
                             let elseBranch = elseIfBranch.elseBranch;
-                            if (reflection_1.isBlock(elseBranch)) {
-                                expectCommentWithText(elseBranch.statements[0], `'comment 7`);
-                                expectCommentWithText(elseBranch.statements[1], `'comment 8`);
-                                expectCommentWithText(elseBranch.statements[3], `'comment 9`);
+                            if ((0, reflection_1.isBlock)(elseBranch)) {
+                                expectCommentWithText(elseBranch.statements[0], `'comment 7\n'comment 8`);
                             }
                             else {
                                 failStatementType(elseBranch, 'Block');
@@ -570,7 +770,6 @@ describe('parser', () => {
                         else {
                             failStatementType(elseIfBranch, 'If');
                         }
-                        expectCommentWithText(fnSmt.func.body.statements[1], `'comment 10`);
                     }
                     else {
                         failStatementType(ifStmt, 'If');
@@ -581,7 +780,7 @@ describe('parser', () => {
                 }
             });
             it('while', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     function a()
                         while true 'comment 1
                             'comment 2
@@ -590,16 +789,13 @@ describe('parser', () => {
                         end while 'comment 4
                     end function
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
-                let stmt = statements[0].func.body.statements[0];
-                chai_1.expect(stmt.body.statements[0].text).to.equal(`'comment 1`);
-                chai_1.expect(stmt.body.statements[1].text).to.equal(`'comment 2`);
-                chai_1.expect(stmt.body.statements[3].text).to.equal(`'comment 3`);
-                chai_1.expect(statements[0].func.body.statements[1].text).to.equal(`'comment 4`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
+                let stmt = ast.statements[0].func.body.statements[0];
+                expectCommentWithText(stmt.body.statements[0], `'comment 1\n'comment 2`);
             });
             it('for', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     function a()
                         for i = 0 to 10 step 1 'comment 1
                             'comment 2
@@ -608,16 +804,13 @@ describe('parser', () => {
                         end for 'comment 4
                     end function
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
-                let stmt = statements[0].func.body.statements[0];
-                chai_1.expect(stmt.body.statements[0].text).to.equal(`'comment 1`);
-                chai_1.expect(stmt.body.statements[1].text).to.equal(`'comment 2`);
-                chai_1.expect(stmt.body.statements[3].text).to.equal(`'comment 3`);
-                chai_1.expect(statements[0].func.body.statements[1].text).to.equal(`'comment 4`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
+                let stmt = ast.statements[0].func.body.statements[0];
+                expectCommentWithText(stmt.body.statements[0], `'comment 1\n'comment 2`);
             });
             it('for each', () => {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     function a()
                         for each val in [1,2,3] 'comment 1
                             'comment 2
@@ -626,13 +819,10 @@ describe('parser', () => {
                         end for 'comment 4
                     end function
                 `);
-                let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
-                let stmt = statements[0].func.body.statements[0];
-                chai_1.expect(stmt.body.statements[0].text).to.equal(`'comment 1`);
-                chai_1.expect(stmt.body.statements[1].text).to.equal(`'comment 2`);
-                chai_1.expect(stmt.body.statements[3].text).to.equal(`'comment 3`);
-                chai_1.expect(statements[0].func.body.statements[1].text).to.equal(`'comment 4`);
+                let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0, 'Error count should be zero');
+                let stmt = ast.statements[0].func.body.statements[0];
+                expectCommentWithText(stmt.body.statements[0], `'comment 1\n'comment 2`);
             });
         });
     });
@@ -644,7 +834,7 @@ describe('parser', () => {
                         then = true
                     end sub
                 `);
-                chai_1.expect(diagnostics).to.be.lengthOf(1);
+                (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
             });
             it('is allowed as an AA property name', () => {
                 var _a;
@@ -657,7 +847,39 @@ describe('parser', () => {
                         print person.then
                     end sub
                 `);
-                chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            });
+            it('allows `mod` as an AA literal property', () => {
+                const parser = parse(`
+                    sub main()
+                        person = {
+                            mod: true
+                        }
+                        person.mod = false
+                        print person.mod
+                    end sub
+                `);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+            });
+            it('converts aa literal property TokenKind to Identifier', () => {
+                const parser = parse(`
+                    sub main()
+                        person = {
+                            mod: true
+                            and: true
+                        }
+                    end sub
+                `);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(parser);
+                const elements = [];
+                parser.ast.walk((0, visitors_1.createVisitor)({
+                    AAMemberExpression: (node) => {
+                        elements.push(node);
+                    }
+                }), {
+                    walkMode: visitors_1.WalkMode.visitAllRecursive
+                });
+                (0, chai_config_spec_1.expect)(elements.map(x => x.tokens.key.kind)).to.eql([TokenKind_1.TokenKind.Identifier, TokenKind_1.TokenKind.Identifier]);
             });
         });
         it('"end" is not allowed as a local identifier', () => {
@@ -666,47 +888,47 @@ describe('parser', () => {
                     end = true
                 end sub
             `);
-            chai_1.expect(diagnostics).to.be.length.greaterThan(0);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
         });
         it('none of them can be used as local variables', () => {
-            let reservedWords = new Set(lexer_1.ReservedWords);
+            let reservedWords = new Set(TokenKind_1.ReservedWords);
             //remove the rem keyword because it's a comment...won't cause error
             reservedWords.delete('rem');
             for (let reservedWord of reservedWords) {
-                let { tokens } = lexer_1.Lexer.scan(`
+                let { tokens } = Lexer_1.Lexer.scan(`
                     sub main()
                         ${reservedWord} = true
                     end sub
                 `);
                 let { diagnostics } = Parser_1.Parser.parse(tokens);
-                chai_1.expect(diagnostics, `assigning to reserved word "${reservedWord}" should have been an error`).to.be.length.greaterThan(0);
+                (0, chai_config_spec_1.expect)(diagnostics, `assigning to reserved word "${reservedWord}" should have been an error`).to.be.length.greaterThan(0);
             }
         });
     });
     describe('import keyword', () => {
         it('parses without errors', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 import "somePath"
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.ImportStatement);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.ImportStatement);
         });
         it('catches import statements used in brightscript files', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 import "somePath"
             `, Parser_1.ParseMode.BrightScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.eql(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('import statements').message);
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.ImportStatement);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.eql(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('import statements').message);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.ImportStatement);
         });
         it('catchs missing file path', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 import
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import').message);
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.ImportStatement);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedStringLiteralAfterKeyword('import').message);
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.ImportStatement);
         });
     });
     describe('Annotations', () => {
@@ -717,7 +939,7 @@ describe('parser', () => {
                 sub main()
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.foundUnexpectedToken('@').message);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unexpectedToken('@').message);
         });
         it('properly handles empty annotation above class method', () => {
             var _a;
@@ -729,7 +951,7 @@ describe('parser', () => {
                     end sub
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier().message);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier().message);
         });
         it('parses with error if annotation is not followed by a statement', () => {
             var _a, _b, _c, _d;
@@ -743,15 +965,15 @@ describe('parser', () => {
                 end class
                 @meta1
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect(diagnostics.length).to.equal(4);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
-            chai_1.expect((_b = diagnostics[1]) === null || _b === void 0 ? void 0 : _b.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
-            chai_1.expect((_c = diagnostics[2]) === null || _c === void 0 ? void 0 : _c.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
-            chai_1.expect((_d = diagnostics[3]) === null || _d === void 0 ? void 0 : _d.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
+            (0, chai_config_spec_1.expect)(diagnostics.length).to.equal(4);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
+            (0, chai_config_spec_1.expect)((_b = diagnostics[1]) === null || _b === void 0 ? void 0 : _b.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
+            (0, chai_config_spec_1.expect)((_c = diagnostics[2]) === null || _c === void 0 ? void 0 : _c.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
+            (0, chai_config_spec_1.expect)((_d = diagnostics[3]) === null || _d === void 0 ? void 0 : _d.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.unusedAnnotation().message);
         });
         it('attaches an annotation to next statement', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1
                 function main()
                 end function
@@ -759,69 +981,69 @@ describe('parser', () => {
                 @meta2 sub init()
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
-            let fn = statements[0];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[0].nameToken.text).to.equal('meta1');
-            chai_1.expect(fn.annotations[0].name).to.equal('meta1');
-            chai_1.expect(statements[1]).to.be.instanceof(Statement_1.FunctionStatement);
-            fn = statements[1];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[0].nameToken.text).to.equal('meta2');
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta1');
+            (0, chai_config_spec_1.expect)(fn.annotations[0].name).to.equal('meta1');
+            (0, chai_config_spec_1.expect)(ast.statements[1]).to.be.instanceof(Statement_1.FunctionStatement);
+            fn = ast.statements[1];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta2');
         });
         it('attaches annotations inside a function body', () => {
             var _a, _b;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 function main()
                     @meta1
                     print "hello"
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let fn = statements[0];
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let fn = ast.statements[0];
             let fnStatements = fn.func.body.statements;
             let stat = fnStatements[0];
-            chai_1.expect(stat).to.exist;
-            chai_1.expect((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(stat).to.exist;
+            (0, chai_config_spec_1.expect)((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('attaches multiple annotations to next statement', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1
                 @meta2 @meta3
                 function main()
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
-            let fn = statements[0];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations.length).to.equal(3);
-            chai_1.expect(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[1]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[2]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations.length).to.equal(3);
+            (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[1]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[2]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('allows annotations with parameters', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1("arg", 2, true, { prop: "value" })
                 function main()
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let fn = statements[0];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[0].nameToken.text).to.equal('meta1');
-            chai_1.expect(fn.annotations[0].call).to.be.instanceof(Expression_1.CallExpression);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[0].tokens.name.text).to.equal('meta1');
+            (0, chai_config_spec_1.expect)(fn.annotations[0].call).to.be.instanceof(Expression_1.CallExpression);
         });
         it('attaches annotations to a class', () => {
             var _a, _b;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1
                 class MyClass
                     function main()
@@ -829,14 +1051,14 @@ describe('parser', () => {
                     end function
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
-            chai_1.expect((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
+            (0, chai_config_spec_1.expect)((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('attaches annotations to multiple clases', () => {
             var _a, _b, _c;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1
                 class MyClass
                     function main()
@@ -850,19 +1072,19 @@ describe('parser', () => {
                     end function
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
-            chai_1.expect((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(cs.annotations[0].name).to.equal('meta1');
-            let cs2 = statements[1];
-            chai_1.expect((_c = cs2.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-            chai_1.expect(cs2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(cs2.annotations[0].name).to.equal('meta2');
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
+            (0, chai_config_spec_1.expect)((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(cs.annotations[0].name).to.equal('meta1');
+            let cs2 = ast.statements[1];
+            (0, chai_config_spec_1.expect)((_c = cs2.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(cs2.annotations[0].name).to.equal('meta2');
         });
         it('attaches annotations to a namespaced class', () => {
             var _a, _b;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 namespace ns
                     @meta1
                     class MyClass
@@ -872,15 +1094,15 @@ describe('parser', () => {
                     end class
                 end namespace
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let ns = statements[0];
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let ns = ast.statements[0];
             let cs = ns.body.statements[0];
-            chai_1.expect((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('attaches annotations to a namespaced class - multiple', () => {
             var _a, _b, _c;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 namespace ns
                     @meta1
                     class MyClass
@@ -896,20 +1118,20 @@ describe('parser', () => {
                     end class
                 end namespace
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let ns = statements[0];
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let ns = ast.statements[0];
             let cs = ns.body.statements[0];
-            chai_1.expect((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(cs.annotations[0].name).to.equal('meta1');
+            (0, chai_config_spec_1.expect)((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(cs.annotations[0].name).to.equal('meta1');
             let cs2 = ns.body.statements[1];
-            chai_1.expect((_c = cs2.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
-            chai_1.expect(cs2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(cs2.annotations[0].name).to.equal('meta2');
+            (0, chai_config_spec_1.expect)((_c = cs2.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(cs2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(cs2.annotations[0].name).to.equal('meta2');
         });
         it('attaches annotations to a class constructor', () => {
             var _a, _b;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 class MyClass
                     @meta1
                     function new()
@@ -920,15 +1142,15 @@ describe('parser', () => {
                     end function
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
             let stat = cs.body[0];
-            chai_1.expect((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('attaches annotations to a class methods', () => {
             var _a, _b;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 class MyClass
                     function new()
                         print "hello"
@@ -939,15 +1161,15 @@ describe('parser', () => {
                     end function
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
             let stat = cs.body[1];
-            chai_1.expect((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
-            chai_1.expect(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_b = stat.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(1);
+            (0, chai_config_spec_1.expect)(stat.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('attaches annotations to a class methods, fields and constructor', () => {
             var _a, _b, _c, _d, _e;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta2
                 @meta1
                 class MyClass
@@ -967,36 +1189,36 @@ describe('parser', () => {
                     public foo="bar"
                 end class
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
-            chai_1.expect((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
-            chai_1.expect(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
+            (0, chai_config_spec_1.expect)((_b = cs.annotations) === null || _b === void 0 ? void 0 : _b.length).to.equal(2);
+            (0, chai_config_spec_1.expect)(cs.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
             let stat1 = cs.body[0];
             let stat2 = cs.body[1];
             let f1 = cs.body[2];
-            chai_1.expect((_c = stat1.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
-            chai_1.expect(stat1.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect((_d = stat2.annotations) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
-            chai_1.expect(stat2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect((_e = f1.annotations) === null || _e === void 0 ? void 0 : _e.length).to.equal(2);
-            chai_1.expect(f1.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_c = stat1.annotations) === null || _c === void 0 ? void 0 : _c.length).to.equal(2);
+            (0, chai_config_spec_1.expect)(stat1.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_d = stat2.annotations) === null || _d === void 0 ? void 0 : _d.length).to.equal(2);
+            (0, chai_config_spec_1.expect)(stat2.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)((_e = f1.annotations) === null || _e === void 0 ? void 0 : _e.length).to.equal(2);
+            (0, chai_config_spec_1.expect)(f1.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
         });
         it('ignores annotations on commented out lines', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 '@meta1
                 '   @meta1
                 function new()
                     print "hello"
                 end function
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            let cs = statements[0];
-            chai_1.expect(cs.annotations).to.be.undefined;
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            let cs = ast.statements[0];
+            (0, chai_config_spec_1.expect)(cs.annotations).to.be.undefined;
         });
         it('can convert argument of an annotation to JS types', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta1
                 function main()
                 end function
@@ -1010,26 +1232,26 @@ describe('parser', () => {
                 sub init()
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
-            let fn = statements[0];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0].getArguments()).to.deep.equal([]);
-            chai_1.expect(statements[1]).to.be.instanceof(Statement_1.FunctionStatement);
-            fn = statements[1];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
-            chai_1.expect(fn.annotations[0].getArguments()).to.deep.equal([
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations[0].getArguments()).to.deep.equal([]);
+            (0, chai_config_spec_1.expect)(ast.statements[1]).to.be.instanceof(Statement_1.FunctionStatement);
+            fn = ast.statements[1];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_1.expect)(fn.annotations[0]).to.be.instanceof(Expression_1.AnnotationExpression);
+            (0, chai_config_spec_1.expect)(fn.annotations[0].getArguments()).to.deep.equal([
                 'arg', 2, true,
                 { prop: 'value' }, [1, 2],
                 null
             ]);
             let allArgs = fn.annotations[0].getArguments(false);
-            chai_1.expect(allArgs.pop()).to.be.instanceOf(Expression_1.FunctionExpression);
+            (0, chai_config_spec_1.expect)(allArgs.pop()).to.be.instanceOf(Expression_1.FunctionExpression);
         });
         it('can handle negative numbers', () => {
             var _a;
-            let { statements, diagnostics } = parse(`
+            let { ast, diagnostics } = parse(`
                 @meta(-100)
                 function main()
                 end function
@@ -1037,161 +1259,1523 @@ describe('parser', () => {
                 sub init()
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-            chai_1.expect(statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
-            let fn = statements[0];
-            chai_1.expect(fn.annotations).to.exist;
-            chai_1.expect(fn.annotations[0].getArguments()).to.deep.equal([-100]);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.annotations).to.exist;
+            (0, chai_config_spec_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
+    describe('type casts', () => {
+        it('is not allowed in brightscript mode', () => {
+            var _a;
+            let parser = parse(`
+                sub main(node as dynamic)
+                    print lcase((node as string))
                 end sub
-            `);
-            const func = parser.ast.statements[0].func;
-            const type = Parser_1.getBscTypeFromExpression(func.body.statements[0].value, func);
-            chai_1.expect(type.returnType).to.be.instanceof(VoidType_1.VoidType);
+            `, Parser_1.ParseMode.BrightScript);
+            (0, chai_config_spec_1.expect)((_a = parser.diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.equal(DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('type cast').message);
         });
-        it('computes return type for sub with explicit return type', () => {
-            const parser = parse(`
+        it('allows type casts after function calls', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
                 sub main()
-                    getMessage = sub() as string
-                        return "hello"
-                    end sub
+                    value = getValue() as integer
                 end sub
-            `);
-            const func = parser.ast.statements[0].func;
-            const type = Parser_1.getBscTypeFromExpression(func.body.statements[0].value, func);
-            chai_1.expect(type.returnType).to.be.instanceof(StringType_1.StringType);
+
+                function getValue()
+                    return 123
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.func.body.statements).to.exist;
+            let assignment = fn.func.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isAssignmentStatement)(assignment)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypecastExpression)(assignment.value)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isCallExpression)(assignment.value.obj)).to.be.true;
+            (0, testHelpers_spec_1.expectTypeToBe)(assignment.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }), IntegerType_1.IntegerType);
         });
-        it('supports sub with custom return type', () => {
-            const parser = parse(`
+        it('allows type casts in the middle of expressions', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
                 sub main()
-                    getPerson = sub() as Person
-                        return new Person()
-                    end sub
+                    value = (getValue() as integer).toStr()
                 end sub
 
-                class Person
-                end class
+                function getValue()
+                    return 123
+                end function
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            const func = parser.ast.statements[0].func;
-            const type = Parser_1.getBscTypeFromExpression(func.body.statements[0].value, func);
-            chai_1.expect(type.returnType).to.be.instanceof(CustomType_1.CustomType);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.func.body.statements).to.exist;
+            let assignment = fn.func.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isAssignmentStatement)(assignment)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isCallExpression)(assignment.value)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isDottedGetExpression)(assignment.value.callee)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isGroupingExpression)(assignment.value.callee.obj)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypecastExpression)(assignment.value.callee.obj.expression)).to.be.true;
+            //grouping expression is an integer
+            (0, testHelpers_spec_1.expectTypeToBe)(assignment.value.callee.obj.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }), IntegerType_1.IntegerType);
         });
-    });
-    describe('symbolTable', () => {
-        it('stores the types', () => {
-            const parser = parse(`
+        it('allows type casts in a function call', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
                 sub main()
-                    someNum = 123
-                    someString = "hello world"
-                    someObj = {foo: "bar"}
-                    someCustom = new CustomKlass()
+                    print cos(getAngle() as float)
                 end sub
 
-                class CustomKlass
-                end class
+                function getAngle()
+                    return 123
+                end function
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            const mainSymbolTable = parser.references.functionExpressions[0].symbolTable;
-            chai_1.expect(mainSymbolTable.getSymbolType('someNum')).to.be.instanceof(IntegerType_1.IntegerType);
-            chai_1.expect(mainSymbolTable.getSymbolType('someString')).to.be.instanceof(StringType_1.StringType);
-            chai_1.expect(mainSymbolTable.getSymbolType('someObj')).to.be.instanceof(ObjectType_1.ObjectType);
-            chai_1.expect(mainSymbolTable.getSymbolType('someCustom')).to.be.instanceof(CustomType_1.CustomType);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.func.body.statements).to.exist;
+            let print = fn.func.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isPrintStatement)(print)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isCallExpression)(print.expressions[0])).to.be.true;
+            let fnCall = print.expressions[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypecastExpression)(fnCall.args[0])).to.be.true;
+            let arg = fnCall.args[0];
+            //argument type is float
+            (0, testHelpers_spec_1.expectTypeToBe)(arg.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }), FloatType_1.FloatType);
         });
-        it('stores typed parameters in functions', () => {
-            const parser = parse(`
-                sub someFunc(param1 as string, param2 as integer)
-                temp = param2
+        it('allows multiple type casts', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
+                sub main()
+                    print getData() as dynamic as float as string
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            const someFuncSymbolTable = parser.references.functionExpressions[0].symbolTable;
-            chai_1.expect(someFuncSymbolTable.getSymbolType('param1')).to.be.instanceof(StringType_1.StringType);
-            chai_1.expect(someFuncSymbolTable.getSymbolType('param2')).to.be.instanceof(IntegerType_1.IntegerType);
-            chai_1.expect(someFuncSymbolTable.getSymbolType('temp')).to.be.instanceof(IntegerType_1.IntegerType);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+            (0, chai_config_spec_1.expect)(ast.statements[0]).to.be.instanceof(Statement_1.FunctionStatement);
+            let fn = ast.statements[0];
+            (0, chai_config_spec_1.expect)(fn.func.body.statements).to.exist;
+            let print = fn.func.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isPrintStatement)(print)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypecastExpression)(print.expressions[0])).to.be.true;
+            //argument type is float
+            (0, testHelpers_spec_1.expectTypeToBe)(print.expressions[0].getType({ flags: 2 /* SymbolTypeFlag.typetime */ }), StringType_1.StringType);
         });
-        it('properly defers typing lazy types', () => {
-            const parser = parse(`
-                sub someFunc()
-                temp = foo()
+        it('flags invalid type cast syntax - multiple as', () => {
+            var _a;
+            let { diagnostics } = parse(`
+                sub foo(key)
+                    getData(key as as string)
                 end sub
-
-                function foo() as string
-                return "foo"
-                end function
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            const someFuncSymbolTable = parser.references.functionExpressions[0].symbolTable;
-            chai_1.expect(someFuncSymbolTable.getSymbolType('temp')).to.be.instanceof(LazyType_1.LazyType);
-            chai_1.expect(someFuncSymbolTable.getSymbolType('temp').toTypeString()).to.eq('string');
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
         });
-        it('does not know about symbols declared in parent functions', () => {
-            const parser = parse(`
-                sub main()
-                    count = 0
-                    addOne = sub()
-                        oldVal = count
-                    end sub
+        it('flags invalid type cast syntax - no type after as', () => {
+            var _a;
+            let { diagnostics } = parse(`
+                sub foo(key)
+                    getData(key as)
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            const addOneSymbolTable = parser.references.functionExpressions[0].childFunctionExpressions[0].symbolTable;
-            chai_1.expect(addOneSymbolTable.getSymbolType('oldVal').toString()).to.eq('uninitialized');
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
         });
-        it('finds params', () => {
-            const parser = parse(`
-                sub alert(p1, p2 as string, p3 = 1)
+        it('allows declaring types on assignment in Brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                    x as string = formatJson("some string")
                 end sub
             `, Parser_1.ParseMode.BrighterScript);
-            testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-            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)]
-            ]);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
         });
-        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
+        it('does not allow declaring types on assignment in brightscript mode', () => {
+            var _a, _b;
+            let { diagnostics } = parse(`
+                sub foo()
+                    x as string = formatJson("some string")
                 end sub
-                `, Parser_1.ParseMode.BrighterScript);
-                testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-                const currentSymbolTable = parser.references.functionExpressions[0].symbolTable;
-                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
+            `, Parser_1.ParseMode.BrightScript);
+            (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+            (0, chai_config_spec_1.expect)((_b = diagnostics[0]) === null || _b === void 0 ? void 0 : _b.message).to.include('typed assignment');
+        });
+    });
+    describe('grouped type expressions', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as (string or integer))
+                    print param
                 end sub
-                `, Parser_1.ParseMode.BrighterScript);
-                testHelpers_spec_1.expectZeroDiagnostics(parser.diagnostics);
-                const currentSymbolTable = parser.references.functionExpressions[0].symbolTable;
-                chai_1.expect(currentSymbolTable.getSymbolType('datum').toString()).to.eq('dynamic');
-            });
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')]);
+        });
+        it('allows group type expressions in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (string or integer))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows group type expressions in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as (string or integer))
+                end sub
+                sub printThing(thing as (string or integer))
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows union of grouped type expressions', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (string or integer) or (float or dynamic))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows nested grouped type expressions', () => {
+            let { diagnostics } = parse(`
+                sub main(param as ((string or integer) or (float or dynamic)))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows complicated grouped type expression', () => {
+            let { diagnostics } = parse(`
+                sub main(param as (({name as string} and {age as integer}) or (string and SomeInterface) or Klass and roAssociativeArray) )
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
         });
     });
-});
-function parse(text, mode) {
-    let { tokens } = lexer_1.Lexer.scan(text);
+    describe('union types', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as string or integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')]);
+        });
+        it('allows union types in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as string or integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows union types in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as string or integer)
+                end sub
+                sub printThing(thing as string or integer)
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('intersection types', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(param as string and integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')]);
+        });
+        it('allows intersection types in parameters', () => {
+            let { diagnostics } = parse(`
+                sub main(param as string and integer)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows intersection types in type casts', () => {
+            let { diagnostics } = parse(`
+                sub main(val)
+                    printThing(val as string and integer)
+                end sub
+                sub printThing(thing as string and integer)
+                    print thing
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('follows order of operations with "or" first lexically', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(param as string or integer and float)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const func = ast.statements[0].func;
+            const paramExpr = func.parameters[0];
+            let binExpr = paramExpr.typeExpression.expression;
+            //first level should be 'or'
+            (0, chai_config_spec_1.expect)(binExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.Or);
+            //right side should be 'and'
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)(binExpr.right)).to.be.true;
+            const rightAndExpr = binExpr.right;
+            (0, chai_config_spec_1.expect)(rightAndExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.And);
+        });
+        it('follows order of operations with "and" first lexically', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(param as string and integer or float)
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const func = ast.statements[0].func;
+            const paramExpr = func.parameters[0];
+            let binExpr = paramExpr.typeExpression.expression;
+            //first level should be 'or'
+            (0, chai_config_spec_1.expect)(binExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.Or);
+            //left side should be 'and'
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)(binExpr.left)).to.be.true;
+            const leftAndExpr = binExpr.left;
+            (0, chai_config_spec_1.expect)(leftAndExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.And);
+        });
+        it('allows grouped expression to override order of operations', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(param as string and (integer or float))
+                    print param
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const func = ast.statements[0].func;
+            const paramExpr = func.parameters[0];
+            let binExpr = paramExpr.typeExpression.expression;
+            //first level should be 'and'
+            (0, chai_config_spec_1.expect)(binExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.And);
+            //right side should be 'or'
+            (0, chai_config_spec_1.expect)((0, reflection_1.isGroupingExpression)(binExpr.right)).to.be.true;
+            const groupedExpr = binExpr.right;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isGroupingExpression)(groupedExpr)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeExpression)(groupedExpr.expression)).to.be.true;
+            const rightOrExpr = groupedExpr.expression.expression;
+            (0, chai_config_spec_1.expect)(rightOrExpr.tokens.operator.kind).to.equal(TokenKind_1.TokenKind.Or);
+        });
+        describe('invalid syntax', () => {
+            it('flags union type with missing sides', () => {
+                let { diagnostics } = parse(`
+                    sub main(param as Thing or )
+                        print param
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('or').message);
+            });
+            it('flags missing type inside binary type', () => {
+                var _a;
+                let { diagnostics } = parse(`
+                    sub main(param as string or and float)
+                        print param
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+            });
+            it('flags missing group paren', () => {
+                var _a;
+                let { diagnostics } = parse(`
+                    sub main(param as (string or float)
+                        print param
+                    end sub
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
+            });
+        });
+    });
+    describe('typed arrays', () => {
+        it('is not allowed in brightscript mode', () => {
+            let parser = parse(`
+                sub main(things as string[])
+                    print things
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(parser.diagnostics, [DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('typed arrays')]);
+        });
+        it('is allowed in brighterscript mode', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(things as string[])
+                    print things
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = ast.statements[0].func.parameters[0].getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType, types_1.ArrayType);
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType.defaultType, StringType_1.StringType);
+        });
+        it('allows multi dimensional arrays', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(things as string[][])
+                    print things
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = ast.statements[0].func.parameters[0].getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType, types_1.ArrayType);
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType.defaultType, types_1.ArrayType);
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType.defaultType.defaultType, StringType_1.StringType);
+        });
+        it('allows arrays as return types', () => {
+            let { ast, diagnostics } = parse(`
+                function getFourPrimes() as integer[]
+                    return [2, 3, 5, 7]
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = ast.statements[0].func.returnTypeExpression.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType, types_1.ArrayType);
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType.defaultType, IntegerType_1.IntegerType);
+        });
+        it('allows arrays in union types', () => {
+            let { ast, diagnostics } = parse(`
+                sub foo(x as integer or integer[] or string or string[])
+                  print x
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = ast.statements[0].func.parameters[0].getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(paramType, types_1.UnionType);
+            (0, chai_config_spec_1.expect)(paramType.toString().includes('Array<string>')).to.be.true;
+            (0, chai_config_spec_1.expect)(paramType.toString().includes('Array<integer>')).to.be.true;
+        });
+    });
+    describe('interfaces', () => {
+        it('allows fields and methods', () => {
+            let { ast, diagnostics } = parse(`
+                interface SomeIFace
+                    name as string
+                    height as integer
+                    function getValue(thing as float) as object
+                    function getMe() as SomeIFace
+                    sub noop()
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+        });
+        it('allows untyped fields', () => {
+            let { ast, diagnostics } = parse(`
+                interface HasUntyped
+                    name
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+        });
+        it('allows optional fields', () => {
+            let { ast, diagnostics } = parse(`
+                interface HasOptional
+                    optional name as string
+                    optional height
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            // eslint-disable-next-line no-bitwise
+            ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */).forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(4 /* SymbolTypeFlag.optional */));
+        });
+        it('allows fields named optional', () => {
+            let { ast, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional
+                    someThingElse
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.false);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+            (0, chai_config_spec_1.expect)(iFaceMembers.length).to.eq(2);
+            // eslint-disable-next-line no-bitwise
+            iFaceMembers.forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(0));
+        });
+        it('allows fields named optional that are also optional', () => {
+            let { ast, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional optional
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+            (0, chai_config_spec_1.expect)(iFaceMembers.length).to.eq(1);
+            // eslint-disable-next-line no-bitwise
+            iFaceMembers.forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(4 /* SymbolTypeFlag.optional */));
+        });
+        it('allows optional methods', () => {
+            let { ast, diagnostics } = parse(`
+                interface HasOptional
+                    optional function getValue() as boolean
+                    optional sub noop()
+                    optional function process()
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.methods.forEach(m => (0, chai_config_spec_1.expect)(m.isOptional).to.equal(true));
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            // eslint-disable-next-line no-bitwise
+            ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */).forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(4 /* SymbolTypeFlag.optional */));
+        });
+        it('allows fields named `as` that are also optional', () => {
+            let { ast, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional as
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+            (0, chai_config_spec_1.expect)(iFaceMembers.length).to.eq(1);
+            // eslint-disable-next-line no-bitwise
+            iFaceMembers.forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(4 /* SymbolTypeFlag.optional */));
+        });
+        it('allows fields named `as` that are also typed', () => {
+            let { ast, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional as as string
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+            (0, chai_config_spec_1.expect)(iFaceMembers.length).to.eq(1);
+            // eslint-disable-next-line no-bitwise
+            iFaceMembers.forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(4 /* SymbolTypeFlag.optional */));
+        });
+        it('allows fields named `optional` that are also typed', () => {
+            let { ast, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional as string
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(ast.statements[0])).to.be.true;
+            const iface = ast.statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.false);
+            const ifaceType = iface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(1 /* SymbolTypeFlag.runtime */);
+            (0, chai_config_spec_1.expect)(iFaceMembers.length).to.eq(1);
+            // eslint-disable-next-line no-bitwise
+            iFaceMembers.forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & 4 /* SymbolTypeFlag.optional */).to.eq(0));
+        });
+    });
+    describe('leadingTrivia', () => {
+        it('gets leading trivia from functions', () => {
+            let { ast } = parse(`
+                ' Nice function, bro
+                function foo()
+                    return 1
+                end function
+            `);
+            const funcStatements = ast.statements.filter(reflection_1.isFunctionStatement);
+            const fooTrivia = funcStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(fooTrivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(fooTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+        it('gets multiple lines of leading trivia', () => {
+            let { ast, diagnostics } = parse(`
+                ' Say hello to someone
+                '
+                ' @param {string} name the person you want to say hello to.
+                sub sayHello(name = "world" as string)
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const funcStatements = ast.statements.filter(reflection_1.isFunctionStatement);
+            const helloTrivia = funcStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(helloTrivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(helloTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(3);
+        });
+        it('gets leading trivia from classes', () => {
+            let { ast } = parse(`
+                ' hello
+                ' classes
+                class Hello
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            const classStatements = ast.statements.filter(reflection_1.isClassStatement);
+            const trivia = classStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(2);
+        });
+        it('gets leading trivia from functions with annotations', () => {
+            let { ast } = parse(`
+                ' hello comment 1
+                ' hello comment 2
+                @annotation
+                ' hello comment 3
+                @otherAnnotation
+                sub sayHello(name  = "world" as string)
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const funcStatements = ast.statements.filter(reflection_1.isFunctionStatement);
+            const helloTrivia = funcStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(helloTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(0);
+            const helloAnnotationTrivia = funcStatements[0].annotations[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(helloAnnotationTrivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(helloAnnotationTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(2);
+            const otherAnnotationTrivia = funcStatements[0].annotations[1].leadingTrivia;
+            (0, chai_config_spec_1.expect)(otherAnnotationTrivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(otherAnnotationTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+        it('gets leading trivia from class methods', () => {
+            let { ast } = parse(`
+                ' hello
+                ' classes
+                class Hello
+
+                    ' Gets the value of PI
+                    ' Not a dessert
+                    function getPi() as float
+                        return 3.14
+                    end function
+
+                    ' Gets a dessert
+                    function getPie() as string
+                        return "Apple Pie"
+                    end function
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            const classStatement = ast.statements.filter(reflection_1.isClassStatement)[0];
+            const methodStatements = classStatement.methods;
+            // function getPi()
+            let trivia = methodStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(2);
+            // function getPie()
+            trivia = methodStatements[1].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+        it('gets leading trivia from class fields', () => {
+            let { ast } = parse(`
+                ' hello
+                ' classes
+                class Thing
+                    ' like the sky
+                    ' or a blueberry, evn though that's purple
+                    color = "blue"
+
+                    ' My name
+                    public name as string
+
+                    ' Only I know how old I am
+                    private age = 42
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            const classStatement = ast.statements.filter(reflection_1.isClassStatement)[0];
+            const fieldStatements = classStatement.fields;
+            // color = "blue"
+            let trivia = fieldStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(2);
+            // public name as string
+            trivia = fieldStatements[1].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+            // private age = 42
+            trivia = fieldStatements[2].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+        it('gets leading trivia from interfaces', () => {
+            let { ast } = parse(`
+                ' Description of interface
+                interface myIface
+                    ' comment
+                    someField as integer
+
+                    'comment
+                    function someFunc() as string
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            const ifaceStatement = ast.statements.filter(reflection_1.isInterfaceStatement)[0];
+            const fieldStatements = ifaceStatement.fields;
+            const methodStatements = ifaceStatement.methods;
+            // interface myIface
+            let trivia = ifaceStatement.leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+            // someField as integer
+            trivia = fieldStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+            // function someFunc() as string
+            trivia = methodStatements[0].leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+        it('gets leading trivia from namespaces', () => {
+            let { ast } = parse(`
+                ' Description of interface
+                namespace Nested.Name.Space
+
+                end  namespace
+            `, Parser_1.ParseMode.BrighterScript);
+            const nameSpaceStatement = ast.statements.filter(reflection_1.isNamespaceStatement)[0];
+            // namespace Nested.Name.Space
+            let trivia = nameSpaceStatement.leadingTrivia;
+            (0, chai_config_spec_1.expect)(trivia.length).to.be.greaterThan(0);
+            (0, chai_config_spec_1.expect)(trivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment).length).to.eq(1);
+        });
+    });
+    describe('unary/binary ordering', () => {
+        it('creates the correct operator order for `not x = x` code', () => {
+            let { ast, diagnostics } = parse(`
+                function isStrNotEmpty(myStr as string) as boolean
+                    return not myStr = ""
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(ast.statements[0])).to.be.true;
+            const insideReturn = ast.statements[0].func.body.statements[0].value;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)(insideReturn.right)).to.be.true;
+        });
+        it('creates the correct operator order for `not x + x` code', () => {
+            let { ast, diagnostics } = parse(`
+                function tryStuff() as integer
+                    return not 1 + 3 ' same as "not (3)" ... eg. the "flipped bits" of 3 (0000 0011) -> 1111 1100, or -4
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(ast.statements[0])).to.be.true;
+            const insideReturn = ast.statements[0].func.body.statements[0].value;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)(insideReturn.right)).to.be.true;
+        });
+        it('creates the correct operator order for `x = not x` code', () => {
+            let { ast, diagnostics } = parse(`
+                function tryStuff() as boolean
+                    return 4 = not -5 ' same as "4 = 4"
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(ast.statements[0])).to.be.true;
+            const insideReturn = ast.statements[0].func.body.statements[0].value;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBinaryExpression)(insideReturn)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isLiteralExpression)(insideReturn.left)).to.be.true;
+            const right = insideReturn.right;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(right)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(right.right)).to.be.true; // not ( - ( 5))
+        });
+        it('allows multiple nots', () => {
+            let { ast, diagnostics } = parse(`
+                function tryStuff() as integer
+                    return not not not 4
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(ast.statements[0])).to.be.true;
+            const insideReturn = ast.statements[0].func.body.statements[0].value;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn.right)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn.right.right)).to.be.true;
+        });
+        it('allows multiple -', () => {
+            let { ast, diagnostics } = parse(`
+                function tryStuff() as integer
+                    return - - - 4
+                end function
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isFunctionStatement)(ast.statements[0])).to.be.true;
+            const insideReturn = ast.statements[0].func.body.statements[0].value;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn.right)).to.be.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isUnaryExpression)(insideReturn.right.right)).to.be.true;
+        });
+    });
+    describe('typecast statement', () => {
+        it('allows typecast statement ', () => {
+            let { ast, diagnostics } = parse(`
+                typeCAST m AS roAssociativeArray
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypecastStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.typecast.text).to.eq('typeCAST');
+            (0, chai_config_spec_1.expect)(stmt.typecastExpression).to.exist;
+        });
+        it('is disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                typecast m AS roAssociativeArray
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('typecast statements')
+            ]);
+        });
+        it('allows `typecast` for function name', () => {
+            let { ast, diagnostics } = parse(`
+                function typecast() as integer
+                    return 1
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements[0].tokens.name.text).to.eq('typecast');
+        });
+        it('allows `typecast` for variable name', () => {
+            let { ast, diagnostics } = parse(`
+                function foo() as integer
+                    typecast = 1
+                    return typecast
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements[0].tokens.name.text).to.eq('typecast');
+        });
+        it('is allowed in function', () => {
+            let { diagnostics } = parse(`
+                function foo() as integer
+                    typecast m as MyObject
+                    return m.getNum()
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('is allowed in function literal', () => {
+            let { diagnostics } = parse(`
+                interface PiGetter
+                    pi as float
+                    function getPi() as float
+                end interface
+
+                function makePiGetter() as object
+                    x = {
+                        pi: 3.14,
+                        getPi: function() as float
+                            typecast m as PiGetter
+                            return m.pi
+                        end function
+                    }
+                    return x
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('conditional compilation', () => {
+        it('contains code from conditional compile blocks', () => {
+            let { ast, diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    print "hello"
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript, { debug: true });
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const funcBlock = ast.statements[0].func.body;
+            (0, chai_config_spec_1.expect)(funcBlock.statements.length).to.eq(1);
+            const ccStmt = funcBlock.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            const printStmt = ccStmt.thenBranch.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isPrintStatement)(printStmt)).to.true;
+        });
+        it('contains code from conditional compile else blocks', () => {
+            let { ast, diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    m.pi = 3.14
+                #else
+                    print "hello"
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const funcBlock = ast.statements[0].func.body;
+            const ccStmt = funcBlock.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch).to.exist;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBlock)(ccStmt.elseBranch)).to.true;
+            const printStmt = ccStmt.elseBranch.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isPrintStatement)(printStmt)).to.true;
+        });
+        it('contains code from conditional compile else if blocks', () => {
+            let { ast, diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    m.pi = 3.14
+                #else if PROD
+                    print "hello"
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const funcBlock = ast.statements[0].func.body;
+            const ccStmt = funcBlock.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch).to.exist;
+            const elseBranch = ccStmt.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(elseBranch)).to.true;
+            (0, chai_config_spec_1.expect)(elseBranch.tokens.condition.text).to.eq('PROD');
+            const printStmt = elseBranch.thenBranch.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isPrintStatement)(printStmt)).to.true;
+        });
+        it('contains code from multiple conditional compile else if blocks', () => {
+            let { ast, diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    m.pi = 3.14
+                #else if PROD
+                    print "hello"
+                #else if ABC
+                    print "hello"
+                #else if DEF
+                    print "hello"
+                #else if HIJ
+                    print "hello"
+                #else
+                    x = 78
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const funcBlock = ast.statements[0].func.body;
+            const ccStmt = funcBlock.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch).to.exist;
+            let elseBranch = ccStmt.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(elseBranch)).to.true;
+            (0, chai_config_spec_1.expect)(elseBranch.tokens.condition.text).to.eq('PROD');
+            elseBranch = elseBranch.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(elseBranch)).to.true;
+            (0, chai_config_spec_1.expect)(elseBranch.tokens.condition.text).to.eq('ABC');
+            elseBranch = elseBranch.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(elseBranch)).to.true;
+            (0, chai_config_spec_1.expect)(elseBranch.tokens.condition.text).to.eq('DEF');
+            elseBranch = elseBranch.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(elseBranch)).to.true;
+            (0, chai_config_spec_1.expect)(elseBranch.tokens.condition.text).to.eq('HIJ');
+            let lastElse = elseBranch.elseBranch;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isBlock)(lastElse)).to.true;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isAssignmentStatement)(lastElse.statements[0])).to.true;
+        });
+        it('allows empty conditional compilation blocks', () => {
+            let { ast, diagnostics } = parse(`
+                #if DEBUG
+                #else if PROD
+                #else
+                #end if
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const ccStmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            (0, chai_config_spec_1.expect)(ccStmt.thenBranch.statements.length).to.eq(0);
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch.thenBranch.statements.length).to.eq(0);
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch.elseBranch.statements.length).to.eq(0);
+        });
+        it('allows only comments in compilation blocks', () => {
+            let { ast, diagnostics } = parse(`
+                ' before if
+                #if DEBUG
+                    ' this is debug
+                #else if PROD
+                    ' this is prod
+                #else
+                    ' this is neither
+                #end if
+                ' after if
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const ccStmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileStatement)(ccStmt)).to.true;
+            (0, chai_config_spec_1.expect)(ccStmt.thenBranch.statements.length).to.eq(0);
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch.thenBranch.statements.length).to.eq(0);
+            (0, chai_config_spec_1.expect)(ccStmt.elseBranch.elseBranch.statements.length).to.eq(0);
+        });
+        it('has no error when safely closing block', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    if m.enabled
+                        print "hello"
+                    end if
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('has error when unsafely closing block', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                    if m.enabled
+                #if DEBUG
+                        print "hello"
+                    end if
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.unsafeUnmatchedTerminatorInConditionalCompileBlock('end if').message
+            ]);
+        });
+        it('has error when unsafely opening block', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    if m.enabled
+                        print "hello"
+                #end if
+                    end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript, { debug: true });
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedTerminator('end if', 'if').message,
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedToken('end if').message
+            ]);
+        });
+        it('has no diagnostics from false blocks', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    blah blah blah
+                #end if
+
+                #if false
+                    there are no diagnostics here
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript, { debug: false });
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows #if not bs_const', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                #if not DEBUG
+                    print "not debug"
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript, { debug: false });
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('allows #elseif not bs_const', () => {
+            let { diagnostics } = parse(`
+                sub foo()
+                #if DEBUG
+                    print "debug"
+                #else if not STAGING
+                    print "not debug and not staging"
+                #end if
+                end sub
+            `, Parser_1.ParseMode.BrighterScript, { debug: false, staging: false });
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        describe('#const', () => {
+            it('parses #const', () => {
+                let { ast, diagnostics } = parse(`
+                    #const test = true
+                    sub foo()
+                        #const debug = test
+                    end sub
+                    #    const spaces = false
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+                //#const test = true
+                let ccc = ast.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileConstStatement)(ccc)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.tokens.name.text).to.eq('test');
+                (0, chai_config_spec_1.expect)((0, reflection_1.isLiteralExpression)(ccc.assignment.value)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.value.tokens.value.text).to.eq('true');
+                //#const debug = test
+                ccc = ast.statements[1].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileConstStatement)(ccc)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.tokens.name.text).to.eq('debug');
+                (0, chai_config_spec_1.expect)((0, reflection_1.isVariableExpression)(ccc.assignment.value)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.value.tokens.name.text).to.eq('test');
+                //#    const spaces = false
+                ccc = ast.statements[2];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileConstStatement)(ccc)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.tokens.name.text).to.eq('spaces');
+                (0, chai_config_spec_1.expect)((0, reflection_1.isLiteralExpression)(ccc.assignment.value)).to.be.true;
+                (0, chai_config_spec_1.expect)(ccc.assignment.value.tokens.value.text).to.eq('false');
+            });
+            it('has diagnostic if no lhs', () => {
+                let { diagnostics } = parse(`
+                    #const test
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedOperator([TokenKind_1.TokenKind.Equal], 'test').message
+                ]);
+            });
+            it('has diagnostic if invalid operator', () => {
+                let { diagnostics } = parse(`
+                    #const test += other
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedOperator([TokenKind_1.TokenKind.Equal], 'test').message
+                ]);
+            });
+            it('has diagnostic if invalid lhs', () => {
+                let { diagnostics } = parse(`
+                    #const test = 4
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.invalidHashConstValue().message
+                ]);
+            });
+        });
+        describe('#error', () => {
+            it('parses #error', () => {
+                let { ast, diagnostics } = parse(`
+                    #error
+                    sub foo()
+                        #error this is a LONG "message" :: with colons, etc.
+                    end sub
+                    #    error this one has spaces
+                `, Parser_1.ParseMode.BrighterScript);
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+                //#error
+                let cce = ast.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileErrorStatement)(cce)).to.be.true;
+                (0, chai_config_spec_1.expect)(cce.tokens.message.kind).to.eq(TokenKind_1.TokenKind.HashErrorMessage);
+                (0, chai_config_spec_1.expect)(cce.tokens.message.text).to.eq('');
+                //#error this is a long "message" :: with colons, etc.
+                cce = ast.statements[1].func.body.statements[0];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileErrorStatement)(cce)).to.be.true;
+                (0, chai_config_spec_1.expect)(cce.tokens.message.kind).to.eq(TokenKind_1.TokenKind.HashErrorMessage);
+                (0, chai_config_spec_1.expect)(cce.tokens.message.text).to.eq('this is a LONG "message" :: with colons, etc.');
+                //#    error this one has spaces
+                cce = ast.statements[2];
+                (0, chai_config_spec_1.expect)((0, reflection_1.isConditionalCompileErrorStatement)(cce)).to.be.true;
+                (0, chai_config_spec_1.expect)(cce.tokens.message.kind).to.eq(TokenKind_1.TokenKind.HashErrorMessage);
+                (0, chai_config_spec_1.expect)(cce.tokens.message.text).to.eq('this one has spaces');
+            });
+        });
+    });
+    describe('alias statement', () => {
+        it('allows alias statement ', () => {
+            let { ast, diagnostics } = parse(`
+                ALIAS x = lcase
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isAliasStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.alias.text).to.eq('ALIAS');
+            (0, chai_config_spec_1.expect)(stmt.value).to.exist;
+        });
+        it('is disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                alias x = lcase
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('alias statements')
+            ]);
+        });
+        it('allows `alias` for function name', () => {
+            let { ast, diagnostics } = parse(`
+                function alias() as integer
+                    return 1
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements[0].tokens.name.text).to.eq('alias');
+        });
+        it('allows `alias` for variable name', () => {
+            let { ast, diagnostics } = parse(`
+                function foo() as integer
+                    alias = 1
+                    return alias
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements[0].tokens.name.text).to.eq('alias');
+        });
+    });
+    describe('type statement', () => {
+        it('allows type statement ', () => {
+            let { ast, diagnostics } = parse(`
+                TYPE x = string
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.type.text).to.eq('TYPE');
+            (0, chai_config_spec_1.expect)(stmt.value).to.exist;
+        });
+        it('is disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                type x = string
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('type statements')
+            ]);
+        });
+        it('disallows `type` for function name', () => {
+            let { diagnostics } = parse(`
+                function type() as integer
+                    return 1
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier('type').message
+            ]);
+        });
+        it('disallows `type` for variable name', () => {
+            let { diagnostics } = parse(`
+                function foo() as integer
+                    type = 1
+                    return type
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotUseReservedWordAsIdentifier('type').message
+            ]);
+        });
+        it('has error when rhs is not a type', () => {
+            let { diagnostics } = parse(`
+                type x = 123
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectDiagnostics)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedIdentifier('=').message
+            ]);
+        });
+        it('allows type statement with complicated type', () => {
+            let { ast, diagnostics } = parse(`
+                type x = string or CustomKlass or roAssociativeArray
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.type.text).to.eq('type');
+            (0, chai_config_spec_1.expect)(stmt.value).to.exist;
+        });
+        it('allows grouped expressions in type statement', () => {
+            let { ast, diagnostics } = parse(`
+                type guy = ({name as string} or {age as integer}) and {foo as boolean, age as integer}
+
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isTypeStatement)(ast.statements[0])).to.be.true;
+            const stmt = ast.statements[0];
+            (0, chai_config_spec_1.expect)(stmt.tokens.type.text).to.eq('type');
+            (0, chai_config_spec_1.expect)(stmt.value).to.exist;
+        });
+    });
+    describe('jump statements', () => {
+        it('should recognize `exit for`', () => {
+            let { ast, diagnostics } = parse(`
+                sub main()
+                    for i = 1 to 10
+                        exit for
+                    end for
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            let loop = ast.statements[0].func.body.statements[0];
+            let exitStmt = loop.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isExitStatement)(exitStmt)).to.be.true;
+            (0, chai_config_spec_1.expect)(exitStmt.tokens.loopType.text).to.eq('for');
+        });
+        it('should recognize `exit while`', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(i)
+                    while i < 10
+                        exit while
+                        i++
+                    end while
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            let loop = ast.statements[0].func.body.statements[0];
+            let exitStmt = loop.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isExitStatement)(exitStmt)).to.be.true;
+            (0, chai_config_spec_1.expect)(exitStmt.tokens.loopType.text).to.eq('while');
+        });
+        it('should recognize `exitwhile` (one word)', () => {
+            let { ast, diagnostics } = parse(`
+                sub main(i)
+                    while i < 10
+                        exitwhile
+                        i++
+                    end while
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            let loop = ast.statements[0].func.body.statements[0];
+            let exitStmt = loop.body.statements[0];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isExitStatement)(exitStmt)).to.be.true;
+            (0, chai_config_spec_1.expect)(exitStmt.tokens.loopType.text).to.eq('while');
+        });
+        it('should allow identifiers named `exitfor` (one word)', () => {
+            let { ast, diagnostics } = parse(`
+                sub main()
+                    for i = 1 to 10
+                        exitfor = 1
+                        exit for
+                    end for
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            let loop = ast.statements[0].func.body.statements[0];
+            let assignment = loop.body.statements[0];
+            (0, chai_config_spec_1.expect)(assignment.tokens.name.text).to.eq('exitfor');
+            let exitStmt = loop.body.statements[1];
+            (0, chai_config_spec_1.expect)((0, reflection_1.isExitStatement)(exitStmt)).to.be.true;
+            (0, chai_config_spec_1.expect)(exitStmt.tokens.loopType.text).to.eq('for');
+        });
+    });
+    describe('custom types', () => {
+        it('built-in interface param types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as roAssociativeArray)
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('built-in interface types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                function test(foo) as roAssociativeArray
+                    return foo.x
+                end function
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('custom param types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as Whatever)
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('custom return types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                function test(foo) as Whatever
+                    return foo.x
+                end function
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('built-in interface param types allowed in brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as roAssociativeArray)
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('built-in interface types allowed in brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                function test(foo) as roAssociativeArray
+                    return foo.x
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('custom param types allowed in brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as Whatever)
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('custom return types allowed in brighterscript mode', () => {
+            let { diagnostics } = parse(`
+                function test(foo) as Whatever
+                    return foo.x
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+    describe('inline interfaces', () => {
+        it('inline interface param types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                sub test(foo as {x as string})
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('inline interface return types disallowed in brightscript mode', () => {
+            let { diagnostics } = parse(`
+                function test() as {x as string}
+                    print {x: "hello"}
+                end function
+            `, Parser_1.ParseMode.BrightScript);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.bsFeatureNotSupportedInBrsFiles('custom types')
+            ]);
+        });
+        it('inline interface as param type', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
+                sub test(foo as {x as string})
+                    print foo.x
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            const func = ast.statements[0].func;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInlineInterfaceExpression)((_a = func.parameters[0].typeExpression) === null || _a === void 0 ? void 0 : _a.expression)).to.be.true;
+        });
+        it('inline interface as return type', () => {
+            let { ast, diagnostics } = parse(`
+               function test() as {x as string}
+                    print {x: "hello"}
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            const func = ast.statements[0].func;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInlineInterfaceExpression)(func.returnTypeExpression.expression)).to.be.true;
+        });
+        it('parses a big inline interface as param type', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
+                sub test(foo as {
+                    x as string,
+                    y as {a as integer}
+                    z})
+                    print foo.x + y.a.toStr()
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            const func = ast.statements[0].func;
+            const inlineIface = (_a = func.parameters[0].typeExpression) === null || _a === void 0 ? void 0 : _a.expression;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInlineInterfaceExpression)(inlineIface)).to.be.true;
+            (0, chai_config_spec_1.expect)(inlineIface.tokens.open).not.to.be.undefined;
+            (0, chai_config_spec_1.expect)(inlineIface.tokens.close).not.to.be.undefined;
+            (0, chai_config_spec_1.expect)(inlineIface.members).to.have.length(3);
+            const iFaceType = inlineIface.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(iFaceType, InlineInterfaceType_1.InlineInterfaceType);
+            (0, testHelpers_spec_1.expectTypeToBe)(iFaceType.getMemberType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), StringType_1.StringType);
+            (0, testHelpers_spec_1.expectTypeToBe)(iFaceType.getMemberType('y', { flags: 1 /* SymbolTypeFlag.runtime */ }), InlineInterfaceType_1.InlineInterfaceType);
+            (0, testHelpers_spec_1.expectTypeToBe)(iFaceType.getMemberType('z', { flags: 1 /* SymbolTypeFlag.runtime */ }), types_1.DynamicType);
+        });
+        it('allows optional members', () => {
+            var _a;
+            let { ast, diagnostics } = parse(`
+                sub test(p as {x as string, optional y})
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements.length).to.eq(1);
+            const func = ast.statements[0].func;
+            const inlineIface = (_a = func.parameters[0].typeExpression) === null || _a === void 0 ? void 0 : _a.expression;
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInlineInterfaceExpression)(inlineIface)).to.be.true;
+            (0, chai_config_spec_1.expect)(inlineIface.members).to.have.length(2);
+            (0, chai_config_spec_1.expect)(inlineIface.members[1].isOptional).to.be.true;
+        });
+        it('is allowed as typecast', () => {
+            let { diagnostics } = parse(`
+                sub test(p)
+                    print (p as {name as string}).name
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('is allowed as class and interface field', () => {
+            let { diagnostics } = parse(`
+                class Klass
+                    x as {name as string}
+                end class
+
+                interface Iface
+                    y as {age as integer}
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have custom type as member type', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                   name as string
+                end interface
+
+                function test(z as {foo as IFace})
+                    return z.foo.name
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have per-member doc comment', () => {
+            let { diagnostics } = parse(`
+                interface IFace
+                    inline as {
+                        ' comment 1
+                        name as string
+                        ' comment 2
+                        age as integer
+                    }
+                end interface
+
+                function test(z as {foo as IFace})
+                    return z.foo.inline.name
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+        it('can have string literals as members', () => {
+            let { diagnostics } = parse(`
+                function test(z as {"this is a stringliteral" as string})
+                    return z["this is a stringliteral"]
+                end function
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+        });
+    });
+});
+function parse(text, mode, bsConsts = {}) {
+    let { tokens } = Lexer_1.Lexer.scan(text);
+    const bsConstMap = new Map();
+    for (const constName in bsConsts) {
+        bsConstMap.set(constName.toLowerCase(), bsConsts[constName]);
+    }
     return Parser_1.Parser.parse(tokens, {
-        mode: mode
+        srcPath: (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`,
+        mode: mode,
+        bsConsts: bsConstMap
     });
 }
+exports.parse = parse;
 function rangeToArray(range) {
     return [
         range.start.line,
@@ -1202,15 +2786,17 @@ function rangeToArray(range) {
 }
 exports.rangeToArray = rangeToArray;
 function expectCommentWithText(stat, text) {
-    if (reflection_1.isCommentStatement(stat)) {
-        chai_1.expect(stat.text).to.equal(text);
+    const trivia = stat.leadingTrivia;
+    if (trivia) {
+        (0, chai_config_spec_1.expect)(trivia.filter(tok => tok.kind === TokenKind_1.TokenKind.Comment).map(t => t.text).join('\n')).to.equal(text);
     }
     else {
         failStatementType(stat, 'Comment');
     }
 }
 function failStatementType(stat, type) {
-    chai_1.assert.fail(`Statement ${stat.constructor.name} line ${stat.range.start.line} is not a ${type}`);
+    var _a;
+    chai_config_spec_1.assert.fail(`Statement ${stat.constructor.name} line ${(_a = stat.location) === null || _a === void 0 ? void 0 : _a.range.start.line} is not a ${type}`);
 }
 exports.failStatementType = failStatementType;
 //# sourceMappingURL=Parser.spec.js.map