Added AbstractAstTransformer, using it now for the code converter. This should fix problem for certain statement combinations.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@979 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Libraries/NRefactory/NRefactoryASTGenerator/Attributes.cs

@@ -100,7 +100,7 @@ namespace NRefactoryASTGenerator
 			prop.Name = name;
 			prop.Type = new CodeTypeReference(typeof(bool));
 			prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-			prop.GetStatements.Add(new CodeSnippetStatement(code));
+			prop.GetStatements.Add(new CodeSnippetStatement("\t\t\t\t" + code));
 			ctd.Members.Add(prop);
 		}
 	}

src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs

@@ -87,10 +87,257 @@ namespace NRefactoryASTGenerator
 				}
 			}
 			
+			System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
+			settings.IndentString = "\t";
+			settings.VerbatimOrder = true;
+			
 			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, null);
+				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
 				File.WriteAllText(directory + "Generated.cs", writer.ToString());
 			}
+			
+			ccu = new CodeCompileUnit();
+			cns = new CodeNamespace("ICSharpCode.NRefactory.Parser");
+			ccu.Namespaces.Add(cns);
+			cns.Imports.Add(new CodeNamespaceImport("System"));
+			cns.Imports.Add(new CodeNamespaceImport("ICSharpCode.NRefactory.Parser.AST"));
+			cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
+			
+			using (StringWriter writer = new StringWriter()) {
+				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
+				File.WriteAllText(visitorsDir + "IAstVisitor.cs", writer.ToString());
+			}
+			
+			ccu = new CodeCompileUnit();
+			cns = new CodeNamespace("ICSharpCode.NRefactory.Parser");
+			ccu.Namespaces.Add(cns);
+			cns.Imports.Add(new CodeNamespaceImport("System"));
+			cns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
+			cns.Imports.Add(new CodeNamespaceImport("System.Diagnostics"));
+			cns.Imports.Add(new CodeNamespaceImport("ICSharpCode.NRefactory.Parser.AST"));
+			cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
+			
+			using (StringWriter writer = new StringWriter()) {
+				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
+				File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
+			}
+			
+			ccu = new CodeCompileUnit();
+			cns = new CodeNamespace("ICSharpCode.NRefactory.Parser");
+			ccu.Namespaces.Add(cns);
+			cns.Imports.Add(new CodeNamespaceImport("System"));
+			cns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
+			cns.Imports.Add(new CodeNamespaceImport("System.Diagnostics"));
+			cns.Imports.Add(new CodeNamespaceImport("ICSharpCode.NRefactory.Parser.AST"));
+			cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
+			
+			using (StringWriter writer = new StringWriter()) {
+				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
+				File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
+			}
+		}
+		
+		static CodeTypeDeclaration CreateAstVisitorInterface(List<Type> nodeTypes)
+		{
+			CodeTypeDeclaration td = new CodeTypeDeclaration("IAstVisitor");
+			td.IsInterface = true;
+			
+			foreach (Type t in nodeTypes) {
+				if (!t.IsAbstract) {
+					CodeMemberMethod m = new CodeMemberMethod();
+					m.Name = "Visit";
+					m.ReturnType = new CodeTypeReference(typeof(object));
+					m.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(t), GetFieldName(t.Name)));
+					m.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), "data"));
+					td.Members.Add(m);
+				}
+			}
+			return td;
+		}
+		
+		static CodeTypeDeclaration CreateAstVisitorClass(List<Type> nodeTypes, bool transformer)
+		{
+			CodeTypeDeclaration td = new CodeTypeDeclaration(transformer ? "AbstractAstTransformer" : "AbstractAstVisitor");
+			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Abstract;
+			td.BaseTypes.Add(new CodeTypeReference("IAstVisitor"));
+			
+			if (transformer) {
+				string comment = "<summary>\n " +
+					"The AbstractAstTransformer will iterate through the whole AST,\n " +
+					"just like the AbstractAstVisitor. However, the AbstractAstTransformer allows\n " +
+					"you to modify the AST at the same time: It does not use 'foreach' internally,\n " +
+					"so you can add members to collections of parents of the current node (but\n " +
+					"you cannot insert or delete items as that will make the index used invalid).\n " +
+					"You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace\n " +
+					"or remove the current node, totally independent from the type of the parent node.\n " +
+					"</summary>";
+				td.Comments.Add(new CodeCommentStatement(comment, true));
+				
+				CodeMemberField field = new CodeMemberField("Stack", "nodeStack");
+				field.Type.TypeArguments.Add("INode");
+				field.InitExpression = new CodeObjectCreateExpression(field.Type);
+				td.Members.Add(field);
+				
+				CodeExpression nodeStack = new CodeVariableReferenceExpression("nodeStack");
+				
+				/*
+				CodeMemberProperty p = new CodeMemberProperty();
+				p.Name = "CurrentNode";
+				p.Type = new CodeTypeReference("INode");
+				p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
+				p.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("currentNode")));
+				p.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("currentNode"),
+				                                            new CodePropertySetValueReferenceExpression()));
+				td.Members.Add(p);
+				 */
+				
+				CodeMemberMethod m = new CodeMemberMethod();
+				m.Name = "ReplaceCurrentNode";
+				m.Attributes = MemberAttributes.Public | MemberAttributes.Final;
+				m.Parameters.Add(new CodeParameterDeclarationExpression("INode", "newNode"));
+				m.Statements.Add(new CodeMethodInvokeExpression(nodeStack, "Pop"));
+				m.Statements.Add(new CodeMethodInvokeExpression(nodeStack, "Push",
+				                                                new CodeVariableReferenceExpression("newNode")));
+				td.Members.Add(m);
+				
+				m = new CodeMemberMethod();
+				m.Name = "RemoveCurrentNode";
+				m.Attributes = MemberAttributes.Public | MemberAttributes.Final;
+				m.Statements.Add(new CodeMethodInvokeExpression(nodeStack, "Pop"));
+				m.Statements.Add(new CodeMethodInvokeExpression(nodeStack, "Push",
+				                                                new CodePrimitiveExpression(null)));
+				td.Members.Add(m);
+			}
+			
+			foreach (Type type in nodeTypes) {
+				if (!type.IsAbstract) {
+					CodeMemberMethod m = new CodeMemberMethod();
+					m.Name = "Visit";
+					m.Attributes = MemberAttributes.Public;
+					m.ReturnType = new CodeTypeReference(typeof(object));
+					m.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(type), GetFieldName(type.Name)));
+					m.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), "data"));
+					td.Members.Add(m);
+					
+					List<CodeStatement> assertions = new List<CodeStatement>();
+					CodeVariableReferenceExpression var = new CodeVariableReferenceExpression(GetFieldName(type.Name));
+					assertions.Add(AssertIsNotNull(var));
+					
+					Type t = type;
+					do {
+						foreach (FieldInfo field in t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)) {
+							AddVisitCode(m, field, var, assertions, transformer);
+						}
+						t = t.BaseType;
+					} while (t != null);
+					
+					if (type.GetCustomAttributes(typeof(HasChildrenAttribute), true).Length > 0) {
+						if (transformer) {
+							m.Statements.Add(new CodeSnippetStatement(CreateTransformerLoop(var.VariableName + ".Children", "INode")));
+							m.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
+						} else {
+							CodeExpression ex = new CodeMethodInvokeExpression(var, "AcceptChildren",
+							                                                   new CodeThisReferenceExpression(),
+							                                                   new CodeVariableReferenceExpression("data"));
+							m.Statements.Add(new CodeMethodReturnStatement(ex));
+						}
+					} else {
+						CodeExpressionStatement lastStatement = null;
+						if (m.Statements.Count > 0) {
+							lastStatement = m.Statements[m.Statements.Count - 1] as CodeExpressionStatement;
+						}
+						if (lastStatement != null) {
+							m.Statements.RemoveAt(m.Statements.Count - 1);
+							m.Statements.Add(new CodeMethodReturnStatement(lastStatement.Expression));
+						} else {
+							m.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
+						}
+					}
+					
+					for (int i = 0; i < assertions.Count; i++) {
+						m.Statements.Insert(i, assertions[i]);
+					}
+				}
+			}
+			return td;
+		}
+		
+		static CodeStatement AssertIsNotNull(CodeExpression expr)
+		{
+			CodeExpression bop = new CodeBinaryOperatorExpression(expr,
+			                                                      CodeBinaryOperatorType.IdentityInequality,
+			                                                      new CodePrimitiveExpression(null)
+			                                                     );
+			return new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Debug"),
+			                                                                  "Assert",
+			                                                                  bop));
+		}
+		
+		static string GetCode(CodeExpression ex)
+		{
+			using (StringWriter writer = new StringWriter()) {
+				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromExpression(ex, writer, null);
+				return writer.ToString();
+			}
+		}
+		
+		static string CreateTransformerLoop(string collection, string typeName)
+		{
+			return
+				"\t\t\tfor (int i = 0; i < " + collection + ".Count; i++) {\n" +
+				"\t\t\t\t" + typeName + " o = " + collection + "[i];\n" +
+				"\t\t\t\tDebug.Assert(o != null);\n" +
+				"\t\t\t\tnodeStack.Push(o);\n" +
+				"\t\t\t\to.AcceptVisitor(this, data);\n" +
+				(typeName == "INode"
+				 ? "\t\t\t\to = nodeStack.Pop();\n"
+				 : "\t\t\t\to = (" + typeName + ")nodeStack.Pop();\n") +
+				"\t\t\t\tif (o == null)\n" +
+				"\t\t\t\t\t" + collection + ".RemoveAt(i--);\n" +
+				"\t\t\t\telse\n" +
+				"\t\t\t\t\t" + collection + "[i] = o;\n" +
+				"\t\t\t}";
+		}
+		
+		static bool AddVisitCode(CodeMemberMethod m, FieldInfo field, CodeVariableReferenceExpression var, List<CodeStatement> assertions, bool transformer)
+		{
+			CodeExpression prop = new CodePropertyReferenceExpression(var, GetPropertyName(field.Name));
+			CodeExpression nodeStack = new CodeVariableReferenceExpression("nodeStack");
+			if (field.FieldType.FullName.StartsWith("System.Collections.Generic.List")) {
+				Type elType = field.FieldType.GetGenericArguments()[0];
+				if (!typeof(INode).IsAssignableFrom(elType))
+					return false;
+				assertions.Add(AssertIsNotNull(prop));
+				string code;
+				if (transformer) {
+					code = CreateTransformerLoop(GetCode(prop), ConvertType(elType).BaseType);
+				} else {
+					code =
+						"\t\t\tforeach (" + ConvertType(elType).BaseType + " o in " + GetCode(prop) + ") {\n" +
+						"\t\t\t\tDebug.Assert(o != null);\n" +
+						"\t\t\t\to.AcceptVisitor(this, data);\n" +
+						"\t\t\t}";
+				}
+				m.Statements.Add(new CodeSnippetStatement(code));
+				return true;
+			}
+			if (!typeof(INode).IsAssignableFrom(field.FieldType))
+				return false;
+			assertions.Add(AssertIsNotNull(prop));
+			if (transformer) {
+				m.Statements.Add(new CodeMethodInvokeExpression(nodeStack, "Push",
+				                                                prop));
+			}
+			m.Statements.Add(new CodeMethodInvokeExpression(prop,
+			                                                "AcceptVisitor",
+			                                                new CodeThisReferenceExpression(),
+			                                                new CodeVariableReferenceExpression("data")));
+			if (transformer) {
+				CodeExpression ex = new CodeMethodInvokeExpression(nodeStack, "Pop");
+				ex = new CodeCastExpression(ConvertType(field.FieldType), ex);
+				m.Statements.Add(new CodeAssignStatement(prop, ex));
+			}
+			return true;
 		}
 		
 		static CodeExpression CreateToString(Type type)
