Renamed VariableResolveResult to LocalResolveResult and added some unit tests.

ICSharpCode.NRefactory.Tests/CSharp/Resolver/SimpleNameLookupTests.cs

@@ -153,7 +153,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	}
 }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("a", result.Variable.Name);
 			Assert.IsTrue(result.IsParameter);
 			Assert.AreEqual("System.String", result.Type.FullName);
@@ -169,7 +169,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	}
 }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("a", result.Variable.Name);
 			Assert.IsFalse(result.IsParameter);
 			
@@ -224,7 +224,7 @@ class Color { public static readonly Color Empty = null; }
 	}
 }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("System.String", result.Type.FullName);
 			Assert.AreEqual("value", result.Variable.Name);
 		}
@@ -241,7 +241,7 @@ class Color { public static readonly Color Empty = null; }
 	}
 }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("System.EventHandler", result.Type.FullName);
 			Assert.AreEqual("value", result.Variable.Name);
 		}
@@ -257,7 +257,7 @@ class Color { public static readonly Color Empty = null; }
 	}
 }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("System.String", result.Type.FullName);
 			Assert.AreEqual("value", result.Variable.Name);
 		}
@@ -273,7 +273,7 @@ class A {
 		};
 	} }
 ";
-			VariableResolveResult result = Resolve<VariableResolveResult>(program);
+			LocalResolveResult result = Resolve<LocalResolveResult>(program);
 			Assert.AreEqual("System.EventArgs", result.Type.FullName);
 			Assert.AreEqual("e", result.Variable.Name);
 		}
@@ -305,11 +305,130 @@ class TestClass {
 	}
 }
 ";
-			VariableResolveResult lr = Resolve<VariableResolveResult>(program.Replace("$1$", "$i$").Replace("$2$", "i"));
+			LocalResolveResult lr = Resolve<LocalResolveResult>(program.Replace("$1$", "$i$").Replace("$2$", "i"));
 			Assert.AreEqual("System.Int32", lr.Type.ReflectionName);
 			
-			lr = Resolve<VariableResolveResult>(program.Replace("$1$", "i").Replace("$2$", "$i$"));
+			lr = Resolve<LocalResolveResult>(program.Replace("$1$", "i").Replace("$2$", "$i$"));
 			Assert.AreEqual("System.Int64", lr.Type.ReflectionName);
 		}
+		
+		[Test]
+		public void NamespacePreferenceTest()
+		{
+			// Classes in the current namespace are preferred over classes from
+			// imported namespaces
+			string program = @"using System;
+namespace Testnamespace {
+class A {
+	$Activator$ a;
+}
+
+class Activator {
+	
+}
+}
+";
+			var result = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Testnamespace.Activator", result.Type.FullName);
+		}
+		
+		[Test]
+		public void ParentNamespaceTypeLookup()
+		{
+			string program = @"using System;
+namespace Root {
+  class Alpha {}
+}
+namespace Root.Child {
+  class Beta {
+    $Alpha$ a;
+  }
+}
+";
+			var result = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Root.Alpha", result.Type.FullName);
+		}
+		
+		[Test, Ignore("type references not implemented")]
+		public void ImportAliasTest()
+		{
+			string program = @"using COL = System.Collections;
+class TestClass {
+	COL.ArrayList ff;
+}
+";
+			TypeResolveResult type = Resolve<TypeResolveResult>(program, "COL.ArrayList");
+			Assert.IsNotNull(type, "COL.ArrayList should resolve to a type");
+			Assert.AreEqual("System.Collections.ArrayList", type.Type.FullName, "TypeResolveResult");
+			
+			MemberResolveResult member = Resolve<MemberResolveResult>(program, "ff");
+			Assert.AreEqual("System.Collections.ArrayList", member.Type.FullName, "the full type should be resolved");
+		}
+		
+		[Test]
+		public void ImportAliasNamespaceResolveTest()
+		{
+			NamespaceResolveResult ns;
+			string program = "using COL = System.Collections;\r\nclass A {\r\n$.ArrayList a;\r\n}\r\n";
+			ns = Resolve<NamespaceResolveResult>(program.Replace("$", "$COL$"));
+			Assert.AreEqual("System.Collections", ns.NamespaceName, "COL");
+			ns = Resolve<NamespaceResolveResult>(program.Replace("$", "$COL.Generic$"));
+			Assert.AreEqual("System.Collections.Generic", ns.NamespaceName, "COL.Generic");
+		}
+		
+		[Test, Ignore("Cannot resolve type references")]
+		public void ImportAliasClassResolveTest()
+		{
+			string program = @"using COL = System.Collections.ArrayList;
+class TestClass {
+	void Test() {
+		COL a = new COL();
+		
+	}
+}
+";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("COL a", "$COL$ a"));
+			Assert.AreEqual("System.Collections.ArrayList", trr.Type.FullName, "COL");
+			ResolveResult rr = Resolve<ResolveResult>(program.Replace("new COL()", "$new COL()$"));
+			Assert.AreEqual("System.Collections.ArrayList", rr.Type.FullName, "a");
+		}
+		
+		[Test]
+		public void ResolveNamespaceSD_863()
+		{
+			string program = @"using System;
+namespace A.C { class D {} }
+namespace A.B.C { class D {} }
+namespace A.B {
+	class TestClass {
+		void Test() {
+			C.D x;
+		}
+	}
+}
+";
+			NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("C.D", "$C$.D"));
+			Assert.AreEqual("A.B.C", nrr.NamespaceName, "nrr.Name");
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("C.D", "$C.D$"));
+			Assert.AreEqual("A.B.C.D", trr.Type.FullName);
+		}
+		
+		[Test, Ignore("Broken due to parser returning incorrect positions")]
+		public void ResolveTypeSD_863()
+		{
+			string program = @"using System;
+namespace A { class C {} }
+namespace A.B {
+	class C {}
+	class TestClass {
+		void Test() {
+			$C$ a;
+		}
+	}
+}
+";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("A.B.C", trr.Type.FullName);
+		}
 	}
 }

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -1500,14 +1500,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				foreach (IVariable v in this.LocalVariables) {
 					if (v.Name == identifier) {
 						object constantValue = v.IsConst ? v.ConstantValue.GetValue(context) : null;
-						return new VariableResolveResult(v, v.Type.Resolve(context), constantValue);
+						return new LocalResolveResult(v, v.Type.Resolve(context), constantValue);
 					}
 				}
 				IParameterizedMember parameterizedMember = this.CurrentMember as IParameterizedMember;
 				if (parameterizedMember != null) {
 					foreach (IParameter p in parameterizedMember.Parameters) {
 						if (p.Name == identifier) {
-							return new VariableResolveResult(p, p.Type.Resolve(context));
+							return new LocalResolveResult(p, p.Type.Resolve(context));
 						}
 					}
 				}
