ResolveVisitor: use explicit interface implementation of IDomVisitor.

Demo App: use NodeListResolveVisitorNavigator to resolve only the currently selected node.

ICSharpCode.NRefactory.Demo/MainForm.cs

@@ -55,6 +55,16 @@ namespace ICSharpCode.NRefactory.Demo
 		}
 		
 		TreeNode MakeTreeNode(INode node)
+		{
+			TreeNode t = new TreeNode(GetNodeTitle(node));
+			t.Tag = node;
+			foreach (INode child in node.Children) {
+				t.Nodes.Add(MakeTreeNode(child));
+			}
+			return t;
+		}
+		
+		string GetNodeTitle(INode node)
 		{
 			StringBuilder b = new StringBuilder();
 			b.Append(DecodeRole(node.Role, node.Parent != null ? node.Parent.GetType() : null));
@@ -81,12 +91,7 @@ namespace ICSharpCode.NRefactory.Demo
 			}
 			if (hasProperties)
 				b.Append(")");
-			TreeNode t = new TreeNode(b.ToString());
-			t.Tag = node;
-			foreach (INode child in node.Children) {
-				t.Nodes.Add(MakeTreeNode(child));
-			}
-			return t;
+			return b.ToString();
 		}
 		
 		string DecodeRole(int role, Type type)
@@ -179,7 +184,6 @@ namespace ICSharpCode.NRefactory.Demo
 		
 		void ResolveButtonClick(object sender, EventArgs e)
 		{
-			resolveButton.Enabled = false;
 			SimpleProjectContent project = new SimpleProjectContent();
 			TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(project, "dummy.cs");
 			convertVisitor.VisitCompilationUnit(compilationUnit, null);
@@ -192,9 +196,15 @@ namespace ICSharpCode.NRefactory.Demo
 			
 			CSharpResolver resolver = new CSharpResolver(context);
 			
-			ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile);
-			visitor.VisitCompilationUnit(compilationUnit, null);
+			IResolveVisitorNavigator navigator = null;
+			if (csharpTreeView.SelectedNode != null) {
+				navigator = new NodeListResolveVisitorNavigator(new[] { (INode)csharpTreeView.SelectedNode.Tag });
+			}
+			ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile, navigator);
+			visitor.Scan(compilationUnit);
+			csharpTreeView.BeginUpdate();
 			ShowResolveResultsInTree(csharpTreeView.Nodes, visitor);
+			csharpTreeView.EndUpdate();
 		}
 		
 		void ShowResolveResultsInTree(TreeNodeCollection c, ResolveVisitor v)
@@ -204,7 +214,9 @@ namespace ICSharpCode.NRefactory.Demo
 				if (node != null) {
 					ResolveResult rr = v.GetResolveResult(node);
 					if (rr != null)
-						t.Text += " " + rr.ToString();
+						t.Text = GetNodeTitle(node) + " " + rr.ToString();
+					else
+						t.Text = GetNodeTitle(node);
 				}
 				ShowResolveResultsInTree(t.Nodes, v);
 			}

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	/// Moreover, there is the <c>ResolveAll</c> mode - it works similar to resolving mode, but will not switch back to scanning mode.
 	/// The whole subtree will be resolved without notifying the navigator.
 	/// </remarks>
-	public class ResolveVisitor : AbstractDomVisitor<object, ResolveResult>
+	public sealed class ResolveVisitor : IDomVisitor<object, ResolveResult>
 	{
 		static readonly ResolveResult errorResult = new ErrorResolveResult(SharedTypes.UnknownType);
 		CSharpResolver resolver;
@@ -126,14 +126,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				Scan(child);
 			}
 		}
-		
-		protected override ResolveResult VisitChildren(INode node, object data)
-		{
-			ScanChildren(node);
-			return null;
-		}
 		#endregion
 		
+		#region GetResolveResult
 		/// <summary>
 		/// Gets the cached resolve result for the specified node.
 		/// Returns <c>null</c> if no cached result was found (e.g. if the node was not visited; or if it was visited in scanning mode).
@@ -146,9 +141,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			else
 				return null;
 		}
+		#endregion
 		
 		#region Track UsingScope