@@ -208,6 +455,11 @@ namespace NRefactoryASTGenerator
 			return new CodeSnippetExpression(code);
 		}
 		
+		internal static string GetFieldName(string typeName)
+		{
+			return char.ToLower(typeName[0]) + typeName.Substring(1);
+		}
+		
 		internal static string GetPropertyName(string fieldName)
 		{
 			return char.ToUpper(fieldName[0]) + fieldName.Substring(1);
@@ -222,6 +474,8 @@ namespace NRefactoryASTGenerator
 				}
 				return tr;
 			} else if (type.FullName.StartsWith("NRefactory") || type.FullName.StartsWith("System.Collections")) {
+				if (type.Name == "Attribute")
+					return new CodeTypeReference("ICSharpCode.NRefactory.Parser.AST.Attribute");
 				return new CodeTypeReference(type.Name);
 			} else {
 				return new CodeTypeReference(type);

src/Libraries/NRefactory/Project/NRefactory.csproj

@@ -120,6 +120,7 @@
     <Compile Include="Src\Parser\AST\General\BlockStatement.cs" />
     <Compile Include="Src\Parser\AST\General\LocalVariableDeclaration.cs" />
     <Compile Include="Src\Parser\AST\General\PrimitiveExpression.cs" />
+    <Compile Include="Src\Parser\Visitors\AbstractAstTransformer.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="Src\Lexer\CSharp\KeywordList.txt" />

src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs

@@ -17,7 +17,7 @@ using ICSharpCode.NRefactory.PrettyPrinter;
 
 namespace ICSharpCode.NRefactory.Parser
 {
-	public class CodeDOMVisitor : AbstractASTVisitor
+	public class CodeDOMVisitor : AbstractAstVisitor
 	{
 		Stack<CodeNamespace>  namespaceDeclarations = new Stack<CodeNamespace>();
 		Stack<CodeTypeDeclaration> typeDeclarations = new Stack<CodeTypeDeclaration>();

src/Libraries/NRefactory/Project/Src/Parser/AST/AbstractNode.cs

@@ -10,14 +10,14 @@ using System.Text;
 using System.Drawing;
 using System.Diagnostics;
 using System.Collections;
+using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.Parser.AST
 {
 	public abstract class AbstractNode : INode
 	{
 		INode       parent;
-//		List<INode> children = new List<INode>();
+		List<INode> children = new List<INode>();
-		ArrayList children = new ArrayList();
 		
 		Point startLocation;
 		Point endLocation;
@@ -49,7 +49,7 @@ namespace ICSharpCode.NRefactory.Parser.AST
 			}
 		}
 		
-		public ArrayList Children {
+		public List<INode> Children {
 			get {
 				return children;
 			}

src/Libraries/NRefactory/Project/Src/Parser/AST/General/Statement.cs

@@ -28,19 +28,6 @@ namespace ICSharpCode.NRefactory.Parser.AST
 		{
 			return statement == null ? NullStatement.Instance : statement;
 		}
-		
-		public static void Replace(Statement oldStatement, Statement newStatement)
-		{
-			INode parent = oldStatement.Parent;
-			StatementWithEmbeddedStatement parentStmt = parent as StatementWithEmbeddedStatement;
-			if (parentStmt != null && parentStmt.EmbeddedStatement == oldStatement)
-				parentStmt.EmbeddedStatement = newStatement;
-			int index = parent.Children.IndexOf(oldStatement);
-			if (index >= 0) {
-				parent.Children[index] = newStatement;
-				newStatement.Parent = parent;
-			}
-		}
 	}
 	
 	public abstract class StatementWithEmbeddedStatement : Statement

src/Libraries/NRefactory/Project/Src/Parser/AST/INode.cs

@@ -7,7 +7,7 @@
 
 using System;
 using System.Drawing;
-using System.Collections;
+using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.Parser.AST
 {
@@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.Parser.AST
 			set;
 		}
 		
-		ArrayList Children {
+		List<INode> Children {
 			get;
 		}
 		

src/Libraries/NRefactory/Project/Src/Parser/Visitors/CSharpConstructsVisitor.cs

@@ -19,7 +19,7 @@ namespace ICSharpCode.NRefactory.Parser
 	/// <summary>
 	/// Converts special C# constructs to use more general AST classes.
 	/// </summary>
-	public class CSharpConstructsVisitor : AbstractASTVisitor
+	public class CSharpConstructsVisitor : AbstractAstTransformer
 	{
 		// The following conversions are implemented:
 		//   a == null -> a Is Nothing
@@ -77,24 +77,9 @@ namespace ICSharpCode.NRefactory.Parser
 		}
 		
 		
-		List<IfElseStatement> ifStatements = new List<IfElseStatement>();
+		public override object Visit(IfElseStatement ifStatement, object data)
-		
-		public override object Visit(IfElseStatement ifElseStatement, object data)
-		{
-			ifStatements.Add(ifElseStatement);
-			return base.Visit(ifElseStatement, data);
-		}
-		
-		void ConvertIfStatements()
-		{
-			foreach (IfElseStatement ifStatement in ifStatements) {
-				ConvertIfStatement(ifStatement);
-			}
-			ifStatements.Clear();
-		}
-		
-		void ConvertIfStatement(IfElseStatement ifStatement)
 		{
+			base.Visit(ifStatement, data);
 			BinaryOperatorExpression boe = ifStatement.Condition as BinaryOperatorExpression;
 			if (ifStatement.ElseIfSections.Count == 0
 			    && ifStatement.FalseStatement.Count == 0
@@ -117,28 +102,18 @@ namespace ICSharpCode.NRefactory.Parser
 				if (ident != null && se != null) {
 					InvocationExpression ie = se.Expression as InvocationExpression;
 					if (ie != null && (ie.TargetObject as IdentifierExpression).Identifier == ident.Identifier) {
-						Statement.Replace(ifStatement, new RaiseEventStatement(ident.Identifier, ie.Arguments));
+						ReplaceCurrentNode(new RaiseEventStatement(ident.Identifier, ie.Arguments));
 					}
 				}
 			}
+			return null;
 		}
 		
-		List<ForStatement> forStatements = new List<ForStatement>();
-		
 		public override object Visit(ForStatement forStatement, object data)
 		{
-			forStatements.Add(forStatement);
+			base.Visit(forStatement, data);
-			// post-pone conversion because the parent's collection cannot be modified while it
+			ConvertForStatement(forStatement);
-			// is in use.
+			return null;
-			return base.Visit(forStatement, data);
-		}
-		
-		void ConvertForStatements()
-		{
-			foreach (ForStatement forStatement in forStatements) {
-				ConvertForStatement(forStatement);
-			}
-			forStatements.Clear();
 		}
 		
 		void ConvertForStatement(ForStatement forStatement)
@@ -224,20 +199,10 @@ namespace ICSharpCode.NRefactory.Parser
 				start = assign.Right;
 			}
 			
-			ForNextStatement forNextStatement = new ForNextStatement(typeReference, iteratorIdentifier.Identifier,
+			ReplaceCurrentNode(new ForNextStatement(typeReference, iteratorIdentifier.Identifier,
-			                                                         start, end,
+			                                        start, end,
-			                                                         (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)),
+			                                        (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)),
-			                                                         forStatement.EmbeddedStatement, null);
+			                                        forStatement.EmbeddedStatement, null));
-			
-			Statement.Replace(forStatement, forNextStatement);
-		}
-		
-		public override object Visit(TypeDeclaration td, object data)
-		{
-			object result = base.Visit(td, data);
-			ConvertForStatements();
-			ConvertIfStatements();
-			return result;
 		}
 	}
 }

