Add partial C# 3.0 support.

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

samples/CSharpCodeCompletion/CodeCompletionProvider.cs

@@ -92,7 +92,7 @@ namespace CSharpEditor
 			//	new DefaultCompletionData("Text", "Description", 1)
 			//};
 			
-			NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent);
+			NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent, mainForm.myProjectContent.Language);
 			Dom.ResolveResult rr = resolver.Resolve(FindExpression(textArea),
 			                                        textArea.Caret.Line,
 			                                        textArea.Caret.Column,
@@ -115,8 +115,8 @@ namespace CSharpEditor
 		/// </summary>
 		Dom.ExpressionResult FindExpression(TextArea textArea)
 		{
-			Dom.CSharp.CSharpExpressionFinder finder;
-			finder = new Dom.CSharp.CSharpExpressionFinder(MainForm.DummyFileName);
+			Dom.VBNet.VBExpressionFinder finder;
+			finder = new Dom.VBNet.VBExpressionFinder();
 			return finder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset);
 		}
 		

samples/CSharpCodeCompletion/MainForm.cs

@@ -59,7 +59,7 @@ namespace CSharpEditor
 		/// SharpDevelop itself uses internal names of the kind "[randomId]/Class1.cs" to support
 		/// code-completion in unsaved files.
 		/// </summary>
-		public const string DummyFileName = "edited.cs";
+		public const string DummyFileName = "edited.vb";
 		
 		public MainForm()
 		{
@@ -68,17 +68,16 @@ namespace CSharpEditor
 			//
 			InitializeComponent();
 			
-			textEditorControl1.Text = @"using System;
-using System.Collections.Generic;
-class MainClass
-{
-	static void Main(string[] args)
-	{
-		
-	}
-}
+			textEditorControl1.Text = @"Imports System
+
+Class A
+ Sub B
+  Dim x As String
+  
+ End Sub
+End Class
 ";
-			textEditorControl1.SetHighlighting("C#");
+			textEditorControl1.SetHighlighting("VB");
 			textEditorControl1.ShowEOLMarkers = false;
 			CodeCompletionKeyHandler.Attach(this, textEditorControl1);
 			HostCallbackImplementation.Register(this);
@@ -92,7 +91,7 @@ class MainClass
 			                                            "CSharpCodeCompletion"));
 			
 			myProjectContent = new Dom.DefaultProjectContent();
-			myProjectContent.Language = Dom.LanguageProperties.CSharp;
+			myProjectContent.Language = Dom.LanguageProperties.VBNet;
 		}
 		
 		protected override void OnLoad(EventArgs e)
@@ -114,7 +113,7 @@ class MainClass
 			ParseStep();
 			
 			string[] referencedAssemblies = {
-				"System", "System.Data", "System.Drawing", "System.Xml", "System.Windows.Forms"
+				"System", "System.Data", "System.Drawing", "System.Xml", "System.Windows.Forms", "Microsoft.VisualBasic"
 			};
 			foreach (string assemblyName in referencedAssemblies) {
 				{ // block for anonymous method
@@ -141,7 +140,7 @@ class MainClass
 			                         }));
 			TextReader textReader = new StringReader(code);
 			Dom.ICompilationUnit newCompilationUnit;
-			using (NRefactory.IParser p = NRefactory.ParserFactory.CreateParser(NRefactory.SupportedLanguage.CSharp, textReader)) {
+			using (NRefactory.IParser p = NRefactory.ParserFactory.CreateParser(NRefactory.SupportedLanguage.VBNet, textReader)) {
 				p.Parse();
 				newCompilationUnit = ConvertCompilationUnit(p.CompilationUnit);
 			}

src/AddIns/BackendBindings/Boo/BooBinding/Project/BooBinding.csproj

@@ -77,7 +77,6 @@
     <Compile Include="Src\Designer\FormsDesignerBinding.cs" />
     <Compile Include="Src\Designer\CodeDomVisitor.cs" />
     <Compile Include="Src\BooCodeGenerator.cs" />
-    <Compile Include="Src\CodeCompletion\ElementReturnType.cs" />
     <Compile Include="Src\FormattingStrategy.cs" />
     <Compile Include="Src\ConvertProject.cs" />
     <Compile Include="Configuration\AssemblyInfo.cs" />

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/BooAmbience.cs

@@ -418,6 +418,10 @@ namespace Grunwald.BooBinding
 		public override string Convert(IMethod m)
 		{
 			StringBuilder builder = new StringBuilder();
+			if (ShowModifiers && m.IsExtensionMethod) {
+				builder.Append("[Extension] ");
+			}
+			
 			builder.Append(Convert(m.Modifiers));
 			
 			if (ShowModifiers) {

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs

@@ -278,7 +278,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		{
 			if (field.Type == null) {
 				if (field.Initializer != null)
-					return new InferredReturnType(field.Initializer, OuterClass);
+					return new BooInferredReturnType(field.Initializer, OuterClass);
 				else
 					return GetDefaultReturnType(_cu.ProjectContent);
 			} else {
@@ -288,13 +288,13 @@ namespace Grunwald.BooBinding.CodeCompletion
 		IReturnType CreateReturnType(AST.Method node, IMethod method)
 		{
 			if (node.ReturnType == null)
-				return new InferredReturnType(node.Body, OuterClass, false);
+				return new BooInferredReturnType(node.Body, OuterClass, false);
 			return CreateReturnType(node.ReturnType, method);
 		}
 		IReturnType CreateReturnType(AST.Property property)
 		{
 			if (property.Type == null && property.Getter != null && property.Getter.Body != null)
-				return new InferredReturnType(property.Getter.Body, OuterClass, false);
+				return new BooInferredReturnType(property.Getter.Body, OuterClass, false);
 			return CreateReturnType(property.Type);
 		}
 		

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ElementReturnType.cs

@@ -1,60 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
-//     <version>$Revision$</version>
-// </file>
-
-using System;
-using ICSharpCode.SharpDevelop.Dom;
-
-namespace Grunwald.BooBinding.CodeCompletion
-{
-	/// <summary>
-	/// The return type that is the element of an enumerable.
-	/// Used to infer the type in "for x in enumerableVariable" loops.
-	/// </summary>
-	public class ElementReturnType : ProxyReturnType
-	{
-		IReturnType listType;
-		IProjectContent pc;
-		
-		public ElementReturnType(IProjectContent pc, IReturnType listType)
-		{
-			if (pc == null)
-				throw new ArgumentNullException("pc");
-			// listType is probably an InferredReturnType
-			this.listType = listType;
-			this.pc = pc;
-		}
-		
-		public override IReturnType BaseType {
-			get {
-				// get element type from listType
-				if (listType.IsArrayReturnType)
-					return listType.CastToArrayReturnType().ArrayElementType;
-				
-				IClass c = listType.GetUnderlyingClass();
-				if (c == null)
-					return null;
-				IClass genumerable = pc.GetClass("System.Collections.Generic.IEnumerable", 1);
-				if (c.IsTypeInInheritanceTree(genumerable)) {
-					return MemberLookupHelper.GetTypeParameterPassedToBaseClass(listType, genumerable, 0);
-				}
-				IClass enumerable = pc.GetClass("System.Collections.IEnumerable", 0);
-				if (c.IsTypeInInheritanceTree(enumerable)) {
-					// We can't use the EnumeratorItemType attribute because SharpDevelop
-					// does not store attribute argument values in the cache.
-					
-					// HACK: Hacked in support for range(), take out when RangeEnumerator implements IEnumerable<int>
-					if (c.FullyQualifiedName == "Boo.Lang.Builtins.RangeEnumerator") {
-						return pc.SystemTypes.Int32;
-					}
-					
-					return pc.SystemTypes.Object;
-				}
-				return null;
-			}
-		}
-	}
-}

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/InferredReturnType.cs

@@ -15,14 +15,14 @@ namespace Grunwald.BooBinding.CodeCompletion
 	/// <summary>
 	/// Return type that is inferred from an expression.
 	/// </summary>
-	public class InferredReturnType : ProxyReturnType
+	public class BooInferredReturnType : ProxyReturnType
 	{
 		Expression expression;
 		Block block;
 		IReturnType cachedType;
 		IClass context;
 		
-		public InferredReturnType(Expression expression, IClass context)
+		public BooInferredReturnType(Expression expression, IClass context)
 		{
 			if (expression == null) throw new ArgumentNullException("expression");
 			this.context = context;
@@ -31,7 +31,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 		
 		bool useLastStatementIfNoReturnStatement;
 		
-		public InferredReturnType(Block block, IClass context, bool useLastStatementIfNoReturnStatement)
+		public BooInferredReturnType(Block block, IClass context, bool useLastStatementIfNoReturnStatement)
 		{
 			if (block == null) throw new ArgumentNullException("block");
 			this.useLastStatementIfNoReturnStatement = useLastStatementIfNoReturnStatement;
@@ -70,8 +70,8 @@ namespace Grunwald.BooBinding.CodeCompletion
 		class GetReturnTypeVisitor : DepthFirstVisitor
 		{
 			IClass context;
-			InferredReturnType parentReturnType;
-			public GetReturnTypeVisitor(InferredReturnType parentReturnType)
+			BooInferredReturnType parentReturnType;
+			public GetReturnTypeVisitor(BooInferredReturnType parentReturnType)
 			{
 				this.context = parentReturnType.context;
 				this.parentReturnType = parentReturnType;

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs

@@ -605,7 +605,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			if (node.ReturnType != null) {
 				amrt.MethodReturnType = ConvertType(node.ReturnType);
 			} else {
-				amrt.MethodReturnType = new InferredReturnType(node.Body, resolver.CallingClass,
+				amrt.MethodReturnType = new BooInferredReturnType(node.Body, resolver.CallingClass,
 				                                               node.ContainsAnnotation("inline"));
 			}
 			ConvertVisitor.AddParameters(node.Parameters, amrt.MethodParameters, resolver.CallingMember, resolver.CallingClass ?? new DefaultClass(resolver.CompilationUnit, "__Dummy"));

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/VariableLookupVisitor.cs

@@ -178,7 +178,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 			if (expr.ContainsAnnotation("DomReturnType")) {
 				returnType = (IReturnType)expr["DomReturnType"];
 			} else {
-				returnType = new InferredReturnType(expr, resolver.CallingClass);
+				returnType = new BooInferredReturnType(expr, resolver.CallingClass);
 				expr.Annotate("DomReturnType", returnType);
 			}
 			if (useElementType)
@@ -219,9 +219,9 @@ namespace Grunwald.BooBinding.CodeCompletion
 				return;
 			if (elementReturnType)
 				results.Add(name, new ElementReturnType(resolver.ProjectContent,
-				                                        new InferredReturnType(expr, resolver.CallingClass)));
+				                                        new BooInferredReturnType(expr, resolver.CallingClass)));
 			else
-				results.Add(name, new InferredReturnType(expr, resolver.CallingClass));
+				results.Add(name, new BooInferredReturnType(expr, resolver.CallingClass));
 		}
 		
 		private void Add(string name, TypeReference reference)

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorExpressions.cs

@@ -455,7 +455,9 @@ namespace NRefactoryToBooConverter
 		{
 			if (!arrayCreateExpression.ArrayInitializer.IsNull) {
 				B.ArrayLiteralExpression ale = ConvertArrayLiteralExpression(arrayCreateExpression.ArrayInitializer);
-				ale.Type = (B.ArrayTypeReference)ConvertTypeReference(arrayCreateExpression.CreateType);
+				if (!arrayCreateExpression.IsImplicitlyTyped) {
+					ale.Type = (B.ArrayTypeReference)ConvertTypeReference(arrayCreateExpression.CreateType);
+				}
 				return ale;
 			}
 			string builtInName = (arrayCreateExpression.Arguments.Count > 1) ? "matrix" : "array";
@@ -477,12 +479,12 @@ namespace NRefactoryToBooConverter
 			return mie;
 		}
 		
-		public object VisitArrayInitializerExpression(ArrayInitializerExpression aie, object data)
+		public object VisitCollectionInitializerExpression(CollectionInitializerExpression aie, object data)
 		{
 			return ConvertArrayLiteralExpression(aie);
 		}
 		
-		B.ArrayLiteralExpression ConvertArrayLiteralExpression(ArrayInitializerExpression aie)
+		B.ArrayLiteralExpression ConvertArrayLiteralExpression(CollectionInitializerExpression aie)
 		{
 			B.ArrayLiteralExpression dims = new B.ArrayLiteralExpression(GetLexicalInfo(aie));
 			ConvertExpressions(aie.CreateExpressions, dims.Items);
@@ -508,6 +510,20 @@ namespace NRefactoryToBooConverter
 			return cbe;
 		}
 		
+		public object VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
+		{
+			B.CallableBlockExpression cbe = new B.CallableBlockExpression(GetLexicalInfo(lambdaExpression));
+			cbe.EndSourceLocation = GetLocation(lambdaExpression.EndLocation);
+			if (lambdaExpression.StatementBody.IsNull) {
+				cbe.Body = new B.Block();
+				cbe.Body.Add(new B.ReturnStatement(ConvertExpression(lambdaExpression.ExpressionBody)));
+			} else {
+				cbe.Body = ConvertBlock(lambdaExpression.StatementBody);
+			}
+			ConvertParameters(lambdaExpression.Parameters, cbe.Parameters);
+			return cbe;
+		}
+		
 		public object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
 		{
 			B.ConditionalExpression te = new B.ConditionalExpression(GetLexicalInfo(conditionalExpression));

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorLINQ.cs

@@ -0,0 +1,67 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using Boo.Lang.Compiler;
+using ICSharpCode.NRefactory;
+using ICSharpCode.NRefactory.Ast;
+using B = Boo.Lang.Compiler.Ast;
+
+namespace NRefactoryToBooConverter
+{
+	partial class ConvertVisitor
+	{
+		public object VisitQueryExpression(QueryExpression queryExpression, object data)
+		{
+			AddError(queryExpression, "QueryExpression is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data)
+		{
+			AddError(queryExpressionFromClause, "QueryExpressionFromClause is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionFromGenerator(QueryExpressionFromGenerator queryExpressionFromGenerator, object data)
+		{
+			AddError(queryExpressionFromGenerator, "QueryExpressionFromGenerator is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data)
+		{
+			AddError(queryExpressionGroupClause, "QueryExpressionGroupClause is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionIntoClause(QueryExpressionIntoClause queryExpressionIntoClause, object data)
+		{
+			AddError(queryExpressionIntoClause, "QueryExpressionIntoClause is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data)
+		{
+			AddError(queryExpressionOrdering, "QueryExpressionOrdering is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
+		{
+			AddError(queryExpressionSelectClause, "queryExpressionSelectClause is not supported.");
+			return null;
+		}
+		
+		public object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data)
+		{
+			AddError(queryExpressionWhereClause, "QueryExpressionWhereClause is not supported.");
+			return null;
+		}
+	}
+}

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/NRefactoryToBooConverter.csproj

@@ -54,6 +54,7 @@
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="Converter.cs" />
     <Compile Include="ConvertVisitor.cs" />
+    <Compile Include="ConvertVisitorLINQ.cs" />
     <Compile Include="Parser.cs" />
     <Compile Include="ConvertVisitorGlobal.cs" />
     <Compile Include="ConvertVisitorTypeMembers.cs" />

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Project/VBToCSharpConverter.cs

@@ -39,7 +39,7 @@ namespace CSharpBinding
 			            delegate(string v) { return v.Replace(',', ';'); });
 		}
 		
-		protected override void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials)
+		protected override void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials, FileProjectItem sourceItem)
 		{
 			PreprocessingDirective.VBToCSharp(specials);
 			compilationUnit.AcceptVisitor(new VBNetToCSharpConvertVisitor(), null);

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Project/CSharpToVBConverter.cs

@@ -16,6 +16,9 @@ using ICSharpCode.NRefactory.Visitors;
 using ICSharpCode.SharpDevelop.Internal.Templates;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Project.Converter;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
+using ICSharpCode.SharpDevelop;
 
 namespace VBNetBinding
 {
@@ -32,10 +35,11 @@ namespace VBNetBinding
 			ConvertFile(sourceItem, targetItem, ".cs", ".vb", SupportedLanguage.CSharp, new VBNetOutputVisitor());
 		}
 		
-		protected override void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials)
+		protected override void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials, FileProjectItem sourceItem)
 		{
 			PreprocessingDirective.CSharpToVB(specials);
-			compilationUnit.AcceptVisitor(new CSharpToVBNetConvertVisitor(), null);
+			IProjectContent pc = ParserService.GetProjectContent(sourceItem.Project) ?? ParserService.CurrentProjectContent;
+			compilationUnit.AcceptVisitor(new CSharpToVBNetConvertVisitor(pc, sourceItem.FileName), null);
 		}
 		
 		protected override void CopyProperties(IProject sourceProject, IProject targetProject)

src/AddIns/DisplayBindings/FormsDesigner/Project/Src/DesignerLoader/NRefactoryDesignerLoader.cs

@@ -233,7 +233,7 @@ namespace ICSharpCode.FormsDesigner
 			}
 			
 			CodeDomVisitor visitor = new CodeDomVisitor();
-			visitor.EnvironmentInformationProvider = new ICSharpCode.SharpDevelop.Dom.NRefactoryResolver.NRefactoryInformationProvider(formClass.ProjectContent, formClass);
+			visitor.EnvironmentInformationProvider = new ICSharpCode.SharpDevelop.Dom.NRefactoryResolver.NRefactoryInformationProvider(formClass.ProjectContent);
 			visitor.VisitCompilationUnit(combinedCu, null);
 			
 			// output generated CodeDOM to the console :

src/AddIns/Misc/ResourceToolkit/Project/Hornung.ResourceToolkit.addin

@@ -5,8 +5,8 @@
        description = "Provides tooltips and code completion for resource entries to simplify working with localizable resources using the standard .NET framework classes or ICSharpCode.Core.">
 	
 	<Manifest>
-		<Identity name="Hornung.ResourceToolkit" version="@Hornung.ResourceToolkit.dll" />
-		<Dependency addin="SharpDevelop" version="2.1.0.1751-2.1"/>
+		<Identity name="Hornung.ResourceToolkit"/>
+		<Dependency addin="SharpDevelop"/>
 	</Manifest>
 	
 	<Runtime>

src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/BclNRefactoryResourceResolver.cs

@@ -360,28 +360,28 @@ namespace Hornung.ResourceToolkit.Resolver
 				}
 			}
 			
-			public override object TrackedVisit(CompilationUnit compilationUnit, object data)
+			public override object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data)
 			{
 				this.compilationUnit = compilationUnit;
-				return base.TrackedVisit(compilationUnit, data);
+				return base.TrackedVisitCompilationUnit(compilationUnit, data);
 			}
 			
-			public override object TrackedVisit(LocalVariableDeclaration localVariableDeclaration, object data)
+			public override object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
 			{
-				return base.TrackedVisit(localVariableDeclaration, localVariableDeclaration);
+				return base.TrackedVisitLocalVariableDeclaration(localVariableDeclaration, localVariableDeclaration);
 			}
 			
-			public override object TrackedVisit(FieldDeclaration fieldDeclaration, object data)
+			public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 			{
-				return base.TrackedVisit(fieldDeclaration, fieldDeclaration);
+				return base.TrackedVisitFieldDeclaration(fieldDeclaration, fieldDeclaration);
 			}
 			
-			public override object TrackedVisit(VariableDeclaration variableDeclaration, object data)
+			public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
 			{
 				// Resolving anything here only makes sense
 				// if this declaration actually has an initializer.
 				if (variableDeclaration.Initializer.IsNull) {
-					return base.TrackedVisit(variableDeclaration, data);
+					return base.TrackedVisitVariableDeclaration(variableDeclaration, data);
 				}
 				
 				LocalVariableDeclaration localVariableDeclaration = data as LocalVariableDeclaration;
@@ -434,10 +434,10 @@ namespace Hornung.ResourceToolkit.Resolver
 					}
 				}
 				
-				return base.TrackedVisit(variableDeclaration, data);
+				return base.TrackedVisitVariableDeclaration(variableDeclaration, data);
 			}
 			
-			public override object TrackedVisit(AssignmentExpression assignmentExpression, object data)
+			public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
 			{
 				if (this.FoundResourceSet == null &&	// skip if already found to improve performance
 				    assignmentExpression.Op == AssignmentOperatorType.Assign && this.PositionAvailable &&
@@ -512,7 +512,7 @@ namespace Hornung.ResourceToolkit.Resolver
 					}
 					
 				}
-				return base.TrackedVisit(assignmentExpression, data);
+				return base.TrackedVisitAssignmentExpression(assignmentExpression, data);
 			}
 			
 			/// <summary>
@@ -544,7 +544,7 @@ namespace Hornung.ResourceToolkit.Resolver
 				}
 			}
 			
-			public override object TrackedVisit(ObjectCreateExpression objectCreateExpression, object data)
+			public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
 			{
 				if (data as bool? ?? false) {
 					
@@ -624,7 +624,7 @@ namespace Hornung.ResourceToolkit.Resolver
 					
 				}
 				
-				return base.TrackedVisit(objectCreateExpression, data);
+				return base.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
 			}
 			
 		}

src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PositionTrackingAstVisitor.cs

@@ -81,10 +81,10 @@ namespace Hornung.ResourceToolkit.Resolver
 		
 		private CompilationUnit compilationUnit;
 		
-		public override object TrackedVisit(CompilationUnit compilationUnit, object data)
+		public override object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data)
 		{
 			this.compilationUnit = compilationUnit;
-			return base.TrackedVisit(compilationUnit, data);
+			return base.TrackedVisitCompilationUnit(compilationUnit, data);
 		}
 		
 		// ********************************************************************************************************************************

src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PropertyFieldAssociationVisitor.cs

@@ -68,7 +68,7 @@ namespace Hornung.ResourceToolkit.Resolver
 			base.EndVisit(node);
 		}
 		
-		public override object TrackedVisit(PropertyDeclaration propertyDeclaration, object data)
+		public override object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
 		{
 			
 			if (this.memberToFind is IProperty) {
@@ -88,10 +88,10 @@ namespace Hornung.ResourceToolkit.Resolver
 				
 			}
 			
-			return base.TrackedVisit(propertyDeclaration, data);
+			return base.TrackedVisitPropertyDeclaration(propertyDeclaration, data);
 		}
 		
-		public override object TrackedVisit(ReturnStatement returnStatement, object data)
+		public override object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data)
 		{
 			// If we are in a property get region,
 			// this may be the statement where the field value is returned.
@@ -162,10 +162,10 @@ namespace Hornung.ResourceToolkit.Resolver
 				
 			}
 			
-			return base.TrackedVisit(returnStatement, data);
+			return base.TrackedVisitReturnStatement(returnStatement, data);
 		}
 		
-		public override object TrackedVisit(AssignmentExpression assignmentExpression, object data)
+		public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
 		{
 			// If we are in a property set region,
 			// this may be the statement where the field value is assigned.
@@ -221,7 +221,7 @@ namespace Hornung.ResourceToolkit.Resolver
 				
 			}
 			
-			return base.TrackedVisit(assignmentExpression, data);
+			return base.TrackedVisitAssignmentExpression(assignmentExpression, data);
 		}
 		
 		// ********************************************************************************************************************************

