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

package/dist/astUtils/visitors.spec.js

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const vscode_languageserver_1 = require("vscode-languageserver");
-const chai_1 = require("chai");
+const chai_config_spec_1 = require("../chai-config.spec");
 const sinon = require("sinon");
 const Program_1 = require("../Program");
 const Statement_1 = require("../parser/Statement");
-const lexer_1 = require("../lexer");
+const TokenKind_1 = require("../lexer/TokenKind");
 const visitors_1 = require("./visitors");
 const reflection_1 = require("./reflection");
 const creators_1 = require("./creators");
 const stackedVisitor_1 = require("./stackedVisitor");
+const Editor_1 = require("./Editor");
+const Parser_1 = require("../parser/Parser");
+const testHelpers_spec_1 = require("../testHelpers.spec");
+const Expression_1 = require("../parser/Expression");
 describe('astUtils visitors', () => {
     const rootDir = process.cwd();
     let program;
@@ -74,27 +78,62 @@ describe('astUtils visitors', () => {
     });
     function functionsWalker(visitor, cancel) {
         return (file) => {
-            file.parser.references.functionExpressions.some(functionExpression => {
+            const funcExpressions = file.ast.findChildren(reflection_1.isFunctionExpression, { walkMode: visitors_1.WalkMode.visitExpressionsRecursive });
+            funcExpressions.some(functionExpression => {
                 visitor(functionExpression.body, undefined);
-                visitors_1.walkStatements(functionExpression.body, (statement, parent) => visitor(statement, parent), cancel);
+                (0, visitors_1.walkStatements)(functionExpression.body, (statement, parent) => visitor(statement, parent), cancel);
                 return cancel === null || cancel === void 0 ? void 0 : cancel.isCancellationRequested;
             });
         };
     }
+    describe('createVisitor', () => {
+        it(`calls the 'AstNode' event for every node`, () => {
+            const file = program.setFile('source/main.brs', `
+                sub Main()
+                    print "Hello"
+                end sub
+            `);
+            const nodes = [];
+            function track(node) {
+                nodes.push(node);
+            }
+            const visitor = (0, visitors_1.createVisitor)({
+                AstNode: track,
+                FunctionStatement: track,
+                FunctionExpression: track,
+                PrintStatement: track,
+                Block: track,
+                LiteralExpression: track
+            });
+            file.ast.walk(visitor, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            (0, chai_config_spec_1.expect)(nodes.map(x => x.constructor.name)).to.eql([
+                'FunctionStatement',
+                'FunctionStatement',
+                'FunctionExpression',
+                'FunctionExpression',
+                'Block',
+                'Block',
+                'PrintStatement',
+                'PrintStatement',
+                'LiteralExpression',
+                'LiteralExpression'
+            ]);
+        });
+    });
     describe('Statements', () => {
         it('Walks through all the statements with depth', () => {
             const actual = [];
-            const visitor = stackedVisitor_1.createStackedVisitor((s, stack) => {
+            const visitor = (0, stackedVisitor_1.createStackedVisitor)((s, stack) => {
                 const d = stack.length;
                 actual.push(`${s.constructor.name}:${d}`);
             });
             const walker = functionsWalker(visitor);
             program.plugins.add({
                 name: 'walker',
-                afterFileParse: (event) => walker(event.file)
+                afterProvideFile: event => walker(event.files[0])
             });
             program.setFile('source/main.brs', PRINTS_SRC);
-            chai_1.expect(actual).to.deep.equal([
+            (0, chai_config_spec_1.expect)(actual).to.deep.equal([
                 'Block:0',
                 'PrintStatement:1',
                 'PrintStatement:1',
@@ -127,10 +166,10 @@ describe('astUtils visitors', () => {
             const walker = functionsWalker(s => actual.push(s.constructor.name), cancel.token);
             program.plugins.add({
                 name: 'walker',
-                afterFileParse: (event) => walker(event.file)
+                afterProvideFile: event => walker(event.files[0])
             });
-            program.setFile('source/file.brs', PRINTS_SRC);
-            chai_1.expect(actual).to.deep.equal([
+            program.setFile('source/main.brs', PRINTS_SRC);
+            (0, chai_config_spec_1.expect)(actual).to.deep.equal([
                 'Block',
                 'PrintStatement',
                 'PrintStatement',
@@ -163,7 +202,7 @@ describe('astUtils visitors', () => {
             let count = 0;
             const walker = functionsWalker(s => {
                 actual.push(s.constructor.name);
-                if (reflection_1.isPrintStatement(s)) {
+                if ((0, reflection_1.isPrintStatement)(s)) {
                     if (++count === 4) {
                         cancel.cancel();
                     }
@@ -171,12 +210,10 @@ describe('astUtils visitors', () => {
             }, cancel.token);
             program.plugins.add({
                 name: 'walker',
-                afterFileParse: (event) => {
-                    walker(event.file);
-                }
+                afterProvideFile: event => walker(event.files[0])
             });
-            program.setFile('source/file.brs', PRINTS_SRC);
-            chai_1.expect(actual).to.deep.equal([
+            program.setFile('source/main.brs', PRINTS_SRC);
+            (0, chai_config_spec_1.expect)(actual).to.deep.equal([
                 'Block',
                 'PrintStatement',
                 'PrintStatement',
@@ -195,46 +232,74 @@ describe('astUtils visitors', () => {
         it('Maps statements to individual handlers', () => {
             const printHandler = sinon.spy();
             const blockHandler = sinon.spy();
-            const visitor = visitors_1.createVisitor({
+            const visitor = (0, visitors_1.createVisitor)({
                 PrintStatement: printHandler,
                 Block: blockHandler
             });
             const printStatement = new Statement_1.PrintStatement({
-                print: creators_1.createToken(lexer_1.TokenKind.Print)
-            }, []);
-            const blockStatement = new Statement_1.Block([], vscode_languageserver_1.Range.create(0, 0, 0, 0));
+                print: (0, creators_1.createToken)(TokenKind_1.TokenKind.Print),
+                expressions: []
+            });
+            const blockStatement = new Statement_1.Block({ statements: [] });
             visitor(printStatement, undefined);
             visitor(blockStatement, undefined);
-            chai_1.expect(printHandler.callCount).to.equal(1);
-            chai_1.expect(printHandler.calledWith(printStatement)).to.be.true;
-            chai_1.expect(blockHandler.callCount).to.equal(1);
-            chai_1.expect(blockHandler.calledWith(blockStatement)).to.be.true;
+            (0, chai_config_spec_1.expect)(printHandler.callCount).to.equal(1);
+            (0, chai_config_spec_1.expect)(printHandler.calledWith(printStatement)).to.be.true;
+            (0, chai_config_spec_1.expect)(blockHandler.callCount).to.equal(1);
+            (0, chai_config_spec_1.expect)(blockHandler.calledWith(blockStatement)).to.be.true;
         });
     });
     describe('Statement editor', () => {
         it('allows replacing statements', () => {
             const printStatement1 = new Statement_1.PrintStatement({
-                print: creators_1.createToken(lexer_1.TokenKind.Print)
-            }, []);
+                print: (0, creators_1.createToken)(TokenKind_1.TokenKind.Print),
+                expressions: []
+            });
+            const printStatement2 = new Statement_1.PrintStatement({
+                print: (0, creators_1.createToken)(TokenKind_1.TokenKind.Print),
+                expressions: []
+            });
+            const block = new Statement_1.Block({
+                statements: [
+                    printStatement1,
+                    new Statement_1.ReturnStatement({ return: (0, creators_1.createToken)(TokenKind_1.TokenKind.Return) })
+                ]
+            });
+            const visitor = (0, visitors_1.createVisitor)({
+                PrintStatement: () => printStatement2
+            });
+            (0, visitors_1.walkStatements)(block, visitor);
+            (0, chai_config_spec_1.expect)(block.statements[0]).to.equal(printStatement2);
+        });
+        it('uses the Editor for replacement when provided', () => {
+            const editor = new Editor_1.Editor();
+            const printStatement1 = new Statement_1.PrintStatement({
+                print: (0, creators_1.createToken)(TokenKind_1.TokenKind.Print),
+                expressions: []
+            });
             const printStatement2 = new Statement_1.PrintStatement({
-                print: creators_1.createToken(lexer_1.TokenKind.Print)
-            }, []);
-            const block = new Statement_1.Block([
-                printStatement1,
-                new Statement_1.ReturnStatement({ return: creators_1.createToken(lexer_1.TokenKind.Return) })
-            ], vscode_languageserver_1.Range.create(0, 0, 0, 0));
-            const visitor = visitors_1.createVisitor({
+                print: (0, creators_1.createToken)(TokenKind_1.TokenKind.Print),
+                expressions: []
+            });
+            const block = new Statement_1.Block({
+                statements: [printStatement1]
+            });
+            block.walk((0, visitors_1.createVisitor)({
                 PrintStatement: () => printStatement2
+            }), {
+                walkMode: visitors_1.WalkMode.visitAll,
+                editor: editor
             });
-            visitors_1.walkStatements(block, visitor);
-            chai_1.expect(block.statements[0]).to.equal(printStatement2);
+            (0, chai_config_spec_1.expect)(block.statements[0]).to.equal(printStatement2);
+            editor.undoAll();
+            (0, chai_config_spec_1.expect)(block.statements[0]).to.equal(printStatement1);
         });
     });
     describe('Expressions', () => {
         it('Walks through all expressions', () => {
             const actual = [];
             let curr;
-            const statementVisitor = stackedVisitor_1.createStackedVisitor((statement, stack) => {
+            const statementVisitor = (0, stackedVisitor_1.createStackedVisitor)((statement, stack) => {
                 curr = { statement: statement, depth: stack.length };
             });
             function expressionVisitor(expression, _) {
@@ -249,13 +314,12 @@ describe('astUtils visitors', () => {
             });
             program.plugins.add({
                 name: 'walker',
-                afterFileParse: (event) => walker(event.file)
+                afterProvideFile: (event) => walker(event.files[0])
             });
-            program.setFile('source/file.brs', EXPRESSIONS_SRC);
-            chai_1.expect(actual).to.deep.equal([
-                //The comment statement is weird because it can't be both a statement and expression, but is treated that way. Just ignore it for now until we refactor comments.
-                //'CommentStatement:1:CommentStatement',          // '<comment>
+            program.setFile('source/main.brs', EXPRESSIONS_SRC);
+            (0, chai_config_spec_1.expect)(actual).to.deep.equal([
                 'PrintStatement:1:LiteralExpression',
+                'PrintStatement:1:PrintSeparatorExpression',
                 'PrintStatement:1:LiteralExpression',
                 'PrintStatement:1:TemplateStringExpression',
                 'PrintStatement:1:TemplateStringQuasiExpression',
@@ -308,8 +372,102 @@ describe('astUtils visitors', () => {
                 walkMode: walkMode
             });
             index = 1;
-            chai_1.expect(items.map(x => `${x.constructor.name}:${x._testId}`)).to.eql(expectedConstructors.map(x => `${x}:${index++}`));
+            (0, chai_config_spec_1.expect)(items.map(x => `${x.constructor.name}:${x._testId}`)).to.eql(expectedConstructors.map(x => `${x}:${index++}`));
         }
+        it('links every ast node to its parent when walked', () => {
+            const { ast } = program.setFile('source/main.bs', `
+                library "v30/bslCore.brs"
+                import "source/main.bs"
+                namespace alpha
+                    namespace beta
+                        sub charlie()
+                            delta = 1
+                            delta++
+                            delta = sub()
+                                'do some printing
+                                print "hello"
+                            end sub
+                            delta()
+                            for i = 0 to 10 step 1
+                                exit for
+                            end for
+                            while false
+                                exit while
+                            end while
+                            if true or false then
+                                print 1.2
+                            else
+                                print 123123123123
+                            end if
+                            dim arr[1, 2]
+                            goto theLabel
+                            theLabel:
+                            return false
+                            end
+                            stop
+                            for each item in [1, 2, 3]
+                                continue for
+                            end for
+                            obj = { name: "bob"}
+                            obj.name = obj.name
+                            obj["name"] = obj["name"]
+                            obj.name = obj@firstName
+                            print (true or false)
+                            print \`true\${false}\\n\`
+                            print not true
+                            print FUNCTION_NAME
+                            print new Person()
+                            print tag\`stuff\${1}\`
+                            print true ? true : false
+                            print true ?? false
+                            print /search stuff/g
+                            try
+                                obj.bob = "carl"
+                                throw "e"
+                            catch e
+                                obj["name"] = "dale"
+                            print e
+                            end try
+                            obj@.doCallfunc(1, 2)
+                        end sub
+                    end namespace
+                end namespace
+                @SomeAnnotation(1, "two")
+                interface IPerson
+                    name as string
+                    function doSomething() as string
+                end interface
+                class Person
+                    name as string = "bob"
+                    function doSomething(value = true) as string
+                    end function
+                end class
+                enum Direction
+                    up = "up"
+                end enum
+                enum Logical
+                    yes = 1
+                    no = 0
+                end enum
+                const CONST_VALUE = 1.2
+            `);
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            const nodes = [];
+            //get every expression and statement in the file
+            ast.walk((node) => {
+                nodes.push(node);
+            }, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            for (let i = 0; i < nodes.length; i++) {
+                const node = nodes[i];
+                //find the top-most ast node
+                let top = node;
+                while (top.parent) {
+                    top = top.parent;
+                }
+                //should be the same instance. If it doesn't then something is wrong with the .parent linking
+                (0, chai_config_spec_1.expect)(top === ast || node === ast, `Node ${node.constructor.name} (index ${i}) has broken parent link`).to.be.true;
+            }
+        });
         it('Walks through all expressions until cancelled', () => {
             const file = program.setFile('source/main.bs', `
                 sub logger(message = "nil" as string)
@@ -331,7 +489,7 @@ describe('astUtils visitors', () => {
                 walkMode: visitors_1.WalkMode.visitAllRecursive,
                 cancel: cancel.token
             });
-            chai_1.expect(count).to.equal(stopIndex);
+            (0, chai_config_spec_1.expect)(count).to.equal(stopIndex);
         });
         it('walks if statement', () => {
             testWalk(`
@@ -492,7 +650,6 @@ describe('astUtils visitors', () => {
                end namespace
             `, [
                 'NamespaceStatement',
-                'NamespacedVariableNameExpression',
                 'DottedGetExpression',
                 'VariableExpression'
             ]);
@@ -646,7 +803,6 @@ describe('astUtils visitors', () => {
                 'Block',
                 'AssignmentStatement',
                 'AALiteralExpression',
-                'CommentStatement',
                 'AAMemberExpression',
                 'LiteralExpression'
             ]);
@@ -718,8 +874,7 @@ describe('astUtils visitors', () => {
                 'LiteralExpression',
                 //else
                 'Block',
-                'ReturnStatement',
-                'CommentStatement'
+                'ReturnStatement'
             ]);
         });
         it('walks TaggedTemplateStringExpression', () => {
@@ -769,7 +924,6 @@ describe('astUtils visitors', () => {
                 'AssignmentStatement',
                 'NewExpression',
                 'CallExpression',
-                'NamespacedVariableNameExpression',
                 'VariableExpression'
             ]);
         });
@@ -799,10 +953,14 @@ describe('astUtils visitors', () => {
                 end class
             `, [
                 'ClassStatement',
-                'ClassFieldStatement',
-                'ClassFieldStatement',
+                'FieldStatement',
+                'TypeExpression',
+                'VariableExpression',
+                'FieldStatement',
+                'TypeExpression',
+                'VariableExpression',
                 'LiteralExpression',
-                'ClassMethodStatement',
+                'MethodStatement',
                 'FunctionExpression',
                 'Block',
                 'ReturnStatement',
@@ -849,6 +1007,426 @@ describe('astUtils visitors', () => {
                 'LiteralExpression'
             ], visitors_1.WalkMode.visitExpressionsRecursive);
         });
+        it('provides owner and key', () => {
+            const items = [];
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    log = sub(message)
+                        print "hello " + message
+                    end sub
+                    log("hello" + " world")
+                end sub
+            `);
+            ast.walk((astNode, parent, owner, key) => {
+                items.push(astNode);
+                (0, chai_config_spec_1.expect)(owner[key]).to.equal(astNode);
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            (0, chai_config_spec_1.expect)(items).to.be.length(17);
+        });
+        it('can be used to delete statements', () => {
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    print 1
+                    print 2
+                    print 3
+                end sub
+            `);
+            let callCount = 0;
+            ast.walk((astNode, parent, owner, key) => {
+                if ((0, reflection_1.isPrintStatement)(astNode)) {
+                    callCount++;
+                    //delete the print statement (we know owner is an array based on this specific test)
+                    owner.splice(key, 1);
+                }
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            //the visitor should have been called for every statement
+            (0, chai_config_spec_1.expect)(callCount).to.eql(3);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements).to.be.lengthOf(0);
+        });
+        it('walks everything when the first element is replaced', () => {
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    print 1
+                    print 2
+                    print 3
+                end sub
+            `);
+            const target = ast.findChild(reflection_1.isBlock).statements[0];
+            let callCount = 0;
+            ast.walk((astNode, parent, owner, key) => {
+                if ((0, reflection_1.isPrintStatement)(astNode)) {
+                    callCount++;
+                }
+                if (astNode === target) {
+                    owner.splice(key, 1);
+                }
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            //the visitor should have been called for every statement
+            (0, chai_config_spec_1.expect)(callCount).to.eql(3);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements).not.to.include(target);
+        });
+        it('walks everything when the middle element is replaced', () => {
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    print 1
+                    print 2
+                    print 3
+                end sub
+            `);
+            const target = ast.findChild(reflection_1.isBlock).statements[1];
+            let callCount = 0;
+            ast.walk((astNode, parent, owner, key) => {
+                if ((0, reflection_1.isPrintStatement)(astNode)) {
+                    callCount++;
+                }
+                if (astNode === target) {
+                    owner.splice(key, 1);
+                }
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            //the visitor should have been called for every statement
+            (0, chai_config_spec_1.expect)(callCount).to.eql(3);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements).not.to.include(target);
+        });
+        it('walks everything when the end element is replaced', () => {
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    print 1
+                    print 2
+                    print 3
+                end sub
+            `);
+            const target = ast.findChild(reflection_1.isBlock).statements[2];
+            let callCount = 0;
+            ast.walk((astNode, parent, owner, key) => {
+                if ((0, reflection_1.isPrintStatement)(astNode)) {
+                    callCount++;
+                }
+                if (astNode === target) {
+                    owner.splice(key, 1);
+                }
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            //the visitor should have been called for every statement
+            (0, chai_config_spec_1.expect)(callCount).to.eql(3);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements).not.to.include(target);
+        });
+        it('can be used to insert statements', () => {
+            const { ast } = Parser_1.Parser.parse(`
+                sub main()
+                    print 1
+                    print 2
+                    print 3
+                end sub
+            `);
+            let printStatementCount = 0;
+            let callExpressionCount = 0;
+            const calls = [];
+            ast.walk((0, visitors_1.createVisitor)({
+                PrintStatement: (astNode, parent, owner, key) => {
+                    printStatementCount++;
+                    //add another expression to the list every time. This should result in 1 the first time, 2 the second, 3 the third.
+                    calls.push(new Statement_1.ExpressionStatement({
+                        expression: (0, creators_1.createCall)((0, creators_1.createVariableExpression)('doSomethingBeforePrint'), [
+                            (0, creators_1.createIntegerLiteral)(callExpressionCount.toString())
+                        ])
+                    }));
+                    owner.splice(key + 1, 0, ...calls.map(x => x.clone()));
+                },
+                CallExpression: (call) => {
+                    callExpressionCount++;
+                    console.log('call visitor for', call.args[0].tokens.value.text);
+                }
+            }), {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            //the visitor should have been called for every statement
+            (0, chai_config_spec_1.expect)(printStatementCount).to.eql(3);
+            //since the calls were injected after each print statement, we should have 1 call for the first print, 2 for the second, and 3 for the third
+            (0, chai_config_spec_1.expect)(callExpressionCount).to.eql(6);
+            (0, chai_config_spec_1.expect)(ast.statements[0].func.body.statements).to.be.lengthOf(9);
+        });
+        it('skips children when requested', () => {
+            const file = program.setFile('source/main.bs', `
+                sub test()
+                    print 1 + 1
+                    print "hello"
+                end sub
+
+                sub test2()
+                    i = 2
+                    while i > 0
+                        print createObject("roDateTime").ToISOString()
+                        i--
+                    end while
+                end sub
+            `);
+            const actual = new Array();
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            // do not walk into print statements
+            const skipper = new visitors_1.ChildrenSkipper();
+            file.ast.walk((node) => {
+                actual.push(node.kind);
+                if ((0, reflection_1.isPrintStatement)(node)) {
+                    skipper.skip();
+                }
+            }, {
+                walkMode: visitors_1.WalkMode.visitAllRecursive,
+                skipChildren: skipper
+            });
+            // Does not walk into print statements
+            (0, chai_config_spec_1.expect)(actual).to.deep.equal([
+                'FunctionStatement',
+                'FunctionExpression',
+                'Block',
+                'PrintStatement',
+                'PrintStatement',
+                'FunctionStatement',
+                'FunctionExpression',
+                'Block',
+                'AssignmentStatement',
+                'LiteralExpression',
+                'WhileStatement',
+                'BinaryExpression',
+                'VariableExpression',
+                'LiteralExpression',
+                'Block',
+                'PrintStatement',
+                'IncrementStatement',
+                'VariableExpression'
+            ]);
+        });
+        it('can get end trivia of any kind of block type node', () => {
+            const file = program.setFile('source/main.bs', `
+                sub test()
+                    x = {
+                        val: [123],
+                        count: 4
+                        ' end comment in literal AA 1
+                    }
+                    for each y in x.val
+                        print y
+                        ' end comment in for 2
+                    end for
+
+                    if x.count > 2
+                        print "hi"
+                        ' end comment in if 3
+                    end if
+
+                    while x.count > 3
+                        x.count--
+                        ' end comment in while 4
+                    end while
+
+                    try
+                        print "in try"
+                    catch e
+                        ' end comment in try 5
+                    end try
+
+                    array = [
+                        1,
+                        2,
+                        ' end comment in array 6
+                    ]
+
+                    ' end comment in function 7
+                end sub
+            `);
+            const comments = [];
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            file.ast.walk((0, visitors_1.createVisitor)({
+                AstNode: (node) => {
+                    const endNodeComments = node.endTrivia.filter(t => t.kind === TokenKind_1.TokenKind.Comment);
+                    comments.push(...endNodeComments);
+                }
+            }), {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+        });
+        it('walks a new child when returned from a visitor', () => {
+            let walkedLiterals = [];
+            Parser_1.Parser.parse(`
+                sub main()
+                    print 1 + 2
+                end sub
+            `).ast.walk((0, visitors_1.createVisitor)({
+                BinaryExpression: (node, parent, owner, key) => {
+                    //replace the `1 + 2` binary expression with a new binary expression
+                    if ((0, reflection_1.isLiteralExpression)(node.left) && node.left.tokens.value.text === '1') {
+                        return new Expression_1.BinaryExpression({
+                            left: (0, creators_1.createIntegerLiteral)('3'),
+                            operator: (0, creators_1.createToken)(TokenKind_1.TokenKind.Plus),
+                            right: (0, creators_1.createIntegerLiteral)('4')
+                        });
+                    }
+                },
+                LiteralExpression: (node) => {
+                    walkedLiterals.push(node.tokens.value.text);
+                }
+            }), {
+                walkMode: visitors_1.WalkMode.visitAllRecursive
+            });
+            (0, chai_config_spec_1.expect)(walkedLiterals).to.eql(['3', '4']);
+        });
+        it('can set bsConst in walk', () => {
+            const { ast } = program.setFile('source/main.brs', `
+                #if DEBUG
+                sub main()
+                end sub
+                #end if
+            `);
+            const bsConsts = new Map();
+            let foundMainFunc = false;
+            const visitor = (0, visitors_1.createVisitor)({
+                FunctionStatement: (func) => {
+                    foundMainFunc || (foundMainFunc = func.getName(Parser_1.ParseMode.BrighterScript) === 'main');
+                }
+            });
+            ast.walk(visitor, {
+                walkMode: visitors_1.WalkMode.visitStatements,
+                bsConsts: bsConsts
+            });
+            // did not walk false block
+            (0, chai_config_spec_1.expect)(foundMainFunc).to.be.false;
+            bsConsts.set('debug', true);
+            ast.walk(visitor, {
+                walkMode: visitors_1.WalkMode.visitStatements,
+                bsConsts: bsConsts
+            });
+            // debug is true, so it did walk block
+            (0, chai_config_spec_1.expect)(foundMainFunc).to.be.true;
+        });
+        it('can walk false cc blocks', () => {
+            const { ast } = program.setFile('source/main.brs', `
+                #if false
+                sub main()
+                end sub
+                #end if
+            `);
+            const bsConsts = new Map();
+            let foundMainFunc = false;
+            const visitor = (0, visitors_1.createVisitor)({
+                FunctionStatement: (func) => {
+                    foundMainFunc || (foundMainFunc = func.getName(Parser_1.ParseMode.BrighterScript) === 'main');
+                }
+            });
+            ast.walk(visitor, {
+                walkMode: visitors_1.WalkMode.visitStatements,
+                bsConsts: bsConsts
+            });
+            // did not walk false block
+            (0, chai_config_spec_1.expect)(foundMainFunc).to.be.false;
+            ast.walk(visitor, {
+                // eslint-disable-next-line no-bitwise
+                walkMode: visitors_1.WalkMode.visitStatements | visitors_1.InternalWalkMode.visitFalseConditionalCompilationBlocks,
+                bsConsts: bsConsts
+            });
+            // did walk false block
+            (0, chai_config_spec_1.expect)(foundMainFunc).to.be.true;
+        });
+        it('will correctly walk `not condition` cc blocks', () => {
+            const { ast } = program.setFile('source/main.brs', `
+                #const DEBUG = false
+                #if not DEBUG
+                sub notDebug()
+                end sub
+                #end if
+                #if not false
+                sub notFalse()
+                end sub
+                #end if
+            `);
+            const bsConsts = new Map();
+            let functionsFound = new Set();
+            const visitor = (0, visitors_1.createVisitor)({
+                FunctionStatement: (func) => {
+                    functionsFound.add(func.getName(Parser_1.ParseMode.BrighterScript));
+                }
+            });
+            ast.walk(visitor, {
+                walkMode: visitors_1.WalkMode.visitStatements,
+                bsConsts: bsConsts
+            });
+            // did walk 'not' block
+            (0, chai_config_spec_1.expect)(functionsFound.has('notDebug')).to.be.true;
+            (0, chai_config_spec_1.expect)(functionsFound.has('notFalse')).to.be.true;
+        });
+        it('walks a new child when returned from a visitor and using an AstEditor', () => {
+            let walkedLiterals = [];
+            Parser_1.Parser.parse(`
+                sub main()
+                    print 1 + 2
+                end sub
+            `).ast.walk((0, visitors_1.createVisitor)({
+                BinaryExpression: (node, parent, owner, key) => {
+                    //replace the `1 + 2` binary expression with a new binary expression
+                    if ((0, reflection_1.isLiteralExpression)(node.left) && node.left.tokens.value.text === '1') {
+                        return new Expression_1.BinaryExpression({
+                            left: (0, creators_1.createIntegerLiteral)('3'),
+                            operator: (0, creators_1.createToken)(TokenKind_1.TokenKind.Plus),
+                            right: (0, creators_1.createIntegerLiteral)('4')
+                        });
+                    }
+                },
+                LiteralExpression: (node) => {
+                    walkedLiterals.push(node.tokens.value.text);
+                }
+            }), {
+                walkMode: visitors_1.WalkMode.visitAllRecursive,
+                editor: new Editor_1.Editor()
+            });
+            (0, chai_config_spec_1.expect)(walkedLiterals).to.eql(['3', '4']);
+        });
+    });
+    describe('walkArray', () => {
+        const one = (0, creators_1.createVariableExpression)('one');
+        const two = (0, creators_1.createVariableExpression)('two');
+        const three = (0, creators_1.createVariableExpression)('three');
+        const four = (0, creators_1.createVariableExpression)('four');
+        const five = (0, creators_1.createVariableExpression)('five');
+        function doTest(startingArray, expected, visitor) {
+            const visitedItems = [];
+            (0, visitors_1.walkArray)(startingArray, (item, parent, owner, key) => {
+                visitedItems.push(item);
+                return visitor === null || visitor === void 0 ? void 0 : visitor(item, parent, owner, key);
+            }, { walkMode: visitors_1.WalkMode.visitAllRecursive });
+            (0, chai_config_spec_1.expect)(visitedItems.map(x => x.tokens.name.text)).to.eql(expected.map(x => x.tokens.name.text));
+        }
+        it('walks every element in the array', () => {
+            doTest([one, two, three, four, five], [one, two, three, four, five]);
+        });
+        it('walks new items added to the array', () => {
+            doTest([one, two], [one, three, two, four], (item, parent, owner, key) => {
+                //insert a value after one
+                if (item === one) {
+                    owner.splice(key + 1, 0, three);
+                    //insert a value after one
+                }
+                else if (item === two) {
+                    owner.splice(key + 1, 0, four);
+                }
+            });
+        });
+        it('triggers on nodes that were skiped due to insertions', () => {
+            doTest([one, two, three], [one, two, four, three], (item, parent, owner, key) => {
+                //insert a value after one
+                if (item === two) {
+                    owner.splice(key, 0, four);
+                }
+            });
+        });
     });
 });
 //# sourceMappingURL=visitors.spec.js.map