src/Libraries/NRefactory/Project/Src/Parser/Visitors/IASTVisitor.cs

@@ -1,133 +1,220 @@
-// <file>
+//------------------------------------------------------------------------------
-//     <copyright see="prj:///doc/copyright.txt"/>
+// <auto-generated>
-//     <license see="prj:///doc/license.txt"/>
+//     This code was generated by a tool.
-//     <owner name="none" email=""/>
+//     Runtime Version:2.0.50727.42
-//     <version>$Revision$</version>
+//
-// </file>
+//     Changes to this file may cause incorrect behavior and will be lost if
-
+//     the code is regenerated.
-using System;
+// </auto-generated>
-using ICSharpCode.NRefactory.Parser.AST;
+//------------------------------------------------------------------------------
-
-namespace ICSharpCode.NRefactory.Parser
-{
-	public interface IAstVisitor
-	{
-		[Obsolete("Warning: you are visiting INode")]
-		object Visit(INode node, object data);
 
-		object Visit(InterfaceImplementation interfaceImplementation, object data);
+namespace ICSharpCode.NRefactory.Parser {
+	using System;
+	using ICSharpCode.NRefactory.Parser.AST;
+	
+	
+	public interface IAstVisitor {
+		
+		object Visit(AddHandlerStatement addHandlerStatement, object data);
+		
+		object Visit(AddressOfExpression addressOfExpression, object data);
+		
+		object Visit(AnonymousMethodExpression anonymousMethodExpression, object data);
+		
+		object Visit(ArrayCreateExpression arrayCreateExpression, object data);
+		
+		object Visit(ArrayInitializerExpression arrayInitializerExpression, object data);
+		
+		object Visit(AssignmentExpression assignmentExpression, object data);
+		
+		object Visit(ICSharpCode.NRefactory.Parser.AST.Attribute attribute, object data);
+		
+		object Visit(AttributeSection attributeSection, object data);
+		
+		object Visit(BaseReferenceExpression baseReferenceExpression, object data);
+		
+		object Visit(BinaryOperatorExpression binaryOperatorExpression, object data);
+		
+		object Visit(BlockStatement blockStatement, object data);
+		
+		object Visit(BreakStatement breakStatement, object data);
+		
+		object Visit(CaseLabel caseLabel, object data);
+		
+		object Visit(CastExpression castExpression, object data);
+		
+		object Visit(CatchClause catchClause, object data);
+		
+		object Visit(CheckedExpression checkedExpression, object data);
+		
+		object Visit(CheckedStatement checkedStatement, object data);
+		
+		object Visit(ClassReferenceExpression classReferenceExpression, object data);
 		
 		object Visit(CompilationUnit compilationUnit, object data);
-		object Visit(TypeReference typeReference, object data);
+		
+		object Visit(ConditionalExpression conditionalExpression, object data);
+		
+		object Visit(ConstructorDeclaration constructorDeclaration, object data);
+		
+		object Visit(ConstructorInitializer constructorInitializer, object data);
+		
+		object Visit(ContinueStatement continueStatement, object data);
+		
+		object Visit(DeclareDeclaration declareDeclaration, object data);
+		
+		object Visit(DefaultValueExpression defaultValueExpression, object data);
+		
+		object Visit(DelegateDeclaration delegateDeclaration, object data);
+		
+		object Visit(DestructorDeclaration destructorDeclaration, object data);
+		
+		object Visit(DirectionExpression directionExpression, object data);
+		
+		object Visit(DoLoopStatement doLoopStatement, object data);
+		
+		object Visit(ElseIfSection elseIfSection, object data);
+		
+		object Visit(EmptyStatement emptyStatement, object data);
+		
+		object Visit(EndStatement endStatement, object data);
+		
+		object Visit(EraseStatement eraseStatement, object data);
+		
+		object Visit(ErrorStatement errorStatement, object data);
+		
+		object Visit(EventAddRegion eventAddRegion, object data);
+		
+		object Visit(EventDeclaration eventDeclaration, object data);
+		
+		object Visit(EventRaiseRegion eventRaiseRegion, object data);
+		
+		object Visit(EventRemoveRegion eventRemoveRegion, object data);
+		
+		object Visit(ExitStatement exitStatement, object data);
+		
+		object Visit(FieldDeclaration fieldDeclaration, object data);
+		
+		object Visit(FieldReferenceExpression fieldReferenceExpression, object data);
+		
+		object Visit(FixedStatement fixedStatement, object data);
+		
+		object Visit(ForeachStatement foreachStatement, object data);
+		
+		object Visit(ForNextStatement forNextStatement, object data);
+		
+		object Visit(ForStatement forStatement, object data);
+		
+		object Visit(GotoCaseStatement gotoCaseStatement, object data);
+		
+		object Visit(GotoStatement gotoStatement, object data);
+		
+		object Visit(IdentifierExpression identifierExpression, object data);
+		
+		object Visit(IfElseStatement ifElseStatement, object data);
+		
+		object Visit(IndexerDeclaration indexerDeclaration, object data);
+		
+		object Visit(IndexerExpression indexerExpression, object data);
+		
 		object Visit(InnerClassTypeReference innerClassTypeReference, object data);
-		object Visit(AttributeSection attributeSection, object data);
+		
-		object Visit(ICSharpCode.NRefactory.Parser.AST.Attribute attribute, object data);
+		object Visit(InterfaceImplementation interfaceImplementation, object data);
+		
+		object Visit(InvocationExpression invocationExpression, object data);
+		
+		object Visit(LabelStatement labelStatement, object data);
+		
+		object Visit(LocalVariableDeclaration localVariableDeclaration, object data);
+		
+		object Visit(LockStatement lockStatement, object data);
+		
+		object Visit(MethodDeclaration methodDeclaration, object data);
+		
 		object Visit(NamedArgumentExpression namedArgumentExpression, object data);
 		
-		// GlobalScope
-		object Visit(Using @using, object data);
-		object Visit(UsingDeclaration usingDeclaration, object data);
 		object Visit(NamespaceDeclaration namespaceDeclaration, object data);
-		object Visit(TypeDeclaration typeDeclaration, object data);
+		
-		object Visit(TemplateDefinition templateDefinition, object data);
+		object Visit(ObjectCreateExpression objectCreateExpression, object data);
-		object Visit(DelegateDeclaration delegateDeclaration, object data);
+		
+		object Visit(OnErrorStatement onErrorStatement, object data);
+		
+		object Visit(OperatorDeclaration operatorDeclaration, object data);
+		
 		object Visit(OptionDeclaration optionDeclaration, object data);
 		
-		// TypeLevel
+		object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data);
-		object Visit(FieldDeclaration    fieldDeclaration, object data);
+		
-		object Visit(VariableDeclaration variableDeclaration, object data);
+		object Visit(ParenthesizedExpression parenthesizedExpression, object data);
+		
+		object Visit(PointerReferenceExpression pointerReferenceExpression, object data);
+		
+		object Visit(PrimitiveExpression primitiveExpression, object data);
+		
 		object Visit(PropertyDeclaration propertyDeclaration, object data);
+		
 		object Visit(PropertyGetRegion propertyGetRegion, object data);
+		
 		object Visit(PropertySetRegion propertySetRegion, object data);
-		object Visit(EventDeclaration eventDeclaration, object data);
-		object Visit(EventAddRegion eventAddRegion, object data);
-		object Visit(EventRemoveRegion eventRemoveRegion, object data);
-		object Visit(EventRaiseRegion eventRaiseRegion, object data); // VB.NET
 		
-		object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data);
+		object Visit(RaiseEventStatement raiseEventStatement, object data);
-		object Visit(MethodDeclaration methodDeclaration, object data);
-		object Visit(ConstructorDeclaration constructorDeclaration, object data);
-		object Visit(ConstructorInitializer constructorInitializer, object data);
-		object Visit(IndexerDeclaration indexerDeclaration, object data);
-		object Visit(DestructorDeclaration destructorDeclaration, object data);
-		object Visit(OperatorDeclaration operatorDeclaration, object data);
 		
-		object Visit(DeclareDeclaration declareDeclaration, object data);
+		object Visit(ReDimStatement reDimStatement, object data);
 		
-		// Statements
-		object Visit(BlockStatement blockStatement, object data);
-		object Visit(AddHandlerStatement addHandlerStatement, object data);
 		object Visit(RemoveHandlerStatement removeHandlerStatement, object data);
-		object Visit(RaiseEventStatement raiseEventStatement, object data);
+		
-		object Visit(EraseStatement eraseStatement, object data);
+		object Visit(ResumeStatement resumeStatement, object data);
-		object Visit(ErrorStatement errorStatement, object data);
+		
-		object Visit(OnErrorStatement onErrorStatement, object data);
-		object Visit(ReDimStatement reDimStatement, object data);
-//		object Visit(ReDimClause reDimClause, object data);
-		object Visit(StatementExpression statementExpression, object data);
-		object Visit(LocalVariableDeclaration localVariableDeclaration, object data);
-		object Visit(EmptyStatement emptyStatement, object data);
-		object Visit(YieldStatement yieldStatement, object data);
 		object Visit(ReturnStatement returnStatement, object data);
-		object Visit(IfElseStatement ifElseStatement, object data);
-		object Visit(ElseIfSection elseIfSection, object data);
 		
-		object Visit(ForStatement forStatement, object data);
+		object Visit(SizeOfExpression sizeOfExpression, object data);
-		object Visit(LabelStatement labelStatement, object data);
+		
-		object Visit(GotoStatement gotoStatement, object data);
+		object Visit(StackAllocExpression stackAllocExpression, object data);
-		object Visit(SwitchStatement switchStatement, object data);
+		
-		object Visit(SwitchSection switchSection, object data);
+		object Visit(StatementExpression statementExpression, object data);
-		object Visit(CaseLabel caseLabel, object data);
+		
-		object Visit(BreakStatement breakStatement, object data);
 		object Visit(StopStatement stopStatement, object data);
-		object Visit(ResumeStatement resumeStatement, object data);
+		
-		object Visit(EndStatement endStatement, object data);
+		object Visit(SwitchSection switchSection, object data);
-		object Visit(ContinueStatement continueStatement, object data);
+		
-		object Visit(GotoCaseStatement gotoCaseStatement, object data);
+		object Visit(SwitchStatement switchStatement, object data);
-		object Visit(DoLoopStatement doLoopStatement, object data);
+		
-		object Visit(ForeachStatement foreachStatement, object data);
+		object Visit(TemplateDefinition templateDefinition, object data);
-		object Visit(LockStatement lockStatement, object data);
+		
-		object Visit(UsingStatement usingStatement, object data);
+		object Visit(ThisReferenceExpression thisReferenceExpression, object data);
-		object Visit(WithStatement withStatement, object data);
+		
-		object Visit(TryCatchStatement tryCatchStatement, object data);
-		object Visit(CatchClause catchClause, object data);
 		object Visit(ThrowStatement throwStatement, object data);
-		object Visit(FixedStatement fixedStatement, object data);
-		object Visit(UnsafeStatement unsafeStatement, object data);
-		object Visit(CheckedStatement checkedStatement, object data);
-		object Visit(UncheckedStatement uncheckedStatement, object data);
-		object Visit(ExitStatement exitStatement, object data);
-		object Visit(ForNextStatement forNextStatement, object data);
 		
-		// Expressions
+		object Visit(TryCatchStatement tryCatchStatement, object data);
-		object Visit(ClassReferenceExpression classReferenceExpression, object data);
+		
-		object Visit(PrimitiveExpression primitiveExpression, object data);
+		object Visit(TypeDeclaration typeDeclaration, object data);
-		object Visit(BinaryOperatorExpression binaryOperatorExpression, object data);
+		
-		object Visit(ParenthesizedExpression parenthesizedExpression, object data);
-		object Visit(InvocationExpression invocationExpression, object data);
-		object Visit(IdentifierExpression identifierExpression, object data);
-		object Visit(TypeReferenceExpression typeReferenceExpression, object data);
-		object Visit(UnaryOperatorExpression unaryOperatorExpression, object data);
-		object Visit(AssignmentExpression assignmentExpression, object data);
-		object Visit(SizeOfExpression sizeOfExpression, object data);
 		object Visit(TypeOfExpression typeOfExpression, object data);
+		
 		object Visit(TypeOfIsExpression typeOfIsExpression, object data);
-		object Visit(DefaultValueExpression defaultValueExpression, object data);
+		
-		object Visit(AddressOfExpression addressOfExpression, object data);
+		object Visit(TypeReference typeReference, object data);
-		object Visit(AnonymousMethodExpression anonymousMethodExpression, object data);
+		
-		object Visit(CheckedExpression checkedExpression, object data);
+		object Visit(TypeReferenceExpression typeReferenceExpression, object data);
+		
+		object Visit(UnaryOperatorExpression unaryOperatorExpression, object data);
+		
 		object Visit(UncheckedExpression uncheckedExpression, object data);
-		object Visit(PointerReferenceExpression pointerReferenceExpression, object data);
+		
-		object Visit(CastExpression castExpression, object data);
+		object Visit(UncheckedStatement uncheckedStatement, object data);
-		object Visit(StackAllocExpression stackAllocExpression, object data);
+		
-		object Visit(IndexerExpression indexerExpression, object data);
+		object Visit(UnsafeStatement unsafeStatement, object data);
-		object Visit(ThisReferenceExpression thisReferenceExpression, object data);
+		
-		object Visit(BaseReferenceExpression baseReferenceExpression, object data);
+		object Visit(Using @using, object data);
-		object Visit(ObjectCreateExpression objectCreateExpression, object data);
+		
-		object Visit(ArrayCreateExpression arrayCreateExpression, object data);
+		object Visit(UsingDeclaration usingDeclaration, object data);
-		object Visit(FieldReferenceExpression fieldReferenceExpression, object data);
+		
-		object Visit(DirectionExpression directionExpression, object data);
+		object Visit(UsingStatement usingStatement, object data);
-		object Visit(ArrayInitializerExpression arrayInitializerExpression, object data);
+		
-		object Visit(ConditionalExpression conditionalExpression, object data);
+		object Visit(VariableDeclaration variableDeclaration, object data);
+		
+		object Visit(WithStatement withStatement, object data);
+		
+		object Visit(YieldStatement yieldStatement, object data);
 	}
 }

