public override bool IsEquivalentTo(JsAstNode otherNode)
 {
     var otherRegExp = otherNode as JsRegExpLiteral;
     return otherRegExp != null
         && string.CompareOrdinal(Pattern, otherRegExp.Pattern) == 0
         && string.CompareOrdinal(PatternSwitches, otherRegExp.PatternSwitches) == 0;
 }

 public bool IsSafe(JsAstNode node)
 {
     // assume it is unless preven otherwise
     m_isSafe = true;
     node.IfNotNull(n => n.Accept(this));
     return m_isSafe;
 }

 public static void Apply(JsAstNode node)
 {
     if (node != null)
     {
         node.Accept(s_instance);
     }
 }

 public void Append(JsAstNode statement)
 {
     if (statement != null)
     {
         Context.UpdateWith(statement.Context);
         Statements.Append(statement);
     }
 }

 public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
 {
     if (Operand == oldNode)
     {
         Operand = newNode;
         return true;
     }
     return false;
 }

 public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
 {
     if (Value == oldNode)
     {
         Value = newNode;
         return true;
     }
     return false;
 }

 public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
 {
     if (Condition == oldNode)
     {
         Condition = newNode;
         return true;
     }
     return false;
 }

        public override bool IsEquivalentTo(JsAstNode otherNode)
        {
            var otherThis = otherNode as JsThisLiteral;

            // this really assume we are comparing this operators from the same object scope.
            // if you compare a this-literal from one function to a this-literal from another,
            // it will pop positive -- but it won't actually be equivalent!
            return otherThis != null;
        }

        public static bool Apply(TextWriter writer, JsAstNode node)
        {
            if (node != null)
            {
                var visitor = new JsonOutputVisitor(writer);
                node.Accept(visitor);
                return visitor.IsValid;
            }

            return false;
        }

        public static void Apply(TextWriter writer, JsAstNode node, JsSettings settings)
        {
            if (node != null)
            {
                var outputVisitor = new JsOutputVisitor(writer, settings);
                node.Accept(outputVisitor);

                // if there is a symbol map that we are tracking, tell it that we have ended an output run
                // and pass it offsets to the last line and column positions.
                settings.IfNotNull(s => s.SymbolsMap.IfNotNull(m => m.EndOutputRun(outputVisitor.m_lineCount, outputVisitor.m_lineLength)));
            }
        }

        public bool Match(JsAstNode node, string identifiers)
        {
            // set the match to false
            m_isMatch = false;

            // identifiers cannot be null or blank and must match: IDENT(.IDENT)*
            // since for JS there has to be at least a global object, the dot must be AFTER the first character.
            if (node != null && !string.IsNullOrEmpty(identifiers))
            {
                // get all the parts
                var parts = identifiers.Split('.');

                // each part must be a valid JavaScript identifier. Assume everything is valid
                // unless at least one is invalid -- then forget it
                var isValid = true;
                foreach (var part in parts)
                {
                    if (!JsScanner.IsValidIdentifier(part))
                    {
                        isValid = false;
                        break;
                    }
                }

                // must be valid to continue
                if (isValid)
                {
                    // save the parts and start the index on the last one, since we'll be walking backwards
                    m_parts = parts;
                    m_index = parts.Length - 1;

                    node.Accept(this);
                }
            }

            return m_isMatch;
        }

        /// <summary>
        /// Replace the existing direct child node of the block with a new node.
        /// </summary>
        /// <param name="oldNode">existing statement node to replace.</param>
        /// <param name="newNode">node with which to replace the existing node.</param>
        /// <returns>true if the replacement was a succeess; false otherwise</returns>
        public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
        {
            for (int ndx = m_list.Count - 1; ndx >= 0; --ndx)
            {
                if (m_list[ndx] == oldNode)
                {
                    m_list[ndx].IfNotNull(n => n.Parent = (n.Parent == this) ? null : n.Parent);
                    if (newNode == null)
                    {
                        // just remove it
                        m_list.RemoveAt(ndx);
                    }
                    else
                    {
                        JsBlock newBlock = newNode as JsBlock;
                        if (newBlock != null)
                        {
                            // the new "statement" is a block. That means we need to insert all
                            // the statements from the new block at the location of the old item.
                            m_list.RemoveAt(ndx);
                            InsertRange(ndx, newBlock.m_list);
                        }
                        else
                        {
                            // not a block -- slap it in there
                            m_list[ndx] = newNode;
                            newNode.Parent = this;
                        }
                    }

                    return true;
                }
            }

            return false;
        }

 public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
 {
     if (TryBlock == oldNode)
     {
         TryBlock = ForceToBlock(newNode);
         return true;
     }
     if (CatchParameter == oldNode)
     {
         CatchParameter = newNode as JsParameterDeclaration;
         return true;
     }
     if (CatchBlock == oldNode)
     {
         CatchBlock = ForceToBlock(newNode);
         return true;
     }
     if (FinallyBlock == oldNode)
     {
         FinallyBlock = ForceToBlock(newNode);
         return true;
     }
     return false;
 }

 /// <summary>
 /// Insert a new node into the given position index within the block
 /// </summary>
 /// <param name="position">zero-based index into which the new node will be inserted</param>
 /// <param name="item">new node to insert into the block</param>
 public void Insert(int position, JsAstNode item)
 {
     if (item != null)
     {
         var block = item as JsBlock;
         if (block != null)
         {
             InsertRange(position, block.Children);
         }
         else
         {
             item.Parent = this;
             m_list.Insert(position, item);
         }
     }
 }

 /// <summary>
 /// Insert the given statement node after an existing node in the block.
 /// </summary>
 /// <param name="after">exisitng child node of the block</param>
 /// <param name="item">node to insert after the existing node</param>
 public void InsertAfter(JsAstNode after, JsAstNode item)
 {
     if (item != null)
     {
         int index = m_list.IndexOf(after);
         if (index >= 0)
         {
             var block = item as JsBlock;
             if (block != null)
             {
                 // don't insert a block into a block -- insert the new block's
                 // children instead (don't want nested blocks)
                 InsertRange(index + 1, block.Children);
             }
             else
             {
                 item.Parent = this;
                 m_list.Insert(index + 1, item);
             }
         }
     }
 }

 /// <summary>
 /// Append the given statement node to the end of the block
 /// </summary>
 /// <param name="element">node to add to the block</param>
 public void Append(JsAstNode element)
 {
     if (element != null)
     {
         element.Parent = this;
         m_list.Add(element);
     }
 }

 /// <summary>
 /// Gets the zero-based index of the given syntax tree node within the block, or -1 if the node is not a direct child of the block
 /// </summary>
 /// <param name="child">node to find</param>
 /// <returns>zero-based index of the node in the block, or -1 if the node is not a direct child of the block</returns>
 public int IndexOf(JsAstNode child)
 {
     return m_list.IndexOf(child);
 }

        private static void ReplaceNodeCheckParens(JsAstNode oldNode, JsAstNode newNode)
        {
            var grouping = oldNode.Parent as JsGroupingOperator;
            if (grouping != null)
            {
                if (newNode != null)
                {
                    var targetPrecedence = grouping.Parent.Precedence;
                    var conditional = grouping.Parent as JsConditional;
                    if (conditional != null)
                    {
                        // the conditional is weird in that the different parts need to be
                        // compared against different precedences, not the precedence of the
                        // conditional itself. The condition should be compared to logical-or,
                        // and the true/false expressions against assignment.
                        targetPrecedence = conditional.Condition == grouping
                            ? JsOperatorPrecedence.LogicalOr
                            : JsOperatorPrecedence.Assignment;
                    }

                    if (newNode.Precedence >= targetPrecedence)
                    {
                        // don't need the parens anymore, so replace the grouping operator
                        // with the new node, thereby eliminating the parens
                        grouping.Parent.ReplaceChild(grouping, newNode);
                    }
                    else
                    {
                        // still need the parens; just replace the node with the literal
                        oldNode.Parent.ReplaceChild(oldNode, newNode);
                    }
                }
                else
                {
                    // eliminate the parens
                    grouping.Parent.ReplaceChild(grouping, null);
                }
            }
            else
            {
                // just replace the node with the literal
                oldNode.Parent.ReplaceChild(oldNode, newNode);
            }
        }

 internal override string GetFunctionGuess(JsAstNode target)
 {
     return Operand2 == target
         ? IsAssign ? Operand1.GetFunctionGuess(this) : Parent.GetFunctionGuess(this)
         : string.Empty;
 }

 public override bool ReplaceChild(JsAstNode oldNode, JsAstNode newNode)
 {
     if (Statement == oldNode)
     {
         Statement = newNode;
         return true;
     }
     return false;
 }