-		public override ResolveResult VisitCompilationUnit(CompilationUnit unit, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCompilationUnit(CompilationUnit unit, object data)
 		{
 			UsingScope previousUsingScope = resolver.UsingScope;
 			try {
@@ -161,7 +157,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
 		{
 			UsingScope previousUsingScope = resolver.UsingScope;
 			try {
@@ -177,14 +173,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region Track CurrentTypeDefinition
-		public override ResolveResult VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
+		ResolveResult VisitTypeOrDelegate(INode typeDeclaration)
 		{
 			ITypeDefinition previousTypeDefinition = resolver.CurrentTypeDefinition;
 			try {
 				ITypeDefinition newTypeDefinition = null;
 				if (resolver.CurrentTypeDefinition != null) {
 					foreach (ITypeDefinition innerClass in resolver.CurrentTypeDefinition.InnerClasses) {
-						if (innerClass.Region.IsInside(typeDeclaration.StartLocation.Line, typeDeclaration.StartLocation.Column)) {
+						if (innerClass.Region.IsInside(typeDeclaration.StartLocation)) {
 							newTypeDefinition = innerClass;
 							break;
 						}
@@ -200,10 +196,20 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				resolver.CurrentTypeDefinition = previousTypeDefinition;
 			}
 		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
+		{
+			return VisitTypeOrDelegate(typeDeclaration);
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
+		{
+			return VisitTypeOrDelegate(delegateDeclaration);
+		}
 		#endregion
 		
 		#region Track CurrentMember
-		public override ResolveResult VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
 		{
 			int initializerCount = fieldDeclaration.Variables.Count();
 			ResolveResult result = null;
@@ -227,7 +233,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return result;
 		}
 		
-		public override ResolveResult VisitVariableInitializer(VariableInitializer variableInitializer, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitVariableInitializer(VariableInitializer variableInitializer, object data)
 		{
 			ScanChildren(variableInitializer);
 			if (resolverEnabled) {
@@ -249,7 +255,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		ResolveResult VisitMethodMember(AbstractMemberBase member, object data)
+		ResolveResult VisitMethodMember(AbstractMemberBase member)
 		{
 			try {
 				if (resolver.CurrentTypeDefinition != null) {
@@ -267,27 +273,28 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
 		{
-			return VisitMethodMember(methodDeclaration, data);
+			return VisitMethodMember(methodDeclaration);
 		}
 		
-		public override ResolveResult VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
 		{
-			return VisitMethodMember(operatorDeclaration, data);
+			return VisitMethodMember(operatorDeclaration);
 		}
 		
-		public override ResolveResult VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
 		{
-			return VisitMethodMember(constructorDeclaration, data);
+			return VisitMethodMember(constructorDeclaration);
 		}
 		
-		public override ResolveResult VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data)
 		{
-			return VisitMethodMember(destructorDeclaration, data);
+			return VisitMethodMember(destructorDeclaration);
 		}
 		
-		public override ResolveResult VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
+		// handle properties/indexers
+		ResolveResult VisitPropertyMember(PropertyDeclaration propertyDeclaration)
 		{
 			try {
 				if (resolver.CurrentTypeDefinition != null) {
@@ -313,12 +320,17 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
+		{
+			return VisitPropertyMember(propertyDeclaration);
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 		{
-			return VisitPropertyDeclaration(indexerDeclaration, data);
+			return VisitPropertyMember(indexerDeclaration);
 		}
 		
-		public override ResolveResult VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
 		{
 			try {
 				if (resolver.CurrentTypeDefinition != null) {
@@ -343,7 +355,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
 		{
 			ScanChildren(parameterDeclaration);
 			if (resolverEnabled) {
@@ -360,10 +372,28 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return null;
 			}
 		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
+		{
+			try {
+				if (resolver.CurrentTypeDefinition != null) {
+					resolver.CurrentMember = resolver.CurrentTypeDefinition.Fields.FirstOrDefault(f => f.Region.IsInside(enumMemberDeclaration.StartLocation));
+				}
+				
+				ScanChildren(enumMemberDeclaration);
+				
+				if (resolverEnabled && resolver.CurrentMember != null)
+					return new MemberResolveResult(resolver.CurrentMember, resolver.CurrentMember.ReturnType.Resolve(resolver.Context));
+				else
+					return errorResult;
+			} finally {
+				resolver.CurrentMember = null;
+			}
+		}
 		#endregion
 		
 		#region Track CheckForOverflow
-		public override ResolveResult VisitCheckedExpression(CheckedExpression checkedExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCheckedExpression(CheckedExpression checkedExpression, object data)
 		{
 			bool oldCheckForOverflow = resolver.CheckForOverflow;
 			try {
@@ -379,7 +409,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data)
 		{
 			bool oldCheckForOverflow = resolver.CheckForOverflow;
 			try {
@@ -395,7 +425,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitCheckedStatement(CheckedStatement checkedStatement, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCheckedStatement(CheckedStatement checkedStatement, object data)
 		{
 			bool oldCheckForOverflow = resolver.CheckForOverflow;
 			try {
@@ -407,7 +437,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data)
 		{
 			bool oldCheckForOverflow = resolver.CheckForOverflow;
 			try {
@@ -432,23 +462,23 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return SharedTypes.UnknownType;
 		}
 		
-		public override ResolveResult VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public override ResolveResult VisitArgListExpression(ArgListExpression argListExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitArgListExpression(ArgListExpression argListExpression, object data)
 		{
 			ScanChildren(argListExpression);
 			return new ResolveResult(resolver.Context.GetClass(typeof(RuntimeArgumentHandle)) ?? SharedTypes.UnknownType);
 		}
 		
-		public override ResolveResult VisitArrayObjectCreateExpression(ArrayObjectCreateExpression arrayObjectCreateExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitArrayObjectCreateExpression(ArrayObjectCreateExpression arrayObjectCreateExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public override ResolveResult VisitAsExpression(AsExpression asExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAsExpression(AsExpression asExpression, object data)
 		{
 			if (resolverEnabled) {
 				Scan(asExpression.Expression);
@@ -459,7 +489,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult left = Resolve(assignmentExpression.Left);
@@ -471,7 +501,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)
 		{
 			if (resolverEnabled) {
 				return resolver.ResolveBaseReference();
@@ -481,7 +511,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult left = Resolve(binaryOperatorExpression.Left);
@@ -493,7 +523,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitCastExpression(CastExpression castExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCastExpression(CastExpression castExpression, object data)
 		{
 			if (resolverEnabled) {
 				return resolver.ResolveCast(ResolveType(castExpression.CastTo), Resolve(castExpression.Expression));
@@ -503,7 +533,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
 		{
 			if (resolverEnabled) {
 				Scan(conditionalExpression.Condition);
@@ -515,7 +545,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
 		{
 			if (resolverEnabled) {
 				return new ConstantResolveResult(ResolveType(defaultValueExpression.TypeReference), null);
@@ -525,7 +555,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitDirectionExpression(DirectionExpression directionExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitDirectionExpression(DirectionExpression directionExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult rr = Resolve(directionExpression.Expression);
@@ -536,7 +566,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
 		{
 			if (resolverEnabled) {
 				// TODO: type arguments?
@@ -559,7 +589,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return arguments;
 		}
 		
-		public override ResolveResult VisitIndexerExpression(IndexerExpression indexerExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIndexerExpression(IndexerExpression indexerExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult target = Resolve(indexerExpression.Target);
@@ -572,7 +602,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitInvocationExpression(InvocationExpression invocationExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitInvocationExpression(InvocationExpression invocationExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult target = Resolve(invocationExpression.Target);
@@ -585,18 +615,18 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitIsExpression(IsExpression isExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIsExpression(IsExpression isExpression, object data)
 		{
 			ScanChildren(isExpression);
 			return new ResolveResult(TypeCode.Boolean.ToTypeReference().Resolve(resolver.Context));
 		}
 		
-		public override ResolveResult VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public override ResolveResult VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult target = Resolve(memberReferenceExpression.Target);
@@ -611,12 +641,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression, object data)
 		{
-			return resolver.ResolvePrimitive(null);
+			if (resolverEnabled) {
+				return resolver.ResolvePrimitive(null);
+			} else {
+				return null;
+			}
 		}
 		
-		public override ResolveResult VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
 		{
 			if (resolverEnabled) {
 				IType type = ResolveType(objectCreateExpression.Type);
@@ -629,7 +663,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
 		{
 			if (resolverEnabled) {
 				return Resolve(parenthesizedExpression.Expression);
@@ -639,17 +673,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data)
 		{
 			throw new NotImplementedException();
 		}
 		
-		public override ResolveResult VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
 		{
-			return resolver.ResolvePrimitive(primitiveExpression.Value);
+			if (resolverEnabled) {
+				return resolver.ResolvePrimitive(primitiveExpression.Value);
+			} else {
+				return null;
+			}
 		}
 		
-		public override ResolveResult VisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data)
 		{
 			if (resolverEnabled) {
 				return resolver.ResolveSizeOf(ResolveType(sizeOfExpression.Type));
@@ -659,7 +697,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data)
 		{
 			if (resolverEnabled) {
 				Scan(stackAllocExpression.CountExpression);
@@ -670,14 +708,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		public override ResolveResult VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
 		{
 			return resolver.ResolveThisReference();
 		}
 		
 		static readonly GetClassTypeReference systemType = new GetClassTypeReference("System.Type", 0);
 		
-		public override ResolveResult VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
 		{
 			ScanChildren(typeOfExpression);
 			if (resolverEnabled)
@@ -686,7 +724,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return null;
 		}
 		
-		public override ResolveResult VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
 		{
 			if (resolverEnabled) {
 				ResolveResult expr = Resolve(unaryOperatorExpression.Expression);
@@ -698,8 +736,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
-		#region Local Variable Scopes
-		public override ResolveResult VisitBlockStatement(BlockStatement blockStatement, object data)
+		#region Local Variable Scopes (Block Statements)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitBlockStatement(BlockStatement blockStatement, object data)
 		{
 			resolver.PushBlock();
 			ScanChildren(blockStatement);
@@ -707,7 +745,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return null;
 		}
 		
-		public override ResolveResult VisitUsingStatement(UsingStatement usingStatement, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUsingStatement(UsingStatement usingStatement, object data)
 		{
 			resolver.PushBlock();
 			ScanChildren(usingStatement);
@@ -715,21 +753,158 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return null;
 		}
 		
-		public override ResolveResult VisitForStatement(ForStatement forStatement, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitFixedStatement(FixedStatement fixedStatement, object data)
+		{
+			resolver.PushBlock();
+			ScanChildren(fixedStatement);
+			resolver.PopBlock();
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitForStatement(ForStatement forStatement, object data)
 		{
 			resolver.PushBlock();
 			ScanChildren(forStatement);
 			resolver.PopBlock();
 			return null;
 		}
+		
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitForeachStatement(ForeachStatement foreachStatement, object data)
+		{
+			resolver.PushBlock();
+			ITypeReference type = MakeTypeReference(foreachStatement.VariableType, foreachStatement.Expression, true);
+			ScanChildren(foreachStatement);
+			resolver.PopBlock();
+			return null;
+		}
+		#endregion
+		
+		#region Simple Statements (only ScanChildren)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
+		{
+			ScanChildren(expressionStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitBreakStatement(BreakStatement breakStatement, object data)
+		{
+			ScanChildren(breakStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitContinueStatement(ContinueStatement continueStatement, object data)
+		{
+			ScanChildren(continueStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitEmptyStatement(EmptyStatement emptyStatement, object data)
+		{
+			ScanChildren(emptyStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitGotoStatement(GotoStatement gotoStatement, object data)
+		{
+			ScanChildren(gotoStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIfElseStatement(IfElseStatement ifElseStatement, object data)
+		{
+			ScanChildren(ifElseStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitLabelStatement(LabelStatement labelStatement, object data)
+		{
+			ScanChildren(labelStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitLockStatement(LockStatement lockStatement, object data)
+		{
+			ScanChildren(lockStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitReturnStatement(ReturnStatement returnStatement, object data)
+		{
+			ScanChildren(returnStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitSwitchStatement(SwitchStatement switchStatement, object data)
+		{
+			ScanChildren(switchStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitSwitchSection(SwitchSection switchSection, object data)
+		{
+			ScanChildren(switchSection);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCaseLabel(CaseLabel caseLabel, object data)
+		{
+			ScanChildren(caseLabel);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitThrowStatement(ThrowStatement throwStatement, object data)
+		{
+			ScanChildren(throwStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)
+		{
+			ScanChildren(unsafeStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitWhileStatement(WhileStatement whileStatement, object data)
+		{
+			ScanChildren(whileStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitYieldStatement(YieldStatement yieldStatement, object data)
+		{
+			ScanChildren(yieldStatement);
+			return null;
+		}
+		#endregion
+		
+		#region Try / Catch
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
+		{
+			ScanChildren(tryCatchStatement);
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitCatchClause(CatchClause catchClause, object data)
+		{
+			resolver.PushBlock();
+			if (catchClause.VariableName != null) {
+				resolver.AddVariable(MakeTypeReference(catchClause.ReturnType, null, false), catchClause.VariableName);
+			}
+			ScanChildren(catchClause);
+			resolver.PopBlock();
+			return null;
+		}
 		#endregion
 		
 		#region VariableDeclarationStatement
-		public override ResolveResult VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
 		{
 			bool isConst = (variableDeclarationStatement.Modifiers & Modifiers.Const) != 0;
 			VariableInitializer firstInitializer = variableDeclarationStatement.Variables.FirstOrDefault();
-			ITypeReference type = MakeTypeReference(variableDeclarationStatement.ReturnType, firstInitializer != null ? firstInitializer.Initializer : null);
+			ITypeReference type = MakeTypeReference(variableDeclarationStatement.ReturnType,
+			                                        firstInitializer != null ? firstInitializer.Initializer : null,
+			                                        false);
 			
 			int initializerCount = variableDeclarationStatement.Variables.Count();
 			ResolveResult result = null;
@@ -760,10 +935,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Creates a type reference for the specified type node.
 		/// If the type node is 'var', performs type inference on the initializer expression.
 		/// </summary>
-		ITypeReference MakeTypeReference(INode type, INode initializerExpression)
+		ITypeReference MakeTypeReference(INode type, INode initializerExpression, bool isForEach)
 		{
 			if (initializerExpression != null && IsVar(type)) {
-				return new VarTypeReference(this, resolver.Clone(), initializerExpression);
+				return new VarTypeReference(this, resolver.Clone(), initializerExpression, isForEach);
 			} else {
 				return SharedTypes.UnknownType; // TODO
 			}
@@ -779,14 +954,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			ResolveVisitor visitor;
 			CSharpResolver storedContext;
 			INode initializerExpression;
+			bool isForEach;
 			
 			IType result;
 			
-			public VarTypeReference(ResolveVisitor visitor, CSharpResolver storedContext, INode initializerExpression)
+			public VarTypeReference(ResolveVisitor visitor, CSharpResolver storedContext, INode initializerExpression, bool isForEach)
 			{
 				this.visitor = visitor;
 				this.storedContext = storedContext;
 				this.initializerExpression = initializerExpression;
+				this.isForEach = isForEach;
 			}
 			
 			public IType Resolve(ITypeResolveContext context)
@@ -800,7 +977,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					visitor.mode = ResolveVisitorNavigationMode.Resolve;
 					visitor.resolver = storedContext;
 					
-					return result = visitor.Resolve(initializerExpression).Type;
+					result = visitor.Resolve(initializerExpression).Type;
+					
+					if (isForEach) {
+						result = GetElementType(result);
+					}
+					
+					return result;
 				} finally {
 					visitor.mode = oldMode;
 					visitor.resolver = oldResolver;
@@ -811,6 +994,24 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			}
 			
+			IType GetElementType(IType result)
+			{
+				foreach (IType baseType in result.GetAllBaseTypes(storedContext.Context)) {
+					ITypeDefinition baseTypeDef = baseType.GetDefinition();
+					if (baseTypeDef != null && baseTypeDef.Name == "IEnumerable") {
+						if (baseTypeDef.Namespace == "System.Collections.Generic" && baseTypeDef.TypeParameterCount == 1) {
+							ParameterizedType pt = baseType as ParameterizedType;
+							if (pt != null) {
+								return pt.TypeArguments[0];
+							}
+						} else if (baseTypeDef.Namespace == "System.Collections" && baseTypeDef.TypeParameterCount == 0) {
+							return TypeCode.Object.ToTypeReference().Resolve(storedContext.Context);
+						}
+					}
+				}
+				return SharedTypes.UnknownType;
+			}
+			
 			public override string ToString()
 			{
 				if (visitor == null)
@@ -820,5 +1021,104 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		#endregion
+		
+		#region Attributes
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAttribute(Attribute attribute, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAttributeSection(AttributeSection attributeSection, object data)
+		{
+			ScanChildren(attributeSection);
+			return null;
+		}
+		#endregion
+		
+		#region Using Declaration
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitUsingAliasDeclaration(UsingAliasDeclaration usingDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+		
+		#region Type References
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitFullTypeName(FullTypeName fullTypeName, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitComposedType(ComposedType composedType, object data)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+		
+		#region Query Expressions
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitIdentifier(Identifier identifier, object data)
+		{
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitConstraint(Constraint constraint, object data)
+		{
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
+		{
+			return null;
+		}
+		
+		ResolveResult IDomVisitor<object, ResolveResult>.VisitAccessorDeclaration(Accessor accessorDeclaration, object data)
+		{
+			return null;
+		}
 	}
 }