src/Libraries/NRefactory/Project/Src/Parser/Visitors/LookupTableVisitor.cs

@@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.Parser
 		}
 	}
 	
-	public class LookupTableVisitor : AbstractASTVisitor
+	public class LookupTableVisitor : AbstractAstVisitor
 	{
 		Dictionary<string, List<LocalLookupVariable>> variables;
 		
@@ -94,6 +94,16 @@ namespace ICSharpCode.NRefactory.Parser
 			return base.Visit(withStatement, data);
 		}
 		
+		Stack<BlockStatement> blockStack = new Stack<BlockStatement>();
+		
+		public override object Visit(BlockStatement blockStatement, object data)
+		{
+			blockStack.Push(blockStatement);
+			base.Visit(blockStatement, data);
+			blockStack.Pop();
+			return null;
+		}
+		
 		public override object Visit(LocalVariableDeclaration localVariableDeclaration, object data)
 		{
 			for (int i = 0; i < localVariableDeclaration.Variables.Count; ++i) {
@@ -102,7 +112,7 @@ namespace ICSharpCode.NRefactory.Parser
 				AddVariable(localVariableDeclaration.GetTypeForVariable(i),
 				            varDecl.Name,
 				            localVariableDeclaration.StartLocation,
-				            CurrentBlock == null ? new Point(-1, -1) : CurrentBlock.EndLocation,
+				            (blockStack.Count == 0) ? new Point(-1, -1) : blockStack.Peek().EndLocation,
 				            (localVariableDeclaration.Modifier & Modifier.Const) == Modifier.Const);
 			}
 			return data;

src/Libraries/NRefactory/Project/Src/Parser/Visitors/PrefixFieldsVisitor.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.NRefactory.Parser
 	/// <summary>
 	/// Prefixes the names of the specified fields with the prefix and replaces the use.
 	/// </summary>
-	public class PrefixFieldsVisitor : AbstractASTVisitor
+	public class PrefixFieldsVisitor : AbstractAstVisitor
 	{
 		List<VariableDeclaration> fields;
 		List<string> curBlock = new List<string>();

src/Libraries/NRefactory/Project/Src/Parser/Visitors/ToCSharpConvertVisitor.cs

@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.Parser
 	/// Not all elements are converted here, most simple elements (e.g. StopStatement)
 	/// are converted in the output visitor.
 	/// </summary>
-	public class ToCSharpConvertVisitor : AbstractASTVisitor
+	public class ToCSharpConvertVisitor : AbstractAstTransformer
 	{
 		// The following conversions should be implemented in the future:
 		//   Public Event EventName(param As String) -> automatic delegate declaration

src/Libraries/NRefactory/Project/Src/Parser/Visitors/ToVBNetConvertVisitor.cs

@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.Parser
 	/// Not all elements are converted here, most simple elements (e.g. ConditionalExpression)
 	/// are converted in the output visitor.
 	/// </summary>
-	public class ToVBNetConvertVisitor : AbstractASTVisitor
+	public class ToVBNetConvertVisitor : AbstractAstTransformer
 	{
 		// The following conversions are implemented:
 		//   Conflicting field/property names -> m_field
@@ -29,8 +29,6 @@ namespace ICSharpCode.NRefactory.Parser
 		//   Simple event handler creation is replaced with AddressOfExpression
 		
 		TypeDeclaration currentType;
-		readonly List<KeyValuePair<Statement, Statement>> replacements = new List<KeyValuePair<Statement, Statement>>();
-		readonly List<MethodDeclaration> newMethods = new List<MethodDeclaration>();
 		
 		public override object Visit(TypeDeclaration td, object data)
 		{
@@ -63,15 +61,6 @@ namespace ICSharpCode.NRefactory.Parser
 			base.Visit(td, data);
 			currentType = outerType;
 			
-			foreach (MethodDeclaration md in newMethods) {
-				td.AddChild(md);
-			}
-			newMethods.Clear();
-			foreach (KeyValuePair<Statement, Statement> pair in replacements) {
-				Statement.Replace(pair.Key, pair.Value);
-			}
-			replacements.Clear();
-			
 			return null;
 		}
 		
@@ -87,12 +76,6 @@ namespace ICSharpCode.NRefactory.Parser
 						break;
 					}
 				}
-				foreach (MethodDeclaration method in newMethods) {
-					if (method != null && method.Name == name) {
-						ok = false;
-						break;
-					}
-				}
 				if (ok)
 					return name;
 			}
@@ -104,11 +87,9 @@ namespace ICSharpCode.NRefactory.Parser
 			AssignmentExpression ass = statementExpression.Expression as AssignmentExpression;
 			if (ass != null && ass.Right is AddressOfExpression) {
 				if (ass.Op == AssignmentOperatorType.Add) {
-					Statement st = new AddHandlerStatement(ass.Left, ass.Right);
+					ReplaceCurrentNode(new AddHandlerStatement(ass.Left, ass.Right));
-					replacements.Add(new KeyValuePair<Statement, Statement>(statementExpression, st));
 				} else if (ass.Op == AssignmentOperatorType.Subtract) {
-					Statement st = new RemoveHandlerStatement(ass.Left, ass.Right);
+					ReplaceCurrentNode(new RemoveHandlerStatement(ass.Left, ass.Right));
-					replacements.Add(new KeyValuePair<Statement, Statement>(statementExpression, st));
 				}
 			}
 			return null;
@@ -137,15 +118,17 @@ namespace ICSharpCode.NRefactory.Parser
 			return null;
 		}
 		