src/AddIns/Misc/StartPage/Project/Src/ICSharpCodePage.cs

@@ -185,7 +185,7 @@ namespace ICSharpCode.StartPage
 
 		public ICSharpCodePage()
 		{
-			ColorScheme = ICSharpCode.StartPage.ColorScheme.brown;
+			ColorScheme = ICSharpCode.StartPage.ColorScheme.green;
 			
 			TopMenu = new List<MenuItem>();
 			PopulateTopMenu();

src/Libraries/NRefactory/NRefactory.sln

@@ -1,5 +1,7 @@
-Microsoft Visual Studio Solution File, Format Version 9.00
-# SharpDevelop 2.1.0.1865
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+# SharpDevelop 2.1.0.2168
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}"

src/Libraries/NRefactory/NRefactoryASTGenerator/AST/Expressions.cs

@@ -38,22 +38,32 @@ namespace NRefactoryASTGenerator.Ast
 		public NamedArgumentExpression(string name, Expression expression) {}
 	}
 	
+	[IncludeBoolProperty("IsAnonymousType", "return createType.IsNull || string.IsNullOrEmpty(createType.Type);")]
+	class ObjectCreateExpression : Expression {
+		TypeReference    createType;
+		List<Expression> parameters;
+		CollectionInitializerExpression objectInitializer;
+		
+		public ObjectCreateExpression(TypeReference createType, List<Expression> parameters) {}
+	}
+	
+	[IncludeBoolProperty("IsImplicitlyTyped", "return createType.IsNull || string.IsNullOrEmpty(createType.Type);")]
 	class ArrayCreateExpression : Expression {
 		TypeReference              createType;
 		List<Expression>           arguments;
-		ArrayInitializerExpression arrayInitializer;
+		CollectionInitializerExpression arrayInitializer;
 		
 		public ArrayCreateExpression(TypeReference createType) {}
 		public ArrayCreateExpression(TypeReference createType, List<Expression> arguments) {}
-		public ArrayCreateExpression(TypeReference createType, ArrayInitializerExpression arrayInitializer) {}
+		public ArrayCreateExpression(TypeReference createType, CollectionInitializerExpression arrayInitializer) {}
 	}
 	
 	[ImplementNullable(NullableImplementation.Shadow)]
-	class ArrayInitializerExpression : Expression {
+	class CollectionInitializerExpression : Expression {
 		List<Expression> createExpressions;
 		
-		public ArrayInitializerExpression() {}
-		public ArrayInitializerExpression(List<Expression> createExpressions) {}
+		public CollectionInitializerExpression() {}
+		public CollectionInitializerExpression(List<Expression> createExpressions) {}
 	}
 	
 	enum AssignmentOperatorType {}
@@ -115,13 +125,6 @@ namespace NRefactoryASTGenerator.Ast
 		public InvocationExpression(Expression targetObject, List<Expression> arguments, List<TypeReference> typeArguments) {}
 	}
 	
-	class ObjectCreateExpression : Expression {
-		TypeReference    createType;
-		List<Expression> parameters;
-		
-		public ObjectCreateExpression(TypeReference createType, List<Expression> parameters) {}
-	}
-	
 	class ParenthesizedExpression : Expression {
 		Expression expression;
 		
@@ -159,6 +162,12 @@ namespace NRefactoryASTGenerator.Ast
 		bool hasParameterList;
 	}
 	
+	class LambdaExpression : Expression {
+		List<ParameterDeclarationExpression> parameters;
+		BlockStatement statementBody;
+		Expression expressionBody;
+	}
+	
 	class CheckedExpression : Expression {
 		Expression expression;
 		
@@ -235,4 +244,56 @@ namespace NRefactoryASTGenerator.Ast
 		
 		public TypeOfIsExpression(Expression expression, TypeReference typeReference) {}
 	}
+	
+	[ImplementNullable(NullableImplementation.Shadow)]
+	class QueryExpression : Expression {
+		QueryExpressionFromClause fromClause;
+		List<QueryExpressionClause> fromOrWhereClauses;
+		List<QueryExpressionOrdering> orderings;
+		QueryExpressionClause selectOrGroupClause;
+		QueryExpressionIntoClause intoClause;
+	}
+	
+	[ImplementNullable]
+	abstract class QueryExpressionClause : AbstractNode, INullable { }
+	
+	class QueryExpressionWhereClause : QueryExpressionClause {
+		Expression condition;
+	}
+	
+	[ImplementNullable(NullableImplementation.Shadow)]
+	class QueryExpressionFromClause : QueryExpressionClause {
+		List<QueryExpressionFromGenerator> generators;
+	}
+	
+	class QueryExpressionFromGenerator : AbstractNode {
+		[QuestionMarkDefault]
+		string identifier;
+		Expression inExpression;
+	}
+	
+	class QueryExpressionOrdering : AbstractNode {
+		Expression criteria;
+		QueryExpressionOrderingDirection direction;
+	}
+	
+	enum QueryExpressionOrderingDirection {
+		None, Ascending, Descending
+	}
+	
+	class QueryExpressionSelectClause : QueryExpressionClause {
+		Expression projection;
+	}
+	
+	class QueryExpressionGroupClause : QueryExpressionClause {
+		Expression projection;
+		Expression groupBy;
+	}
+	
+	[ImplementNullable(NullableImplementation.Shadow)]
+	class QueryExpressionIntoClause : QueryExpressionClause {
+		[QuestionMarkDefault]
+		string intoIdentifier;
+		QueryExpression continuedQuery;
+	}
 }

src/Libraries/NRefactory/NRefactoryASTGenerator/AST/TypeLevel.cs

@@ -44,7 +44,7 @@ namespace NRefactoryASTGenerator.Ast
 	enum ConstructorInitializerType { None }
 	
 	[ImplementNullable]
-	class ConstructorInitializer : AbstractNode
+	class ConstructorInitializer : AbstractNode, INullable
 	{
 		ConstructorInitializerType constructorInitializerType;
 		List<Expression>           arguments;
@@ -149,6 +149,7 @@ namespace NRefactoryASTGenerator.Ast
 		List<string>     handlesClause;
 		List<InterfaceImplementation> interfaceImplementations;
 		List<TemplateDefinition> templates;
+		bool isExtensionMethod;
 		
 		public MethodDeclaration(string name, Modifiers modifier, TypeReference typeReference, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes) : base(modifier, attributes, name, parameters) {}
 	}

src/Libraries/NRefactory/NRefactoryASTGenerator/Attributes.cs

@@ -7,6 +7,8 @@
 
 using System;
 using System.CodeDom;
+using System.Reflection;
+using ICSharpCode.EasyCodeDom;
 
 namespace NRefactoryASTGenerator
 {
@@ -132,33 +134,27 @@ namespace NRefactoryASTGenerator
 				ctd.Members.Add(prop);
 			}
 			if (implementation != NullableImplementation.Abstract) {
-				CodeTypeDeclaration newType = new CodeTypeDeclaration("Null" + ctd.Name);
+				EasyTypeDeclaration newType = new EasyTypeDeclaration("Null" + ctd.Name);
+				newType.TypeAttributes = TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.Sealed;
 				newType.BaseTypes.Add(new CodeTypeReference(ctd.Name));
 				cns.Types.Add(newType);
 				
 				System.Reflection.ConstructorInfo baseCtor = MainClass.GetBaseCtor(type);
-				CodeConstructor ctor = new CodeConstructor();
-				ctor.Attributes = MemberAttributes.Private;
 				if (baseCtor != null) {
+					CodeConstructor ctor = new CodeConstructor();
+					ctor.Attributes = MemberAttributes.Private;
 					foreach (object o in baseCtor.GetParameters()) {
 						ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(null));
 					}
+					newType.Members.Add(ctor);
 				}
-				newType.Members.Add(ctor);
 				
-				CodeMemberField field = new CodeMemberField(newType.Name, "instance");
-				field.Attributes = MemberAttributes.Static;
+				CodeMemberField field = new CodeMemberField(newType.Name, "Instance");
+				field.Attributes = MemberAttributes.Static | MemberAttributes.Assembly;
 				field.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference(newType.Name));
 				newType.Members.Add(field);
 				
 				CodeMemberProperty prop = new CodeMemberProperty();
-				prop.Name = "Instance";
-				prop.Type = new CodeTypeReference(newType.Name);
-				prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
-				prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("instance")));
-				newType.Members.Add(prop);
-				
-				prop = new CodeMemberProperty();
 				prop.Name = "IsNull";
 				prop.Type = new CodeTypeReference(typeof(bool));
 				prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;

src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs

@@ -518,7 +518,7 @@ namespace NRefactoryASTGenerator
 //					m.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("result")));
 					m.Body.InvokeMethod(Easy.This, "BeginVisit", var);
 					m.Body.DeclareVariable(typeof(object), "result").InitExpression
-						= Easy.This.InvokeMethod("TrackedVisit", var, Easy.Var("data"));
+						= Easy.This.InvokeMethod("TrackedVisit" + type.Name, var, Easy.Var("data"));
 					m.Body.InvokeMethod(Easy.This, "EndVisit", var);
 					m.Body.Return(Easy.Var("result"));
 				}
@@ -527,7 +527,7 @@ namespace NRefactoryASTGenerator
 			foreach (Type type in nodeTypes) {
 				if (!type.IsAbstract) {
 					
-					m = td.AddMethod(typeof(object), "TrackedVisit");
+					m = td.AddMethod(typeof(object), "TrackedVisit" + type.Name);
 					m.Attributes = MemberAttributes.Public;
 					m.AddParameter(ConvertType(type), GetFieldName(type.Name));
 					m.AddParameter(new CodeTypeReference(typeof(object)), "data");

src/Libraries/NRefactory/Project/NRefactory.csproj

@@ -90,18 +90,19 @@
     <Compile Include="Src\PrettyPrinter\AbstractOutputFormatter.cs" />
     <Compile Include="Src\PrettyPrinter\AbstractPrettyPrintOptions.cs" />
     <Compile Include="Src\PrettyPrinter\IOutputAstVisitor.cs" />
-    <Compile Include="Src\PrettyPrinter\NodeInformVisitor.cs" />
     <Compile Include="Src\PrettyPrinter\SpecialNodesInserter.cs" />
     <Compile Include="Src\Visitors\AbstractAstTransformer.cs" />
     <Compile Include="Src\Visitors\AbstractASTVisitor.cs" />
     <Compile Include="Src\Visitors\CodeDOMOutputVisitor.cs" />
     <Compile Include="Src\Visitors\CodeDOMVerboseOutputGenerator.cs" />
+    <Compile Include="Src\Visitors\ConvertVisitorBase.cs" />
     <Compile Include="Src\Visitors\CSharpConstructsVisitor.cs" />
-    <Compile Include="Src\Visitors\CSharpToVBNetConvertVisitor.cs" />
     <Compile Include="Src\Visitors\LookupTableVisitor.cs" />
     <Compile Include="Src\Visitors\PrefixFieldsVisitor.cs" />
+    <Compile Include="Src\Visitors\RenameIdentifierVisitor.cs" />
     <Compile Include="Src\Visitors\ToCSharpConvertVisitor.cs" />
     <Compile Include="Src\Visitors\ToVBNetConvertVisitor.cs" />
+    <Compile Include="Src\Visitors\ToVBNetRenameConflictingVariables.cs" />
     <Compile Include="Src\Visitors\VBNetConstructsConvertVisitor.cs" />
     <Compile Include="Src\Visitors\VBNetToCSharpConvertVisitor.cs" />
     <Compile Include="Src\EnvironmentInformationProvider.cs" />

src/Libraries/NRefactory/Project/Src/Ast/Enums.cs

@@ -358,4 +358,12 @@ namespace ICSharpCode.NRefactory.Ast
 		CompareBinary,
 		CompareText
 	}
+	
+	/// <summary>
+	/// Specifies the ordering direction of a QueryExpressionOrdering node.
+	/// </summary>
+	public enum QueryExpressionOrderingDirection
+	{
+		None, Ascending, Descending
+	}
 }

src/Libraries/NRefactory/Project/Src/Ast/General/BlockStatement.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.NRefactory.Ast
 		// Children in C#: LabelStatement, LocalVariableDeclaration, Statement
 		// Children in VB: LabelStatement, EndStatement, Statement
 		
-		public static new NullBlockStatement Null {
+		public static new BlockStatement Null {
 			get {
 				return NullBlockStatement.Instance;
 			}
@@ -32,9 +32,9 @@ namespace ICSharpCode.NRefactory.Ast
 		}
 	}
 	
-	public class NullBlockStatement : BlockStatement
+	internal sealed class NullBlockStatement : BlockStatement
 	{
-		static NullBlockStatement nullBlockStatement = new NullBlockStatement();
+		public static readonly NullBlockStatement Instance = new NullBlockStatement();
 		
 		public override bool IsNull {
 			get {
@@ -42,16 +42,6 @@ namespace ICSharpCode.NRefactory.Ast
 			}
 		}
 		
-		public static NullBlockStatement Instance {
-			get {
-				return nullBlockStatement;
-			}
-		}
-		
-		NullBlockStatement()
-		{
-		}
-		
 		public override object AcceptVisitor(IAstVisitor visitor, object data)
 		{
 			return data;

src/Libraries/NRefactory/Project/Src/Ast/General/Expression.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.Ast
 {
 	public abstract class Expression : AbstractNode, INullable
 	{
-		public static NullExpression Null {
+		public static Expression Null {
 			get {
 				return NullExpression.Instance;
 			}
@@ -77,9 +77,9 @@ namespace ICSharpCode.NRefactory.Ast
 		}
 	}
 	
-	public class NullExpression : Expression
+	internal sealed class NullExpression : Expression
 	{
-		static NullExpression nullExpression = new NullExpression();
+		internal static readonly NullExpression Instance = new NullExpression();
 		
 		public override bool IsNull {
 			get {
@@ -87,16 +87,6 @@ namespace ICSharpCode.NRefactory.Ast
 			}
 		}
 		
-		public static NullExpression Instance {
-			get {
-				return nullExpression;
-			}
-		}
-		
-		NullExpression()
-		{
-		}
-		
 		public override object AcceptVisitor(IAstVisitor visitor, object data)
 		{
 			return null;

src/Libraries/NRefactory/Project/Src/Ast/General/Statement.cs

@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.Ast
 {
 	public abstract class Statement : AbstractNode, INullable
 	{
-		public static NullStatement Null {
+		public static Statement Null {
 			get {
 				return NullStatement.Instance;
 			}
@@ -45,22 +45,14 @@ namespace ICSharpCode.NRefactory.Ast
 		}
 	}
 	
-	public class NullStatement : Statement
+	internal sealed class NullStatement : Statement
 	{
-		static NullStatement nullStatement = new NullStatement();
+		public static readonly NullStatement Instance = new NullStatement();
 		
 		public override bool IsNull {
 			get { return true; }
 		}
 		
-		public static NullStatement Instance {
-			get { return nullStatement; }
-		}
-		
-		NullStatement()
-		{
-		}
-		
 		public override object AcceptVisitor(IAstVisitor visitor, object data)
 		{
 			return data;

src/Libraries/NRefactory/Project/Src/Ast/TypeReference.cs

@@ -197,6 +197,7 @@ namespace ICSharpCode.NRefactory.Ast
 				return pointerNestingLevel;
 			}
 			set {
+				Debug.Assert(this.IsNull == false);
 				pointerNestingLevel = value;
 			}
 		}
@@ -212,6 +213,7 @@ namespace ICSharpCode.NRefactory.Ast
 				return rankSpecifier;
 			}
 			set {
+				Debug.Assert(this.IsNull == false);
 				rankSpecifier = value;
 			}
 		}
@@ -233,7 +235,7 @@ namespace ICSharpCode.NRefactory.Ast
 			return typeReference ?? NullTypeReference.Instance;
 		}
 		
-		public static NullTypeReference Null {
+		public static TypeReference Null {
 			get {
 				return NullTypeReference.Instance;
 			}
@@ -354,9 +356,9 @@ namespace ICSharpCode.NRefactory.Ast
 		}
 	}
 
-	public class NullTypeReference : TypeReference
+	internal sealed class NullTypeReference : TypeReference
 	{
-		static NullTypeReference nullTypeReference = new NullTypeReference();
+		public static readonly NullTypeReference Instance = new NullTypeReference();
 		public override bool IsNull {
 			get {
 				return true;
@@ -366,12 +368,7 @@ namespace ICSharpCode.NRefactory.Ast
 		{
 			return null;
 		}
-		public static NullTypeReference Instance {
-			get {
-				return nullTypeReference;
-			}
-		}
-		NullTypeReference() {}
+		
 		public override string ToString()
 		{
 			return String.Format("[NullTypeReference]");

src/Libraries/NRefactory/Project/Src/EnvironmentInformationProvider.cs

@@ -14,8 +14,10 @@ namespace ICSharpCode.NRefactory
 		bool HasField(string fullTypeName, string fieldName);
 	}
 	
-	class DummyEnvironmentInformationProvider : IEnvironmentInformationProvider
+	sealed class DummyEnvironmentInformationProvider : IEnvironmentInformationProvider
 	{
+		internal static readonly IEnvironmentInformationProvider Instance = new DummyEnvironmentInformationProvider();
+		
 		public bool HasField(string fullTypeName, string fieldName)
 		{
 			return false;

src/Libraries/NRefactory/Project/Src/IAstVisitor.cs

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.42
+//     Runtime Version:2.0.50727.312
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -23,8 +23,6 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data);
 		
-		object VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, object data);
-		
 		object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data);
 		
 		object VisitAttribute(ICSharpCode.NRefactory.Ast.Attribute attribute, object data);
@@ -51,6 +49,8 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data);
 		
+		object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data);
+		
 		object VisitCompilationUnit(CompilationUnit compilationUnit, object data);
 		
 		object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data);
@@ -127,6 +127,8 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitLabelStatement(LabelStatement labelStatement, object data);
 		
+		object VisitLambdaExpression(LambdaExpression lambdaExpression, object data);
+		
 		object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data);
 		
 		object VisitLockStatement(LockStatement lockStatement, object data);
@@ -159,6 +161,22 @@ namespace ICSharpCode.NRefactory {
 		
 		object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data);
 		
+		object VisitQueryExpression(QueryExpression queryExpression, object data);
+		
+		object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data);
+		
+		object VisitQueryExpressionFromGenerator(QueryExpressionFromGenerator queryExpressionFromGenerator, object data);
+		
+		object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data);
+		
+		object VisitQueryExpressionIntoClause(QueryExpressionIntoClause queryExpressionIntoClause, object data);
+		
+		object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data);
+		
+		object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data);
+		
+		object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data);
+		
 		object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data);
 		
 		object VisitReDimStatement(ReDimStatement reDimStatement, object data);

src/Libraries/NRefactory/Project/Src/Lexer/BuildKeywords.pl

@@ -78,7 +78,7 @@ sub write_keywordfile
 	print DAT "\n";
 	print DAT "namespace " . $properties{'Namespace'} . "\n";
 	print DAT "{\n";
