brighterscript 0.66.0-alpha.1 → 0.66.0-alpha.11

package/dist/parser/Parser.spec.js

@@ -20,6 +20,7 @@ const SymbolTable_1 = require("../SymbolTable");
 const IntegerType_1 = require("../types/IntegerType");
 const FloatType_1 = require("../types/FloatType");
 const StringType_1 = require("../types/StringType");
+const types_1 = require("../types");
 describe('parser', () => {
     it('emits empty object when empty token list is provided', () => {
         (0, chai_config_spec_1.expect)(Parser_1.Parser.parse([])).to.deep.include({
@@ -52,12 +53,18 @@ describe('parser', () => {
         });
         function expressionsToStrings(expressions) {
             return [...expressions.values()].map(x => {
-                const file = new BrsFile_1.BrsFile('', '', new Program_1.Program({}));
+                const file = new BrsFile_1.BrsFile({
+                    srcPath: '',
+                    destPath: '',
+                    program: new Program_1.Program({})
+                });
                 const state = new BrsTranspileState_1.BrsTranspileState(file);
                 return new source_map_1.SourceNode(null, null, null, x.transpile(state)).toString();
             });
         }
-        it('works for references.expressions', () => {
+        // eslint-disable-next-line func-names, prefer-arrow-callback
+        it('works for references.expressions', function () {
+            this.timeout(5000); // this test takes a long time on github
             const parser = Parser_1.Parser.parse(`
                 b += "plus-equal"
                 a += 1 + 2
@@ -552,14 +559,100 @@ describe('parser', () => {
             let { diagnostics } = Parser_1.Parser.parse(tokens);
             (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1, 'Error count should be 0');
         });
-        it.skip('allows printing object with trailing period', () => {
+        it('allows printing object with trailing period', () => {
             let { tokens } = Lexer_1.Lexer.scan(`print a.`);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
+            let { diagnostics, statements } = Parser_1.Parser.parse(tokens);
+            let printStatement = statements[0];
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod());
+            (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 { diagnostics, statements } = Parser_1.Parser.parse(tokens);
             let printStatement = statements[0];
-            (0, chai_config_spec_1.expect)(diagnostics).to.be.empty;
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedPropertyNameAfterPeriod());
             (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 { diagnostics, statements } = Parser_1.Parser.parse(tokens);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, DiagnosticMessages_1.DiagnosticMessages.expectedStatementOrFunctionCallButReceivedExpression());
+                let stmt = 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.name.text).to.equal('NameA');
+            });
+            it('adds unended call statements', () => {
+                let { tokens } = Lexer_1.Lexer.scan(`
+                    function a()
+                        lcase(
+                    end function
+                `);
+                let { statements } = Parser_1.Parser.parse(tokens);
+                let stmt = 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.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 { statements } = Parser_1.Parser.parse(tokens);
+                let stmt = 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.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 { statements } = Parser_1.Parser.parse(tokens);
+                let stmt = 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.name.text).to.equal('a');
+                (0, chai_config_spec_1.expect)(stmt.expression.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);
+            });
+        });
         describe('comments', () => {
             it('combines multi-line comments', () => {
                 let { tokens } = Lexer_1.Lexer.scan(`
@@ -1196,6 +1289,15 @@ describe('parser', () => {
         });
     });
     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
+            `, 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('allows type casts after function calls', () => {
             var _a;
             let { statements, diagnostics } = parse(`
@@ -1301,6 +1403,456 @@ describe('parser', () => {
             (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).to.exist;
         });
     });
+    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.expectedStatementOrFunctionCallButReceivedExpression()]);
+        });
+        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('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 { statements, diagnostics } = parse(`
+                sub main(things as string[])
+                    print things
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = statements[0].func.parameters[0].getType({ flags: SymbolTable_1.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 { statements, diagnostics } = parse(`
+                sub main(things as string[][])
+                    print things
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            const paramType = statements[0].func.parameters[0].getType({ flags: SymbolTable_1.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 { statements, 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 = statements[0].func.returnTypeExpression.getType({ flags: SymbolTable_1.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 { statements, 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 = statements[0].func.parameters[0].getType({ flags: SymbolTable_1.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 { statements, 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)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+        });
+        it('allows untyped fields', () => {
+            let { statements, diagnostics } = parse(`
+                interface HasUntyped
+                    name
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+        });
+        it('allows optional fields', () => {
+            let { statements, 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)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            // eslint-disable-next-line no-bitwise
+            ifaceType.getMemberTable().getAllSymbols(SymbolTable_1.SymbolTypeFlag.runtime).forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & SymbolTable_1.SymbolTypeFlag.optional).to.eq(SymbolTable_1.SymbolTypeFlag.optional));
+        });
+        it('allows fields named optional', () => {
+            let { statements, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional
+                    someThingElse
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.false);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.optional).to.eq(0));
+        });
+        it('allows fields named optional that are also optional', () => {
+            let { statements, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional optional
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.optional).to.eq(SymbolTable_1.SymbolTypeFlag.optional));
+        });
+        it('allows optional methods', () => {
+            let { statements, 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)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.methods.forEach(m => (0, chai_config_spec_1.expect)(m.isOptional).to.equal(true));
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            // eslint-disable-next-line no-bitwise
+            ifaceType.getMemberTable().getAllSymbols(SymbolTable_1.SymbolTypeFlag.runtime).forEach(sym => (0, chai_config_spec_1.expect)(sym.flags & SymbolTable_1.SymbolTypeFlag.optional).to.eq(SymbolTable_1.SymbolTypeFlag.optional));
+        });
+        it('allows fields named `as` that are also optional', () => {
+            let { statements, diagnostics } = parse(`
+                interface IsJustOptional
+                    optional as
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.optional).to.eq(SymbolTable_1.SymbolTypeFlag.optional));
+        });
+        it('allows fields named `as` that are also typed', () => {
+            let { statements, 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)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.true);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.optional).to.eq(SymbolTable_1.SymbolTypeFlag.optional));
+        });
+        it('allows fields named `optional` that are also typed', () => {
+            let { statements, 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)(statements.length).to.eq(1);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isInterfaceStatement)(statements[0])).to.be.true;
+            const iface = statements[0];
+            iface.fields.forEach(f => (0, chai_config_spec_1.expect)(f.isOptional).to.be.false);
+            const ifaceType = iface.getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+            const iFaceMembers = ifaceType.getMemberTable().getAllSymbols(SymbolTable_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 & SymbolTable_1.SymbolTypeFlag.optional).to.eq(0));
+        });
+    });
+    describe('leadingTrivia', () => {
+        it('gets leading trivia from functions', () => {
+            let { statements } = parse(`
+                ' Nice function, bro
+                function foo()
+                    return 1
+                end function
+            `);
+            const funcStatements = statements.filter(reflection_1.isFunctionStatement);
+            const fooTrivia = funcStatements[0].getLeadingTrivia();
+            (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 { statements } = parse(`
+                ' Say hello to someone
+                '
+                ' @param {string} name the person you want to say hello to.
+                sub sayHello(name as string = "world")
+                end sub
+            `);
+            const funcStatements = statements.filter(reflection_1.isFunctionStatement);
+            const helloTrivia = funcStatements[0].getLeadingTrivia();
+            (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 { statements } = parse(`
+                ' hello
+                ' classes
+                class Hello
+                end class
+            `, Parser_1.ParseMode.BrighterScript);
+            const classStatements = statements.filter(reflection_1.isClassStatement);
+            const trivia = classStatements[0].getLeadingTrivia();
+            (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 { statements } = parse(`
+                ' hello comment 1
+                ' hello comment 2
+                @annotation
+                sub sayHello(name as string = "world")
+                end sub
+            `, Parser_1.ParseMode.BrighterScript);
+            const funcStatements = statements.filter(reflection_1.isFunctionStatement);
+            const helloTrivia = funcStatements[0].getLeadingTrivia();
+            (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(2);
+        });
+        it('gets leading trivia from class methods', () => {
+            let { statements } = 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 = statements.filter(reflection_1.isClassStatement)[0];
+            const methodStatements = classStatement.methods;
+            // function getPi()
+            let trivia = methodStatements[0].getLeadingTrivia();
+            (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].getLeadingTrivia();
+            (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 { statements } = 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 = statements.filter(reflection_1.isClassStatement)[0];
+            const fieldStatements = classStatement.fields;
+            // color = "blue"
+            let trivia = fieldStatements[0].getLeadingTrivia();
+            (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].getLeadingTrivia();
+            (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].getLeadingTrivia();
+            (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 { statements } = parse(`
+                ' Description of interface
+                interface myIface
+                    ' comment
+                    someField as integer
+
+                    'comment
+                    function someFunc() as string
+                end interface
+            `, Parser_1.ParseMode.BrighterScript);
+            const ifaceStatement = statements.filter(reflection_1.isInterfaceStatement)[0];
+            const fieldStatements = ifaceStatement.fields;
+            const methodStatements = ifaceStatement.methods;
+            // interface myIface
+            let trivia = ifaceStatement.getLeadingTrivia();
+            (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].getLeadingTrivia();
+            (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].getLeadingTrivia();
+            (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 { statements } = parse(`
+                ' Description of interface
+                namespace Nested.Name.Space
+
+                end  namespace
+            `, Parser_1.ParseMode.BrighterScript);
+            const nameSpaceStatement = statements.filter(reflection_1.isNamespaceStatement)[0];
+            // namespace Nested.Name.Space
+            let trivia = nameSpaceStatement.getLeadingTrivia();
+            (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 { diagnostics, statements } = 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)(statements[0])).to.be.true;
+            const insideReturn = 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 { diagnostics, statements } = 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)(statements[0])).to.be.true;
+            const insideReturn = 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 { diagnostics, statements } = 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)(statements[0])).to.be.true;
+            const insideReturn = 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 { diagnostics, statements } = 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)(statements[0])).to.be.true;
+            const insideReturn = 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 { diagnostics, statements } = 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)(statements[0])).to.be.true;
+            const insideReturn = 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;
+        });
+    });
 });
 function parse(text, mode) {
     let { tokens } = Lexer_1.Lexer.scan(text);