+		public override object Visit(AnonymousMethodExpression anonymousMethodExpression, object data)
+		{
+			MethodDeclaration method = new MethodDeclaration(GetAnonymousMethodName(), Modifier.Private, new TypeReference("System.Void"), anonymousMethodExpression.Parameters, null);
+			method.Body = anonymousMethodExpression.Body;
+			currentType.Children.Add(method);
+			ReplaceCurrentNode(new AddressOfExpression(new IdentifierExpression(method.Name)));
+			return null;
+		}
+		
 		public override object Visit(AssignmentExpression assignmentExpression, object data)
 		{
-			AnonymousMethodExpression ame = assignmentExpression.Right as AnonymousMethodExpression;
-			if (currentType != null && ame != null) {
-				MethodDeclaration method = new MethodDeclaration(GetAnonymousMethodName(), Modifier.Private, new TypeReference("System.Void"), ame.Parameters, null);
-				method.Body = ame.Body;
-				newMethods.Add(method);
-				assignmentExpression.Right = new AddressOfExpression(new IdentifierExpression(method.Name));
-			}
 			if (assignmentExpression.Op == AssignmentOperatorType.Add
 			    || assignmentExpression.Op == AssignmentOperatorType.Subtract)
 			{

src/Libraries/NRefactory/Project/Src/Parser/Visitors/VBNetConstructsConvertVisitor.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.NRefactory.Parser
 	/// <summary>
 	/// Converts special VB constructs to use more general AST classes.
 	/// </summary>
-	public class VBNetConstructsConvertVisitor : AbstractASTVisitor
+	public class VBNetConstructsConvertVisitor : AbstractAstTransformer
 	{
 		// The following conversions are implemented:
 		//   MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()

src/Libraries/NRefactory/Test/General/UnitTest.cs

@@ -67,7 +67,7 @@ namespace ICSharpCode.NRefactory.Tests
 		public void TestAbstractASTVisitorVisitor()
 		{
 			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
-			Type visitor = typeof(AbstractASTVisitor);
+			Type visitor = typeof(AbstractAstVisitor);
 			
 			foreach (Type type in allTypes) {
 				if (type.IsClass && !type.IsAbstract && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {

src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs

@@ -136,6 +136,18 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			           "End Sub");
 		}
 		
+		[Test]
+		public void AnonymousMethodInVarDeclaration()
+		{
+			TestMember("void A() { SomeDelegate i = delegate(int argument) { return argument * 2; }; }",
+			           "Sub A()\n" +
+			           "\tDim i As SomeDelegate = AddressOf ConvertedAnonymousMethod1\n" +
+			           "End Sub\n" +
+			           "Private Sub ConvertedAnonymousMethod1(ByVal argument As Integer)\n" +
+			           "\tReturn argument * 2\n" +
+			           "End Sub");
+		}
+		
 		[Test]
 		public void RegisterEvent()
 		{

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryASTConvertVisitor.cs

@@ -20,7 +20,7 @@ using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 {
-	public class NRefactoryASTConvertVisitor : RefParser.AbstractASTVisitor
+	public class NRefactoryASTConvertVisitor : RefParser.AbstractAstVisitor
 	{
 		ICompilationUnit cu;
 		Stack currentNamespace = new Stack();

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs

@@ -210,7 +210,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				return null;
 			}
 		}
-		private class DummyFindVisitor : AbstractASTVisitor {
+		private class DummyFindVisitor : AbstractAstVisitor {
 			internal const string dummyName = "___withStatementExpressionDummy";
 			internal FieldReferenceExpression result;
 			public override object Visit(FieldReferenceExpression fieldReferenceExpression, object data)

src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs

@@ -19,7 +19,7 @@ using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 {
-	public class TypeVisitor : AbstractASTVisitor
+	public class TypeVisitor : AbstractAstVisitor
 	{
 		NRefactoryResolver resolver;