-	print DAT "\tpublic class Keywords\n";
+	print DAT "\tpublic static class Keywords\n";
 	print DAT "\t{\n";
 	print DAT "\t\tstatic readonly string[] keywordList = {\n";
 	if ($properties{'UpperCaseKeywords'} eq "True") {
@@ -209,6 +209,14 @@ sub write_tokensfile {
 		print DAT "\t\t\t}\n";
 		print DAT "\t\t\treturn bitArray;\n";
 		print DAT "\t\t}\n";
+		print DAT "\t\tstatic BitArray NewSet(BitArray existing, params int[] values)\n";
+		print DAT "\t\t{\n";
+		print DAT "\t\t\tBitArray bitArray = new BitArray(existing);\n";
+		print DAT "\t\t\tforeach (int val in values) {\n";
+		print DAT "\t\t\tbitArray[val] = true;\n";
+		print DAT "\t\t\t}\n";
+		print DAT "\t\t\treturn bitArray;\n";
+		print DAT "\t\t}\n";
 		for ($i=0; $i <= $#sets; $i++) {
 			print DAT "\t\tpublic static BitArray ". $sets[$i] . " = NewSet(";
 			print_list($i);
@@ -266,10 +274,10 @@ sub write_unittests {
 	print DAT "\t{\n";
 	print DAT "\t\tILexer GenerateLexer(StringReader sr)\n";
 	print DAT "\t\t{\n";
-	print DAT "\t\t\treturn ParserFactory.CreateLexer(SupportedLanguages.CSharp, sr);\n";
+	print DAT "\t\t\treturn ParserFactory.CreateLexer(SupportedLanguage.CSharp, sr);\n";
 	print DAT "\t\t}\n\n";
 
-	for ($i=0; $i < $#special_values; $i++) {
+	for ($i=0; $i <= $#special_values; $i++) {
 	
 		print DAT "\t\t[Test]\n";
 		print DAT "\t\tpublic void Test" . $special_chars[$i] ."()\n";

src/Libraries/NRefactory/Project/Src/Lexer/CSharp/KeywordList.txt

@@ -73,6 +73,7 @@ ShiftLeftAssign = "<<="
 #Removed because of generics
 #ShiftRightAssign = ">>="
 Pointer = "->"
+LambdaArrow = "=>"
 
 # Keywordlist
 "abstract"
@@ -153,15 +154,35 @@ Pointer = "->"
 "volatile"
 "while"
 
+# Context dependent keywords.
+"partial"
+"where"
+"get"
+"set"
+"add"
+"remove"
+"yield"
+"select"
+"group"
+"by"
+"into"
+"from"
+"ascending"
+"descending"
+"orderby"
+
 #Sets
 
+# When changing IdentifierTokens, ensure you also change the "Identifier" production in cs.ATG
+IdentifierTokens(Identifier, "partial", "where", "get", "set", "add", "remove", "yield", "select", "group", "by", "into", "from", "ascending", "descending", "orderby")
+
 OverloadableUnaryOp("+", "!", "~", "++", "--", "true", "false")
 OverloadableBinaryOp("+", "-", "*", "/", "%", "&", "|", "^", "<<", "==", "!=", ">", "<", ">=", "<=")
 
 TypeKW("char", "bool", "object", "string", "sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "float", "double", "decimal")
 UnaryHead("+", "-", "!", "~", "*", "++", "--", "&")
 AssnStartOp("+", "-", "!", "~", "*")
-CastFollower(Identifier, Literal, "(", "new", "this", "base", "null", "checked", "unchecked", "typeof", "sizeof", "delegate", @OverloadableUnaryOp)
+CastFollower(IdentifierTokens, Literal, "(", "new", "this", "base", "null", "checked", "unchecked", "typeof", "sizeof", "delegate", @OverloadableUnaryOp)
 AssgnOps("=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "<<=")
 UnaryOp("+", "-", "!", "~", "*", "++", "--", "&")
 TypeDeclarationKW("class", "interface", "struct", "enum", "delegate")

src/Libraries/NRefactory/Project/Src/Lexer/CSharp/Keywords.cs

@@ -1,10 +1,3 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="none" email=""/>
-//     <version>$Revision$</version>
-// </file>
-
 // this file was autogenerated by a tool.
 using System;
 
@@ -89,7 +82,22 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			"virtual",
 			"void",
 			"volatile",
-			"while"
+			"while",
+			"partial",
+			"where",
+			"get",
+			"set",
+			"add",
+			"remove",
+			"yield",
+			"select",
+			"group",
+			"by",
+			"into",
+			"from",
+			"ascending",
+			"descending",
+			"orderby"
 		};
 		
 		static LookupTable keywords = new LookupTable(true);

src/Libraries/NRefactory/Project/Src/Lexer/CSharp/Lexer.cs

@@ -95,7 +95,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 							string s = ReadIdent(ch);
 							int keyWordToken = Keywords.GetToken(s);
 							if (keyWordToken >= 0) {
-								return new Token(keyWordToken, x, y);
+								return new Token(keyWordToken, x, y, s);
 							}
 							return new Token(Tokens.Identifier, x, y, s);
 						} else if (Char.IsDigit(ch)) {
@@ -617,6 +617,9 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 						case '=':
 							ReaderRead();
 							return new Token(Tokens.Equal, x, y);
+						case '>':
+							ReaderRead();
+							return new Token(Tokens.LambdaArrow, x, y);
 					}
 					return new Token(Tokens.Assign, x, y);
 				case '<':

src/Libraries/NRefactory/Project/Src/Lexer/CSharp/Tokens.cs

@@ -1,10 +1,3 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="none" email=""/>
-//     <version>$Revision$</version>
-// </file>
-
 // this file was autogenerated by a tool.
 using System;
 using System.Collections;
@@ -64,87 +57,103 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		public const int XorAssign            = 45;
 		public const int ShiftLeftAssign      = 46;
 		public const int Pointer              = 47;
+		public const int LambdaArrow          = 48;
 
 		// ----- keywords -----
-		public const int Abstract             = 48;
-		public const int As                   = 49;
-		public const int Base                 = 50;
-		public const int Bool                 = 51;
-		public const int Break                = 52;
-		public const int Byte                 = 53;
-		public const int Case                 = 54;
-		public const int Catch                = 55;
-		public const int Char                 = 56;
-		public const int Checked              = 57;
-		public const int Class                = 58;
-		public const int Const                = 59;
-		public const int Continue             = 60;
-		public const int Decimal              = 61;
-		public const int Default              = 62;
-		public const int Delegate             = 63;
-		public const int Do                   = 64;
-		public const int Double               = 65;
-		public const int Else                 = 66;
-		public const int Enum                 = 67;
-		public const int Event                = 68;
-		public const int Explicit             = 69;
-		public const int Extern               = 70;
-		public const int False                = 71;
-		public const int Finally              = 72;
-		public const int Fixed                = 73;
-		public const int Float                = 74;
-		public const int For                  = 75;
-		public const int Foreach              = 76;
-		public const int Goto                 = 77;
-		public const int If                   = 78;
-		public const int Implicit             = 79;
-		public const int In                   = 80;
-		public const int Int                  = 81;
-		public const int Interface            = 82;
-		public const int Internal             = 83;
-		public const int Is                   = 84;
-		public const int Lock                 = 85;
-		public const int Long                 = 86;
-		public const int Namespace            = 87;
-		public const int New                  = 88;
-		public const int Null                 = 89;
-		public const int Object               = 90;
-		public const int Operator             = 91;
-		public const int Out                  = 92;
-		public const int Override             = 93;
-		public const int Params               = 94;
-		public const int Private              = 95;
-		public const int Protected            = 96;
-		public const int Public               = 97;
-		public const int Readonly             = 98;
-		public const int Ref                  = 99;
-		public const int Return               = 100;
-		public const int Sbyte                = 101;
-		public const int Sealed               = 102;
-		public const int Short                = 103;
-		public const int Sizeof               = 104;
-		public const int Stackalloc           = 105;
-		public const int Static               = 106;
-		public const int String               = 107;
-		public const int Struct               = 108;
-		public const int Switch               = 109;
-		public const int This                 = 110;
-		public const int Throw                = 111;
-		public const int True                 = 112;
-		public const int Try                  = 113;
-		public const int Typeof               = 114;
-		public const int Uint                 = 115;
-		public const int Ulong                = 116;
-		public const int Unchecked            = 117;
-		public const int Unsafe               = 118;
-		public const int Ushort               = 119;
-		public const int Using                = 120;
-		public const int Virtual              = 121;
-		public const int Void                 = 122;
-		public const int Volatile             = 123;
-		public const int While                = 124;
+		public const int Abstract             = 49;
+		public const int As                   = 50;
+		public const int Base                 = 51;
+		public const int Bool                 = 52;
+		public const int Break                = 53;
+		public const int Byte                 = 54;
+		public const int Case                 = 55;
+		public const int Catch                = 56;
+		public const int Char                 = 57;
+		public const int Checked              = 58;
+		public const int Class                = 59;
+		public const int Const                = 60;
+		public const int Continue             = 61;
+		public const int Decimal              = 62;
+		public const int Default              = 63;
+		public const int Delegate             = 64;
+		public const int Do                   = 65;
+		public const int Double               = 66;
+		public const int Else                 = 67;
+		public const int Enum                 = 68;
+		public const int Event                = 69;
+		public const int Explicit             = 70;
+		public const int Extern               = 71;
+		public const int False                = 72;
+		public const int Finally              = 73;
+		public const int Fixed                = 74;
+		public const int Float                = 75;
+		public const int For                  = 76;
+		public const int Foreach              = 77;
+		public const int Goto                 = 78;
+		public const int If                   = 79;
+		public const int Implicit             = 80;
+		public const int In                   = 81;
+		public const int Int                  = 82;
+		public const int Interface            = 83;
+		public const int Internal             = 84;
+		public const int Is                   = 85;
+		public const int Lock                 = 86;
+		public const int Long                 = 87;
+		public const int Namespace            = 88;
+		public const int New                  = 89;
+		public const int Null                 = 90;
+		public const int Object               = 91;
+		public const int Operator             = 92;
+		public const int Out                  = 93;
+		public const int Override             = 94;
+		public const int Params               = 95;
+		public const int Private              = 96;
+		public const int Protected            = 97;
+		public const int Public               = 98;
+		public const int Readonly             = 99;
+		public const int Ref                  = 100;
+		public const int Return               = 101;
+		public const int Sbyte                = 102;
+		public const int Sealed               = 103;
+		public const int Short                = 104;
+		public const int Sizeof               = 105;
+		public const int Stackalloc           = 106;
+		public const int Static               = 107;
+		public const int String               = 108;
+		public const int Struct               = 109;
+		public const int Switch               = 110;
+		public const int This                 = 111;
+		public const int Throw                = 112;
+		public const int True                 = 113;
+		public const int Try                  = 114;
+		public const int Typeof               = 115;
+		public const int Uint                 = 116;
+		public const int Ulong                = 117;
+		public const int Unchecked            = 118;
+		public const int Unsafe               = 119;
+		public const int Ushort               = 120;
+		public const int Using                = 121;
+		public const int Virtual              = 122;
+		public const int Void                 = 123;
+		public const int Volatile             = 124;
+		public const int While                = 125;
+		public const int Partial              = 126;
+		public const int Where                = 127;
+		public const int Get                  = 128;
+		public const int Set                  = 129;
+		public const int Add                  = 130;
+		public const int Remove               = 131;
+		public const int Yield                = 132;
+		public const int Select               = 133;
+		public const int Group                = 134;
+		public const int By                   = 135;
+		public const int Into                 = 136;
+		public const int From                 = 137;
+		public const int Ascending            = 138;
+		public const int Descending           = 139;
+		public const int Orderby              = 140;
 
-		public const int MaxToken = 125;
+		public const int MaxToken = 141;
 		static BitArray NewSet(params int[] values)
 		{
 			BitArray bitArray = new BitArray(MaxToken);
@@ -153,12 +162,21 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			}
 			return bitArray;
 		}
+		static BitArray NewSet(BitArray existing, params int[] values)
+		{
+			BitArray bitArray = new BitArray(existing);
+			foreach (int val in values) {
+			bitArray[val] = true;
+			}
+			return bitArray;
+		}
+		public static BitArray IdentifierTokens = NewSet(Identifier, Partial, Where, Get, Set, Add, Remove, Yield, Select, Group, By, Into, From, Ascending, Descending, Orderby);
 		public static BitArray OverloadableUnaryOp = NewSet(Plus, Not, BitwiseComplement, Increment, Decrement, True, False);
 		public static BitArray OverloadableBinaryOp = NewSet(Plus, Minus, Times, Div, Mod, BitwiseAnd, BitwiseOr, Xor, ShiftLeft, Equal, NotEqual, GreaterThan, LessThan, GreaterEqual, LessEqual);
 		public static BitArray TypeKW = NewSet(Char, Bool, Object, String, Sbyte, Byte, Short, Ushort, Int, Uint, Long, Ulong, Float, Double, Decimal);
 		public static BitArray UnaryHead = NewSet(Plus, Minus, Not, BitwiseComplement, Times, Increment, Decrement, BitwiseAnd);
 		public static BitArray AssnStartOp = NewSet(Plus, Minus, Not, BitwiseComplement, Times);
-		public static BitArray CastFollower = NewSet(Identifier, Literal, OpenParenthesis, New, This, Base, Null, Checked, Unchecked, Typeof, Sizeof, Delegate, Plus, Not, BitwiseComplement, Increment, Decrement, True, False);
+		public static BitArray CastFollower = NewSet(IdentifierTokens, Literal, OpenParenthesis, New, This, Base, Null, Checked, Unchecked, Typeof, Sizeof, Delegate, Plus, Not, BitwiseComplement, Increment, Decrement, True, False);
 		public static BitArray AssgnOps = NewSet(Assign, PlusAssign, MinusAssign, TimesAssign, DivAssign, ModAssign, BitwiseAndAssign, BitwiseOrAssign, ShiftLeftAssign);
 		public static BitArray UnaryOp = NewSet(Plus, Minus, Not, BitwiseComplement, Times, Increment, Decrement, BitwiseAnd);
 		public static BitArray TypeDeclarationKW = NewSet(Class, Interface, Struct, Enum, Delegate);
@@ -214,6 +232,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			"^=",
 			"<<=",
 			"->",
+			"=>",
 			// ----- keywords -----
 			"abstract",
 			"as",
@@ -292,6 +311,21 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			"void",
 			"volatile",
 			"while",
+			"partial",
+			"where",
+			"get",
+			"set",
+			"add",
+			"remove",
+			"yield",
+			"select",
+			"group",
+			"by",
+			"into",
+			"from",
+			"ascending",
+			"descending",
+			"orderby",
 		};
 		public static string GetTokenString(int token)
 		{

src/Libraries/NRefactory/Project/Src/Parser/CSharp/CSharpParser.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Diagnostics;
 
 using ICSharpCode.NRefactory.Ast;
 
@@ -20,6 +21,9 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		public Parser(ILexer lexer) : base(lexer)
 		{
 			this.lexer = (Lexer)lexer;
+			// due to anonymous methods, we always need a compilation unit, so
+			// create it in the constructor
+			compilationUnit = new CompilationUnit();
 		}
 		
 		StringBuilder qualidentBuilder = new StringBuilder();
@@ -76,7 +80,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			if (!IsTypeKWForTypeCast(ref pt)) {
 				return false;
 			}
-			if (pt.kind == Tokens.Question)
+			if (pt.kind == Tokens.Question) // TODO: check if IsTypeKWForTypeCast doesn't already to this
 				pt = lexer.Peek();
 			return pt.kind == Tokens.CloseParenthesis;
 		}
@@ -97,8 +101,8 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		/* !!! Proceeds from current peek position !!! */
 		bool IsTypeNameOrKWForTypeCast(ref Token pt)
 		{
-			if (IsTypeKWForTypeCast(ref pt))
-				return true;
+			if (Tokens.TypeKW[pt.kind] || pt.kind == Tokens.Void)
+				return IsTypeKWForTypeCast(ref pt);
 			else
 				return IsTypeNameForTypeCast(ref pt);
 		}
@@ -108,14 +112,14 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		bool IsTypeNameForTypeCast(ref Token pt)
 		{
 			// ident
-			if (pt.kind != Tokens.Identifier) {
+			if (!IsIdentifierToken(pt)) {
 				return false;
 			}
 			pt = Peek();
 			// "::" ident
 			if (pt.kind == Tokens.DoubleColon) {
 				pt = Peek();
-				if (pt.kind != Tokens.Identifier) {
+				if (!IsIdentifierToken(pt)) {
 					return false;
 				}
 				pt = Peek();
@@ -172,18 +176,49 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			return Tokens.CastFollower[pt.kind] || (Tokens.TypeKW[pt.kind] && lexer.Peek().kind == Tokens.Dot);
 		}
 		// END IsTypeCast
+		
+		// ( { [TypeNameOrKWForTypeCast] ident "," } )
+		bool IsLambdaExpression()
+		{
+			if (la.kind != Tokens.OpenParenthesis) {
+				return false;
+			}
+			StartPeek();
+			Token pt = Peek();
+			while (pt.kind != Tokens.CloseParenthesis) {
+				if (!IsTypeNameOrKWForTypeCast(ref pt)) {
+					return false;
+				}
+				if (IsIdentifierToken(pt)) {
+					// make ident optional: if implicitly typed lambda arguments are used, IsTypeNameForTypeCast
+					// has already accepted the identifier
+					pt = Peek();
+				}
+				if (pt.kind == Tokens.CloseParenthesis) {
+					break;
+				}
+				// require comma between parameters:
+				if (pt.kind == Tokens.Comma) {
+					pt = Peek();
+				} else {
+					return false;
+				}
+			}
+			pt = Peek();
+			return pt.kind == Tokens.LambdaArrow;
+		}
 
 		/* Checks whether the next sequences of tokens is a qualident *
 		 * and returns the qualident string                           */
 		/* !!! Proceeds from current peek position !!! */
 		bool IsQualident(ref Token pt, out string qualident)
 		{
-			if (pt.kind == Tokens.Identifier) {
+			if (IsIdentifierToken(pt)) {
 				qualidentBuilder.Length = 0; qualidentBuilder.Append(pt.val);
 				pt = Peek();
 				while (pt.kind == Tokens.Dot || pt.kind == Tokens.DoubleColon) {
 					pt = Peek();
-					if (pt.kind != Tokens.Identifier) {
+					if (!IsIdentifierToken(pt)) {
 						qualident = String.Empty;
 						return false;
 					}
@@ -248,7 +283,12 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		/* True, if ident is followed by "=" */
 		bool IdentAndAsgn ()
 		{
-			return la.kind == Tokens.Identifier && Peek(1).kind == Tokens.Assign;
+			return IsIdentifierToken(la) && Peek(1).kind == Tokens.Assign;
+		}
+		
+		bool IdentAndDoubleColon ()
+		{
+			return IsIdentifierToken(la) && Peek(1).kind == Tokens.DoubleColon;
 		}
 
 		bool IsAssignment () { return IdentAndAsgn(); }
@@ -256,7 +296,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		/* True, if ident is followed by ",", "=", "[" or ";" */
 		bool IsVarDecl () {
 			int peek = Peek(1).kind;
-			return la.kind == Tokens.Identifier &&
+			return IsIdentifierToken(la) &&
 				(peek == Tokens.Comma || peek == Tokens.Assign || peek == Tokens.Semicolon || peek == Tokens.OpenSquareBracket);
 		}
 
@@ -281,19 +321,19 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 
 		/* True, if "." is followed by an ident */
 		bool DotAndIdent () {
-			return la.kind == Tokens.Dot && Peek(1).kind == Tokens.Identifier;
+			return la.kind == Tokens.Dot && IsIdentifierToken(Peek(1));
 		}
 
 		/* True, if ident is followed by ":" */
 		bool IdentAndColon () {
-			return la.kind == Tokens.Identifier && Peek(1).kind == Tokens.Colon;
+			return IsIdentifierToken(la) && Peek(1).kind == Tokens.Colon;
 		}
 
 		bool IsLabel () { return IdentAndColon(); }
 
 		/* True, if ident is followed by "(" */
 		bool IdentAndLPar () {
-			return la.kind == Tokens.Identifier && Peek(1).kind == Tokens.OpenParenthesis;
+			return IsIdentifierToken(la) && Peek(1).kind == Tokens.OpenParenthesis;
 		}
 
 		/* True, if "catch" is followed by "(" */
@@ -306,7 +346,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		bool IsGlobalAttrTarget () {
 			Token pt = Peek(1);
 			return la.kind == Tokens.OpenSquareBracket &&
-				pt.kind == Tokens.Identifier && pt.val == "assembly";
+				IsIdentifierToken(pt) && pt.val == "assembly";
 		}
 
 		/* True, if "[" is followed by "," or "]" */
@@ -357,7 +397,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			
 			StartPeek();
 			Token pt = la;
-			return IsTypeNameOrKWForTypeCast(ref pt) && pt.kind == Tokens.Identifier;
+			return IsTypeNameOrKWForTypeCast(ref pt) && IsIdentifierToken(pt);
 		}
 
 		/* True if lookahead is type parameters (<...>) followed by the specified token */
@@ -383,34 +423,9 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			return false;
 		}
 
-		/* True, if lookahead ident is "where" */
-		bool IdentIsWhere () {
-			return la.kind == Tokens.Identifier && la.val == "where";
-		}
-
-		/* True, if lookahead ident is "get" */
-		bool IdentIsGet () {
-			return la.kind == Tokens.Identifier && la.val == "get";
-		}
-
-		/* True, if lookahead ident is "set" */
-		bool IdentIsSet () {
-			return la.kind == Tokens.Identifier && la.val == "set";
-		}
-
-		/* True, if lookahead ident is "add" */
-		bool IdentIsAdd () {
-			return la.kind == Tokens.Identifier && la.val == "add";
-		}
-
-		/* True, if lookahead ident is "remove" */
-		bool IdentIsRemove () {
-			return la.kind == Tokens.Identifier && la.val == "remove";
-		}
-
 		/* True, if lookahead ident is "yield" and than follows a break or return */
 		bool IsYieldStatement () {
-			return la.kind == Tokens.Identifier && la.val == "yield" && (Peek(1).kind == Tokens.Return || Peek(1).kind == Tokens.Break);
+			return la.kind == Tokens.Yield && (Peek(1).kind == Tokens.Return || Peek(1).kind == Tokens.Break);
 		}
 
 		/* True, if lookahead is a local attribute target specifier, *
@@ -421,7 +436,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			string val = la.val;
 
 			return (cur == Tokens.Event || cur == Tokens.Return ||
-			        (cur == Tokens.Identifier &&
+			        (Tokens.IdentifierTokens[cur] &&
 			         (val == "field" || val == "method"   || val == "module" ||
 			          val == "param" || val == "property" || val == "type"))) &&
 				Peek(1).kind == Tokens.Colon;
@@ -490,5 +505,30 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 				return false;
 			}
 		}
+		
+		bool StartOfQueryExpression()
+		{
+			return la.kind == Tokens.From && IsIdentifierToken(Peek(1));
+		}
+		
+		static bool IsIdentifierToken(Token tk)
+		{
+			return Tokens.IdentifierTokens[tk.kind];
+		}
+		
+		/// <summary>
+		/// Adds a child item to a collection stored in the parent node.
+		/// Also set's the item's parent to <paramref name="parent"/>.
+		/// Does nothing if item is null.
+		/// </summary>
+		static void SafeAdd<T>(INode parent, List<T> list, T item) where T : class, INode
+		{
+			Debug.Assert(parent != null);
+			Debug.Assert((parent is INullable) ? !(parent as INullable).IsNull : true);
+			if (item != null) {
+				list.Add(item);
+				item.Parent = parent;
+			}
+		}
 	}
 }

src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs

@@ -3202,18 +3202,18 @@ la.kind == Tokens.OpenParenthesis) {
 					ArrayTypeModifiers(
 #line  1846 "VBNET.ATG" 
 out dimensions);
-					ArrayInitializer(
+					CollectionInitializer(
 #line  1847 "VBNET.ATG" 
 out initializer);
 				} else {
-					ArrayInitializer(
+					CollectionInitializer(
 #line  1848 "VBNET.ATG" 
 out initializer);
 				}
 			}
 
 #line  1850 "VBNET.ATG" 
-			if (canBeReDim && !canBeNormal && initializer == null) initializer = new ArrayInitializerExpression(); 
+			if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); 
 		}
 
 #line  1853 "VBNET.ATG" 
@@ -3224,7 +3224,7 @@ out initializer);
 			if (dimensions == null) dimensions = new ArrayList();
 			dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0));
 			type.RankSpecifier = (int[])dimensions.ToArray(typeof(int));
-			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as ArrayInitializerExpression);
+			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as CollectionInitializerExpression);
 			ace.Arguments = arguments;
 			oce = ace;
 		}
@@ -3243,7 +3243,7 @@ out Expression initializerExpression) {
 #line  1437 "VBNET.ATG" 
 out initializerExpression);
 		} else if (la.kind == 22) {
-			ArrayInitializer(
+			CollectionInitializer(
 #line  1438 "VBNET.ATG" 
 out initializerExpression);
 		} else SynErr(236);
@@ -3292,13 +3292,13 @@ out expr);
 		}
 	}
 
-	void ArrayInitializer(
+	void CollectionInitializer(
 #line  1442 "VBNET.ATG" 
 out Expression outExpr) {
 
 #line  1444 "VBNET.ATG" 
 		Expression expr = null;
-		ArrayInitializerExpression initializer = new ArrayInitializerExpression();
+		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
 		
 		Expect(22);
 		if (StartOf(28)) {

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -1435,14 +1435,14 @@ VariableInitializer<out Expression initializerExpression>
 		initializerExpression = null;
 	.) =
 	Expr<out initializerExpression>
-	| ArrayInitializer<out initializerExpression>
+	| CollectionInitializer<out initializerExpression>
 	.
 
 /* 9.6.3.4 */
-ArrayInitializer<out Expression outExpr>
+CollectionInitializer<out Expression outExpr>
 	(.
 		Expression expr = null;
-		ArrayInitializerExpression initializer = new ArrayInitializerExpression();
+		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
 	.) =
 	"{"
 	[
@@ -1588,7 +1588,9 @@ SimpleNonInvocationExpression<out Expression pexpr>
 		|	"False"											(.pexpr = new PrimitiveExpression(false, "false"); .)
 		|	"Nothing"											(.pexpr = new PrimitiveExpression(null, "null");  .)
 		|	/* 11.4.2 */ "(" Expr<out expr> ")" 				(. pexpr = new ParenthesizedExpression(expr); .)
-		|	/* 11.4.4 */ Identifier					(. pexpr = new IdentifierExpression(t.val); .)
+		|	/* 11.4.4 */ Identifier
+				(. pexpr = new IdentifierExpression(t.val); .)
+				(. pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation; .)
 		|	(. string val = String.Empty; .)
 			( PrimitiveTypeName<out val> | "Object" (. val = "Object"; .) )
 			"." (. t.val = ""; .) Identifier (. pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); .)
@@ -1844,10 +1846,10 @@ ObjectCreateExpression<out Expression oce>
 	["(" NormalOrReDimArgumentList<out arguments, out canBeNormal, out canBeReDim> ")"
 		[ IF (la.kind == Tokens.OpenParenthesis)
 			ArrayTypeModifiers<out dimensions>
-			ArrayInitializer<out initializer>
-		|	ArrayInitializer<out initializer>
+			CollectionInitializer<out initializer>
+		|	CollectionInitializer<out initializer>
 		]
-		(. if (canBeReDim && !canBeNormal && initializer == null) initializer = new ArrayInitializerExpression(); .)
+		(. if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); .)
 	]
 	(.
 		if (type == null) type = new TypeReference("Object"); // fallback type on parser errors
@@ -1857,7 +1859,7 @@ ObjectCreateExpression<out Expression oce>
 			if (dimensions == null) dimensions = new ArrayList();
 			dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0));
 			type.RankSpecifier = (int[])dimensions.ToArray(typeof(int));
-			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as ArrayInitializerExpression);
+			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as CollectionInitializerExpression);
 			ace.Arguments = arguments;
 			oce = ace;
 		}

src/Libraries/NRefactory/Project/Src/Parser/gen.bat

@@ -22,6 +22,6 @@ del VBNET.ATG
 :exit
 pause
 cd ..
-pushd ..\..\..
-%windir%\microsoft.net\framework\v2.0.50727\msbuild
-popd
+rem pushd ..\..\..
+rem %windir%\microsoft.net\framework\v2.0.50727\msbuild
+rem popd

src/Libraries/NRefactory/Project/Src/PrettyPrinter/IOutputAstVisitor.cs

@@ -7,6 +7,7 @@
 
 using System;
 using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.NRefactory.Ast;
 
 namespace ICSharpCode.NRefactory.PrettyPrinter
 {
@@ -15,9 +16,8 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 	/// </summary>
 	public interface IOutputAstVisitor : IAstVisitor
 	{
-		NodeTracker NodeTracker {
-			get;
-		}
+		event Action<INode> BeforeNodeVisit;
+		event Action<INode> AfterNodeVisit;
 		
 		string Text {
 			get;
@@ -27,7 +27,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 			get;
 		}
 		
-		object Options {
+		AbstractPrettyPrintOptions Options {
 			get;
 			set;
 		}

src/Libraries/NRefactory/Project/Src/PrettyPrinter/NodeInformVisitor.cs

@@ -1,67 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
-//     <version>$Revision$</version>
-// </file>
-
-using System;
-using ICSharpCode.NRefactory.Ast;
-
-namespace ICSharpCode.NRefactory.PrettyPrinter
-{
-	public delegate void InformNode(INode node);
-	
-	public class NodeTracker
-	{
-		IAstVisitor callVisitor;
-		
-		public IAstVisitor CallVisitor {
-			get {
-				return callVisitor;
-			}
-		}
-		
-		public NodeTracker(IAstVisitor callVisitor)
-		{
-			this.callVisitor = callVisitor;
-		}
-		
-		public void BeginNode(INode node)
-		{
-			if (NodeVisiting != null) {
-				NodeVisiting(node);
-			}
-		}
-		
-		public void EndNode(INode node)
-		{
-			if (NodeVisited != null) {
-				NodeVisited(node);
-			}
-		}
-		
-		public object TrackedVisit(INode node, object data)
-		{
-			BeginNode(node);
-			object ret = node.AcceptVisitor(callVisitor, data);
-			EndNode(node);
-			return ret;
-		}
-		
-		public object TrackedVisitChildren(INode node, object data)
-		{
-			foreach (INode child in node.Children) {
-				TrackedVisit(child, data);
-			}
-			if (NodeChildrenVisited != null) {
-				NodeChildrenVisited(node);
-			}
-			return data;
-		}
-		
-		public event InformNode NodeVisiting;
-		public event InformNode NodeChildrenVisited;
-		public event InformNode NodeVisited;
-	}
-}

src/Libraries/NRefactory/Project/Src/PrettyPrinter/SpecialNodesInserter.cs

@@ -122,8 +122,8 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
 		public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputAstVisitor outputVisitor)
 		{
 			SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
-			outputVisitor.NodeTracker.NodeVisiting += sni.AcceptNodeStart;
-			outputVisitor.NodeTracker.NodeVisited  += sni.AcceptNodeEnd;
+			outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
+			outputVisitor.AfterNodeVisit  += sni.AcceptNodeEnd;
 			return sni;
 		}
 	}

src/Libraries/NRefactory/Project/Src/Visitors/AbstractASTVisitor.cs

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.42
+//     Runtime Version:2.0.50727.312
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -55,16 +55,6 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
 		}
 		
-		public virtual object VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, object data) {
-			Debug.Assert((arrayInitializerExpression != null));
-			Debug.Assert((arrayInitializerExpression.CreateExpressions != null));
-			foreach (Expression o in arrayInitializerExpression.CreateExpressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
 		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
 			Debug.Assert((assignmentExpression != null));
 			Debug.Assert((assignmentExpression.Left != null));
@@ -164,6 +154,16 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+			Debug.Assert((collectionInitializerExpression != null));
+			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
+			foreach (Expression o in collectionInitializerExpression.CreateExpressions) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			return null;
+		}
+		
 		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
 			Debug.Assert((compilationUnit != null));
 			return compilationUnit.AcceptChildren(this, data);
@@ -605,6 +605,19 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+			Debug.Assert((lambdaExpression != null));
+			Debug.Assert((lambdaExpression.Parameters != null));
+			Debug.Assert((lambdaExpression.StatementBody != null));
+			Debug.Assert((lambdaExpression.ExpressionBody != null));
+			foreach (ParameterDeclarationExpression o in lambdaExpression.Parameters) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			lambdaExpression.StatementBody.AcceptVisitor(this, data);
+			return lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
+		}
+		
 		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
 			Debug.Assert((localVariableDeclaration != null));
 			Debug.Assert((localVariableDeclaration.TypeReference != null));
@@ -669,12 +682,13 @@ namespace ICSharpCode.NRefactory.Visitors {
 			Debug.Assert((objectCreateExpression != null));
 			Debug.Assert((objectCreateExpression.CreateType != null));
 			Debug.Assert((objectCreateExpression.Parameters != null));
+			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
 			objectCreateExpression.CreateType.AcceptVisitor(this, data);
 			foreach (Expression o in objectCreateExpression.Parameters) {
 				Debug.Assert(o != null);
 				o.AcceptVisitor(this, data);
 			}
-			return null;
+			return objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
 		}
 		
 		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
@@ -805,6 +819,74 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
+			Debug.Assert((queryExpression != null));
+			Debug.Assert((queryExpression.FromClause != null));
+			Debug.Assert((queryExpression.FromOrWhereClauses != null));
+			Debug.Assert((queryExpression.Orderings != null));
+			Debug.Assert((queryExpression.SelectOrGroupClause != null));
+			Debug.Assert((queryExpression.IntoClause != null));
+			queryExpression.FromClause.AcceptVisitor(this, data);
+			foreach (QueryExpressionClause o in queryExpression.FromOrWhereClauses) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			foreach (QueryExpressionOrdering o in queryExpression.Orderings) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			queryExpression.SelectOrGroupClause.AcceptVisitor(this, data);
+			return queryExpression.IntoClause.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+			Debug.Assert((queryExpressionFromClause != null));
+			Debug.Assert((queryExpressionFromClause.Generators != null));
+			foreach (QueryExpressionFromGenerator o in queryExpressionFromClause.Generators) {
+				Debug.Assert(o != null);
+				o.AcceptVisitor(this, data);
+			}
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionFromGenerator(QueryExpressionFromGenerator queryExpressionFromGenerator, object data) {
+			Debug.Assert((queryExpressionFromGenerator != null));
+			Debug.Assert((queryExpressionFromGenerator.InExpression != null));
+			return queryExpressionFromGenerator.InExpression.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+			Debug.Assert((queryExpressionGroupClause != null));
+			Debug.Assert((queryExpressionGroupClause.Projection != null));
+			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
+			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
+			return queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionIntoClause(QueryExpressionIntoClause queryExpressionIntoClause, object data) {
+			Debug.Assert((queryExpressionIntoClause != null));
+			Debug.Assert((queryExpressionIntoClause.ContinuedQuery != null));
+			return queryExpressionIntoClause.ContinuedQuery.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+			Debug.Assert((queryExpressionOrdering != null));
+			Debug.Assert((queryExpressionOrdering.Criteria != null));
+			return queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+			Debug.Assert((queryExpressionSelectClause != null));
+			Debug.Assert((queryExpressionSelectClause.Projection != null));
+			return queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
+		}
+		
+		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+			Debug.Assert((queryExpressionWhereClause != null));
+			Debug.Assert((queryExpressionWhereClause.Condition != null));
+			return queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
+		}
+		
 		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
 			Debug.Assert((raiseEventStatement != null));
 			Debug.Assert((raiseEventStatement.Arguments != null));

src/Libraries/NRefactory/Project/Src/Visitors/AbstractAstTransformer.cs

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:2.0.50727.42
+//     Runtime Version:2.0.50727.312
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -102,24 +102,7 @@ namespace ICSharpCode.NRefactory.Visitors {
 			}
 			nodeStack.Push(arrayCreateExpression.ArrayInitializer);
 			arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
-			arrayCreateExpression.ArrayInitializer = ((ArrayInitializerExpression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, object data) {
-			Debug.Assert((arrayInitializerExpression != null));
-			Debug.Assert((arrayInitializerExpression.CreateExpressions != null));
-			for (int i = 0; i < arrayInitializerExpression.CreateExpressions.Count; i++) {
-				Expression o = arrayInitializerExpression.CreateExpressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					arrayInitializerExpression.CreateExpressions.RemoveAt(i--);
-				else
-					arrayInitializerExpression.CreateExpressions[i] = o;
-			}
+			arrayCreateExpression.ArrayInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
 			return null;
 		}
 		
@@ -287,6 +270,23 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+			Debug.Assert((collectionInitializerExpression != null));
+			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
+			for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++) {
+				Expression o = collectionInitializerExpression.CreateExpressions[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (Expression)nodeStack.Pop();
+				if (o == null)
+					collectionInitializerExpression.CreateExpressions.RemoveAt(i--);
+				else
+					collectionInitializerExpression.CreateExpressions[i] = o;
+			}
+			return null;
+		}
+		
 		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
 			Debug.Assert((compilationUnit != null));
 			for (int i = 0; i < compilationUnit.Children.Count; i++) {
@@ -1100,6 +1100,31 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+			Debug.Assert((lambdaExpression != null));
+			Debug.Assert((lambdaExpression.Parameters != null));
+			Debug.Assert((lambdaExpression.StatementBody != null));
+			Debug.Assert((lambdaExpression.ExpressionBody != null));
+			for (int i = 0; i < lambdaExpression.Parameters.Count; i++) {
+				ParameterDeclarationExpression o = lambdaExpression.Parameters[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (ParameterDeclarationExpression)nodeStack.Pop();
+				if (o == null)
+					lambdaExpression.Parameters.RemoveAt(i--);
+				else
+					lambdaExpression.Parameters[i] = o;
+			}
+			nodeStack.Push(lambdaExpression.StatementBody);
+			lambdaExpression.StatementBody.AcceptVisitor(this, data);
+			lambdaExpression.StatementBody = ((BlockStatement)(nodeStack.Pop()));
+			nodeStack.Push(lambdaExpression.ExpressionBody);
+			lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
+			lambdaExpression.ExpressionBody = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
 		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
 			Debug.Assert((localVariableDeclaration != null));
 			Debug.Assert((localVariableDeclaration.TypeReference != null));
@@ -1224,6 +1249,7 @@ namespace ICSharpCode.NRefactory.Visitors {
 			Debug.Assert((objectCreateExpression != null));
 			Debug.Assert((objectCreateExpression.CreateType != null));
 			Debug.Assert((objectCreateExpression.Parameters != null));
+			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
 			nodeStack.Push(objectCreateExpression.CreateType);
 			objectCreateExpression.CreateType.AcceptVisitor(this, data);
 			objectCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
@@ -1238,6 +1264,9 @@ namespace ICSharpCode.NRefactory.Visitors {
 				else
 					objectCreateExpression.Parameters[i] = o;
 			}
+			nodeStack.Push(objectCreateExpression.ObjectInitializer);
+			objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
+			objectCreateExpression.ObjectInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
 			return null;
 		}
 		
@@ -1483,6 +1512,122 @@ namespace ICSharpCode.NRefactory.Visitors {
 			return null;
 		}
 		
+		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
+			Debug.Assert((queryExpression != null));
+			Debug.Assert((queryExpression.FromClause != null));
+			Debug.Assert((queryExpression.FromOrWhereClauses != null));
+			Debug.Assert((queryExpression.Orderings != null));
+			Debug.Assert((queryExpression.SelectOrGroupClause != null));
+			Debug.Assert((queryExpression.IntoClause != null));
+			nodeStack.Push(queryExpression.FromClause);
+			queryExpression.FromClause.AcceptVisitor(this, data);
+			queryExpression.FromClause = ((QueryExpressionFromClause)(nodeStack.Pop()));
+			for (int i = 0; i < queryExpression.FromOrWhereClauses.Count; i++) {
+				QueryExpressionClause o = queryExpression.FromOrWhereClauses[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (QueryExpressionClause)nodeStack.Pop();
+				if (o == null)
+					queryExpression.FromOrWhereClauses.RemoveAt(i--);
+				else
+					queryExpression.FromOrWhereClauses[i] = o;
+			}
+			for (int i = 0; i < queryExpression.Orderings.Count; i++) {
+				QueryExpressionOrdering o = queryExpression.Orderings[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (QueryExpressionOrdering)nodeStack.Pop();
+				if (o == null)
+					queryExpression.Orderings.RemoveAt(i--);
+				else
+					queryExpression.Orderings[i] = o;
+			}
+			nodeStack.Push(queryExpression.SelectOrGroupClause);
+			queryExpression.SelectOrGroupClause.AcceptVisitor(this, data);
+			queryExpression.SelectOrGroupClause = ((QueryExpressionClause)(nodeStack.Pop()));
+			nodeStack.Push(queryExpression.IntoClause);
+			queryExpression.IntoClause.AcceptVisitor(this, data);
+			queryExpression.IntoClause = ((QueryExpressionIntoClause)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+			Debug.Assert((queryExpressionFromClause != null));
+			Debug.Assert((queryExpressionFromClause.Generators != null));
+			for (int i = 0; i < queryExpressionFromClause.Generators.Count; i++) {
+				QueryExpressionFromGenerator o = queryExpressionFromClause.Generators[i];
+				Debug.Assert(o != null);
+				nodeStack.Push(o);
+				o.AcceptVisitor(this, data);
+				o = (QueryExpressionFromGenerator)nodeStack.Pop();
+				if (o == null)
+					queryExpressionFromClause.Generators.RemoveAt(i--);
+				else
+					queryExpressionFromClause.Generators[i] = o;
+			}
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionFromGenerator(QueryExpressionFromGenerator queryExpressionFromGenerator, object data) {
+			Debug.Assert((queryExpressionFromGenerator != null));
+			Debug.Assert((queryExpressionFromGenerator.InExpression != null));
+			nodeStack.Push(queryExpressionFromGenerator.InExpression);
+			queryExpressionFromGenerator.InExpression.AcceptVisitor(this, data);
+			queryExpressionFromGenerator.InExpression = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+			Debug.Assert((queryExpressionGroupClause != null));
+			Debug.Assert((queryExpressionGroupClause.Projection != null));
+			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
+			nodeStack.Push(queryExpressionGroupClause.Projection);
+			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
+			queryExpressionGroupClause.Projection = ((Expression)(nodeStack.Pop()));
+			nodeStack.Push(queryExpressionGroupClause.GroupBy);
+			queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
+			queryExpressionGroupClause.GroupBy = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionIntoClause(QueryExpressionIntoClause queryExpressionIntoClause, object data) {
+			Debug.Assert((queryExpressionIntoClause != null));
+			Debug.Assert((queryExpressionIntoClause.ContinuedQuery != null));
+			nodeStack.Push(queryExpressionIntoClause.ContinuedQuery);
+			queryExpressionIntoClause.ContinuedQuery.AcceptVisitor(this, data);
+			queryExpressionIntoClause.ContinuedQuery = ((QueryExpression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+			Debug.Assert((queryExpressionOrdering != null));
+			Debug.Assert((queryExpressionOrdering.Criteria != null));
+			nodeStack.Push(queryExpressionOrdering.Criteria);
+			queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
+			queryExpressionOrdering.Criteria = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+			Debug.Assert((queryExpressionSelectClause != null));
+			Debug.Assert((queryExpressionSelectClause.Projection != null));
+			nodeStack.Push(queryExpressionSelectClause.Projection);
+			queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
+			queryExpressionSelectClause.Projection = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
+		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+			Debug.Assert((queryExpressionWhereClause != null));
+			Debug.Assert((queryExpressionWhereClause.Condition != null));
+			nodeStack.Push(queryExpressionWhereClause.Condition);
+			queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
+			queryExpressionWhereClause.Condition = ((Expression)(nodeStack.Pop()));
+			return null;
+		}
+		
 		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
 			Debug.Assert((raiseEventStatement != null));
 			Debug.Assert((raiseEventStatement.Arguments != null));

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

@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.Visitors
 	/// <summary>
 	/// Converts special C# constructs to use more general AST classes.
 	/// </summary>
-	public class CSharpConstructsVisitor : AbstractAstTransformer
+	public class CSharpConstructsVisitor : ConvertVisitorBase
 	{
 		// The following conversions are implemented:
 		//   a == null -> a Is Nothing
@@ -69,16 +69,14 @@ namespace ICSharpCode.NRefactory.Visitors
 			return base.VisitExpressionStatement(expressionStatement, data);
 		}
 		
-		
 		public override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data)
 		{
-			base.VisitIfElseStatement(ifElseStatement, data);
 			BinaryOperatorExpression boe = ifElseStatement.Condition as BinaryOperatorExpression;
 			if (ifElseStatement.ElseIfSections.Count == 0
 			    && ifElseStatement.FalseStatement.Count == 0
 			    && ifElseStatement.TrueStatement.Count == 1
 			    && boe != null
-			    && boe.Op == BinaryOperatorType.ReferenceInequality
+			    && boe.Op == BinaryOperatorType.InEquality
 			    && (IsNullLiteralExpression(boe.Left) || IsNullLiteralExpression(boe.Right))
 			   )
 			{
@@ -102,7 +100,7 @@ namespace ICSharpCode.NRefactory.Visitors
 					}
 				}
 			}
-			return null;
+			return base.VisitIfElseStatement(ifElseStatement, data);
 		}
 		
 		public override object VisitForStatement(ForStatement forStatement, object data)

src/Libraries/NRefactory/Project/Src/Visitors/CSharpToVBNetConvertVisitor.cs

@@ -1,25 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
-//     <version>$Revision$</version>
-// </file>
-
-using System;
-using ICSharpCode.NRefactory.Ast;
-
-namespace ICSharpCode.NRefactory.Visitors
-{
-	/// <summary>
-	/// This class converts C# constructs to their VB.NET equivalents.
-	/// </summary>
-	public class CSharpToVBNetConvertVisitor : CSharpConstructsVisitor
-	{
-		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
-		{
-			base.VisitCompilationUnit(compilationUnit, data);
-			compilationUnit.AcceptVisitor(new ToVBNetConvertVisitor(), data);
-			return null;
-		}
-	}
-}

src/Libraries/NRefactory/Project/Src/Visitors/CodeDOMOutputVisitor.cs

@@ -24,13 +24,13 @@ namespace ICSharpCode.NRefactory.Visitors
 		
 		TypeDeclaration currentTypeDeclaration = null;
 		
-		IEnvironmentInformationProvider environmentInformationProvider = new DummyEnvironmentInformationProvider();
+		IEnvironmentInformationProvider environmentInformationProvider = DummyEnvironmentInformationProvider.Instance;
 		
 		public IEnvironmentInformationProvider EnvironmentInformationProvider {
-			get {
-				return environmentInformationProvider;
-			}
+			get { return environmentInformationProvider; }
 			set {
+				if (value == null)
+					throw new ArgumentNullException("value");
 				environmentInformationProvider = value;
 			}
 		}
@@ -70,7 +70,6 @@ namespace ICSharpCode.NRefactory.Visitors
 			}
 		}
 		
-		// FIXME: map all modifiers correctly
 		static MemberAttributes ConvMemberAttributes(Modifiers modifier)
 		{
 			MemberAttributes attr = (MemberAttributes)0;
@@ -131,7 +130,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			namespaceDeclarations.Pop();
 			codeCompileUnit.Namespaces.Add(currentNamespace);
 			
-			// TODO : Nested namespaces allowed in CodeDOM ? Doesn't seem so :(
+			// Nested namespaces are not allowed in CodeDOM
 			return null;
 		}
 		
@@ -538,7 +537,7 @@ namespace ICSharpCode.NRefactory.Visitors
 					break;
 					
 				case BinaryOperatorType.ExclusiveOr:
-					// TODO ExclusiveOr
+					// CodeDom doesn't support ExclusiveOr
 					op = CodeBinaryOperatorType.BitwiseAnd;
 					break;
 			}

src/Libraries/NRefactory/Project/Src/Visitors/ConvertVisitorBase.cs

@@ -0,0 +1,19 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+namespace ICSharpCode.NRefactory.Visitors
+{
+	/// <summary>
+	/// Base class for the conversion visitors.
+	/// </summary>
+	public class ConvertVisitorBase : AbstractAstTransformer
+	{
+		
+	}
+}

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

@@ -12,45 +12,27 @@ using ICSharpCode.NRefactory.Ast;
 
 namespace ICSharpCode.NRefactory.Visitors
 {
-	public class LocalLookupVariable
+	public sealed class LocalLookupVariable
 	{
-		TypeReference typeRef;
-		Location startPos;
-		Location endPos;
-		bool  isConst;
-		
-		public TypeReference TypeRef {
-			get {
-				return typeRef;
-			}
-		}
-		public Location StartPos {
-			get {
-				return startPos;
-			}
-		}
-		public Location EndPos {
-			get {
-				return endPos;
-			}
-		}
-		
-		public bool IsConst {
-			get {
-				return isConst;
-			}
-		}
-		
-		public LocalLookupVariable(TypeReference typeRef, Location startPos, Location endPos, bool isConst)
+		public readonly TypeReference TypeRef;
+		public readonly Location StartPos;
+		public readonly Location EndPos;
+		public readonly bool IsConst;
+		public readonly bool IsLoopVariable;
+		public readonly Expression Initializer;
+		
+		public LocalLookupVariable(TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer)
 		{
-			this.typeRef = typeRef;
-			this.startPos = startPos;
-			this.endPos = endPos;
-			this.isConst = isConst;
+			this.TypeRef = typeRef;
+			this.StartPos = startPos;
+			this.EndPos = endPos;
+			this.IsConst = isConst;
+			this.IsLoopVariable = isLoopVariable;
+			this.Initializer = initializer;
 		}
 	}
 	
-	public class LookupTableVisitor : AbstractAstVisitor
+	public sealed class LookupTableVisitor : AbstractAstVisitor
 	{
 		Dictionary<string, List<LocalLookupVariable>> variables;
 		
@@ -74,7 +56,9 @@ namespace ICSharpCode.NRefactory.Visitors
 			variables = new Dictionary<string, List<LocalLookupVariable>>(nameComparer);
 		}
 		
-		public void AddVariable(TypeReference typeRef, string name, Location startPos, Location endPos, bool isConst)
+		public void AddVariable(TypeReference typeRef, string name,
+		                        Location startPos, Location endPos, bool isConst,
+		                        bool isLoopVariable, Expression initializer)
 		{
 			if (name == null || name.Length == 0) {
 				return;
@@ -85,7 +69,7 @@ namespace ICSharpCode.NRefactory.Visitors
 			} else {
 				list = (List<LocalLookupVariable>)variables[name];
 			}
-			list.Add(new LocalLookupVariable(typeRef, startPos, endPos, isConst));
+			list.Add(new LocalLookupVariable(typeRef, startPos, endPos, isConst, isLoopVariable, initializer));
 		}
 		
 		public override object VisitWithStatement(WithStatement withStatement, object data)
@@ -119,7 +103,8 @@ namespace ICSharpCode.NRefactory.Visitors
 				            varDecl.Name,
 				            localVariableDeclaration.StartLocation,
 				            CurrentEndLocation,
-				            (localVariableDeclaration.Modifier & Modifiers.Const) == Modifiers.Const);
+				            (localVariableDeclaration.Modifier & Modifiers.Const) == Modifiers.Const,
+				            false, varDecl.Initializer);
 			}
 			return base.VisitLocalVariableDeclaration(localVariableDeclaration, data);
 		}
@@ -127,11 +112,38 @@ namespace ICSharpCode.NRefactory.Visitors
 		public override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
 		{
 			foreach (ParameterDeclarationExpression p in anonymousMethodExpression.Parameters) {
-				AddVariable(p.TypeReference, p.ParameterName, anonymousMethodExpression.StartLocation, anonymousMethodExpression.EndLocation, false);
+				AddVariable(p.TypeReference, p.ParameterName,
+				            anonymousMethodExpression.StartLocation, anonymousMethodExpression.EndLocation,
+				            false, false, null);
 			}
 			return base.VisitAnonymousMethodExpression(anonymousMethodExpression, data);
 		}
 		
+		public override object VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
+		{
+			foreach (ParameterDeclarationExpression p in lambdaExpression.Parameters) {
+				AddVariable(p.TypeReference, p.ParameterName,
+				            lambdaExpression.StartLocation, lambdaExpression.EndLocation,
+				            false, false, null);
+			}
+			return base.VisitLambdaExpression(lambdaExpression, data);
+		}
+		
+		public override object VisitQueryExpressionFromGenerator(QueryExpressionFromGenerator queryExpressionFromGenerator, object data)
+		{
+			if (queryExpressionFromGenerator.Parent != null) {
+				// find parent QueryExpression
+				QueryExpression parentExpression = queryExpressionFromGenerator.Parent.Parent as QueryExpression;
+				
+				if (parentExpression != null) {
+					AddVariable(null, queryExpressionFromGenerator.Identifier,
+					            parentExpression.StartLocation, parentExpression.EndLocation,
+					            false, true, queryExpressionFromGenerator.InExpression);
+				}
+			}
+			return base.VisitQueryExpressionFromGenerator(queryExpressionFromGenerator, data);
+		}
+		
 		public override object VisitForNextStatement(ForNextStatement forNextStatement, object data)
 		{
 			// uses LocalVariableDeclaration, we just have to put the end location on the stack
@@ -177,7 +189,8 @@ namespace ICSharpCode.NRefactory.Visitors
 			            foreachStatement.VariableName,
 			            foreachStatement.StartLocation,
 			            foreachStatement.EndLocation,
-			            false);
+			            false, true,
+			            foreachStatement.Expression);
 			
 			if (foreachStatement.Expression != null) {
 				foreachStatement.Expression.AcceptVisitor(this, data);
@@ -204,7 +217,7 @@ namespace ICSharpCode.NRefactory.Visitors
 							            catchClause.VariableName,
 							            catchClause.StatementBlock.StartLocation,
 							            catchClause.StatementBlock.EndLocation,
-							            false);
+							            false, false, null);
 						}
 						catchClause.StatementBlock.AcceptVisitor(this, data);
 					}

