public static void VisitTreeNodes(TreeNodeCollection nodes, NodeVisitor visitNode)
 {
     foreach (TreeNode n in nodes) {
         visitNode(n);
         VisitTreeNodes(n.Nodes, visitNode);
     }
 }

		/// <summary>Visits the iterator expression and the iterated object expression.</summary>
		/// <remarks>
		/// Visits the iterator expression and the iterated object expression.
		/// There is no body-expression for this loop type.
		/// </remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				iterator.Visit(v);
				iteratedObject.Visit(v);
			}
		}

 public void accept(NodeVisitor visitor)
 {
     foreach (Statement child in Children)
     {
         child.accept(visitor);
     }
     visitor.visit(this);
 }

 public override void Accept(NodeVisitor visitor)
 {
     if (call == null) {
         visitor.VisitAssign(this);
     }
     else {
         call.Accept(visitor);
     }
 }

		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				foreach (Node kid in this)
				{
					((AstNode)kid).Visit(v);
				}
			}
		}

    public static void ConvertRoslynToCCI(
      IMetadataHost host,
      Microsoft.CodeAnalysis.CSharp.SyntaxTree tree,
      Microsoft.CodeAnalysis.CSharp.Semantics.SemanticModel semanticModel,
      out IModule module,
      out ISourceLocationProvider sourceLocationProvider) {

      sourceLocationProvider = new SourceLocationProvider();

      var transformer = new NodeVisitor(host, semanticModel, sourceLocationProvider);
      var assembly = (Module)transformer.Visit(tree.GetRoot());
      assembly.Location = Path.GetFullPath(tree.FilePath);
      module = assembly;
    }

		/// <summary>
		/// Visits this node, then each label in the label-list, and finally the
		/// statement.
		/// </summary>
		/// <remarks>
		/// Visits this node, then each label in the label-list, and finally the
		/// statement.
		/// </remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				foreach (AstNode label in labels)
				{
					label.Visit(v);
				}
				statement.Visit(v);
			}
		}

            VisitNodes(ArrayList nodes, NodeVisitor v)
            {
                if (nodes == null)
                {
                    return;
                }

                for (int i = 0; i < nodes.Count; ++i)
                {
                    ProgressNode node = (ProgressNode)nodes[i];
                    Dbg.Assert(node != null, "nodes should not contain null elements");

                    if (!v.Visit(node, nodes, i))
                    {
                        return;
                    }

                    if (node.Children != null)
                    {
                        VisitNodes(node.Children, v);
                    }
                }
            }

		/// <summary>
		/// Visits this node, then the switch-expression, then the cases
		/// in lexical order.
		/// </summary>
		/// <remarks>
		/// Visits this node, then the switch-expression, then the cases
		/// in lexical order.
		/// </remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				expression.Visit(v);
				foreach (SwitchCase sc in GetCases())
				{
					sc.Visit(v);
				}
			}
		}

 public override void Accept(NodeVisitor visitor)
 {
     visitor.VisitParameterDeclaration(this);
 }

		/// <summary>Visits this node, then visits its element expressions in order.</summary>
		/// <remarks>
		/// Visits this node, then visits its element expressions in order.
		/// Any empty elements are represented by
		/// <see cref="EmptyExpression">EmptyExpression</see>
		/// objects, so the callback will never be passed
		/// <code>null</code>
		/// .
		/// </remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				foreach (AstNode e in GetElements())
				{
					e.Visit(v);
				}
			}
		}

 public abstract void Accept(NodeVisitor visitor);

 public override void Accept(NodeVisitor visitor)
 {
     visitor.VisitSourceFile(this);
 }

 public override void Accept(NodeVisitor visitor)
 {
     visitor.VisitTypeSpecifier(this);
 }

 public override void Accept(NodeVisitor visitor)
 {
     visitor.Visit (this);
 }

		/// <summary>Visits this node, then the child expression.</summary>
		/// <remarks>Visits this node, then the child expression.</remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				expression.Visit(v);
			}
		}

		/// <summary>
		/// Visits this node, then each
		/// <see cref="VariableInitializer">VariableInitializer</see>
		/// child.
		/// </summary>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				foreach (AstNode var in variables)
				{
					var.Visit(v);
				}
			}
		}

		/// <summary>
		/// Jumps are only used directly during code generation, and do
		/// not support this interface.
		/// </summary>
		/// <remarks>
		/// Jumps are only used directly during code generation, and do
		/// not support this interface.
		/// </remarks>
		/// <exception cref="System.NotSupportedException">System.NotSupportedException</exception>
		public override void Visit(NodeVisitor visitor)
		{
			throw new NotSupportedException(this.ToString());
		}

		/// <summary>Visits this node.</summary>
		/// <remarks>Visits this node.  There are no children to visit.</remarks>
		public override void Visit(NodeVisitor v)
		{
			v.Visit(this);
		}

		/// <summary>
		/// Visits this node, then the try-block, then any catch clauses,
		/// and then any finally block.
		/// </summary>
		/// <remarks>
		/// Visits this node, then the try-block, then any catch clauses,
		/// and then any finally block.
		/// </remarks>
		public override void Visit(NodeVisitor v)
		{
			if (v.Visit(this))
			{
				tryBlock.Visit(v);
				foreach (CatchClause cc in GetCatchClauses())
				{
					cc.Visit(v);
				}
				if (finallyBlock != null)
				{
					finallyBlock.Visit(v);
				}
			}
		}