public void ReplaceBy(Node node)
 {
     if(parent_node != null)
     {
     parent_node.ReplaceChild(this, node);
     }
 }

 public CloneMethod(SharedData data, Dictionary<AALocalDecl, PLvalue> localMap, Node currentCloneNode, ExtraCheckDelegate extraCheck = null)
 {
     this.data = data;
     this.localMap = localMap;
     this.currentCloneNode = currentCloneNode;
     this.extraCheck = extraCheck;
 }

 public override void DefaultIn(Node node)
 {
     if (node is PStm)
     {
         internalAssignments.Clear();
     }
     base.DefaultIn(node);
 }

 public Node Insert(Node node, AExpStm newStm)
 {
     //Node must be a node for an AExpStm
     Node newNode = new Node(newStm);
     foreach (Node successor in node.Successors)
     {
         newNode.AddSucc(successor);
     }
     foreach (Node successor in newNode.Successors)
     {
         node.RemoveSucc(successor);
     }
     node.AddSucc(newNode);
     Nodes.Insert(Nodes.IndexOf(node) + 1, newNode);
     return newNode;
 }

 public override void DefaultOut(Node node)
 {
     if (node is PType)
     {
         Link((PType) node, node);
     }
     else if (node is PExp)
     {
         Link(data.ExpTypes[(PExp) node], node);
     }
     else if (node is PLvalue && !(node.Parent() is ASyncInvokeExp || node.Parent() is AAsyncInvokeStm))
     {
         Link(data.LvalueTypes[(PLvalue)node], node);
     }
     base.DefaultOut(node);
 }

 public void Remove(Node node)
 {
     Nodes.Remove(node);
     //Set succ/pred of succ/pred nodes
     foreach (Node predecessor in node.Predecessors)
     {
         foreach (Node successor in node.Successors)
         {
             predecessor.AddSucc(successor);
         }
     }
     //Remove node from succ/pred lists
     for (int i = node.Predecessors.Count - 1; i >= 0; i--)
     {
         Node predecessor = node.Predecessors[i];
         node.RemovePred(predecessor);
     }
     for (int i = node.Successors.Count - 1; i >= 0; i--)
     {
         Node successor = node.Successors[i];
         node.RemoveSucc(successor);
     }
 }

 internal override void RemoveChild(Node child)
 {
     if (_token_ == child)
     {
         _token_ = null;
         return;
     }
 }

 internal override void ReplaceChild(Node oldChild, Node newChild)
 {
 }

 public override void DefaultIn(Node node)
 {
     if (node is PStm)
     {
         safeVariables = new List<VariableDecl>();
         PStm prev = GetPrevious((PStm) node);
         if (prev != null)
         {
             safeVariables.AddRange(safeVariablesAfterStatement[prev]);
         }
         unsafeVariables = new List<VariableDecl>();
     }
     base.DefaultIn(node);
 }