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

package/dist/bscPlugin/validation/BrsFileValidator.spec.js

@@ -0,0 +1,1517 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_config_spec_1 = require("../../chai-config.spec");
+const DiagnosticMessages_1 = require("../../DiagnosticMessages");
+const testHelpers_spec_1 = require("../../testHelpers.spec");
+const Program_1 = require("../../Program");
+const reflection_1 = require("../../astUtils/reflection");
+const util_1 = require("../../util");
+const visitors_1 = require("../../astUtils/visitors");
+const ClassType_1 = require("../../types/ClassType");
+const FloatType_1 = require("../../types/FloatType");
+const IntegerType_1 = require("../../types/IntegerType");
+const InterfaceType_1 = require("../../types/InterfaceType");
+const StringType_1 = require("../../types/StringType");
+const ArrayType_1 = require("../../types/ArrayType");
+const DynamicType_1 = require("../../types/DynamicType");
+const TypedFunctionType_1 = require("../../types/TypedFunctionType");
+const Parser_1 = require("../../parser/Parser");
+const AssociativeArrayType_1 = require("../../types/AssociativeArrayType");
+const types_1 = require("../../types");
+const TypeStatementType_1 = require("../../types/TypeStatementType");
+describe('BrsFileValidator', () => {
+    let program;
+    beforeEach(() => {
+        program = new Program_1.Program({
+            rootDir: testHelpers_spec_1.rootDir
+        });
+    });
+    it('links dotted get expression parents', () => {
+        const file = program.setFile('source/main.bs', `
+            sub main()
+                print {}.beta.charlie
+            end sub
+        `);
+        program.validate();
+        const func = file.parser.ast.statements[0];
+        const print = func.func.body.statements[0];
+        (0, chai_config_spec_1.expect)(print.parent).to.equal(func.func.body);
+        const charlie = print.expressions[0];
+        (0, chai_config_spec_1.expect)(charlie.parent).to.equal(print);
+        const beta = charlie.obj;
+        (0, chai_config_spec_1.expect)(beta.parent).to.equal(charlie);
+        const aaLiteral = beta.obj;
+        (0, chai_config_spec_1.expect)(aaLiteral.parent).to.equal(beta);
+    });
+    it('links namespace name dotted get parents', () => {
+        const { ast } = program.setFile('source/main.bs', `
+            namespace alpha.bravo
+                class Delta extends alpha.bravo.Charlie
+                end class
+                class Charlie
+                end class
+            end namespace
+        `);
+        const namespace = ast.findChild(reflection_1.isNamespaceStatement);
+        const deltaClass = namespace.findChild(reflection_1.isClassStatement);
+        (0, chai_config_spec_1.expect)(deltaClass.parent).to.equal(namespace.body);
+        const charlie = deltaClass.parentClassName.expression;
+        (0, chai_config_spec_1.expect)(charlie.parent).to.equal(deltaClass.parentClassName);
+        const bravo = charlie.obj;
+        (0, chai_config_spec_1.expect)(bravo.parent).to.equal(charlie);
+        const alpha = bravo.obj;
+        (0, chai_config_spec_1.expect)(alpha.parent).to.equal(bravo);
+    });
+    describe('namespace validation', () => {
+        it('succeeds if namespaces are defined inside other namespaces', () => {
+            program.setFile('source/main.bs', `
+                namespace alpha
+                    ' random comment
+                    namespace bravo
+                        ' random comment
+                        sub main()
+                        end sub
+                    end namespace
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('fails if namespaces are defined inside a function', () => {
+            program.setFile('source/main.bs', `
+                function f()
+                    namespace alpha
+                    end namespace
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('namespace')
+            ]);
+        });
+    });
+    it('allows classes in correct locations', () => {
+        program.setFile('source/main.bs', `
+            class Alpha
+            end class
+            namespace Beta
+                class Charlie
+                end class
+                namespace Delta
+                    class Echo
+                    end class
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags classes in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                class Alpha
+                end class
+                if true then
+                    class Beta
+                    end class
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('class')), { location: { range: util_1.util.createRange(2, 16, 2, 27) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('class')), { location: { range: util_1.util.createRange(5, 20, 5, 30) } })]);
+    });
+    it('allows enums in correct locations', () => {
+        program.setFile('source/main.bs', `
+            enum Alpha
+                value1
+            end enum
+            namespace Beta
+                enum Charlie
+                    value1
+                end enum
+                namespace Delta
+                    enum Echo
+                        value1
+                    end enum
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags enums in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                enum Alpha
+                    value1
+                end enum
+                if true then
+                    enum Beta
+                        value1
+                    end enum
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('enum')), { location: { range: util_1.util.createRange(2, 16, 2, 26) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('enum')), { location: { range: util_1.util.createRange(6, 20, 6, 29) } })]);
+    });
+    it('allows functions in correct locations', () => {
+        program.setFile('source/main.bs', `
+            function Alpha()
+            end function
+            namespace Beta
+                function Charlie()
+                end function
+                namespace Delta
+                    function Echo()
+                    end function
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags functions in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                function Alpha()
+                end function
+                if true then
+                    function Beta()
+                    end function
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('function')), { location: { range: util_1.util.createRange(2, 16, 2, 30) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('function')), { location: { range: util_1.util.createRange(5, 20, 5, 33) } })]);
+    });
+    it('allows namespaces in correct locations', () => {
+        program.setFile('source/main.bs', `
+            namespace Alpha
+            end namespace
+            namespace Beta
+                namespace Charlie
+                end namespace
+                namespace Delta
+                    namespace Echo
+                    end namespace
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags namespaces in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                namespace Alpha
+                end namespace
+                if true then
+                    namespace Beta
+                    end namespace
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('namespace')), { location: { range: util_1.util.createRange(2, 16, 2, 31) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('namespace')), { location: { range: util_1.util.createRange(5, 20, 5, 34) } })]);
+    });
+    it('allows interfaces in correct locations', () => {
+        program.setFile('source/main.bs', `
+            interface Alpha
+                prop as string
+            end interface
+            namespace Beta
+                interface Charlie
+                    prop as string
+                end interface
+                namespace Delta
+                    interface Echo
+                        prop as string
+                    end interface
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags interfaces in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                interface Alpha
+                    prop as string
+                end interface
+                if true then
+                    interface Beta
+                        prop as string
+                    end interface
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('interface')), { location: { range: util_1.util.createRange(2, 16, 2, 31) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('interface')), { location: { range: util_1.util.createRange(6, 20, 6, 34) } })]);
+    });
+    it('allows consts in correct locations', () => {
+        program.setFile('source/main.bs', `
+            const Alpha = 1
+            namespace Beta
+                const Charlie = 2
+                namespace Delta
+                    const Echo = 3
+                end namespace
+            end namespace
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+    });
+    it('flags consts in wrong locations', () => {
+        program.setFile('source/main.bs', `
+            function test()
+                const Alpha = 1
+                if true then
+                    const Beta = 2
+                end if
+            end function
+        `);
+        program.validate();
+        (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('const')), { location: { range: util_1.util.createRange(2, 16, 2, 27) } }), Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('const')), { location: { range: util_1.util.createRange(4, 20, 4, 30) } })]);
+    });
+    describe('for each', () => {
+        it('handles getting default type of array of AAs with reference types', () => {
+            const mainFile = program.setFile('source/main.bs', `
+                function test()
+                    settings = []
+                    screensData = [
+                        { id: "home", actions: [Actions.TrackUser1, Actions.Next], listMode: ListModes.Avatar },
+                        { id: "home", actions: [Actions.TrackUser1, Actions.Next], listMode: ListModes.Small },
+                        { id: "test", actions: [Actions.TrackUser2, Actions.Next], listMode: ListModes.Profile },
+                        { id: "autoplay", actions: [Actions.TrackUser2, Actions.Next], listMode: ListModes.Large }
+                    ]
+
+                    for each screenData in screensData
+                        if screenData.id = "test"
+                            settings.push(screenData)
+                        end if
+                    end for
+                    return settings
+                end function
+
+                enum Actions
+                    TrackUser1
+                    TrackUser2
+                    Next
+                end enum
+
+                enum ListModes
+                    Avatar
+                    Small
+                    Profile
+                    Large
+                end enum
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const forStmt = mainFile.ast.findChild(reflection_1.isForEachStatement);
+            const insideFor = forStmt.body.statements[0];
+            const screensDataType = insideFor.getSymbolTable().getSymbolType('screensData', { flags: 1 /* SymbolTypeFlag.runtime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(screensDataType, ArrayType_1.ArrayType);
+            const screenDataType = insideFor.getSymbolTable().getSymbolType('screenData', { flags: 1 /* SymbolTypeFlag.runtime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(screenDataType, AssociativeArrayType_1.AssociativeArrayType);
+        });
+        it('handles getting default type of array of reference types', () => {
+            const mainFile = program.setFile('source/main.bs', `
+                function test()
+                    result = []
+                    actions = [Actions.TrackUser1, Actions.Next2]
+
+                    for each action in actions
+                        if action = Actions.Next2
+                            actions.push(action)
+                        end if
+                    end for
+                    return result
+                end function
+
+                enum Actions
+                    TrackUser1
+                    TrackUser2
+                    Next2
+                end enum
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const forStmt = mainFile.ast.findChild(reflection_1.isForEachStatement);
+            const insideFor = forStmt.body.statements[0];
+            const actionsType = insideFor.getSymbolTable().getSymbolType('actions', { flags: 1 /* SymbolTypeFlag.runtime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(actionsType, ArrayType_1.ArrayType);
+            const actionType = insideFor.getSymbolTable().getSymbolType('action', { flags: 1 /* SymbolTypeFlag.runtime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(actionType, DynamicType_1.DynamicType);
+        });
+    });
+    describe('typecast statement', () => {
+        it('allows being at start of file', () => {
+            program.setFile('source/main.bs', `
+                typecast m as object
+
+                sub noop()
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('has diagnostic if more than one usage per block', () => {
+            program.setFile('source/main.bs', `
+                typecast m as object
+                typecast m as integer
+
+                sub noop()
+                    typecast m as object
+                    typecast m as string
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('typecast', 'at the top of the file or beginning of function or namespace').message,
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('typecast', 'at the top of the file or beginning of function or namespace').message
+            ]);
+        });
+        it('has diagnostic if not typecasting m', () => {
+            program.setFile('source/main.bs', `
+                typecast alpha.beta.notM as object ' error
+
+                const notM = "also not m"
+
+                sub noop()
+                    typecast notM as object ' error
+                end sub
+
+                sub foo()
+                    typecast M as object ' no error!
+                end sub
+
+                namespace alpha.beta
+                    const notM = "namespaced not m"
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.invalidTypecastStatementApplication('alpha.beta.notM').message,
+                DiagnosticMessages_1.DiagnosticMessages.invalidTypecastStatementApplication('notM').message
+            ]);
+        });
+        it('has diagnostic if not first in file', () => {
+            program.setFile('source/main.bs', `
+                sub noop()
+                end sub
+
+                typecast m as object
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('typecast', 'at the top of the file or beginning of function or namespace').message
+            ]);
+        });
+        it('allows being at start of function ', () => {
+            program.setFile('source/main.bs', `
+                interface Thing
+                    value as integer
+                end interface
+
+                sub noop()
+                    typecast m as Thing
+                    print m.value
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('has diagnostic when not at start of function', () => {
+            program.setFile('source/main.bs', `
+                interface Thing
+                    value as integer
+                end interface
+
+                sub noop()
+                    print m.value
+                    typecast m as Thing
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('typecast', 'at the top of the file or beginning of function or namespace').message
+            ]);
+        });
+        it('sets the type of m', () => {
+            program.setFile('source/types.bs', `
+                interface Thing1
+                    value as integer
+                end interface
+
+                interface Thing2
+                    value as string
+                end interface
+
+                interface Thing3
+                    value as float
+                end interface
+            `);
+            const file = program.setFile('source/main.bs', `
+                import "types.bs"
+                typecast m as Thing1
+
+                sub func1()
+                    x = m.value
+                    print x
+                end sub
+
+                sub func2()
+                    typecast m as Thing2
+                    x = m.value
+                    print x
+                end sub
+
+                sub func3()
+                    aa = {
+                        innerFunc: sub()
+                            typecast m as Thing3
+                            x = m.value
+                            print x
+                        end sub
+                    }
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const assigns = [];
+            // find places in AST where "x" is assigned
+            file.ast.walk((0, visitors_1.createVisitor)({
+                AssignmentStatement: (stmt) => {
+                    if (stmt.tokens.name.text.toLowerCase() === 'x') {
+                        assigns.push(stmt);
+                    }
+                }
+            }), { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            // func1 - uses file level typecast
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('Thing1');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), IntegerType_1.IntegerType);
+            // func2 - uses func level typecast
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[1].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(assigns[1].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('Thing2');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[1].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), StringType_1.StringType);
+            // func3 - uses innerFunc level typecast
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[2].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(assigns[2].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('Thing3');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[2].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), FloatType_1.FloatType);
+        });
+        it('should allow classes to override m typecast', () => {
+            program.setFile('source/types.bs', `
+                interface Thing1
+                    value as integer
+                end interface
+            `);
+            const file = program.setFile('source/main.bs', `
+                import "types.bs"
+                typecast m as Thing1
+
+                class TestKlass
+                    value as string
+
+                    sub method1()
+                        x = m.value
+                        print x
+                    end sub
+
+                    sub method2()
+                        typecast m as Thing1
+                        x = m.value
+                        print x
+                    end sub
+                end class
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const assigns = [];
+            // find places in AST where "x" is assigned
+            file.ast.walk((0, visitors_1.createVisitor)({
+                AssignmentStatement: (stmt) => {
+                    if (stmt.tokens.name.text.toLowerCase() === 'x') {
+                        assigns.push(stmt);
+                    }
+                }
+            }), { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            // method1 - uses class 'm'
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), ClassType_1.ClassType);
+            (0, chai_config_spec_1.expect)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('TestKlass');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), StringType_1.StringType);
+            // method2 - uses func level typecast
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[1].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(assigns[1].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('Thing1');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[1].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), IntegerType_1.IntegerType);
+        });
+        it('has diagnostic when used in a class', () => {
+            program.setFile('source/main.bs', `
+                class TestKlass
+                    typecast m as object
+
+                    value as string
+
+                    sub method1()
+                        x = m.value
+                        print x
+                    end sub
+                end class
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectHasDiagnostics)(program);
+        });
+        it('is allowed in namespace', () => {
+            program.setFile('source/types.bs', `
+                interface Thing1
+                    value as integer
+                end interface
+            `);
+            const file = program.setFile('source/main.bs', `
+                import "types.bs"
+
+                namespace Alpha.Beta
+                    typecast m as Thing1
+
+                    sub method1()
+                        x = m.value
+                        print x
+                    end sub
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            // find places in AST where "x" is assigned
+            const assigns = [];
+            file.ast.walk((0, visitors_1.createVisitor)({
+                AssignmentStatement: (stmt) => {
+                    if (stmt.tokens.name.text.toLowerCase() === 'x') {
+                        assigns.push(stmt);
+                    }
+                }
+            }), { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            // method1 - uses Thing1 'm'
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }), InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(assigns[0].getSymbolTable().getSymbolType('m', { flags: 1 /* SymbolTypeFlag.runtime */ }).toString()).to.eq('Thing1');
+            (0, testHelpers_spec_1.expectTypeToBe)(assigns[0].getSymbolTable().getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */ }), IntegerType_1.IntegerType);
+        });
+    });
+    describe('alias statement', () => {
+        it('allows being at start of file', () => {
+            program.setFile('source/main.bs', `
+                alias x = lcase
+                sub noop()
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('no diagnostic if more than one usage per block', () => {
+            program.setFile('source/main.bs', `
+                alias x = lcase
+                alias y = Str
+                sub noop()
+                   print x(y(1))
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('has diagnostic if used not at top of file', () => {
+            program.setFile('source/main.bs', `
+                namespace alpha
+                    alias x = lcase
+                    sub noop()
+                        alias y = str
+                        print "hello"
+                    end sub
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('alias', 'at the top of the file').message,
+                DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('alias', 'at the top of the file').message
+            ]);
+        });
+        it('sets the type of the name', () => {
+            program.setFile('source/types.bs', `
+                interface Thing1
+                    value as string
+                end interface
+                namespace alpha.beta
+                    function piAsStr()
+                        return "3.14"
+                    end function
+                    const eulerAsStr = "2.78"
+                end namespace
+                function lowercase(text as string) as string
+                    return lcase(text)
+                end function
+            `);
+            const file = program.setFile('source/main.bs', `
+                import "types.bs"
+                alias t = Thing1
+                alias p = alpha.beta.piAsStr
+                alias e = alpha.beta.eulerAsStr
+                alias l = lowercase
+                namespace ns1.ns2
+                    function lowercase(x as integer) as integer
+                        return x
+                    end function
+                    sub func1(usedAsType as t)
+                        x = usedAsType.value
+                        print
+                        print l(x)
+                        print l(p())
+                        print l(e)
+                    end sub
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            let func;
+            // find places in AST where "x" is assigned
+            file.ast.walk((0, visitors_1.createVisitor)({
+                FunctionStatement: (stmt) => {
+                    if (stmt.getName(Parser_1.ParseMode.BrighterScript) === 'ns1.ns2.func1') {
+                        func = stmt.func;
+                    }
+                }
+            }), { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const symbolTable = func.getSymbolTable();
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('t', { flags: 2 /* SymbolTypeFlag.typetime */ }), InterfaceType_1.InterfaceType);
+            const tType = symbolTable.getSymbolType('t', { flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, chai_config_spec_1.expect)(tType.name).to.eq('Thing1');
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('p', { flags: 1 /* SymbolTypeFlag.runtime */ }), TypedFunctionType_1.TypedFunctionType);
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('e', { flags: 1 /* SymbolTypeFlag.runtime */ }), StringType_1.StringType);
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('l', { flags: 1 /* SymbolTypeFlag.runtime */ }), TypedFunctionType_1.TypedFunctionType);
+        });
+        it('has diagnostic when rhs not found', () => {
+            program.setFile('source/main.bs', `
+                alias x = notThere
+                sub noop()
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotFindName('notThere').message
+            ]);
+        });
+    });
+    describe('type statement', () => {
+        it('allows being at top of ast', () => {
+            program.setFile('source/main.bs', `
+                type x = string
+                sub noop(input as x)
+                    print input
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('no diagnostic if more than one usage per block', () => {
+            program.setFile('source/main.bs', `
+                type x = string
+                type y = integer
+                sub noop(input as x) as y
+                   return input.len()
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('has diagnostic if used not at top of file', () => {
+            program.setFile('source/main.bs', `
+                namespace alpha
+                    sub noop()
+                        type y = string
+                        print "hello"
+                    end sub
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('type').message
+            ]);
+        });
+        it('sets the type of the name', () => {
+            program.setFile('source/types.bs', `
+                interface Thing1
+                    value as string
+                end interface
+                namespace alpha.beta
+                    enum someEnum
+                        up = "up"
+                        down = "down"
+                    end enum
+                end namespace
+            `);
+            const file = program.setFile('source/main.bs', `
+                import "types.bs"
+                type t = Thing1
+                type t2 = alpha.beta.someEnum
+
+                namespace ns1.ns2
+                    function getDirection(x as t) as t2
+                        if x.value = "go up" then
+                            return alpha.beta.someEnum.up
+                        else
+                            return alpha.beta.someEnum.down
+                        end if
+                    end function
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            let func;
+            // find places in AST where "x" is assigned
+            file.ast.walk((0, visitors_1.createVisitor)({
+                FunctionStatement: (stmt) => {
+                    if (stmt.getName(Parser_1.ParseMode.BrighterScript) === 'ns1.ns2.getDirection') {
+                        func = stmt.func;
+                    }
+                }
+            }), { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const symbolTable = func.getSymbolTable();
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('t', { flags: 2 /* SymbolTypeFlag.typetime */ }), TypeStatementType_1.TypeStatementType);
+            const tType = symbolTable.getSymbolType('t', { flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, chai_config_spec_1.expect)(tType.name).to.eq('t');
+            (0, testHelpers_spec_1.expectTypeToBe)(tType.wrappedType, InterfaceType_1.InterfaceType);
+            (0, chai_config_spec_1.expect)(tType.wrappedType.name).to.eq('Thing1');
+            (0, testHelpers_spec_1.expectTypeToBe)(symbolTable.getSymbolType('t2', { flags: 2 /* SymbolTypeFlag.typetime */ }), TypeStatementType_1.TypeStatementType);
+            const t2Type = symbolTable.getSymbolType('t2', { flags: 2 /* SymbolTypeFlag.typetime */ });
+            (0, testHelpers_spec_1.expectTypeToBe)(t2Type.wrappedType, types_1.EnumType);
+            (0, chai_config_spec_1.expect)(t2Type.wrappedType.name).to.eq('alpha.beta.someEnum');
+        });
+        it('has diagnostic when rhs not found', () => {
+            program.setFile('source/main.bs', `
+                type x = notThere
+                sub noop()
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotFindName('notThere').message
+            ]);
+        });
+    });
+    describe('conditional compile', () => {
+        it('allows top level definitions inside #if block', () => {
+            program.setFile('source/main.bs', `
+                #const debug = true
+                #if debug
+                function f()
+                    return 3.14
+                end function
+                #end if
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('does not allow top level definitions inside #if block inside a function', () => {
+            program.setFile('source/main.bs', `
+                #const debug = true
+                function f()
+                    #if debug
+                    namespace alpha
+                    end namespace
+                    #end if
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel('namespace')
+            ]);
+        });
+        it('shows diagnostic for #error', () => {
+            program.setFile('source/main.bs', `
+                #const debug = true
+                function f()
+                    #if debug
+                    #error This is a conditional compile error
+                    #end if
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.hashError('This is a conditional compile error')
+            ]);
+        });
+        it('does not show diagnostic for #error when inside false CC block', () => {
+            program.setFile('source/main.bs', `
+                #const debug = false
+                function f()
+                    #if debug
+                    #error This is a conditional compile error
+                    #end if
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+    });
+    describe('types', () => {
+        it('sets assignments of invalid as dynamic', () => {
+            const file = program.setFile('source/main.bs', `
+                sub test()
+                    channel = invalid
+                    if true
+                        channel = {
+                            height: 123
+                        }
+                    end if
+
+                    height = 0
+                    if channel <> invalid then
+                        height += channel.height
+                    end if
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const func = file.ast.statements[0].findChild(reflection_1.isFunctionExpression, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const table = func.body.getSymbolTable();
+            const data = {};
+            const channelType = table.getSymbolType('channel', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(channelType, DynamicType_1.DynamicType);
+        });
+        it('sets default arg of invalid as dynamic', () => {
+            const file = program.setFile('source/main.bs', `
+                sub test(channel = invalid)
+                    if true
+                        channel = {
+                            height: 123
+                        }
+                    end if
+
+                    height = 0
+                    if channel <> invalid then
+                        height += channel.height
+                    end if
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const func = file.ast.statements[0].findChild(reflection_1.isFunctionExpression, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const table = func.body.getSymbolTable();
+            const data = {};
+            const channelType = table.getSymbolType('channel', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(channelType, DynamicType_1.DynamicType);
+        });
+    });
+    describe('instances of types', () => {
+        it('sets assigned variables as instances', () => {
+            const file = program.setFile('source/main.bs', `
+            sub makeKlass()
+                x = new Klass()
+            end sub
+
+            class Klass
+            end class
+        `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const func = file.ast.statements[0].findChild(reflection_1.isFunctionExpression, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const table = func.body.getSymbolTable();
+            const data = {};
+            const xType = table.getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(xType, ClassType_1.ClassType);
+            (0, chai_config_spec_1.expect)(data.isInstance).to.be.true;
+            (0, chai_config_spec_1.expect)(table.isSymbolTypeInstance('x')).to.be.true;
+        });
+        it('sets params as instances', () => {
+            const file = program.setFile('source/main.bs', `
+            sub makeKlass(x as Klass, n = x.name)
+            end sub
+
+            class Klass
+                name as string
+            end class
+        `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const func = file.ast.statements[0].findChild(reflection_1.isFunctionExpression, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            const table = func.getSymbolTable();
+            const data = {};
+            const xType = table.getSymbolType('x', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(xType, ClassType_1.ClassType);
+            (0, chai_config_spec_1.expect)(data.isInstance).to.be.true;
+            (0, chai_config_spec_1.expect)(table.isSymbolTypeInstance('x')).to.be.true;
+            const nType = table.getSymbolType('n', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(nType, StringType_1.StringType);
+            (0, chai_config_spec_1.expect)(data.isInstance).to.be.true;
+            (0, chai_config_spec_1.expect)(table.isSymbolTypeInstance('n')).to.be.true;
+        });
+        it('allows super as instance', () => {
+            const file = program.setFile('source/main.bs', `
+            class SuperKlass
+                name as string
+                sub new(name as string)
+                    m.name = name
+                end sub
+            end class
+
+            class Klass extends SuperKlass
+                sub new()
+                    super("hello")
+                end sub
+
+                function getName()
+                    return super.name
+                end function
+            end class
+        `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const klass = file.ast.statements[1];
+            const newTable = klass.methods[0].func.body.getSymbolTable();
+            let data = {};
+            const newSuperType = newTable.getSymbolType('super', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(newSuperType, ClassType_1.ClassType);
+            (0, chai_config_spec_1.expect)(data.isInstance).to.be.true;
+            const getNameTable = klass.methods[0].func.body.getSymbolTable();
+            data = {};
+            const getNameSuperType = getNameTable.getSymbolType('super', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            (0, testHelpers_spec_1.expectTypeToBe)(getNameSuperType, ClassType_1.ClassType);
+            (0, chai_config_spec_1.expect)(data.isInstance).to.be.true;
+        });
+    });
+    describe('types in comments', () => {
+        describe('@param', () => {
+            it('uses @param type in brs file', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param {string} name
+                    function sayHello(name)
+                        print "Hello " + name
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                let data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), StringType_1.StringType);
+                data = {};
+                const printSymbolTable = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable();
+                (0, testHelpers_spec_1.expectTypeToBe)(printSymbolTable.getSymbolType('name', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), StringType_1.StringType);
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+            it('handles no type in @param tag', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param  name
+                    function sayHello(name)
+                        print "Hello " + name
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                let data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), DynamicType_1.DynamicType);
+                data = {};
+                const printSymbolTable = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable();
+                (0, testHelpers_spec_1.expectTypeToBe)(printSymbolTable.getSymbolType('name', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), DynamicType_1.DynamicType);
+            });
+            it('uses @param type in brs file that can refer to a custom type', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param {Klass} myClass
+                    function sayHello(myClass)
+                        print "Hello " + myClass.name
+                    end function
+                `);
+                program.setFile('source/klass.bs', `
+                    class Klass
+                        name as string
+                    end class
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const funcParamExpr = file.ast.findChild(reflection_1.isFunctionParameterExpression);
+                (0, testHelpers_spec_1.expectTypeToBe)(funcParamExpr.getType({
+                    flags: 2 /* SymbolTypeFlag.typetime */, data: data
+                }), ClassType_1.ClassType);
+                const myClassType = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable().getSymbolType('myClass', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                });
+                (0, testHelpers_spec_1.expectTypeToBe)(myClassType, ClassType_1.ClassType);
+                (0, testHelpers_spec_1.expectTypeToBe)(myClassType.getMemberType('name', { flags: 1 /* SymbolTypeFlag.runtime */ }), StringType_1.StringType);
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+            it('uses @param type in brs file that can refer to a built in type', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param {roDeviceInfo} info
+                    function sayHello(info)
+                        print "Hello " + info.getModel()
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 2 /* SymbolTypeFlag.typetime */, data: data
+                }), InterfaceType_1.InterfaceType);
+                const infoType = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable().getSymbolType('info', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                });
+                (0, testHelpers_spec_1.expectTypeToBe)(infoType, InterfaceType_1.InterfaceType);
+                (0, testHelpers_spec_1.expectTypeToBe)(infoType.getMemberType('getModel', { flags: 1 /* SymbolTypeFlag.runtime */ }), TypedFunctionType_1.TypedFunctionType);
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+            it('allows jsdoc comment style /** prefix', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' /**
+                    ' * @param {string} info
+                    ' */
+                    function sayHello(info)
+                        print "Hello " + info
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), StringType_1.StringType);
+                const infoType = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable().getSymbolType('info', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                });
+                (0, testHelpers_spec_1.expectTypeToBe)(infoType, StringType_1.StringType);
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+            it('ignores types it cannot find', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param {TypeNotThere} info
+                    function sayHello(info)
+                        print "Hello " + info.prop
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.cannotFindName('TypeNotThere').message
+                ]);
+                const data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), DynamicType_1.DynamicType);
+                const infoType = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable().getSymbolType('info', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                });
+                (0, testHelpers_spec_1.expectTypeToBe)(infoType, DynamicType_1.DynamicType);
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+            it('allows built-in type in @param in Brightscript mode', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @param {roAssociativeArray} thing
+                    function sayHello(thing)
+                        print "Hello " + thing.name
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                let data = {};
+                (0, testHelpers_spec_1.expectTypeToBe)(file.ast.findChild(reflection_1.isFunctionParameterExpression).getType({
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                }), InterfaceType_1.InterfaceType);
+                data = {};
+                const printSymbolTable = file.ast.findChild(reflection_1.isPrintStatement).getSymbolTable();
+                const thingType = printSymbolTable.getSymbolType('thing', {
+                    flags: 1 /* SymbolTypeFlag.runtime */, data: data
+                });
+                (0, testHelpers_spec_1.expectTypeToBe)(thingType, InterfaceType_1.InterfaceType);
+                (0, chai_config_spec_1.expect)(thingType.toString()).to.eql('roAssociativeArray');
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+        });
+        describe('@return', () => {
+            it('uses @return type in brs file', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @return {string}
+                    function getPie()
+                        return "pumpkin"
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const funcType = funcStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(funcType, TypedFunctionType_1.TypedFunctionType);
+                const returnType = funcType.returnType;
+                (0, testHelpers_spec_1.expectTypeToBe)(returnType, StringType_1.StringType);
+            });
+            it('allows unknown type when using @return tag', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @return {TypeNotThere}
+                    function getPie()
+                        return "pumpkin"
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.cannotFindName('TypeNotThere').message
+                ]);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const funcType = funcStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(funcType, TypedFunctionType_1.TypedFunctionType);
+                const returnType = funcType.returnType;
+                (0, testHelpers_spec_1.expectTypeToBe)(returnType, DynamicType_1.DynamicType);
+            });
+            it('validates return statements against @return tag with valid type', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @return {integer}
+                    function getPie()
+                        return "pumpkin"
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('string', 'integer').message
+                ]);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const funcType = funcStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(funcType, TypedFunctionType_1.TypedFunctionType);
+                const returnType = funcType.returnType;
+                (0, testHelpers_spec_1.expectTypeToBe)(returnType, IntegerType_1.IntegerType);
+            });
+            it('checks return statements against @return tag with valid custom type', () => {
+                const file = program.setFile('source/main.brs', `
+                    ' @return {alpha.Klass}
+                    function getPie()
+                        return alpha_Klass()
+                    end function
+                `);
+                program.setFile('source/klass.bs', `
+                    namespace alpha
+                        class Klass
+                            name as string
+                        end class
+                    end namespace
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const funcType = funcStmt.getType({ flags: 2 /* SymbolTypeFlag.typetime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(funcType, TypedFunctionType_1.TypedFunctionType);
+                const returnType = funcType.returnType;
+                (0, testHelpers_spec_1.expectTypeToBe)(returnType, ClassType_1.ClassType);
+            });
+            it('validates return statements against @return tag with valid custom type', () => {
+                program.setFile('source/main.brs', `
+                    ' @return {alpha.Klass}
+                    function getPie()
+                        return "foo"
+                    end function
+                `);
+                program.setFile('source/klass.bs', `
+                    namespace alpha
+                        class Klass
+                            name as string
+                        end class
+                    end namespace
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('string', 'alpha.Klass').message
+                ]);
+            });
+        });
+        describe('@type', () => {
+            it('uses @type type in brs file', () => {
+                const file = program.setFile('source/main.brs', `
+                    function getPie() as string
+                        ' @type {string}
+                        pieType = getFruit()
+                        return pieType
+                    end function
+
+                    function getFruit()
+                        return "apple"
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const returnStmt = funcStmt.findChild(reflection_1.isReturnStatement);
+                const varType = returnStmt.getSymbolTable().getSymbolType('pieType', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(varType, StringType_1.StringType);
+            });
+            it('allows unknown type when using @type tag', () => {
+                const file = program.setFile('source/main.brs', `
+
+                    function getValue()
+                        ' @type {unknown}
+                        something = {}
+                        return something
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.cannotFindName('unknown').message
+                ]);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const funcType = funcStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(funcType, TypedFunctionType_1.TypedFunctionType);
+                const returnType = funcType.returnType;
+                (0, testHelpers_spec_1.expectTypeToBe)(returnType, DynamicType_1.DynamicType);
+            });
+            it('treats variable as type given in @type', () => {
+                const file = program.setFile('source/main.brs', `
+                    function getModelName()
+                        ' @type {roDeviceInfo}
+                        info = getData()
+                        return info.getModel()
+                    end function
+
+                    function getData()
+                        return {}
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const assignStmt = file.ast.findChild(reflection_1.isAssignmentStatement);
+                const infoType = assignStmt.getSymbolTable().getSymbolType('info', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(infoType, InterfaceType_1.InterfaceType);
+                (0, chai_config_spec_1.expect)(infoType.toString()).to.eq('roDeviceInfo');
+                (0, chai_config_spec_1.expect)(data.isFromDocComment).to.be.true;
+            });
+        });
+        // Skipped until we can figure out how to handle @var tags
+        describe.skip('@var', () => {
+            it('uses @var type in brs file to define types of variables', () => {
+                const file = program.setFile('source/main.brs', `
+                    function getPie() as string
+                        ' @var {string} someDate
+                        if m.top.isTrue
+                            someDate = getDate()
+                        else
+                            someDate = m.date2
+                        end if
+
+                        if m.someProp
+                            someDate = m.someProp.date
+                        end if
+
+                        return someDate
+                    end function
+
+                    function getDate()
+                        return "Dec 25"
+                    end function
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+                const data = {};
+                const funcStmt = file.ast.findChild(reflection_1.isFunctionStatement);
+                const returnStmt = funcStmt.findChild(reflection_1.isReturnStatement);
+                const varType = returnStmt.getSymbolTable().getSymbolType('someDate', { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                (0, testHelpers_spec_1.expectTypeToBe)(varType, StringType_1.StringType);
+            });
+        });
+    });
+    describe('try/catch', () => {
+        it('allows omitting the exception variable in standard brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                sub new()
+                    try
+                        print "hello"
+                    catch
+                        print "error"
+                    end try
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('shows diagnostic when omitting the exception variable in standard brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                sub new()
+                    try
+                        print "hello"
+                    catch
+                        print "error"
+                    end try
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectDiagnostics)(program, []);
+        });
+        it('shows diagnostics when using  when omitting the exception variable in standard brightscript mode', () => {
+            program.setFile('source/main.brs', `
+                sub new()
+                    try
+                        print "hello"
+                    catch
+                        print "error"
+                    end try
+                end sub
+            `);
+            (0, testHelpers_spec_1.expectDiagnostics)(program, []);
+        });
+    });
+    describe('function return values', () => {
+        it('catches sub with return value', () => {
+            program.setFile('source/main.brs', `
+                sub test()
+                    return true
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('sub')), { location: util_1.util.createLocation(2, 20, 2, 31, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches sub as void with return value', () => {
+            program.setFile('source/main.brs', `
+                sub test() as void
+                    return true
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('sub')), { location: util_1.util.createLocation(2, 20, 2, 31, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches function as void with return value', () => {
+            program.setFile('source/main.brs', `
+                function test() as void
+                    return true
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('function')), { location: util_1.util.createLocation(2, 20, 2, 31, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches sub as <type> without return value', () => {
+            program.setFile('source/main.brs', `
+                sub test() as integer
+                    return
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('sub')), { location: util_1.util.createLocation(2, 20, 2, 26, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('void', 'integer', {})
+            ]);
+        });
+        it('catches function without return value', () => {
+            program.setFile('source/main.brs', `
+                function test()
+                    return
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('function')), { location: util_1.util.createLocation(2, 20, 2, 26, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) })]);
+        });
+        it('catches function as <type> without return value', () => {
+            program.setFile('source/main.brs', `
+                function test() as integer
+                    return
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('function')), { location: util_1.util.createLocation(2, 20, 2, 26, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('void', 'integer', {})
+            ]);
+        });
+        it('catches anon sub with return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = sub()
+                        return true
+                    end sub
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('sub')), { location: util_1.util.createLocation(3, 24, 3, 35, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches sub as void with return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = sub() as void
+                        return true
+                    end sub
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('sub')), { location: util_1.util.createLocation(3, 24, 3, 35, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches function as void with return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = function() as void
+                        return true
+                    end function
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue('function')), { location: util_1.util.createLocation(3, 24, 3, 35, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('boolean', 'void', {})
+            ]);
+        });
+        it('catches sub as <type> without return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = sub() as integer
+                        return
+                    end sub
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('sub')), { location: util_1.util.createLocation(3, 24, 3, 30, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('void', 'integer', {})
+            ]);
+        });
+        it('catches function without return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = function()
+                        return
+                    end function
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('function')), { location: util_1.util.createLocation(3, 24, 3, 30, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) })]);
+        });
+        it('catches function as <type> without return value', () => {
+            program.setFile('source/main.brs', `
+                sub main()
+                    test = function() as integer
+                        return
+                    end function
+                end sub
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue('function')), { location: util_1.util.createLocation(3, 24, 3, 30, (0, util_1.standardizePath) `${testHelpers_spec_1.rootDir}/source/main.brs`) }),
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('void', 'integer', {})
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=BrsFileValidator.spec.js.map