private void VisitNodeInternalUp(JSNode node, IEnumerable<SequencePoint> sequencePoints)
        {
            if (node == null)
            {
                return;
            }

            if (sequencePoints != null && node.SymbolInfo == null)
            {
                node.SymbolInfo = new SymbolInfo(sequencePoints, true);
            }

            foreach (var child in node.Children)
            {
                if (child == null)
                {
                    continue;
                }

                if (child.SymbolInfo != null)
                {
                    sequencePoints = child.SymbolInfo.SequencePoints;
                }

                VisitNodeInternalUp(child, sequencePoints);
            }
        }

        protected void EliminateVariable (JSNode context, JSVariable variable, JSExpression replaceWith, QualifiedMemberIdentifier method) {
            {
                var replacer = new VariableEliminator(
                    variable,
                    JSChangeTypeExpression.New(replaceWith, variable.GetActualType(TypeSystem), TypeSystem)
                );
                replacer.Visit(context);
            }

            {
                var replacer = new VariableEliminator(variable, replaceWith);
                var assignments = (from a in FirstPass.Assignments where 
                                       variable.Equals(a.NewValue) ||
                                       a.NewValue.SelfAndChildrenRecursive.Any(variable.Equals)
                                       select a).ToArray();

                foreach (var a in assignments) {
                    if (!variable.Equals(a.NewValue))
                        replacer.Visit(a.NewValue);
                }
            }

            Variables.Remove(variable.Identifier);
            FunctionSource.InvalidateFirstPass(method);
        }

        public JSAstCursor(JSNode root, params string[] namesToSkip)
        {
            Root = root;
            NamesToSkip = new HashSet<string>(namesToSkip);

            Reset();
        }

 public State (JSNode node, string name, int depth, int nodeIndex, int? statementIndex) {
     Node = node;
     Name = name;
     Depth = depth;
     NodeIndex = nodeIndex;
     StatementIndex = statementIndex;
 }

        public static JSExpression DeconstructMutationAssignment (
            JSNode parentNode, JSBinaryOperatorExpression boe, TypeSystem typeSystem, TypeReference intermediateType
        ) {
            var assignmentOperator = boe.Operator as JSAssignmentOperator;
            if (assignmentOperator == null)
                return null;

            JSBinaryOperator replacementOperator;
            if (!IntroduceEnumCasts.ReverseCompoundAssignments.TryGetValue(assignmentOperator, out replacementOperator))
                return null;

            var leftType = boe.Left.GetActualType(typeSystem);

            var newBoe = new JSBinaryOperatorExpression(
                JSOperator.Assignment, MakeLhsForAssignment(boe.Left),
                new JSBinaryOperatorExpression(
                    replacementOperator, boe.Left, boe.Right, intermediateType
                ),
                leftType
            );

            var result = ConvertReadExpressionToWriteExpression(newBoe, typeSystem);
            if (parentNode is JSExpressionStatement) {
                return result;
            } else {
                var comma = new JSCommaExpression(
                    newBoe, boe.Left
                );
                return comma;
            }
        }

        private void SkipNode (JSNode node, string name, Indices indices, int depth) {
            indices.GetNodeIndex();

            if (node is JSStatement)
                indices.GetStatementIndex();

            foreach (var e in VisitChildren(node, indices, depth)) {
                foreach (var c in e)
                    ;
            }
        }

        public static bool IsPropertySetterInvocation(JSNode parentNode, JSBinaryOperatorExpression boe, out JSPropertyAccess pa)
        {
            var isValidParent =
                (parentNode is JSExpressionStatement);

            pa = boe.Left as JSPropertyAccess;

            return (pa != null) &&
                pa.IsWrite &&
                (boe.Operator == JSOperator.Assignment) &&
                isValidParent &&
                CanConvertToInvocation(pa);
        }

        public override void ReplaceChild (JSNode oldChild, JSNode newChild) {
            if (oldChild == null)
                throw new ArgumentNullException("oldChild");

            var stmt = newChild as JSStatement;
            if (stmt == null)
                return;

            for (int i = 0, c = Statements.Count; i < c; i++) {
                if (Statements[i] == oldChild)
                    Statements[i] = stmt;
            }
        }

        public static bool IsPropertyGetterInvocation(JSNode parentNode, JSPropertyAccess pa)
        {
            var parentBoe = parentNode as JSBinaryOperatorExpression;
            var parentUoe = parentNode as JSUnaryOperatorExpression;

            bool isMutation = (
                    (parentUoe != null) &&
                    (parentUoe.Operator is JSUnaryMutationOperator)
                ) || (
                    (parentBoe != null) &&
                    (parentBoe.Operator is JSAssignmentOperator) &&
                    (pa == parentBoe.Left)
                );

            return !pa.IsWrite &&
                !isMutation &&
                CanConvertToInvocation(pa);
        }

        public override void VisitNode(JSNode node)
        {
            if (node == null)
            {
                return;
            }

            if (node.SymbolInfo != null /* && node.SymbolInfo.Inferred*/)
            {
                if ((ParentNode is JSForLoop && ((JSForLoop) ParentNode).Condition == node))
                {
                }
                else
                {
                    node.SymbolInfo = null;
                }
            }

            VisitChildren(node);
        }

        private IEnumerable<State> VisitNode (JSNode node, string name = null, Indices indices = null, int depth = 0) {
            int? statementIndex = null;

            if (indices == null)
                indices = new Indices();

            int nodeIndex = indices.GetNodeIndex();

            if (node is JSStatement)
                statementIndex = indices.GetStatementIndex();

            yield return new State(
                node, name, depth, nodeIndex, statementIndex
            );

            foreach (var e in VisitChildren(node, indices, depth)) {
                foreach (var c in e)
                    yield return c;
            }
        }

        private void VisitNodeInternalDown(JSNode node)
        {
            if (node == null)
            {
                return;
            }

            foreach (var child in node.Children)
            {
                VisitNodeInternalDown(child);
            }

            if (node.SymbolInfo == null)
            {
                var childSymboInfo = node.Children.Where(item => item != null).Select(item => item.SymbolInfo).FirstOrDefault(item => item != null);
                if (childSymboInfo != null)
                {
                    node.SymbolInfo = new SymbolInfo(childSymboInfo.SequencePoints, true);
                }
            }
        }

        public override void ReplaceChild(JSNode oldChild, JSNode newChild)
        {
            if (oldChild == null)
                throw new ArgumentNullException("oldChild");

            if (CatchVariable == oldChild)
                CatchVariable = (JSVariable)newChild;

            if (Catch == oldChild)
                Catch = (JSStatement)newChild;

            if (Finally == oldChild)
                Finally = (JSStatement)newChild;

            Body.ReplaceChild(oldChild, newChild);
        }

        protected static bool GetChild(JSNode parent, int index, out JSNode node, out string name)
        {
            var self = (JSLabelGroupStatement)parent;

            if (index >= self.Labels.Count) {
                node = null;
                name = null;
                return false;
            }

            node = self.Labels.AtIndex(index).Value;
            name = "Labels";
            return true;
        }

        public override void ReplaceChild(JSNode oldChild, JSNode newChild)
        {
            if (GenericArguments == null)
                return;

            var oldExpression = oldChild as JSExpression;
            var newExpression = newChild as JSExpression;

            if (
                (oldExpression != null) &&
                ((newExpression != null) == (newChild != null))
            ) {
                for (var i = 0; i < GenericArguments.Length; i++) {
                    if (GenericArguments[i] == oldExpression)
                        GenericArguments[i] = newExpression;
                }
            }
        }

        private IEnumerable<IEnumerable<State>> VisitChildren(JSNode node, Indices indices, int depth)
        {
            if (node == null)
                throw new ArgumentNullException("node");

            JSNode nextSibling = null;
            string nextSiblingName = null;

            int nextDepth = depth + 1;

            using (var e = node.Children.EnumeratorTemplate)
            while (e.MoveNext()) {
                var toVisit = nextSibling;
                var toVisitName = nextSiblingName;
                nextSibling = e.Current;
                nextSiblingName = e.CurrentName;

                if (toVisit != null) {
                    if (toVisitName == null || !NamesToSkip.Contains(toVisitName)) {
                        yield return VisitNode(toVisit, toVisitName, indices, nextDepth);
                    } else {
                        SkipNode(toVisit, toVisitName, indices, nextDepth);
                    }
                }
            }

            if (nextSibling != null) {
                if (nextSiblingName == null || !NamesToSkip.Contains(nextSiblingName)) {
                    yield return VisitNode(nextSibling, nextSiblingName, indices, nextDepth);
                } else {
                    SkipNode(nextSibling, nextSiblingName, indices, nextDepth);
                }
            }
        }

        protected void EliminateVariable(JSNode context, JSVariable variable, JSExpression replaceWith)
        {
            {
                var replacer = new VariableEliminator(
                    variable,
                    JSChangeTypeExpression.New(replaceWith, TypeSystem, variable.GetExpectedType(TypeSystem))
                );
                replacer.Visit(context);
            }

            {
                var replacer = new VariableEliminator(variable, replaceWith);
                var assignments = (from a in FirstPass.Assignments where
                                       variable.Equals(a.NewValue) ||
                                       a.NewValue.AllChildrenRecursive.Any((_n) => variable.Equals(_n))
                                       select a).ToArray();

                foreach (var a in assignments) {
                    if (variable.Equals(a.NewValue)) {
                        FirstPass.Assignments.Remove(a);
                        FirstPass.Assignments.Add(
                            new FunctionAnalysis1stPass.Assignment(
                                a.StatementIndex, a.NodeIndex,
                                a.Target, replaceWith, a.Operator,
                                a.TargetType, a.SourceType
                            )
                        );
                    } else {
                        replacer.Visit(a.NewValue);
                    }
                }
            }

            Variables.Remove(variable.Identifier);
        }

        public override void ReplaceChild(JSNode oldChild, JSNode newChild)
        {
            if (oldChild == null)
                throw new ArgumentNullException("oldChild");

            var boe = newChild as JSBinaryOperatorExpression;

            if (boe == null)
                Declarations.RemoveAll((c) => c == oldChild);
            else
                for (int i = 0, c = Declarations.Count; i < c; i++) {
                    if (Declarations[i] == oldChild)
                        Declarations[i] = boe;
                }
        }

 public void Emit(JSNode node)
 {
 }

        protected void VisitControlFlowNode(JSNode node)
        {
            var stackSlice = Stack.Take(3).ToArray();
            var parentEs = stackSlice[1] as JSExpressionStatement;
            var parentBlock = stackSlice[2] as JSBlockStatement;

            if ((parentEs != null) && (parentBlock == BlockStack.Peek())) {
                AbsoluteJumpsSeen += 1;

                if (AbsoluteJumpsSeen > 1) {
                    if (TraceLevel >= 1)
                        Console.WriteLine("// Eliminating {0}", node);

                    var replacement = new JSNullExpression();
                    ParentNode.ReplaceChild(node, replacement);
                    return;
                } else {
                    if (TraceLevel >= 3)
                        Console.WriteLine("// Not eliminating {0}", node);
                }
            }

            VisitChildren(node);
        }