src/Libraries/NRefactory/Project/Src/Visitors/RenameIdentifierVisitor.cs

@@ -0,0 +1,65 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.NRefactory.Ast;
+
+namespace ICSharpCode.NRefactory.Visitors
+{
+	class RenameIdentifierVisitor : AbstractAstVisitor
+	{
+		protected StringComparer nameComparer;
+		protected string from, to;
+		
+		public RenameIdentifierVisitor(string from, string to, StringComparer nameComparer)
+		{
+			this.nameComparer = nameComparer;
+			this.from = from;
+			this.to = to;
+		}
+		
+		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
+		{
+			if (nameComparer.Equals(identifierExpression.Identifier, from)) {
+				identifierExpression.Identifier = to;
+			}
+			return base.VisitIdentifierExpression(identifierExpression, data);
+		}
+	}
+	
+	sealed class RenameLocalVariableVisitor : RenameIdentifierVisitor
+	{
+		public RenameLocalVariableVisitor(string from, string to, StringComparer nameComparer)
+			: base(from, to, nameComparer)
+		{
+		}
+		
+		public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
+		{
+			if (nameComparer.Equals(from, variableDeclaration.Name)) {
+				variableDeclaration.Name = to;
+			}
+			return base.VisitVariableDeclaration(variableDeclaration, data);
+		}
+		
+		public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
+		{
+			if (nameComparer.Equals(from, parameterDeclarationExpression.ParameterName)) {
+				parameterDeclarationExpression.ParameterName = to;
+			}
+			return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data);
+		}
+		
+		public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
+		{
+			if (nameComparer.Equals(from, foreachStatement.VariableName)) {
+				foreachStatement.VariableName = to;
+			}
+			return base.VisitForeachStatement(foreachStatement, data);
+		}
+	}
+}

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

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

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

@@ -17,10 +17,11 @@ namespace ICSharpCode.NRefactory.Visitors
 	/// Not all elements are converted here, most simple elements (e.g. ConditionalExpression)
 	/// are converted in the output visitor.
 	/// </summary>
-	public class ToVBNetConvertVisitor : AbstractAstTransformer
+	public class ToVBNetConvertVisitor : ConvertVisitorBase
 	{
 		// The following conversions are implemented:
 		//   Conflicting field/property names -> m_field
+		//   Conflicting variable names inside methods
 		//   Anonymous methods are put into new methods
 		//   Simple event handler creation is replaced with AddressOfExpression
 		//   Move Imports-statements out of namespaces
@@ -218,6 +219,9 @@ namespace ICSharpCode.NRefactory.Visitors
 					}
 				}
 			}
+			
+			ToVBNetRenameConflictingVariablesVisitor.RenameConflicting(methodDeclaration);
+			
 			return null;
 		}
 		
@@ -300,7 +304,11 @@ namespace ICSharpCode.NRefactory.Visitors
 		{
 			if (!IsClassType(ClassType.Interface) && (propertyDeclaration.Modifier & Modifiers.Visibility) == 0)
 				propertyDeclaration.Modifier |= Modifiers.Private;
-			return base.VisitPropertyDeclaration(propertyDeclaration, data);
+			base.VisitPropertyDeclaration(propertyDeclaration, data);
+			
+			ToVBNetRenameConflictingVariablesVisitor.RenameConflicting(propertyDeclaration);
+			
+			return null;
 		}
 		
 		public override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
@@ -315,7 +323,11 @@ namespace ICSharpCode.NRefactory.Visitors
 			// make constructor private if visiblity is not set (unless constructor is static)
 			if ((constructorDeclaration.Modifier & (Modifiers.Visibility | Modifiers.Static)) == 0)
 				constructorDeclaration.Modifier |= Modifiers.Private;
-			return base.VisitConstructorDeclaration(constructorDeclaration, data);
+			base.VisitConstructorDeclaration(constructorDeclaration, data);
+			
+			ToVBNetRenameConflictingVariablesVisitor.RenameConflicting(constructorDeclaration);
+			
+			return null;
 		}
 		
 		public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)

src/Libraries/NRefactory/Project/Src/Visitors/ToVBNetRenameConflictingVariables.cs

@@ -0,0 +1,91 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.NRefactory.Ast;
+
+namespace ICSharpCode.NRefactory.Visitors
+{
+	/// <summary>
+	/// Renames local variables if they conflict with other locals, fields or parameters.
+	/// </summary>
+	static class ToVBNetRenameConflictingVariablesVisitor
+	{
+		public static void RenameConflicting(ParametrizedNode method)
+		{
+			// variable name => case sensitive variable name
+			// value is null if there are multiple casings for the variable -> the variable is conflicting
+			Dictionary<string, string> caseInsensitive = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+			
+			LookupTableVisitor ltv = new LookupTableVisitor(StringComparer.InvariantCulture);
+			method.AcceptVisitor(ltv, null);
+			
+			// add method parameters to caseInsensitive
+			foreach (ParameterDeclarationExpression pde in method.Parameters) {
+				AddVariableToDict(caseInsensitive, pde.ParameterName, true);
+			}
+			
+			// add local variables to caseInsensitive
+			foreach (KeyValuePair<string, List<LocalLookupVariable>> var in ltv.Variables) {
+				AddVariableToDict(caseInsensitive, var.Key, true);
+			}
+			
+			// add used identifiers to caseInsensitive
+			FindIdentifiersVisitor fvv = new FindIdentifiersVisitor();
+			method.AcceptVisitor(fvv, null);
+			
+			foreach (KeyValuePair<string, string> pair in fvv.usedIdentifiers) {
+				AddVariableToDict(caseInsensitive, pair.Key, false);
+			}
+			
+			int index = 0;
+			foreach (ParameterDeclarationExpression pde in method.Parameters) {
+				if (caseInsensitive[pde.ParameterName] == null) {
+					RenameVariable(method, pde.ParameterName, ref index);
+				}
+			}
+			foreach (KeyValuePair<string, List<LocalLookupVariable>> var in ltv.Variables) {
+				if (caseInsensitive[var.Key] == null) {
+					RenameVariable(method, var.Key, ref index);
+				}
+			}
+		}
+		
+		static void RenameVariable(INode method, string from, ref int index)
+		{
+			index += 1;
+			method.AcceptVisitor(new RenameLocalVariableVisitor(from, from + "__" + index, StringComparer.InvariantCulture), null);
+		}
+		
+		static void AddVariableToDict(Dictionary<string, string> caseInsensitive, string varName, bool hasDeclaration)
+		{
+			string existing;
+			if (caseInsensitive.TryGetValue(varName, out existing)) {
+				if (existing != null && existing != varName) {
+					caseInsensitive[varName] = null;
+				}
+			} else {
+				if (hasDeclaration) {
+					caseInsensitive.Add(varName, varName);
+				}
+			}
+		}
+		
+		sealed class FindIdentifiersVisitor : AbstractAstVisitor
+		{
+			// use dictionary as HashSet to remember used identifiers
+			internal readonly Dictionary<string, string> usedIdentifiers = new Dictionary<string, string>();
+			
+			public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
+			{
+				usedIdentifiers[identifierExpression.Identifier] = null;
+				return null;
+			}
+		}
+	}
+}

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

@@ -17,7 +17,7 @@ namespace ICSharpCode.NRefactory.Visitors
 	/// <summary>
 	/// Converts special VB constructs to use more general AST classes.
 	/// </summary>
-	public class VBNetConstructsConvertVisitor : AbstractAstTransformer
+	public class VBNetConstructsConvertVisitor : ConvertVisitorBase
 	{
 		// The following conversions are implemented:
 		//   MyBase.New() and MyClass.New() calls inside the constructor are converted to :base() and :this()
@@ -26,6 +26,7 @@ namespace ICSharpCode.NRefactory.Visitors
 		//   IIF(cond, true, false) => ConditionalExpression
 		//   Built-in methods => Prefix with class name
 		//   Function A() \n A = SomeValue \n End Function -> convert to return statement
+		//   Comparison with empty string literal ->
 		
 		Dictionary<string, string> usings;
 		List<UsingDeclaration> addedUsings;
@@ -326,31 +327,12 @@ namespace ICSharpCode.NRefactory.Visitors
 					from = p.ParameterName;
 					p.ParameterName = "Value";
 				}
-				propertyDeclaration.SetRegion.AcceptVisitor(new RenameIdentifierVisitor(from, "value"), null);
+				propertyDeclaration.SetRegion.AcceptVisitor(new RenameIdentifierVisitor(from, "value", StringComparer.InvariantCultureIgnoreCase), null);
 			}
 			
 			return base.VisitPropertyDeclaration(propertyDeclaration, data);
 		}
 		
-		class RenameIdentifierVisitor : AbstractAstVisitor
-		{
-			string from, to;
-			
-			public RenameIdentifierVisitor(string from, string to)
-			{
-				this.from = from;
-				this.to = to;
-			}
-			
-			public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
-			{
-				if (string.Equals(identifierExpression.Identifier, from, StringComparison.InvariantCultureIgnoreCase)) {
-					identifierExpression.Identifier = to;
-				}
-				return base.VisitIdentifierExpression(identifierExpression, data);
-			}
-		}
-		
 		static volatile Dictionary<string, Expression> constantTable;
 		static volatile Dictionary<string, Expression> methodTable;
 		
@@ -456,5 +438,45 @@ namespace ICSharpCode.NRefactory.Visitors
 			}
 			return base.VisitUsingStatement(usingStatement, data);
 		}
+		
+		bool IsEmptyStringLiteral(Expression expression)
+		{
+			PrimitiveExpression pe = expression as PrimitiveExpression;
+			if (pe != null) {
+				return (pe.Value as string) == "";
+			} else {
+				return false;
+			}
+		}
+		
+		Expression CallStringIsNullOrEmpty(Expression stringVariable)
+		{
+			List<Expression> arguments = new List<Expression>();
+			arguments.Add(stringVariable);
+			return new InvocationExpression(
+				new FieldReferenceExpression(new TypeReferenceExpression("System.String"), "IsNullOrEmpty"),
+				arguments);
+		}
+		
+		public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
+		{
+			base.VisitBinaryOperatorExpression(binaryOperatorExpression, data);
+			if (IsEmptyStringLiteral(binaryOperatorExpression.Right)) {
+				if (binaryOperatorExpression.Op == BinaryOperatorType.Equality) {
+					ReplaceCurrentNode(CallStringIsNullOrEmpty(binaryOperatorExpression.Left));
+				} else if (binaryOperatorExpression.Op == BinaryOperatorType.InEquality) {
+					ReplaceCurrentNode(new UnaryOperatorExpression(CallStringIsNullOrEmpty(binaryOperatorExpression.Left),
+					                                               UnaryOperatorType.Not));
+				}
+			} else if (IsEmptyStringLiteral(binaryOperatorExpression.Left)) {
+				if (binaryOperatorExpression.Op == BinaryOperatorType.Equality) {
+					ReplaceCurrentNode(CallStringIsNullOrEmpty(binaryOperatorExpression.Right));
+				} else if (binaryOperatorExpression.Op == BinaryOperatorType.InEquality) {
+					ReplaceCurrentNode(new UnaryOperatorExpression(CallStringIsNullOrEmpty(binaryOperatorExpression.Right),
+					                                               UnaryOperatorType.Not));
+				}
+			}
+			return null;
+		}
 	}
 }

src/Libraries/NRefactory/Project/Src/Visitors/VBNetToCSharpConvertVisitor.cs

@@ -20,7 +20,8 @@ namespace ICSharpCode.NRefactory.Visitors
 		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
 		{
 			base.VisitCompilationUnit(compilationUnit, data);
-			compilationUnit.AcceptVisitor(new ToCSharpConvertVisitor(), data);
+			ToCSharpConvertVisitor v = new ToCSharpConvertVisitor();
+			compilationUnit.AcceptVisitor(v, data);
 			return null;
 		}
 	}

src/Libraries/NRefactory/Test/Lexer/CSharp/CustomLexerTests.cs

@@ -41,6 +41,16 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			Assert.AreEqual("a_Bc05", t.val);
 		}
 		
+		[Test]
+		public void TestYieldAsIdentifier()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("yield"));
+			Token t = lexer.NextToken();
+			Assert.AreEqual(Tokens.Yield, t.kind);
+			Assert.IsTrue(Tokens.IdentifierTokens[t.kind]);
+			Assert.AreEqual("yield", t.val);
+		}
+		
 		[Test]
 		public void TestSkippedEmptyBlock()
 		{

src/Libraries/NRefactory/Test/Lexer/CSharp/LexerTests.cs

@@ -330,6 +330,20 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			Assert.AreEqual(Tokens.ShiftLeftAssign, lexer.NextToken().kind);
 		}
 
+		[Test]
+		public void TestPointer()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("->"));
+			Assert.AreEqual(Tokens.Pointer, lexer.NextToken().kind);
+		}
+
+		[Test]
+		public void TestLambdaArrow()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("=>"));
+			Assert.AreEqual(Tokens.LambdaArrow, lexer.NextToken().kind);
+		}
+
 		[Test()]
 		public void TestAbstract()
 		{
@@ -792,5 +806,95 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			ILexer lexer = GenerateLexer(new StringReader("while"));
 			Assert.AreEqual(Tokens.While, lexer.NextToken().kind);
 		}
+		[Test()]
+		public void TestPartial()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("partial"));
+			Assert.AreEqual(Tokens.Partial, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestWhere()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("where"));
+			Assert.AreEqual(Tokens.Where, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestGet()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("get"));
+			Assert.AreEqual(Tokens.Get, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestSet()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("set"));
+			Assert.AreEqual(Tokens.Set, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestAdd()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("add"));
+			Assert.AreEqual(Tokens.Add, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestRemove()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("remove"));
+			Assert.AreEqual(Tokens.Remove, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestYield()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("yield"));
+			Assert.AreEqual(Tokens.Yield, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestSelect()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("select"));
+			Assert.AreEqual(Tokens.Select, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestGroup()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("group"));
+			Assert.AreEqual(Tokens.Group, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestBy()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("by"));
+			Assert.AreEqual(Tokens.By, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestInto()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("into"));
+			Assert.AreEqual(Tokens.Into, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestFrom()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("from"));
+			Assert.AreEqual(Tokens.From, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestAscending()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("ascending"));
+			Assert.AreEqual(Tokens.Ascending, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestDescending()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("descending"));
+			Assert.AreEqual(Tokens.Descending, lexer.NextToken().kind);
+		}
+		[Test()]
+		public void TestOrderby()
+		{
+			ILexer lexer = GenerateLexer(new StringReader("orderby"));
+			Assert.AreEqual(Tokens.Orderby, lexer.NextToken().kind);
+		}
 	}
 }

src/Libraries/NRefactory/Test/NRefactoryTests.csproj

@@ -46,6 +46,8 @@
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="Lexer\CSharp\LexerTests.cs" />
     <Compile Include="General\UnitTest.cs" />
+    <Compile Include="Parser\Expressions\LambdaExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\QueryExpressionTests.cs" />
     <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" />
     <Compile Include="Output\CSharp\CSharpOutputTest.cs" />
     <Compile Include="Parser\Expressions\PrimitiveExpressionTests.cs" />

src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs

@@ -48,6 +48,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(expression + ";"));
 			Expression e = parser.ParseExpression();
 			Assert.AreEqual("", parser.Errors.ErrorOutput);
+			Assert.IsNotNull(e, "ParseExpression returned null");
 			CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
 			e.AcceptVisitor(outputVisitor, null);
 			Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
@@ -126,7 +127,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 		[Test]
 		public void ArrayInitializer()
 		{
-			TestStatement("object[] a = new object[] {1, 2, 3};");
+			TestStatement("object[] a = new object[] { 1, 2, 3 };");
 		}
 		
 		[Test]
@@ -414,6 +415,12 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			TestProgram("public struct Rational<T, O> where O : class\n{\n}");
 		}
 		
+		[Test]
+		public void ExtensionMethod()
+		{
+			TestTypeMember("public static T[] Slice<T>(this T[] source, int index, int count)\n{ }");
+		}
+		
 		[Test]
 		public void FixedStructField()
 		{
@@ -431,5 +438,113 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 	fixed byte data[4 * sizeof(int)], data2[10];
 }");
 		}
+		
+		[Test]
+		public void ImplicitlyTypedLambda()
+		{
+			TestExpression("x => x + 1");
+		}
+		
+		[Test]
+		public void ImplicitlyTypedLambdaWithBody()
+		{
+			TestExpression("x => { return x + 1; }");
+			TestStatement("Func<int, int> f = x => { return x + 1; };");
+		}
+		
+		[Test]
+		public void ExplicitlyTypedLambda()
+		{
+			TestExpression("(int x) => x + 1");
+		}
+		
+		[Test]
+		public void ExplicitlyTypedLambdaWithBody()
+		{
+			TestExpression("(int x) => { return x + 1; }");
+		}
+		
+		[Test]
+		public void LambdaMultipleParameters()
+		{
+			TestExpression("(x, y) => x * y");
+			TestExpression("(x, y) => { return x * y; }");
+			TestExpression("(int x, int y) => x * y");
+			TestExpression("(int x, int y) => { return x * y; }");
+		}
+		
+		[Test]
+		public void LambdaNoParameters()
+		{
+			TestExpression("() => Console.WriteLine()");
+			TestExpression("() => { Console.WriteLine(); }");
+		}
+		
+		[Test]
+		public void ObjectInitializer()
+		{
+			TestExpression("new Point { X = 0, Y = 1 }");
+			TestExpression("new Rectangle { P1 = new Point { X = 0, Y = 1 }, P2 = new Point { X = 2, Y = 3 } }");
+			TestExpression("new Rectangle(arguments) { P1 = { X = 0, Y = 1 }, P2 = { X = 2, Y = 3 } }");
+		}
+		
+		[Test]
+		public void CollectionInitializer()
+		{
+			TestExpression("new List<int> { 0, 1, 2, 3, 4, 5 }");
+			TestExpression(@"new List<Contact> { new Contact { Name = ""Chris Smith"", PhoneNumbers = { ""206-555-0101"", ""425-882-8080"" } }, new Contact { Name = ""Bob Harris"", PhoneNumbers = { ""650-555-0199"" } } }");
+		}
+		
+		[Test]
+		public void AnonymousTypeCreation()
+		{
+			TestExpression("new { obj.Name, Price = 26.9, ident }");
+		}
+		
+		[Test]
+		public void ImplicitlyTypedArrayCreation()
+		{
+			TestExpression("new[] { 1, 10, 100, 1000 }");
+		}
+		
+		[Test]
+		public void QuerySimpleWhere()
+		{
+			TestExpression("from n in numbers where n < 5 select n");
+		}
+		
+		[Test]
+		public void QueryMultipleFrom()
+		{
+			TestExpression("from c in customers" +
+			               " where c.Region == \"WA\"" +
+			               " from o in c.Orders" +
+			               " where o.OrderDate >= cutoffDate" +
+			               " select new { c.CustomerID, o.OrderID }");
+		}
+		
+		[Test]
+		public void QuerySimpleOrdering()
+		{
+			TestExpression("from w in words" +
+			               " orderby w" +
+			               " select w");
+		}
+		
+		[Test]
+		public void QueryComplexOrdering()
+		{
+			TestExpression("from w in words" +
+			               " orderby w.Length descending, w ascending" +
+			               " select w");
+		}
+		
+		[Test]
+		public void QueryGroupInto()
+		{
+			TestExpression("from n in numbers" +
+			               " group n by n % 5 into g" +
+			               " select new { Remainder = g.Key, Numbers = g }");
+		}
 	}
 }

src/Libraries/NRefactory/Test/Output/CSharp/VBToCSharpConverterTest.cs

@@ -598,5 +598,15 @@ static int static_Test2_j = 0;");
 		{
 			TestStatement("CType(obj, IDisposable).Dispose()", "((IDisposable)obj).Dispose();");
 		}
+		
+		[Test]
+		public void ComparisonWithEmptyStringLiteral()
+		{
+			TestStatement("If a = \"\" Then Return", "if (string.IsNullOrEmpty(a)) return; ");
+			TestStatement("If a <> \"\" Then Return", "if (!string.IsNullOrEmpty(a)) return; ");
+			
+			TestStatement("If \"\" = a Then Return", "if (string.IsNullOrEmpty(a)) return; ");
+			TestStatement("If \"\" <> a Then Return", "if (!string.IsNullOrEmpty(a)) return; ");
+		}
 	}
 }

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

@@ -24,7 +24,8 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(input));
 			parser.Parse();
 			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			parser.CompilationUnit.AcceptVisitor(new CSharpToVBNetConvertVisitor(), null);
+			parser.CompilationUnit.AcceptVisitor(new CSharpConstructsVisitor(), null);
+			parser.CompilationUnit.AcceptVisitor(new ToVBNetConvertVisitor(), null);
 			VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor();
 			outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
 			Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
@@ -224,7 +225,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
 			           "\tReturn argument * 2\n" +
 			           "End Function");
 		}
-		*/
+		 */
 		
 		[Test]
 		public void RegisterEvent()
@@ -449,5 +450,15 @@ End Class
 		{
 			TestStatement("a = (int)number;", "a = CInt(number)");
 		}
+		
+		[Test]
+		public void CaseConflictingMethod()
+		{
+			TestMember("void T(int v) { int V = v; M(V, v); }",
+			           "Private Sub T(ByVal v__1 As Integer)\n" +
+			           "\tDim V__2 As Integer = v__1\n" +
+			           "\tM(V__2, v__1)\n" +
+			           "End Sub");
+		}
 	}
 }

src/Libraries/NRefactory/Test/Parser/Expressions/ArrayCreateExpressionTests.cs

@@ -25,6 +25,15 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(1, ace.Arguments.Count);
 			Assert.AreEqual(new int[] {0}, ace.CreateType.RankSpecifier);
 		}
+		
+		[Test]
+		public void CSharpImplicitlyTypedArrayCreateExpression()
+		{
+			ArrayCreateExpression ace = ParseUtilCSharp.ParseExpression<ArrayCreateExpression>("new[] { 1, 10, 100, 1000 }");
+			Assert.AreEqual("", ace.CreateType.Type);
+			Assert.AreEqual(0, ace.Arguments.Count);
+			Assert.AreEqual(4, ace.ArrayInitializer.CreateExpressions.Count);
+		}
 		#endregion
 		
 		#region VB.NET

src/Libraries/NRefactory/Test/Parser/Expressions/LambdaExpressionTests.cs

@@ -0,0 +1,69 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.IO;
+using NUnit.Framework;
+using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.NRefactory.Ast;
+
+namespace ICSharpCode.NRefactory.Tests.Ast
+{
+	[TestFixture]
+	public class LambdaExpressionTests
+	{
+		static LambdaExpression Parse(string program)
+		{
+			return ParseUtilCSharp.ParseExpression<LambdaExpression>(program);
+		}
+		
+		[Test]
+		public void ImplicitlyTypedExpressionBody()
+		{
+			LambdaExpression e = Parse("(x) => x + 1");
+			Assert.AreEqual("x", e.Parameters[0].ParameterName);
+			Assert.IsTrue(e.Parameters[0].TypeReference.IsNull);
+			Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression);
+		}
+		
+		[Test]
+		public void ImplicitlyTypedExpressionBodyWithoutParenthesis()
+		{
+			LambdaExpression e = Parse("x => x + 1");
+			Assert.AreEqual("x", e.Parameters[0].ParameterName);
+			Assert.IsTrue(e.Parameters[0].TypeReference.IsNull);
+			Assert.IsTrue(e.ExpressionBody is BinaryOperatorExpression);
+		}
+		
+		[Test]
+		public void ImplicitlyTypedStatementBody()
+		{
+			LambdaExpression e = Parse("(x) => { return x + 1; }");
+			Assert.AreEqual("x", e.Parameters[0].ParameterName);
+			Assert.IsTrue(e.Parameters[0].TypeReference.IsNull);
+			Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement);
+		}
+		
+		[Test]
+		public void ImplicitlyTypedStatementBodyWithoutParenthesis()
+		{
+			LambdaExpression e = Parse("x => { return x + 1; }");
+			Assert.AreEqual("x", e.Parameters[0].ParameterName);
+			Assert.IsTrue(e.Parameters[0].TypeReference.IsNull);
+			Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement);
+		}
+		
+		[Test]
+		public void ExplicitlyTypedStatementBody()
+		{
+			LambdaExpression e = Parse("(int x) => { return x + 1; }");
+			Assert.AreEqual("x", e.Parameters[0].ParameterName);
+			Assert.AreEqual("int", e.Parameters[0].TypeReference.Type);
+			Assert.IsTrue(e.StatementBody.Children[0] is ReturnStatement);
+		}
+	}
+}

src/Libraries/NRefactory/Test/Parser/Expressions/ObjectCreateExpressionTests.cs

@@ -20,6 +20,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		{
 			Assert.AreEqual("MyObject", oce.CreateType.Type);
 			Assert.AreEqual(3, oce.Parameters.Count);
+			Assert.IsTrue(oce.ObjectInitializer.IsNull);
 			
 			for (int i = 0; i < oce.Parameters.Count; ++i) {
 				Assert.IsTrue(oce.Parameters[i] is PrimitiveExpression);
@@ -64,6 +65,121 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(1, typeRef.GenericTypes.Count);
 			Assert.AreEqual("int", typeRef.GenericTypes[0].Type);
 		}
+		
+		Expression CheckPropertyInitializationExpression(Expression e, string name)
+		{
+			Assert.IsInstanceOfType(typeof(AssignmentExpression), e);
+			Expression left = ((AssignmentExpression)e).Left;
+			Assert.IsInstanceOfType(typeof(IdentifierExpression), left);
+			Assert.AreEqual(name, ((IdentifierExpression)left).Identifier);
+			return ((AssignmentExpression)e).Right;
+		}
+		
+		void CheckPointObjectCreation(ObjectCreateExpression oce)
+		{
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "X"));
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "Y"));
+		}
+		
+		[Test]
+		public void CSharpObjectInitializer()
+		{
+			CheckPointObjectCreation(ParseUtilCSharp.ParseExpression<ObjectCreateExpression>("new Point() { X = 0, Y = 1 }"));
+		}
+		
+		[Test]
+		public void CSharpObjectInitializerWithoutParenthesis()
+		{
+			CheckPointObjectCreation(ParseUtilCSharp.ParseExpression<ObjectCreateExpression>("new Point { X = 0, Y = 1 }"));
+		}
+		
+		[Test]
+		public void CSharpObjectInitializerTrailingComma()
+		{
+			CheckPointObjectCreation(ParseUtilCSharp.ParseExpression<ObjectCreateExpression>("new Point() { X = 0, Y = 1, }"));
+		}
+		
+		[Test]
+		public void CSharpNestedObjectInitializer()
+		{
+			ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression<ObjectCreateExpression>(
+				"new Rectangle { P1 = new Point { X = 0, Y = 1 }, P2 = new Point { X = 2, Y = 3 } }"
+			);
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
+			CheckPointObjectCreation((ObjectCreateExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "P1"));
+			CheckPointObjectCreation((ObjectCreateExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "P2"));
+		}
+		
+		[Test]
+		public void CSharpNestedObjectInitializerForPreinitializedProperty()
+		{
+			ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression<ObjectCreateExpression>(
+				"new Rectangle { P1 = { X = 0, Y = 1 }, P2 = { X = 2, Y = 3 } }"
+			);
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
+			CollectionInitializerExpression aie = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "P1");
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[0], "X"));
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[1], "Y"));
+			aie = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "P2");
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[0], "X"));
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(aie.CreateExpressions[1], "Y"));
+		}
+		
+		[Test]
+		public void CSharpCollectionInitializer()
+		{
+			ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression<ObjectCreateExpression>(
+				"new List<int> { 0, 1, 2 }"
+			);
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(3, oce.ObjectInitializer.CreateExpressions.Count);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), oce.ObjectInitializer.CreateExpressions[0]);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), oce.ObjectInitializer.CreateExpressions[1]);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), oce.ObjectInitializer.CreateExpressions[2]);
+		}
+		
+		[Test]
+		public void CSharpComplexCollectionInitializer()
+		{
+			ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression<ObjectCreateExpression>(
+				@"new List<Contact> {
+	new Contact {
+		Name = ""Chris"",
+		PhoneNumbers = { ""206-555-0101"" }
+	},
+	new Contact(additionalParameter) {
+		Name = ""Bob"",
+		PhoneNumbers = { ""650-555-0199"", ""425-882-8080"" }
+	}
+}"			);
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(2, oce.ObjectInitializer.CreateExpressions.Count);
+			
+			oce = (ObjectCreateExpression)oce.ObjectInitializer.CreateExpressions[1]; // look at Bob
+			Assert.AreEqual(1, oce.Parameters.Count);
+			Assert.IsInstanceOfType(typeof(IdentifierExpression), oce.Parameters[0]);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "Name"));
+			CollectionInitializerExpression phoneNumbers = (CollectionInitializerExpression)CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[1], "PhoneNumbers");
+			Assert.AreEqual(2, phoneNumbers.CreateExpressions.Count);
+		}
+		
+		[Test]
+		public void CSharpAnonymousType()
+		{
+			ObjectCreateExpression oce = ParseUtilCSharp.ParseExpression<ObjectCreateExpression>(
+				"new { Name = \"Test\", Price, Something.Property }"
+			);
+			Assert.IsTrue(oce.CreateType.IsNull);
+			Assert.AreEqual(0, oce.Parameters.Count);
+			Assert.AreEqual(3, oce.ObjectInitializer.CreateExpressions.Count);
+			Assert.IsInstanceOfType(typeof(PrimitiveExpression), CheckPropertyInitializationExpression(oce.ObjectInitializer.CreateExpressions[0], "Name"));
+			Assert.IsInstanceOfType(typeof(IdentifierExpression), oce.ObjectInitializer.CreateExpressions[1]);
+			Assert.IsInstanceOfType(typeof(FieldReferenceExpression), oce.ObjectInitializer.CreateExpressions[2]);
+		}
 		#endregion
 		
 		#region VB.NET

src/Libraries/NRefactory/Test/Parser/Expressions/QueryExpressionTests.cs

@@ -0,0 +1,53 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.IO;
+using NUnit.Framework;
+using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.NRefactory.Ast;
+
+namespace ICSharpCode.NRefactory.Tests.Ast
+{
+	[TestFixture]
+	public class QueryExpressionTests
+	{
+		[Test]
+		public void SimpleExpression()
+		{
+			QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(
+				"from c in customers where c.City == \"London\" select c"
+			);
+			Assert.AreEqual(1, qe.FromClause.Generators.Count);
+			Assert.AreEqual("c", qe.FromClause.Generators[0].Identifier);
+			Assert.AreEqual("customers", ((IdentifierExpression)qe.FromClause.Generators[0].InExpression).Identifier);
+			Assert.AreEqual(1, qe.FromOrWhereClauses.Count);
+			Assert.IsInstanceOfType(typeof(QueryExpressionWhereClause), qe.FromOrWhereClauses[0]);
+			QueryExpressionWhereClause wc = (QueryExpressionWhereClause)qe.FromOrWhereClauses[0];
+			Assert.IsInstanceOfType(typeof(BinaryOperatorExpression), wc.Condition);
+			Assert.IsInstanceOfType(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
+		}
+		
+		[Test]
+		public void MultipleGenerators()
+		{
+			QueryExpression qe = ParseUtilCSharp.ParseExpression<QueryExpression>(@"
+from c in customers
+where c.City == ""London""
+from o in c.Orders
+where o.OrderDate.Year == 2005
+select new { c.Name, o.OrderID, o.Total }");
+			Assert.AreEqual(1, qe.FromClause.Generators.Count);
+			Assert.AreEqual(3, qe.FromOrWhereClauses.Count);
+			Assert.IsInstanceOfType(typeof(QueryExpressionWhereClause), qe.FromOrWhereClauses[0]);
+			Assert.IsInstanceOfType(typeof(QueryExpressionFromClause), qe.FromOrWhereClauses[1]);
+			Assert.IsInstanceOfType(typeof(QueryExpressionWhereClause), qe.FromOrWhereClauses[2]);
+			
+			Assert.IsInstanceOfType(typeof(QueryExpressionSelectClause), qe.SelectOrGroupClause);
+		}
+	}
+}

src/Libraries/NRefactory/Test/Parser/GlobalScope/DelegateDeclarationTests.cs

@@ -48,7 +48,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			string program = "public delegate void(int a, int secondParam, MyObj lastParam);\n";
 			DelegateDeclaration dd = ParseUtilCSharp.ParseGlobal<DelegateDeclaration>(program, true);
 			Assert.AreEqual("System.Void", dd.ReturnType.SystemType);
-			Assert.AreEqual("?", dd.Name);
+			//Assert.AreEqual("?", dd.Name);
 			TestParameters(dd);
 		}
 		

src/Libraries/NRefactory/Test/Parser/TypeLevel/FieldDeclarationTests.cs

@@ -47,7 +47,9 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(2, fd.Fields.Count);
 			
 			Assert.AreEqual("String", ((VariableDeclaration)fd.Fields[0]).TypeReference.Type);
+			Assert.IsFalse(((VariableDeclaration)fd.Fields[0]).TypeReference.IsArrayType);
 			Assert.AreEqual("String", ((VariableDeclaration)fd.Fields[1]).TypeReference.Type);
+			Assert.IsFalse(((VariableDeclaration)fd.Fields[1]).TypeReference.IsArrayType);
 		}
 		
 		[Test]

src/Libraries/NRefactory/Test/Parser/TypeLevel/MethodDeclarationTests.cs

@@ -21,6 +21,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod() {} ");
 			Assert.AreEqual("void", md.TypeReference.Type);
 			Assert.AreEqual(0, md.Parameters.Count);
+			Assert.IsFalse(md.IsExtensionMethod);
 		}
 		
 		[Test]
@@ -62,7 +63,7 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>("void MyMethod(int) {} ", true);
 			Assert.AreEqual("void", md.TypeReference.Type);
 			Assert.AreEqual(1, md.Parameters.Count);
-			Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
+			//Assert.AreEqual("?", ((ParameterDeclarationExpression)md.Parameters[0]).ParameterName);
 		}
 		
 		[Test]
@@ -196,6 +197,30 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual("T", md.Templates[0].Name);
 			Assert.AreEqual(0, md.Templates[0].Bases.Count);
 		}
+		
+		[Test]
+		public void CSharpExtensionMethodTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public static int ToInt32(this string s) { return int.Parse(s); }"
+			);
+			Assert.AreEqual("ToInt32", md.Name);
+			Assert.IsTrue(md.IsExtensionMethod);
+			Assert.AreEqual("s", md.Parameters[0].ParameterName);
+			Assert.AreEqual("string", md.Parameters[0].TypeReference.Type);
+		}
+		
+		[Test]
+		public void CSharpVoidExtensionMethodTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"public static void Print(this string s) { Console.WriteLine(s); }"
+			);
+			Assert.AreEqual("Print", md.Name);
+			Assert.IsTrue(md.IsExtensionMethod);
+			Assert.AreEqual("s", md.Parameters[0].ParameterName);
+			Assert.AreEqual("string", md.Parameters[0].TypeReference.Type);
+		}
 		#endregion
 		
 		#region VB.NET

src/Main/Base/Project/Src/Commands/VBConverter/ConvertBuffer.cs

@@ -14,6 +14,7 @@ using ICSharpCode.NRefactory;
 using ICSharpCode.NRefactory.PrettyPrinter;
 using ICSharpCode.NRefactory.Visitors;
 using ICSharpCode.SharpDevelop.Gui;
+using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
 
 namespace ICSharpCode.SharpDevelop.Commands
 {
@@ -36,7 +37,9 @@ namespace ICSharpCode.SharpDevelop.Commands
 				
 				List<ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials;
 				PreprocessingDirective.CSharpToVB(specials);
-				new CSharpToVBNetConvertVisitor().VisitCompilationUnit(p.CompilationUnit, null);
+				IAstVisitor v = new CSharpToVBNetConvertVisitor(ParserService.CurrentProjectContent,
+				                                                window.ViewContent.FileName);
+				v.VisitCompilationUnit(p.CompilationUnit, null);
 				using (SpecialNodesInserter.Install(specials, vbv)) {
 					vbv.VisitCompilationUnit(p.CompilationUnit, null);
 				}

src/Main/Base/Project/Src/Project/Converter/LanguageConverter.cs

@@ -190,7 +190,8 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 
 	public abstract class NRefactoryLanguageConverter : LanguageConverter
 	{
-		protected abstract void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials);
+		protected abstract void ConvertAst(CompilationUnit compilationUnit, List<ISpecial> specials,
+		                                   FileProjectItem sourceItem);
 		
 		protected void ConvertFile(FileProjectItem sourceItem, FileProjectItem targetItem,
 		                           string sourceExtension, string targetExtension,
@@ -214,7 +215,7 @@ namespace ICSharpCode.SharpDevelop.Project.Converter
 				
 				List<ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials;
 				
-				ConvertAst(p.CompilationUnit, specials);
+				ConvertAst(p.CompilationUnit, specials, sourceItem);
 				
 				using (SpecialNodesInserter.Install(specials, outputVisitor)) {
 					outputVisitor.VisitCompilationUnit(p.CompilationUnit, null);

src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs

@@ -132,8 +132,8 @@ namespace ICSharpCode.SharpDevelop
 			if (ShowModifiers) {
 				if (property.IsIndexer)
 					builder.Append("Indexer ");
-					else
-				builder.Append("Property ");
+				else
+					builder.Append("Property ");
 			}
 			
 			if (UseFullyQualifiedNames) {
@@ -184,6 +184,9 @@ namespace ICSharpCode.SharpDevelop
 		{
 			StringBuilder builder = new StringBuilder();
 			if (ShowModifiers) {
+				if (m.IsExtensionMethod) {
+					builder.Append("[Extension] ");
+				}
 				builder.Append("Method ");
 			}
 			

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs

@@ -172,7 +172,11 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 					ResolveResult.AddExtensions(language, list, result.CallingClass, result.ContainingType);
 					foreach (IMethodOrProperty mp in list) {
 						if (language.NameComparer.Equals(mp.Name, result.Name) && mp is IMethod) {
-							IMethod m = (IMethod)mp.Clone();
+							DefaultMethod m = (DefaultMethod)mp.Clone();
+							// for the insight window, remove first parameter and mark the
+							// method as normal - this is required to show the list of
+							// parameters the method expects.
+							m.IsExtensionMethod = false;
 							m.Parameters.RemoveAt(0);
 							methods.Add(m);
 						}

src/Main/Base/Test/CodeConverterTests.cs

@@ -0,0 +1,198 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.IO;
+using System.Text;
+using System.Diagnostics;
+using ICSharpCode.NRefactory;
+using ICSharpCode.NRefactory.PrettyPrinter;
+using ICSharpCode.NRefactory.Visitors;
+using NUnit.Framework;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
+
+namespace ICSharpCode.SharpDevelop.Tests
+{
+	/// <summary>
+	/// Tests advanced code-conversion features that rely on the type system.
+	/// </summary>
+	[TestFixture]
+	public class CodeConverterTests
+	{
+		#region TestProgram (converting code)
+		ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry;
+		
+		void TestProgramCS2VB(string sourceCode, string expectedOutput)
+		{
+			TestProgram(SupportedLanguage.CSharp, sourceCode, expectedOutput);
+		}
+		
+		void TestProgramVB2CS(string sourceCode, string expectedOutput)
+		{
+			TestProgram(SupportedLanguage.CSharp, sourceCode, expectedOutput);
+		}
+		
+		void TestProgram(SupportedLanguage sourceLanguage, string sourceCode, string expectedOutput)
+		{
+			DefaultProjectContent pc = new DefaultProjectContent();
+			pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
+			if (sourceLanguage == SupportedLanguage.VBNet) {
+				pc.DefaultImports = new DefaultUsing(pc);
+				pc.DefaultImports.Usings.Add("System");
+				pc.DefaultImports.Usings.Add("Microsoft.VisualBasic");
+			}
+			pc.Language = sourceLanguage == SupportedLanguage.CSharp ? LanguageProperties.CSharp : LanguageProperties.VBNet;
+			HostCallback.GetCurrentProjectContent = delegate {
+				return pc;
+			};
+			
+			ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser(sourceLanguage, new StringReader(sourceCode));
+			parser.Parse();
+			Assert.AreEqual("", parser.Errors.ErrorOutput);
+			
+			NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
+			visitor.VisitCompilationUnit(parser.CompilationUnit, null);
+			visitor.Cu.FileName = sourceLanguage == SupportedLanguage.CSharp ? "a.cs" : "a.vb";
+			foreach (IClass c in visitor.Cu.Classes) {
+				pc.AddClassToNamespaceList(c);
+			}
+			
+			HostCallback.GetParseInformation = delegate(string fileName) {
+				ParseInformation pi = new ParseInformation();
+				pi.ValidCompilationUnit = visitor.Cu;
+				return pi;
+			};
+			
+			if (sourceLanguage == SupportedLanguage.CSharp) {
+				CSharpToVBNetConvertVisitor convertVisitor = new CSharpToVBNetConvertVisitor(pc, visitor.Cu.FileName);
+				parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
+			} else {
+				VBNetToCSharpConvertVisitor convertVisitor = new VBNetToCSharpConvertVisitor();
+				parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
+			}
+			
+			IOutputAstVisitor outputVisitor = sourceLanguage == SupportedLanguage.CSharp ? (IOutputAstVisitor)new VBNetOutputVisitor() : new CSharpOutputVisitor();
+			outputVisitor.Options.IndentationChar = ' ';
+			outputVisitor.Options.IndentSize = 2;
+			using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(),
+			                                    outputVisitor)) {
+				outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
+			}
+			Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
+			Assert.AreEqual(expectedOutput.Replace("\r", ""), outputVisitor.Text.Trim().Replace("\r", ""));
+		}
+		#endregion
+		
+		#region TestMember/TestStatement/TestExpression
+		string IndentAllLines(string code)
+		{
+			StringBuilder b = new StringBuilder();
+			using (StringReader r = new StringReader(code)) {
+				string line;
+				while ((line = r.ReadLine()) != null) {
+					b.Append("  ");
+					b.AppendLine(line);
+				}
+			}
+			return b.ToString();
+		}
+		
+		void TestMemberCS2VB(string sourceCode, string expectedCode)
+		{
+			TestProgramCS2VB("using System;\n" +
+			                 "class MyClassName {\n" +
+			                 IndentAllLines(sourceCode) +
+			                 "}",
+			                 
+			                 "Imports System\n" +
+			                 "Class MyClassName\n" +
+			                 IndentAllLines(expectedCode) +
+			                 "End Class");
+		}
+		
+		void TestMemberVB2CS(string sourceCode, string expectedCode)
+		{
+			TestProgramVB2CS("Class MyClassName\n" +
+			                 IndentAllLines(sourceCode) +
+			                 "End Class",
+			                 
+			                 "using System;\n" +
+			                 "using Microsoft.VisualBasic;\n" +
+			                 "class MyClassName {\n" +
+			                 IndentAllLines(expectedCode) +
+			                 "}");
+		}
+		
+		void TestStatementsCS2VB(string sourceCode, string expectedCode)
+		{
+			TestMemberCS2VB("void T() {\n" +
+			                IndentAllLines(sourceCode) +
+			                "}",
+			                
+			                "Private Sub T()\n" +
+			                IndentAllLines(expectedCode) +
+			                "End Sub");
+		}
+		#endregion
+		
+		[Test]
+		public void RaiseEventCS2VB()
+		{
+			TestMemberCS2VB("public event EventHandler Click;" +
+			                "void T() { if (Click != null) { Click(this, EventArgs.Empty); } }",
+			                "Public Event Click As EventHandler\n" +
+			                "Private Sub T()\n" +
+			                "  RaiseEvent Click(Me, EventArgs.Empty)\n" +
+			                "End Sub");
+			
+			TestMemberCS2VB("public event EventHandler Click;" +
+			                "void T() { Click(this, EventArgs.Empty); }",
+			                "Public Event Click As EventHandler\n" +
+			                "Private Sub T()\n" +
+			                "  RaiseEvent Click(Me, EventArgs.Empty)\n" +
+			                "End Sub");
+		}
+		
+		[Test]
+		public void ReferenceEqualityAndValueEquality()
+		{
+			// Reference equality:
+			TestStatementsCS2VB("object a = new object();\n" +
+			                    "object b = new object();\n" +
+			                    "if (a == b) {\n" +
+			                    "}",
+			                    
+			                    "Dim a As New Object()\n" +
+			                    "Dim b As New Object()\n" +
+			                    "If a Is b Then\n" +
+			                    "End If");
+			
+			// Value type equality:
+			TestStatementsCS2VB("int a = 3;\n" +
+			                    "int b = 4;\n" +
+			                    "if (a == b) {\n" +
+			                    "}",
+			                    
+			                    "Dim a As Integer = 3\n" +
+			                    "Dim b As Integer = 4\n" +
+			                    "If a = b Then\n" +
+			                    "End If");
+			
+			// String equality:
+			TestStatementsCS2VB("string a = \"3\";\n" +
+			                    "string b = \"4\";\n" +
+			                    "if (a == b) {\n" +
+			                    "}",
+			                    
+			                    "Dim a As String = \"3\"\n" +
+			                    "Dim b As String = \"4\"\n" +
+			                    "If a = b Then\n" +
+			                    "End If");
+		}
+	}
+}

src/Main/Base/Test/ICSharpCode.SharpDevelop.Tests.csproj

@@ -49,6 +49,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="CodeConverterTests.cs" />
     <Compile Include="NRefactoryResolverTests.cs" />
     <Compile Include="ReflectionLayerTests.cs" />
     <Compile Include="GenericResolverTests.cs" />

src/Main/Base/Test/MemberLookupHelperTests.cs

@@ -7,6 +7,7 @@
 
 using System;
 using ICSharpCode.Core;
+using System.Collections.Generic;
 using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Dom;
 using NUnit.Framework;
@@ -27,20 +28,35 @@ namespace ICSharpCode.SharpDevelop.Tests
 			swf = r.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms");
 		}
 		
-		public IReturnType DictionaryRT {
+		IReturnType DictionaryRT {
 			get {
 				return new GetClassReturnType(msc, "System.Collections.Generic.Dictionary", 2);
 			}
 		}
 		
-		public IClass EnumerableClass {
+		IClass EnumerableClass {
 			get {
 				return msc.GetClass("System.Collections.Generic.IEnumerable", 1);
 			}
 		}
 		
+		ConstructedReturnType EnumerableOf(IReturnType element)
+		{
+			return new ConstructedReturnType(EnumerableClass.DefaultReturnType, new IReturnType[] { element });
+		}
+		
+		ConstructedReturnType IListOf(IReturnType element)
+		{
+			return new ConstructedReturnType(msc.GetClass("System.Collections.Generic.IList", 1).DefaultReturnType, new IReturnType[] { element });
+		}
+		
+		ConstructedReturnType ListOf(IReturnType element)
+		{
+			return new ConstructedReturnType(msc.GetClass("System.Collections.Generic.List", 1).DefaultReturnType, new IReturnType[] { element });
+		}
+		
 		[Test]
-		public void TypeParameterPassedToBaseClassTest()
+		public void TypeParameterPassedToBaseClassTestDictionary()
 		{
 			IReturnType[] stringInt = { msc.SystemTypes.String, msc.SystemTypes.Int32 };
 			IReturnType rrt = new ConstructedReturnType(DictionaryRT, stringInt);
@@ -51,6 +67,74 @@ namespace ICSharpCode.SharpDevelop.Tests
 			Assert.AreEqual("System.Int32", resc.TypeArguments[1].FullyQualifiedName);
 		}
 		
+		[Test]
+		public void TypeParameterPassedToBaseClassTestString()
+		{
+			IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(msc.SystemTypes.String, EnumerableClass, 0);
+			Assert.AreEqual("System.Char", res.FullyQualifiedName);
+		}
+		
+		DefaultClass CreateClassDerivingFromListOfString()
+		{
+			DefaultProjectContent dpc = new DefaultProjectContent();
+			dpc.ReferencedContents.Add(msc);
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(dpc);
+			cu.Usings.Add(new DefaultUsing(dpc, new DomRegion(1,1, 5,5)));
+			cu.Usings[0].Usings.Add("System.Collections.Generic");
+			
+			DefaultClass listDerivingClass = new DefaultClass(cu, "DerivesFromList");
+			cu.Classes.Add(listDerivingClass);
+			listDerivingClass.BaseTypes.Add(new ConstructedReturnType(new SearchClassReturnType(dpc, listDerivingClass, 3, 1,
+			                                                                                    "List", 1),
+			                                                          new IReturnType[] {
+			                                                          	new GetClassReturnType(dpc, "System.String", 0)
+			                                                          }));
+			
+			return listDerivingClass;
+		}
+		
+		DefaultClass CreateGenericClassDerivingFromList()
+		{
+			DefaultProjectContent dpc = new DefaultProjectContent();
+			dpc.ReferencedContents.Add(msc);
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(dpc);
+			cu.Usings.Add(new DefaultUsing(dpc, new DomRegion(1,1, 5,5)));
+			cu.Usings[0].Usings.Add("System.Collections.Generic");
+			
+			DefaultClass listDerivingClass = new DefaultClass(cu, "DerivesFromList");
+			cu.Classes.Add(listDerivingClass);
+			listDerivingClass.TypeParameters.Add(new DefaultTypeParameter(listDerivingClass, "T", 0));
+			listDerivingClass.BaseTypes.Add(new ConstructedReturnType(new SearchClassReturnType(dpc, listDerivingClass, 3, 1,
+			                                                                                    "List", 1),
+			                                                          new IReturnType[] {
+			                                                          	new GenericReturnType(listDerivingClass.TypeParameters[0])
+			                                                          }));
+			return listDerivingClass;
+		}
+		
+		[Test]
+		public void TypeParameterPassedToBaseClassTestClassDerivingFromList()
+		{
+			DefaultClass listDerivingClass = CreateClassDerivingFromListOfString();
+			
+			IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(listDerivingClass.DefaultReturnType,
+			                                                                       EnumerableClass, 0);
+			Assert.AreEqual("System.String", res.FullyQualifiedName);
+		}
+		
+		[Test]
+		public void TypeParameterPassedToBaseClassTestGenericClassDerivingFromList()
+		{
+			DefaultClass listDerivingClass = CreateGenericClassDerivingFromList();
+			
+			ConstructedReturnType testType = new ConstructedReturnType(listDerivingClass.DefaultReturnType,
+			                                                           new IReturnType[] { msc.SystemTypes.String });
+			
+			IReturnType res = MemberLookupHelper.GetTypeParameterPassedToBaseClass(testType,
+			                                                                       EnumerableClass, 0);
+			Assert.AreEqual("System.String", res.FullyQualifiedName);
+		}
+		
 		[Test]
 		public void TypeParameterPassedToBaseClassSameClass()
 		{
@@ -68,5 +152,182 @@ namespace ICSharpCode.SharpDevelop.Tests
 			                                                   swf.GetClass("System.Windows.Forms.ToolStripSeparator").DefaultReturnType);
 			Assert.AreEqual("System.Windows.Forms.ToolStripItem", res.FullyQualifiedName);
 		}
+		
+		[Test]
+		public void GetTypeInheritanceTreeOfClassDerivingFromListOfString()
+		{
+			List<string> results = new List<IReturnType>(
+				MemberLookupHelper.GetTypeInheritanceTree(CreateClassDerivingFromListOfString().DefaultReturnType)
+			).ConvertAll<string>(delegate (IReturnType rt) { return rt.DotNetName; });
+			
+			results.Sort(); // order is not guaranteed, so sort for the unit test
+			
+			Assert.AreEqual("DerivesFromList;" +
+			                "System.Collections.Generic.ICollection{System.String};" +
+			                "System.Collections.Generic.IEnumerable{System.String};" +
+			                "System.Collections.Generic.IList{System.String};" +
+			                "System.Collections.Generic.List{System.String};" +
+			                "System.Collections.ICollection;" +
+			                "System.Collections.IEnumerable;" +
+			                "System.Collections.IList;" +
+			                "System.Object",
+			                string.Join(";", results.ToArray()));
+		}
+		
+		[Test]
+		public void GetTypeInheritanceTreeOfStringArray()
+		{
+			List<string> results = new List<IReturnType>(
+				MemberLookupHelper.GetTypeInheritanceTree(new ArrayReturnType(msc, msc.SystemTypes.String, 1))
+			).ConvertAll<string>(delegate (IReturnType rt) { return rt.DotNetName; });
+			
+			results.Sort(); // order is not guaranteed, so sort for the unit test
+			
+			Assert.AreEqual("System.Collections.Generic.ICollection{System.String};" +
+			                "System.Collections.Generic.IEnumerable{System.String};" +
+			                "System.Collections.Generic.IList{System.String};" +
+			                "System.Collections.ICollection;" +
+			                "System.Collections.IEnumerable;" +
+			                "System.Collections.IList;" +
+			                "System.Object;" +
+			                "System.String[]",
+			                string.Join(";", results.ToArray()));
+		}
+		
+		[Test]
+		public void ConversionExistsFromStringArrayToObjectArray()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(new ArrayReturnType(msc, msc.SystemTypes.String, 1),
+			                                                  new ArrayReturnType(msc, msc.SystemTypes.Object, 1)));
+		}
+		
+		[Test]
+		public void NoConversionExistsFromObjectArrayToStringArray()
+		{
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(new ArrayReturnType(msc, msc.SystemTypes.Object, 1),
+			                                                   new ArrayReturnType(msc, msc.SystemTypes.String, 1)));
+		}
+		
+		[Test]
+		public void ConversionExistsFromStringArrayToStringEnumerable()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(new ArrayReturnType(msc, msc.SystemTypes.String, 1),
+			                                                  EnumerableOf(msc.SystemTypes.String)));
+		}
+		
+		[Test]
+		public void NoConversionExistsFromStringEnumerableToObjectEnumerable()
+		{
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(EnumerableOf(msc.SystemTypes.String),
+			                                                   EnumerableOf(msc.SystemTypes.Object)));
+		}
+		
+		[Test]
+		public void ConversionExistsFromStringIListToStringEnumerable()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(IListOf(msc.SystemTypes.String),
+			                                                  EnumerableOf(msc.SystemTypes.String)));
+		}
+		
+		[Test]
+		public void NoConversionExistsFromStringIListToIntEnumerable()
+		{
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(IListOf(msc.SystemTypes.String),
+			                                                   EnumerableOf(msc.SystemTypes.Int32)));
+		}
+		
+		[Test]
+		public void ConversionExistsFromStringListToStringEnumerable()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(ListOf(msc.SystemTypes.String),
+			                                                  EnumerableOf(msc.SystemTypes.String)));
+		}
+		
+		[Test]
+		public void ConversionExistsFromClassDerivingFromListOfStringToStringEnumerable()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(CreateClassDerivingFromListOfString().DefaultReturnType,
+			                                                  EnumerableOf(msc.SystemTypes.String)));
+		}
+		
+		[Test]
+		public void ConversionExistsFromClassDerivingFromListOfStringToListOfString()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(CreateClassDerivingFromListOfString().DefaultReturnType,
+			                                                  ListOf(msc.SystemTypes.String)));
+		}
+		
+		GenericReturnType CreateT()
+		{
+			DefaultProjectContent dpc = new DefaultProjectContent();
+			dpc.ReferencedContents.Add(msc);
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(dpc);
+			DefaultClass c = new DefaultClass(cu, "DummyClass");
+			cu.Classes.Add(c);
+			DefaultMethod m = new DefaultMethod(c, "DummyMethod");
+			c.Methods.Add(m);
+			m.TypeParameters.Add(new DefaultTypeParameter(m, "T", 0));
+			return new GenericReturnType(m.TypeParameters[0]);
+		}
+		
+		GenericReturnType CreateTWithDisposableConstraint()
+		{
+			GenericReturnType rt = CreateT();
+			rt.TypeParameter.Constraints.Add(msc.GetClass("System.IDisposable").DefaultReturnType);
+			return rt;
+		}
+		
+		[Test]
+		public void StringIsApplicableOnT()
+		{
+			// no conversion exists
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.SystemTypes.String,
+			                                                   CreateT()));
+			
+			// but it is applicable
+			Assert.IsTrue(MemberLookupHelper.IsApplicable(msc.SystemTypes.String,
+			                                              CreateT()));
+		}
+		
+		[Test]
+		public void NoConversionExistsFromStringToDisposableT()
+		{
+			Assert.IsFalse(MemberLookupHelper.IsApplicable(msc.SystemTypes.String,
+			                                               CreateTWithDisposableConstraint()));
+			
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.SystemTypes.String,
+			                                                   CreateTWithDisposableConstraint()));
+		}
+		
+		[Test]
+		public void DisposableClassIsApplicableOnDisposableT()
+		{
+			Assert.IsFalse(MemberLookupHelper.ConversionExists(msc.GetClass("System.CharEnumerator").DefaultReturnType,
+			                                                   CreateTWithDisposableConstraint()));
+			
+			Assert.IsTrue(MemberLookupHelper.IsApplicable(msc.GetClass("System.CharEnumerator").DefaultReturnType,
+			                                              CreateTWithDisposableConstraint()));
+		}
+		
+		[Test]
+		public void ConversionExistsFromListOfStringToListOfT()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(ListOf(msc.SystemTypes.String),
+			                                                  ListOf(CreateT())));
+		}
+		
+		[Test]
+		public void ConversionExistsFromListOfStringToIEnumerableOfT()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(ListOf(msc.SystemTypes.String),
+			                                                  EnumerableOf(CreateT())));
+		}
+		
+		[Test]
+		public void ConversionExistsFromArrayOfStringToIListOfT()
+		{
+			Assert.IsTrue(MemberLookupHelper.ConversionExists(new ArrayReturnType(msc, msc.SystemTypes.String, 1),
+			                                                  IListOf(CreateT())));
+		}
 	}
 }

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -106,7 +106,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			ResolveResult rr = Resolve(program, expression, line);
 			Assert.IsNotNull(rr, "Resolve returned null");
-			Assert.IsTrue(rr is T, "result is " + typeof(T).Name);
+			Assert.AreEqual(typeof(T), rr.GetType());
 			return (T)rr;
 		}
 		
@@ -114,7 +114,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			ResolveResult rr = ResolveVB(program, expression, line);
 			Assert.IsNotNull(rr, "Resolve returned null");
-			Assert.IsTrue(rr is T, "result is " + typeof(T).Name);
+			Assert.AreEqual(typeof(T), rr.GetType());
 			return (T)rr;
 		}
 		#endregion
@@ -204,50 +204,6 @@ End Module
 		#endregion
 		
 		#region Simple Tests
-		const string arrayListConflictProgram = @"using System.Collections;
-class A {
-	void Test() {
-		
-	}
-	
-	ArrayList arrayList;
-	public ArrayList ArrayList {
-		get {
-			return arrayList;
-		}
-	}
-}
-";
-		
-		[Test]
-		public void PropertyTypeConflictTest()
-		{
-			ResolveResult result = Resolve<MemberResolveResult>(arrayListConflictProgram, "arrayList", 4);
-			Assert.AreEqual("System.Collections.ArrayList", result.ResolvedType.FullyQualifiedName);
-		}
-		
-		[Test]
-		public void PropertyTypeConflictCompletionResultTest()
-		{
-			ResolveResult result = Resolve(arrayListConflictProgram, "ArrayList", 4);
-			// CC should offer both static and non-static results
-			ArrayList list = result.GetCompletionData(lastPC);
-			bool ok = false;
-			foreach (object o in list) {
-				IMethod method = o as IMethod;
-				if (method != null && method.Name == "AddRange")
-					ok = true;
-			}
-			Assert.IsTrue(ok, "AddRange should exist");
-			ok = false;
-			foreach (object o in list) {
-				IMethod method = o as IMethod;
-				if (method != null && method.Name == "Adapter")
-					ok = true;
-			}
-			Assert.IsTrue(ok, "Adapter should exist");
-		}
-		
 		[Test]
 		public void InheritedInterfaceResolveTest()
 		{
@@ -615,6 +571,23 @@ class TestClass {
 			lr = Resolve<LocalResolveResult>(program, "i", 8);
 			Assert.AreEqual("System.Int64", lr.ResolvedType.FullyQualifiedName);
 		}
+		
+		[Test]
+		public void ShortMaxValueTest()
+		{
+			string program = @"using System;
+class TestClass {
+	void Test() {
+		
+	}
+}
+";
+			ResolveResult rr = Resolve<MemberResolveResult>(program, "short.MaxValue", 4);
+			Assert.AreEqual("System.Int16", rr.ResolvedType.FullyQualifiedName);
+			
+			rr = Resolve<ResolveResult>(program, "(short.MaxValue)", 4);
+			Assert.AreEqual("System.Int16", rr.ResolvedType.FullyQualifiedName);
+		}
 		#endregion
 		
 		#region Import namespace tests
@@ -931,6 +904,50 @@ class B {
 		#endregion
 		
 		#region MixedType tests
+		const string arrayListMixedTypeProgram = @"using System.Collections;
+class A {
+	void Test() {
+		
+	}
+	
+	ArrayList arrayList;
+	public ArrayList ArrayList {
+		get {
+			return arrayList;
+		}
+	}
+}
+";
+		
+		[Test]
+		public void PropertyTypeConflictTest()
+		{
+			ResolveResult result = Resolve<MemberResolveResult>(arrayListMixedTypeProgram, "arrayList", 4);
+			Assert.AreEqual("System.Collections.ArrayList", result.ResolvedType.FullyQualifiedName);
+		}
+		
+		[Test]
+		public void PropertyTypeConflictCompletionResultTest()
+		{
+			ResolveResult result = Resolve(arrayListMixedTypeProgram, "ArrayList", 4);
+			// CC should offer both static and non-static results
+			ArrayList list = result.GetCompletionData(lastPC);
+			bool ok = false;
+			foreach (object o in list) {
+				IMethod method = o as IMethod;
+				if (method != null && method.Name == "AddRange")
+					ok = true;
+			}
+			Assert.IsTrue(ok, "AddRange should exist");
+			ok = false;
+			foreach (object o in list) {
+				IMethod method = o as IMethod;
+				if (method != null && method.Name == "Adapter")
+					ok = true;
+			}
+			Assert.IsTrue(ok, "Adapter should exist");
+		}
+		
 		const string mixedTypeTestProgram = @"using System;
 class A {
 	void TestMethod() {

src/Main/Base/Test/OverloadFinding.cs

@@ -43,7 +43,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		{
 			string[] overloads = {"<T>(T a)", "(int a)"};
 			Test("(1)", 1, overloads);
-			Test("(short.MaxValue)", 1, overloads);
+			Test("(short.MaxValue)", 0, overloads);
 			Test("(long.MaxValue)", 0, overloads);
 		}
 		

src/Main/ICSharpCode.SharpDevelop.Dom/Project/ICSharpCode.SharpDevelop.Dom.csproj

@@ -65,6 +65,7 @@
     <Compile Include="Src\Implementations\CombinedReturnType.cs" />
     <Compile Include="Src\Implementations\CompoundClass.cs" />
     <Compile Include="Src\Implementations\ConstructedReturnType.cs" />
+    <Compile Include="Src\Implementations\DecoratingReturnType.cs" />
     <Compile Include="Src\Implementations\DefaultAttribute.cs" />
     <Compile Include="Src\Implementations\DefaultClass.cs" />
     <Compile Include="Src\Implementations\DefaultComment.cs" />
@@ -77,6 +78,7 @@
     <Compile Include="Src\Implementations\DefaultReturnType.cs" />
     <Compile Include="Src\Implementations\DefaultTypeParameter.cs" />
     <Compile Include="Src\Implementations\DefaultUsing.cs" />
+    <Compile Include="Src\Implementations\ElementReturnType.cs" />
     <Compile Include="Src\Implementations\GenericReturnType.cs" />
     <Compile Include="Src\Implementations\GetClassReturnType.cs" />
     <Compile Include="Src\Implementations\NullReturnType.cs" />
@@ -84,6 +86,8 @@
     <Compile Include="Src\Implementations\SearchClassReturnType.cs" />
     <Compile Include="Src\Implementations\SystemTypes.cs" />
     <Compile Include="Src\Interfaces\ExplicitInterfaceImplementation.cs" />
+    <Compile Include="Src\NRefactoryResolver\CSharpToVBNetConvertVisitor.cs" />
+    <Compile Include="Src\NRefactoryResolver\InferredReturnType.cs" />
     <Compile Include="Src\NRefactoryResolver\NRefactoryASTConvertVisitor.cs" />
     <Compile Include="Src\NRefactoryResolver\NRefactoryInformationProvider.cs" />
     <Compile Include="Src\NRefactoryResolver\NRefactoryResolver.cs" />

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CSharp/CSharpAmbience.cs

@@ -406,6 +406,8 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			builder.Append("(");
 			if (IncludeHTMLMarkup) builder.Append("<br>");
 			
+			if (m.IsExtensionMethod) builder.Append("this ");
+			
 			for (int i = 0; i < m.Parameters.Count; ++i) {
 				if (IncludeHTMLMarkup) builder.Append("&nbsp;&nbsp;&nbsp;");
 				builder.Append(Convert(m.Parameters[i]));

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/AbstractReturnType.cs

@@ -27,11 +27,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public override bool Equals(object o)
+		public virtual bool Equals(IReturnType other)
 		{
-			IReturnType rt = o as IReturnType;
-			if (rt == null) return false;
-			return rt.IsDefaultReturnType && this.FullyQualifiedName == rt.FullyQualifiedName && this.TypeParameterCount == rt.TypeParameterCount;
+			if (other == null)
+				return false;
+			return other.IsDefaultReturnType && this.FullyQualifiedName == other.FullyQualifiedName && this.TypeParameterCount == other.TypeParameterCount;
+		}
+		
+		public sealed override bool Equals(object o)
+		{
+			return Equals(o as IReturnType);
 		}
 		
 		public override int GetHashCode()
@@ -92,7 +97,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		public virtual ArrayReturnType CastToArrayReturnType()
 		{
-			throw new InvalidCastException("Cannot cast " + ToString() + " to expected type.");
+			return null;
 		}
 		
 		public virtual bool IsGenericReturnType {
@@ -102,7 +107,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		public virtual GenericReturnType CastToGenericReturnType()
 		{
-			throw new InvalidCastException("Cannot cast " + ToString() + " to expected type.");
+			return null;
 		}
 		
 		public virtual bool IsConstructedReturnType {
@@ -112,7 +117,17 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		public virtual ConstructedReturnType CastToConstructedReturnType()
 		{
-			throw new InvalidCastException("Cannot cast " + ToString() + " to expected type.");
+			return null;
+		}
+		
+		public bool IsDecoratingReturnType<T>() where T : DecoratingReturnType
+		{
+			return false;
+		}
+		
+		public T CastToDecoratingReturnType<T>() where T : DecoratingReturnType
+		{
+			return null;
 		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/AnonymousMethodReturnType.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// <summary>
 	/// The return type of anonymous method expressions or lambda expressions.
 	/// </summary>
-	public sealed class AnonymousMethodReturnType : ProxyReturnType
+	public sealed class AnonymousMethodReturnType : DecoratingReturnType
 	{
 		IReturnType returnType;
 		IList<IParameter> parameters = new List<IParameter>();
@@ -25,6 +25,28 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.cu = cu;
 		}
 		
+		public override bool Equals(IReturnType other)
+		{
+			if (other == null) return false;
+			AnonymousMethodReturnType o = other.CastToDecoratingReturnType<AnonymousMethodReturnType>();
+			if (o == null) return false;
+			return this.FullyQualifiedName == o.FullyQualifiedName;
+		}
+		
+		public override int GetHashCode()
+		{
+			return this.FullyQualifiedName.GetHashCode();
+		}
+		
+		public override T CastToDecoratingReturnType<T>()
+		{
+			if (typeof(T) == typeof(AnonymousMethodReturnType)) {
+				return (T)(object)this;
+			} else {
+				return null;
+			}
+		}
+		
 		/// <summary>
 		/// Return type of the anonymous method. Can be null if inferred from context.
 		/// </summary>
@@ -50,12 +72,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public override bool IsDefaultReturnType {
-			get {
-				return false;
-			}
-		}
-		
 		volatile DefaultClass cachedClass;
 		
 		public override IClass GetUnderlyingClass()

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ArrayReturnType.cs

@@ -17,7 +17,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// The element type is only used as return type for the indexer; all methods and fields
 	/// are retrieved from System.Array.
 	/// </summary>
-	public sealed class ArrayReturnType : ProxyReturnType
+	public sealed class ArrayReturnType : DecoratingReturnType
 	{
 		IReturnType elementType;
 		int dimensions;
@@ -42,9 +42,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.dimensions = dimensions;
 		}
 		
-		public override bool Equals(object o)
+		public override bool Equals(IReturnType rt)
 		{
-			IReturnType rt = o as IReturnType;
 			if (rt == null || !rt.IsArrayReturnType) return false;
 			ArrayReturnType art = rt.CastToArrayReturnType();
 			if (art.ArrayDimensions != dimensions) return false;
@@ -58,6 +57,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override T CastToDecoratingReturnType<T>()
+		{
+			if (typeof(T) == typeof(ArrayReturnType)) {
+				return (T)(object)this;
+			} else {
+				return null;
+			}
+		}
+		
 		public IReturnType ArrayElementType {
 			get {
 				return elementType;
@@ -136,34 +144,5 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			return String.Format("[ArrayReturnType: {0}, dimensions={1}]", elementType, AppendArrayString(""));
 		}
-		
-		public override bool IsDefaultReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsArrayReturnType {
-			get {
-				return true;
-			}
-		}
-		
-		public override ArrayReturnType CastToArrayReturnType()
-		{
-			return this;
-		}
-		
-		public override bool IsConstructedReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsGenericReturnType {
-			get {
-				return false;
-			}
-		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/CombinedReturnType.cs

@@ -22,7 +22,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		string @namespace;
 		string dotnetName;
 		
-		public override bool Equals(object obj)
+		public override bool Equals(IReturnType obj)
 		{
 			CombinedReturnType combined = obj as CombinedReturnType;
 			if (combined == null) return false;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ConstructedReturnType.cs

@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// collection.
 	/// Example: List<string>
 	/// </summary>
-	public sealed class ConstructedReturnType : ProxyReturnType
+	public sealed class ConstructedReturnType : DecoratingReturnType
 	{
 		// Return types that should be substituted for the generic types
 		// If a substitution is unknown (type could not be resolved), the list
@@ -42,11 +42,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.baseType = baseType;
 		}
 		
-		public override bool Equals(object o)
+		public override T CastToDecoratingReturnType<T>()
 		{
-			IReturnType rt = o as IReturnType;
-			if (rt == null) return false;
-			return this.DotNetName == rt.DotNetName;
+			if (typeof(T) == typeof(ConstructedReturnType)) {
+				return (T)(object)this;
+			} else {
+				return null;
+			}
+		}
+		
+		public override bool Equals(IReturnType rt)
+		{
+			return rt != null
+				&& rt.IsConstructedReturnType
+				&& this.DotNetName == rt.DotNetName;
 		}
 		
 		public override int GetHashCode()
@@ -235,34 +244,5 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			return r + ">]";
 		}
-		
-		public override bool IsDefaultReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsArrayReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsConstructedReturnType {
-			get {
-				return true;
-			}
-		}
-		
-		public override ConstructedReturnType CastToConstructedReturnType()
-		{
-			return this;
-		}
-		
-		public override bool IsGenericReturnType {
-			get {
-				return false;
-			}
-		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DecoratingReturnType.cs

@@ -0,0 +1,28 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// A return type that modifies the base return type and is not regarded equal to its base type.
+	/// </summary>
+	public abstract class DecoratingReturnType : ProxyReturnType
+	{
+		public abstract override bool Equals(IReturnType other);
+		public abstract override int GetHashCode();
+		
+		public sealed override bool IsDefaultReturnType {
+			get {
+				return false;
+			}
+		}
+		
+		public abstract override T CastToDecoratingReturnType<T>();
+	}
+}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultClass.cs

@@ -317,7 +317,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 					if (typesToVisit.Count > 0) {
 						nextType = typesToVisit.Dequeue();
 					} else {
-						nextType = enqueuedLastBaseType ? null : GetBaseTypeByClassType();
+						nextType = enqueuedLastBaseType ? null : GetBaseTypeByClassType(this);
 						enqueuedLastBaseType = true;
 					}
 					if (nextType != null) {
@@ -357,28 +357,28 @@ namespace ICSharpCode.SharpDevelop.Dom
 					}
 				}
 				if (cachedBaseType == null) {
-					return GetBaseTypeByClassType();
+					return GetBaseTypeByClassType(this);
 				} else {
 					return cachedBaseType;
 				}
 			}
 		}
 		
-		IReturnType GetBaseTypeByClassType()
+		internal static IReturnType GetBaseTypeByClassType(IClass c)
 		{
-			switch (ClassType) {
+			switch (c.ClassType) {
 				case ClassType.Class:
 				case ClassType.Interface:
-					if (FullyQualifiedName != "System.Object") {
-						return this.ProjectContent.SystemTypes.Object;
+					if (c.FullyQualifiedName != "System.Object") {
+						return c.ProjectContent.SystemTypes.Object;
 					}
 					break;
 				case ClassType.Enum:
-					return this.ProjectContent.SystemTypes.Enum;
+					return c.ProjectContent.SystemTypes.Enum;
 				case ClassType.Delegate:
-					return this.ProjectContent.SystemTypes.Delegate;
+					return c.ProjectContent.SystemTypes.Delegate;
 				case ClassType.Struct:
-					return this.ProjectContent.SystemTypes.ValueType;
+					return c.ProjectContent.SystemTypes.ValueType;
 			}
 			return null;
 		}
@@ -390,20 +390,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 					if (baseClass != null && baseClass.ClassType == this.ClassType)
 						return baseClass;
 				}
-				switch (ClassType) {
-					case ClassType.Class:
-						if (FullyQualifiedName != "System.Object") {
-							return this.ProjectContent.SystemTypes.Object.GetUnderlyingClass();
-						}
-						break;
-					case ClassType.Enum:
-						return this.ProjectContent.SystemTypes.Enum.GetUnderlyingClass();
-					case ClassType.Delegate:
-						return this.ProjectContent.SystemTypes.Delegate.GetUnderlyingClass();
-					case ClassType.Struct:
-						return this.ProjectContent.SystemTypes.ValueType.GetUnderlyingClass();
-				}
-				return null;
+				IReturnType defaultBaseType = GetBaseTypeByClassType(this);
+				if (defaultBaseType != null)
+					return defaultBaseType.GetUnderlyingClass();
+				else
+					return null;
 			}
 		}
 		

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultUsing.cs

@@ -63,8 +63,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			if (HasAliases) {
 				foreach (KeyValuePair<string, IReturnType> entry in aliases) {
-					if (!entry.Value.IsDefaultReturnType)
-						continue;
 					string aliasString = entry.Key;
 					string nsName;
 					if (projectContent.Language.NameComparer.Equals(partialNamespaceName, aliasString)) {
@@ -104,7 +102,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				foreach (KeyValuePair<string, IReturnType> entry in aliases) {
 					string aliasString = entry.Key;
 					if (projectContent.Language.NameComparer.Equals(partialTypeName, aliasString)) {
-						if (entry.Value.IsDefaultReturnType && entry.Value.GetUnderlyingClass() == null)
+						if (entry.Value.GetUnderlyingClass() == null)
 							continue; // type not found, maybe entry was a namespace
 						yield return entry.Value;
 					}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ElementReturnType.cs

@@ -0,0 +1,52 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// The type reference that is the element of an enumerable.
+	/// This class is used in combination with an InferredReturnType to
+	/// represent the implicitly typed loop variable <c>v</c> in
+	/// "<c>foreach (var v in enumerableInstance) {}</c>"
+	/// </summary>
+	public class ElementReturnType : ProxyReturnType
+	{
+		IReturnType enumerableType;
+		IProjectContent pc;
+		
+		public ElementReturnType(IProjectContent pc, IReturnType enumerableType)
+		{
+			if (pc == null)
+				throw new ArgumentNullException("pc");
+			this.enumerableType = enumerableType;
+			this.pc = pc;
+		}
+		
+		public override IReturnType BaseType {
+			get {
+				// get element type from enumerableType
+				if (enumerableType.IsArrayReturnType)
+					return enumerableType.CastToArrayReturnType().ArrayElementType;
+				
+				IClass c = enumerableType.GetUnderlyingClass();
+				if (c == null)
+					return null;
+				IClass genumerable = pc.GetClass("System.Collections.Generic.IEnumerable", 1);
+				if (c.IsTypeInInheritanceTree(genumerable)) {
+					return MemberLookupHelper.GetTypeParameterPassedToBaseClass(enumerableType, genumerable, 0);
+				}
+				IClass enumerable = pc.GetClass("System.Collections.IEnumerable", 0);
+				if (c.IsTypeInInheritanceTree(enumerable)) {
+					return pc.SystemTypes.Object;
+				}
+				return null;
+			}
+		}
+	}
+}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/GenericReturnType.cs

@@ -13,7 +13,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// <summary>
 	/// GenericReturnType is a reference to a type parameter.
 	/// </summary>
-	public sealed class GenericReturnType : ProxyReturnType
+	public sealed class GenericReturnType : DecoratingReturnType
 	{
 		ITypeParameter typeParameter;
 		
@@ -23,14 +23,22 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public override bool Equals(object o)
+		public override bool Equals(IReturnType rt)
 		{
-			IReturnType rt = o as IReturnType;
 			if (rt == null || !rt.IsGenericReturnType)
 				return false;
 			return typeParameter.Equals(rt.CastToGenericReturnType().typeParameter);
 		}
 		
+		public override T CastToDecoratingReturnType<T>()
+		{
+			if (typeof(T) == typeof(GenericReturnType)) {
+				return (T)(object)this;
+			} else {
+				return null;
+			}
+		}
+		
 		public override int GetHashCode()
 		{
 			return typeParameter.GetHashCode();
@@ -107,34 +115,5 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			return String.Format("[GenericReturnType: {0}]", typeParameter);
 		}
-		
-		public override bool IsDefaultReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsArrayReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsConstructedReturnType {
-			get {
-				return false;
-			}
-		}
-		
-		public override bool IsGenericReturnType {
-			get {
-				return true;
-			}
-		}
-		
-		public override ICSharpCode.SharpDevelop.Dom.GenericReturnType CastToGenericReturnType()
-		{
-			return this;
-		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/GetClassReturnType.cs

@@ -39,17 +39,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public override bool Equals(object o)
+		public override bool Equals(IReturnType o)
 		{
 			GetClassReturnType rt = o as GetClassReturnType;
-			if (rt == null) {
-				IReturnType rt2 = o as IReturnType;
-				if (rt2 != null && rt2.IsDefaultReturnType)
-					return rt2.FullyQualifiedName == fullName && rt2.TypeParameterCount == this.TypeParameterCount;
-				else
-					return false;
+			if (rt != null) {
+				return fullName == rt.fullName && typeParameterCount == rt.typeParameterCount && content == rt.content;
 			}
-			return fullName == rt.fullName && typeParameterCount == rt.typeParameterCount && content == rt.content;
+			return base.Equals(o);
 		}
 		
 		public override int GetHashCode()

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/NullReturnType.cs

@@ -15,7 +15,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		public static readonly NullReturnType Instance = new NullReturnType();
 		
-		public override bool Equals(object o)
+		public override bool Equals(IReturnType o)
 		{
 			return o is NullReturnType;
 		}