@@ -1795,7 +1795,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (mgrr != null && mgrr.Methods.Count > 0)
 				return mgrr.Methods[0].Name;
 			
-			VariableResolveResult vrr = rr as VariableResolveResult;
+			LocalResolveResult vrr = rr as LocalResolveResult;
 			if (vrr != null)
 				return MakeParameterName(vrr.Variable.Name);
 			

ICSharpCode.NRefactory/CSharp/Resolver/LocalResolveResult.cs

@@ -9,12 +9,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	/// <summary>
 	/// Represents a local variable.
 	/// </summary>
-	public class VariableResolveResult : ResolveResult
+	public class LocalResolveResult : ResolveResult
 	{
 		readonly IVariable variable;
 		readonly object constantValue;
 		
-		public VariableResolveResult(IVariable variable, IType type, object constantValue = null)
+		public LocalResolveResult(IVariable variable, IType type, object constantValue = null)
 			: base(type)
 		{
 			if (variable == null)

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -250,7 +250,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					foreach (IVariable v in resolver.LocalVariables) {
 						if (v.Name == identifier) {
 							object constantValue = v.IsConst ? v.ConstantValue.GetValue(resolver.Context) : null;
-							return new VariableResolveResult(v, v.Type.Resolve(resolver.Context), constantValue);
+							return new LocalResolveResult(v, v.Type.Resolve(resolver.Context), constantValue);
 						}
 					}
 				}
@@ -368,7 +368,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				if (pm != null) {
 					foreach (IParameter p in pm.Parameters) {
 						if (p.Name == parameterDeclaration.Name) {
-							return new VariableResolveResult(p, p.Type.Resolve(resolver.Context));
+							return new LocalResolveResult(p, p.Type.Resolve(resolver.Context));
 						}
 					}
 				}

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -177,7 +177,7 @@
     <Compile Include="CSharp\Resolver\TypeResolveResult.cs" />
     <Compile Include="CSharp\Resolver\UnknownMemberResolveResult.cs" />
     <Compile Include="CSharp\Resolver\UsingScope.cs" />
-    <Compile Include="CSharp\Resolver\VariableResolveResult.cs" />
+    <Compile Include="CSharp\Resolver\LocalResolveResult.cs" />
     <Compile Include="Documentation\BinaryDocumentationProvider.cs" />
     <Compile Include="Documentation\XmlDocumentationProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />