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

package/dist/parser/tests/controlFlow/If.spec.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const chai_1 = require("chai");
+const chai_config_spec_1 = require("../../../chai-config.spec");
 const assert = require("assert");
 const Parser_1 = require("../../Parser");
-const lexer_1 = require("../../../lexer");
+const Lexer_1 = require("../../../lexer/Lexer");
+const TokenKind_1 = require("../../../lexer/TokenKind");
 const Parser_spec_1 = require("../Parser.spec");
-const astUtils_1 = require("../../../astUtils");
+const reflection_1 = require("../../../astUtils/reflection");
+const testHelpers_spec_1 = require("../../../testHelpers.spec");
+const DiagnosticMessages_1 = require("../../../DiagnosticMessages");
+const util_1 = require("../../../util");
 describe('parser if statements', () => {
     it('allows empty if blocks', () => {
         var _a;
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true then
 
             else if true then
@@ -18,13 +22,13 @@ describe('parser if statements', () => {
                 stop
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('allows empty elseif blocks', () => {
         var _a;
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true then
                 stop
             else if true then
@@ -33,13 +37,13 @@ describe('parser if statements', () => {
                 stop
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('allows empty else blocks', () => {
         var _a;
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true then
                 stop
             else if true then
@@ -48,13 +52,13 @@ describe('parser if statements', () => {
 
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)((_a = diagnostics[0]) === null || _a === void 0 ? void 0 : _a.message).not.to.exist;
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('single-line if next to else or endif', () => {
         var _a;
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if type(component.TextAttrs.font) = "roString"
                 font = m.fonts.Lookup(component.TextAttrs.font)
                 if font = invalid then font = m.fonts.medium
@@ -64,146 +68,146 @@ describe('parser if statements', () => {
                 font = m.fonts.reg.GetDefaultFont()
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
-        let ifs = statements[0];
-        if (!astUtils_1.isIfStatement(ifs) || !astUtils_1.isIfStatement((_a = ifs.thenBranch) === null || _a === void 0 ? void 0 : _a.statements[1])) {
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
+        let ifs = ast.statements[0];
+        if (!(0, reflection_1.isIfStatement)(ifs) || !(0, reflection_1.isIfStatement)((_a = ifs.thenBranch) === null || _a === void 0 ? void 0 : _a.statements[1])) {
             assert.fail('Missing single-line if inside if-then');
         }
-        if (!astUtils_1.isIfStatement(ifs.elseBranch)) {
+        if (!(0, reflection_1.isIfStatement)(ifs.elseBranch)) {
             assert.fail('Missing chained else-if statement');
         }
-        chai_1.expect(ifs.elseBranch.elseBranch).to.exist;
+        (0, chai_config_spec_1.expect)(ifs.elseBranch.elseBranch).to.exist;
     });
     it('single-line if inside multi-line if', () => {
         var _a;
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true
                 if true then t = 1
             else
                 ' empty line or line with just a comment causes crash
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
-        let ifs = statements[0];
-        if (!astUtils_1.isIfStatement(ifs) || !astUtils_1.isIfStatement((_a = ifs.thenBranch) === null || _a === void 0 ? void 0 : _a.statements[0])) {
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
+        let ifs = ast.statements[0];
+        if (!(0, reflection_1.isIfStatement)(ifs) || !(0, reflection_1.isIfStatement)((_a = ifs.thenBranch) === null || _a === void 0 ? void 0 : _a.statements[0])) {
             assert.fail('Missing single-line if inside if-then');
         }
-        chai_1.expect(ifs.elseBranch).to.exist;
-        if (!astUtils_1.isBlock(ifs.elseBranch) || !astUtils_1.isCommentStatement(ifs.elseBranch.statements[0])) {
+        (0, chai_config_spec_1.expect)(ifs.elseBranch).to.exist;
+        if (!(0, reflection_1.isBlock)(ifs.elseBranch)) {
             assert.fail('Missing comment inside else branch');
         }
     });
     it('dotted set in else block', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true then m.top.visible = true else m.top.visible = false
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
         if (diagnostics.length > 0) {
             console.log(diagnostics);
         }
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     describe('single-line if', () => {
         it('parses if only', () => {
-            let { statements, diagnostics } = Parser_1.Parser.parse([
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Less, '<'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.token(lexer_1.TokenKind.Then, 'then'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Newline, '\n'),
+            let { ast, diagnostics } = Parser_1.Parser.parse([
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Less, '<'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Then, 'then'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Newline, '\n'),
                 Parser_spec_1.EOF
             ]);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('parses if-else', () => {
-            let { statements, diagnostics } = Parser_1.Parser.parse([
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Less, '<'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.token(lexer_1.TokenKind.Then, 'then'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Else, 'else'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.False, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Newline, '\n'),
+            let { ast, diagnostics } = Parser_1.Parser.parse([
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Less, '<'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Then, 'then'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Else, 'else'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.False, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Newline, '\n'),
                 Parser_spec_1.EOF
             ]);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('parses if-elseif-else', () => {
-            let { statements, diagnostics } = Parser_1.Parser.parse([
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Less, '<'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.token(lexer_1.TokenKind.Then, 'then'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Else, 'else'),
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.token(lexer_1.TokenKind.Then, 'then'),
-                Parser_spec_1.identifier('same'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Else, 'else'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Newline, '\n'),
+            let { ast, diagnostics } = Parser_1.Parser.parse([
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Less, '<'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Then, 'then'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Else, 'else'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Then, 'then'),
+                (0, Parser_spec_1.identifier)('same'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Else, 'else'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Newline, '\n'),
                 Parser_spec_1.EOF
             ]);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('allows \'then\' to be skipped', () => {
             // if 1 < 2 foo = true else if 1 = 2 same = true
-            let { statements, diagnostics } = Parser_1.Parser.parse([
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Less, '<'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Else, 'else'),
-                Parser_spec_1.token(lexer_1.TokenKind.If, 'if'),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '1'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.IntegerLiteral, '2'),
-                Parser_spec_1.identifier('same'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.True, 'true'),
-                Parser_spec_1.token(lexer_1.TokenKind.Else, 'else'),
-                Parser_spec_1.identifier('foo'),
-                Parser_spec_1.token(lexer_1.TokenKind.Equal, '='),
-                Parser_spec_1.token(lexer_1.TokenKind.False, 'false'),
-                Parser_spec_1.token(lexer_1.TokenKind.Newline, '\n'),
+            let { ast, diagnostics } = Parser_1.Parser.parse([
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Less, '<'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Else, 'else'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.If, 'if'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '1'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.IntegerLiteral, '2'),
+                (0, Parser_spec_1.identifier)('same'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.True, 'true'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Else, 'else'),
+                (0, Parser_spec_1.identifier)('foo'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Equal, '='),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.False, 'false'),
+                (0, Parser_spec_1.token)(TokenKind_1.TokenKind.Newline, '\n'),
                 Parser_spec_1.EOF
             ]);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('parses special statements in inline block', () => {
-            const { statements, diagnostics } = Parser_1.Parser.parse(`
+            const { ast, diagnostics } = Parser_1.Parser.parse(`
                 if true print 1 else print 1
                 if true then print 1 else print 1
                 if true print "x=" ; 1 else print 1
@@ -212,26 +216,146 @@ describe('parser if statements', () => {
                 if true return else print 1
                 if true then return else print 1
             `);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
+        });
+        it('colon used between inline else statements', () => {
+            const { ast, diagnostics } = Parser_1.Parser.parse(`
+                if x print 1 else print 2 : print 3
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(1);
+            const ifStatement = ast.statements[0];
+            (0, chai_config_spec_1.expect)(ifStatement.thenBranch.statements).to.be.lengthOf(1);
+            (0, chai_config_spec_1.expect)(ifStatement.elseBranch.statements).to.be.lengthOf(2);
+        });
+        it('colon used between inline else if statements', () => {
+            const { ast, diagnostics } = Parser_1.Parser.parse(`
+                if x print 1 else if y print 2 : print 3
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(1);
+            const ifStatement = ast.statements[0];
+            (0, chai_config_spec_1.expect)(ifStatement.thenBranch.statements).to.be.lengthOf(1);
+            (0, chai_config_spec_1.expect)(ifStatement.elseBranch.thenBranch.statements).to.be.lengthOf(2);
+        });
+        it('colon used between all kinds of statements', () => {
+            const { ast, diagnostics } = Parser_1.Parser.parse(`
+                if x print 1 : print 1 else if y print 2 : print 2 : print 2 else print 3 : print 3: print 3: print 3
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(1);
+            const ifStatement = ast.statements[0];
+            (0, chai_config_spec_1.expect)(ifStatement.thenBranch.statements).to.be.lengthOf(2);
+            const elseIf = ifStatement.elseBranch;
+            (0, chai_config_spec_1.expect)(elseIf.thenBranch.statements).to.be.lengthOf(3);
+            (0, chai_config_spec_1.expect)(elseIf.elseBranch.statements).to.be.lengthOf(4);
+        });
+        it('has diagnostic with extra else', () => {
+            const { diagnostics } = Parser_1.Parser.parse(`
+                if x=1 print 1 else print 2 else print 3
+            `);
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                DiagnosticMessages_1.DiagnosticMessages.expectedNewlineOrColon().message
+            ]);
+        });
+        it('nested inline if statements', () => {
+            const { ast, diagnostics } = Parser_1.Parser.parse(`
+                if x=1 print 1 else if x=2 print 2 : if y=1 print "y is 1" else print "y is not 1" else print 3: print 3: print 3
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(diagnostics);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(1);
+            const ifStatement = ast.statements[0];
+            (0, chai_config_spec_1.expect)(ifStatement.thenBranch.statements).to.be.lengthOf(1);
+            const elseIf = ifStatement.elseBranch;
+            (0, chai_config_spec_1.expect)(elseIf.thenBranch.statements).to.be.lengthOf(2);
+            (0, chai_config_spec_1.expect)((0, reflection_1.isIfStatement)(elseIf.thenBranch.statements[1])).to.be.true;
+            const nestedInlineIf = elseIf.thenBranch.statements[1];
+            (0, chai_config_spec_1.expect)(nestedInlineIf.thenBranch.statements).to.be.lengthOf(1);
+            (0, chai_config_spec_1.expect)(nestedInlineIf.elseBranch.statements).to.be.lengthOf(1);
+            (0, chai_config_spec_1.expect)(elseIf.elseBranch.statements).to.be.lengthOf(3);
+        });
+        describe('expected inline if', () => {
+            it('non-inline statement used in inline if', () => {
+                const { ast, diagnostics } = Parser_1.Parser.parse(`
+                    if true print 1 else
+                        print 1
+                    end if
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement().message
+                ]);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.be.greaterThan(0);
+            });
+            it('non inline statement used in inline else if', () => {
+                const { ast, diagnostics } = Parser_1.Parser.parse(`
+                    if x print 1 else if y
+                        print 2
+                    end if
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement().message
+                ]);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.be.greaterThan(0);
+            });
+            it('colon used after inline else', () => {
+                const { ast, diagnostics } = Parser_1.Parser.parse(`
+                    if x print 1 else : print 2 : print 3: end if
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement().message
+                ]);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.be.greaterThan(0);
+            });
+            it('new line used in inline else', () => {
+                const { ast, diagnostics } = Parser_1.Parser.parse(`
+                    if x print 1 else
+                        print 2
+                        print 3
+                    end if
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement().message
+                ]);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.be.greaterThan(0);
+            });
+            it('colon used after inline else if', () => {
+                const { diagnostics } = Parser_1.Parser.parse(`
+                    if x print 1 else if y : print 2
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedTerminator(['end if', 'else if', 'else'], 'then', 'block').message
+                ]);
+            });
+            it('new line used in inline else if', () => {
+                const { ast, diagnostics } = Parser_1.Parser.parse(`
+                    if x print 1 else if y
+                        print 2
+                    end if
+                `);
+                (0, testHelpers_spec_1.expectDiagnosticsIncludes)(diagnostics, [
+                    DiagnosticMessages_1.DiagnosticMessages.expectedInlineIfStatement().message
+                ]);
+                (0, chai_config_spec_1.expect)(ast.statements.length).to.be.greaterThan(0);
+            });
         });
     });
     describe('block if', () => {
         it('parses if only', () => {
             //because the parser depends on line numbers for certain if statements, this needs to be location-aware
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 if 1 < 2 THEN
                     foo = true
                     bar = true
                 end if
             `);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('parses if-else', () => {
             //this test requires token locations, so use the lexer
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 if 1 < 2 then
                     foo = true
                 else
@@ -239,13 +363,13 @@ describe('parser if statements', () => {
                     bar = false
                 end if
             `);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('parses if-elseif-else', () => {
             //this test requires token locations, so use the lexer
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 if 1 < 2 then
                     foo = true
                 else if 1 > 2 then
@@ -255,13 +379,13 @@ describe('parser if statements', () => {
                     foo = false
                 end if
             `);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('allows \'then\' to be skipped', () => {
             //this test requires token locations, so use the lexer
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 if 1 < 2
                     foo = true
                 else if 1 > 2
@@ -271,13 +395,13 @@ describe('parser if statements', () => {
                     foo = false
                 end if
             `);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
         });
         it('sets endif token properly', () => {
             //this test requires token locations, so use the lexer
-            let { tokens } = lexer_1.Lexer.scan(`
+            let { tokens } = Lexer_1.Lexer.scan(`
                 sub a()
                     if true then
                         print false
@@ -288,20 +412,20 @@ describe('parser if statements', () => {
                     end if 'comment
                 end sub
             `);
-            let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-            chai_1.expect(diagnostics).to.be.lengthOf(0);
-            chai_1.expect(statements).to.be.length.greaterThan(0);
+            let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+            (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+            (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
             //the endif token should be set
-            let ifs = statements[0].func.body.statements[0];
-            if (!astUtils_1.isIfStatement(ifs) || !astUtils_1.isIfStatement(ifs.elseBranch)) {
+            let ifs = ast.statements[0].func.body.statements[0];
+            if (!(0, reflection_1.isIfStatement)(ifs) || !(0, reflection_1.isIfStatement)(ifs.elseBranch)) {
                 assert.fail('Unexpected statement found');
             }
-            chai_1.expect(ifs.tokens.endIf).to.not.exist;
-            chai_1.expect(ifs.elseBranch.tokens.endIf).to.exist;
+            (0, chai_config_spec_1.expect)(ifs.tokens.endIf).to.not.exist;
+            (0, chai_config_spec_1.expect)(ifs.elseBranch.tokens.endIf).to.exist;
         });
     });
     it('supports trailing colons after conditional statements', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             sub main()
                 if 1 > 0:
                     print "positive!"
@@ -312,126 +436,126 @@ describe('parser if statements', () => {
                 end if
             end sub
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports trailing colons for one-line if statements', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2: return true: end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches one-line if statement missing first colon', () => {
         //missing colon after 2
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 return true : end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches one-line if statement with multiple statements missing first colon', () => {
         //missing colon after 2
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 print "ok" : return true : end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches one-line if statement missing second colon', () => {
         //missing colon after `2`
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 : return true end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches one-line if statement with else missing colons', () => {
         //missing colon after `2`
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 : return true: else return false end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches one-line if statement with colon and missing end if', () => {
         //missing colon after `2`
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2: return true
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.lengthOf(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(0);
     });
     it('catches one-line if multi-statement with colon and missing end if', () => {
         //missing colon after `2`
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2: print "ok": return true
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.lengthOf(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(0);
     });
     it('catches one-line if statement with colon and missing endif inside a function', () => {
         //missing 'end if'
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             function missingendif()
                 if true : return true
             end function
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(2);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(2);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches extraneous colon at the end of one-line if-else', () => {
         //colon at the end not allowed
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then return true else return false:
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches colon before if, unless there is `then` before', () => {
         //colon before if isn't allowed
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then: if 2<3: return false: end if
             : if 1 < 2: return true: end if
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches extraneous colon+end if at the end of one-line if-else', () => {
         //expected newline + unexpected endif
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then return true else return false: end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(2);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(2);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('recovers from extraneous endif at the end of one-line if-else', () => {
         //unexpected endif
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             function test1()
                 if 1 < 2: return true: else return false end if
             end function
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(2);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(2);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('recovers from missing end-if', () => {
         //unexpected endif
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             function test1()
                 if 1 < 2 then if 1 < 3
                     return true
@@ -439,113 +563,132 @@ describe('parser if statements', () => {
             function test2()
             end function
         `);
-        let { statements, diagnostics, references } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.lengthOf(2);
-        chai_1.expect(references.functionStatements).to.be.lengthOf(2);
+        const { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(2);
+        const functionStatements = ast.findChildren(reflection_1.isFunctionStatement);
+        (0, chai_config_spec_1.expect)(functionStatements).to.be.lengthOf(2);
     });
     it('catches extraneous colon at the end of one-line if', () => {
         //colon at the end not allowed
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then return true:
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches multi-line if inside a one-line if branch', () => {
         //second if should be inline
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then if 1 < 3
                 return true
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports multiple statements in one-line if statements', () => {
         //second if should be inline
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then ok = true : m.ok = true : print "ok" : ook() else if 1 < 3
                 return true
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches multi-line if inside a one-line if else branch', () => {
         //second if should be inline
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then return false else if 1 < 3
                 return true
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(1);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(1);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('catches else statement missing colon', () => {
         //missing colon before `end if`
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2
               return true
             else return false end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.length.greaterThan(0);
-        chai_1.expect(statements).to.be.lengthOf(1);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.length.greaterThan(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.lengthOf(1);
     });
     it('supports if statement with condition and action on one line, but end if on separate line', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2: return true
             end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports colon after return in single-line if statement', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if false : print "true" : end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports if elseif endif single line', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true: print "8 worked": else if true: print "not run": else: print "not run": end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports comment at the end of one-line if', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 > 2 then return true 'OK
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports colon at the beginning of a line', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if 1 < 2 then: if 1 < 4 then return false
             : end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
     });
     it('supports one-line functions inside of one-line if statement', () => {
-        let { tokens } = lexer_1.Lexer.scan(`
+        let { tokens } = Lexer_1.Lexer.scan(`
             if true then : test = sub() : print "yes" : end sub : end if
         `);
-        let { statements, diagnostics } = Parser_1.Parser.parse(tokens);
-        chai_1.expect(diagnostics).to.be.lengthOf(0);
-        chai_1.expect(statements).to.be.length.greaterThan(0);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        (0, chai_config_spec_1.expect)(ast.statements).to.be.length.greaterThan(0);
+    });
+    it('single-line if block statements have correct range', () => {
+        let { tokens } = Lexer_1.Lexer.scan(`
+            if false then print "true"
+            if false then print "true": a = 10
+            if false then print "true" else print "false"
+            if false then print "true" else print "false": a = 20
+        `);
+        let { ast, diagnostics } = Parser_1.Parser.parse(tokens);
+        (0, chai_config_spec_1.expect)(diagnostics).to.be.lengthOf(0);
+        const then1 = ast.statements[0].thenBranch;
+        (0, chai_config_spec_1.expect)(then1.location).to.eql(util_1.util.createBoundingLocation(...then1.statements));
+        const then2 = ast.statements[1].thenBranch;
+        (0, chai_config_spec_1.expect)(then2.location).to.eql(util_1.util.createBoundingLocation(...then2.statements));
+        const else1 = ast.statements[2].elseBranch;
+        (0, chai_config_spec_1.expect)(else1.location).to.eql(util_1.util.createBoundingLocation(...else1.statements));
+        const else2 = ast.statements[3].elseBranch;
+        (0, chai_config_spec_1.expect)(else2.location).to.eql(util_1.util.createBoundingLocation(...else2.statements));
     });
 });
 //# sourceMappingURL=If.spec.js.map