Add lots of resolver unit tests.

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

@@ -0,0 +1,96 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture, Ignore("DOM for attributes is incomplete")]
+	public class AttributeTests : ResolverTestBase
+	{
+		[Test]
+		public void NamespaceInAttributeContext()
+		{
+			string program = "using System; [$System.Runtime$.CompilerServices.IndexerName(\"bla\")] class Test { }";
+			NamespaceResolveResult result = Resolve<NamespaceResolveResult>(program);
+			Assert.AreEqual("System.Runtime", result.NamespaceName);
+		}
+		
+		[Test]
+		public void AttributeWithShortName()
+		{
+			string program = "using System; [$Obsolete$] class Test {}";
+			
+			TypeResolveResult result = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("System.ObsoleteAttribute", result.Type.FullName);
+		}
+		
+		[Test]
+		public void QualifiedAttributeWithShortName()
+		{
+			string program = "using System; [$System.Obsolete$] class Test {}";
+			
+			TypeResolveResult result = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("System.ObsoleteAttribute", result.Type.FullName);
+		}
+		
+		[Test]
+		public void AttributeConstructor1()
+		{
+			string program = "using System; [$LoaderOptimization(3)$] class Test { }";
+			var mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("System.LoaderOptimization.#ctor", mrr.Member.FullName);
+			Assert.AreEqual("System.Byte", (mrr.Member as IMethod).Parameters[0].Type.Resolve(context).FullName);
+		}
+		
+		[Test]
+		public void AttributeConstructor2()
+		{
+			string program = "using System; [$LoaderOptimization(LoaderOptimization.NotSpecified)$] class Test { }";
+			var mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("System.LoaderOptimization.#ctor", mrr.Member.FullName);
+			Assert.AreEqual("System.LoaderOptimization", (mrr.Member as IMethod).Parameters[0].Type.Resolve(context).FullName);
+		}
+		
+		[Test]
+		public void AttributeArgumentInClassContext1()
+		{
+			string program = @"using System;
+[AttributeUsage($XXX$)] class MyAttribute : Attribute {
+	public const AttributeTargets XXX = AttributeTargets.All;
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("MyAttribute.XXX", result.Member.FullName);
+		}
+		
+		[Test]
+		public void AttributeArgumentInClassContext2()
+		{
+			string program = @"using System; namespace MyNamespace {
+[SomeAttribute($E.A$)] class Test { }
+enum E { A, B }
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("MyNamespace.E.A", result.Member.FullName);
+		}
+		
+		[Test]
+		public void SD_1384()
+		{
+			string program = @"using System;
+class Flags {
+	[Flags]
+	enum $Test$ { }
+}";
+			TypeResolveResult result = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Flags.Test", result.Type.FullName);
+			
+			var rt = result.Type.GetDefinition().Attributes[0].AttributeType.Resolve(context);
+			Assert.AreEqual("System.FlagsAttribute", rt.FullName);
+		}
+	}
+}

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

@@ -0,0 +1,89 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture, Ignore("Extension method support not yet implemented")]
+	public class ExtensionMethodTests : ResolverTestBase
+	{
+		[Test]
+		public void ExtensionMethodsTest()
+		{
+			string program = @"using XN;
+class TestClass {
+	static void Test(A a, B b, C c) {
+		$;
+	}
+}
+class A { }
+class B {
+	public void F(int i) { }
+}
+class C {
+	public void F(object obj) { }
+}
+namespace XN {
+	public static class XC {
+		public static void F(this object obj, int i) { }
+		public static void F(this object obj, string s) { }
+	}
+}
+";
+			MemberResolveResult mrr;
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$a.F(1)$"));
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
+			Assert.AreEqual("System.Int32", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$a.F(\"text\")$"));
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
+			Assert.AreEqual("System.String", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$b.F(1)$"));
+			Assert.AreEqual("B.F", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$b.F(\"text\")$"));
+			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
+			Assert.AreEqual("System.String", ((IMethod)mrr.Member).Parameters[1].Type.Resolve(context).FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$c.F(1)$"));
+			Assert.AreEqual("C.F", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$c.F(\"text\")$"));
+			Assert.AreEqual("C.F", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Test fails due to parser returning incorrect position")]
+		public void ExtensionMethodsTest2()
+		{
+			string program = @"using System; using System.Collections.Generic;
+class TestClass {
+	static void Test(string[] args) {
+		$;
+	}
+}
+public static class XC {
+	public static int ToInt32(this string s) { return int.Parse(s); }
+	public static T[] Slice<T>(this T[] source, int index, int count) { throw new NotImplementedException(); }
+	public static IEnumerable<T> Filter<T>(this IEnumerable<T> source, Predicate<T> predicate) { throw new NotImplementedException(); }
+}
+";
+			MemberResolveResult mrr;
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$\"text\".ToInt32()$"));
+			Assert.AreEqual("XC.ToInt32", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$args.Slice(1, 2)$"));
+			Assert.AreEqual("XC.Slice", mrr.Member.FullName);
+			Assert.AreEqual("System.String[]", mrr.Type.ReflectionName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$args.Filter(delegate { return true; })$"));
+			Assert.AreEqual("XC.Filter", mrr.Member.FullName);
+			Assert.AreEqual("System.Collections.Generic.IEnumerable{System.String}", mrr.Type.ReflectionName);
+		}
+	}
+}

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

@@ -187,5 +187,82 @@ class A {
 			Assert.AreEqual("System.String", result.GetMethodIfSingleOverload().Parameters[0].ReturnType.FullyQualifiedName);
 		}
 		 */
+		
+		[Test]
+		public void TestOverloadingByRef()
+		{
+			string program = @"using System;
+class Program {
+	public static void Main() {
+		int a = 42;
+		T(a);
+		T(ref a);
+	}
+	static void T(int x) {}
+	static void T(ref int y) {}
+}";
+			
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program, "T(a)");
+			Assert.IsFalse(((IMethod)mrr.Member).Parameters[0].IsRef);
+			
+			mrr = Resolve<MemberResolveResult>(program, "T(ref a)");
+			Assert.IsTrue(((IMethod)mrr.Member).Parameters[0].IsRef);
+		}
+		
+		[Test, Ignore("Type references not supported in parser")]
+		public void AddedOverload()
+		{
+			string program = @"class BaseClass {
+	static void Main(DerivedClass d) {
+		$d.Test(3)$;
+	}
+	public void Test(int a) { }
+}
+class DerivedClass : BaseClass {
+	public void Test(object a) { }
+}";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Type references not supported in parser")]
+		public void AddedNonApplicableOverload()
+		{
+			string program = @"class BaseClass {
+	static void Main(DerivedClass d) {
+		$d.Test(3)$;
+	}
+	public void Test(int a) { }
+}
+class DerivedClass : BaseClass {
+	public void Test(string a) { }
+}";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("(3)", "(\"3\")"));
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Type references not supported in parser")]
+		public void OverrideShadowed()
+		{
+			string program = @"using System;
+class BaseClass {
+	static void Main() {
+		$new DerivedClass().Test(3)$;
+	}
+	public virtual void Test(int a) { }
+}
+class MiddleClass : BaseClass {
+	public void Test(object a) { }
+}
+class DerivedClass : MiddleClass {
+	public override void Test(int a) { }
+}";
+			
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("MiddleClass.Test", mrr.Member.FullName);
+		}
 	}
 }

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

@@ -0,0 +1,278 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture, Ignore("Lambda support not yet implemented")]
+	public class LambdaTests : ResolverTestBase
+	{
+		[Test]
+		public void SimpleLambdaTest()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		Test(i => Console.WriteLine(i));
+	}
+	public void Test(Action<int> ac) { ac(42); }
+}";
+			var lrr = Resolve<LocalResolveResult>(program.Replace("(i)", "($i$)"));
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+			
+			lrr = Resolve<LocalResolveResult>(program.Replace("i =>", "$i$ =>"));
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInConstructorTest()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		TestClass t = new TestClass(i => Console.WriteLine($i$));
+	}
+	public TestClass(Action<int> ac) { ac(42); }
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInGenericConstructorTest()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		var t = new SomeClass<string>(i => Console.WriteLine($i$));
+	}
+}
+class SomeClass<T> {
+	public SomeClass(Action<T> ac) { }
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+		}
+		
+		#region Lambda In Initializer
+		[Test]
+		public void LambdaInCollectionInitializerTest1()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		Converter<int, string>[] arr = {
+			i => $i$.ToString()
+		};
+	}
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInCollectionInitializerTest2()
+		{
+			string program = @"using System; using System.Collections.Generic;
+class TestClass {
+	static void Main() {
+		a = new List<Converter<int, string>> {
+			i => $i$.ToString()
+		};
+	}
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInCollectionInitializerTest3()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		a = new Converter<int, string>[] {
+			i => $i$.ToString()
+		};
+	}
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInCollectionInitializerTest4()
+		{
+			string program = @"using System;
+class TestClass {
+	Converter<int, string>[] field = new Converter<int, string>[] {
+		i => $i$.ToString()
+	};
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInCollectionInitializerTest5()
+		{
+			string program = @"using System;
+class TestClass {
+	Converter<int, string>[] field = {
+		i => $i$.ToString()
+	};
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInObjectInitializerTest()
+		{
+			string program = @"using System;
+class X {
+	void SomeMethod() {
+		Helper h = new Helper {
+			F = i => $i$.ToString()
+		};
+	}
+}
+class Helper {
+	public Converter<int, string> F;
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		#endregion
+		
+		[Test]
+		public void LambdaExpressionInCastExpression()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void Main(string[] args) {
+		var f = (Func<int, string>) ( i => $i$ );
+	}
+	public delegate R Func<T, R>(T arg);
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaExpressionInReturnStatement()
+		{
+			string program = @"using System;
+static class TestClass {
+	static Converter<int, string> GetToString() {
+		return i => $i$.ToString();
+	}
+}";
+			var lrr = Resolve<LocalResolveResult>(program, "i");
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaExpressionInReturnStatementInStatementLambda()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void SomeMethod() {
+		Func<Func<string, string>> getStringTransformer = () => {
+			return s => $s$.ToUpper();
+		};
+	}
+	public delegate R Func<T, R>(T arg);
+	public delegate R Func<R>();
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaExpressionInReturnStatementInAnonymousMethod()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void SomeMethod() {
+		Func<Func<string, string>> getStringTransformer = delegate {
+			return s => $s$.ToUpper();
+		};
+	}
+	public delegate R Func<T, R>(T arg);
+	public delegate R Func<R>();
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void CurriedLambdaExpressionInCastExpression()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void Main(string[] args) {
+		var f = (Func<char, Func<string, int>>) ( a => b => 0 );
+	}
+	public delegate R Func<T, R>(T arg);
+}";
+			var lrr = Resolve<LocalResolveResult>(program.Replace("a =>", "$a$ =>"));
+			Assert.AreEqual("System.Char", lrr.Type.ReflectionName);
+			
+			lrr = Resolve<LocalResolveResult>(program.Replace("b =>", "$b$ =>"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaExpressionInVariableInitializer()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void Main() {
+		Func<int, string> f = $i$ => i.ToString();
+	}
+	public delegate R Func<T, R>(T arg);
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaExpressionInVariableAssignment()
+		{
+			string program = @"using System;
+static class TestClass {
+	static void Main() {
+		Func<int, string> f;
+ 		f = $i$ => i.ToString();
+	}
+	public delegate R Func<T, R>(T arg);
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void LambdaInDelegateCall()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		Func<Func<int, string>, char> f;
+		f($i$ => i.ToString());
+	}
+	public delegate R Func<T, R>(T arg);
+}";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+		}
+	}
+}

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

@@ -0,0 +1,136 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture, Ignore("LINQ not yet implemented")]
+	public class LinqTests : ResolverTestBase
+	{
+		[Test]
+		public void SimpleLinqTest()
+		{
+			string program = @"using System; using System.Linq;
+class TestClass {
+	void Test(string[] input) {
+		var r = from e in input
+			where e.StartsWith(""/"")
+			select e.Trim();
+		r.ToString();
+	}
+}
+";
+			LocalResolveResult lrr = Resolve<LocalResolveResult>(program.Replace("where e", "where $e$"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("select e", "select $e$"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("from e", "from $e$"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+			
+			lrr = Resolve<LocalResolveResult>(program.Replace("r.ToString", "$r$.ToString"));
+			Assert.AreEqual("System.Collections.Generic.IEnumerable", lrr.Type.FullName);
+			Assert.AreEqual("System.String", ((ParameterizedType)lrr.Type).TypeArguments[0].FullName);
+		}
+		
+		[Test]
+		public void LinqGroupTest()
+		{
+			string program = @"using System; using System.Linq;
+class TestClass {
+	void Test(string[] input) {
+		var r = from e in input
+			group e.ToUpper() by e.Length;
+		$r$.ToString();
+	}
+}
+";
+			LocalResolveResult lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Collections.Generic.IEnumerable", lrr.Type.FullName);
+			ParameterizedType rt = (ParameterizedType)((ParameterizedType)lrr.Type).TypeArguments[0];
+			Assert.AreEqual("System.Linq.IGrouping", rt.FullName);
+			Assert.AreEqual("System.Int32", rt.TypeArguments[0].FullName);
+			Assert.AreEqual("System.String", rt.TypeArguments[1].FullName);
+		}
+		
+		[Test]
+		public void LinqQueryableGroupTest()
+		{
+			string program = @"using System; using System.Linq;
+class TestClass {
+	void Test(IQueryable<string> input) {
+		var r = from e in input
+			group e.ToUpper() by e.Length;
+		$r$.ToString();
+	}
+}
+";
+			LocalResolveResult lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Linq.IQueryable", lrr.Type.FullName);
+			ParameterizedType rt = (ParameterizedType)((ParameterizedType)lrr.Type).TypeArguments[0];
+			Assert.AreEqual("System.Linq.IGrouping", rt.FullName);
+			Assert.AreEqual("System.Int32", rt.TypeArguments[0].FullName);
+			Assert.AreEqual("System.String", rt.TypeArguments[1].FullName);
+		}
+		
+		[Test]
+		public void ParenthesizedLinqTest()
+		{
+			string program = @"using System; using System.Linq;
+class TestClass {
+	void Test(string[] input) {
+		$(from e in input select e.Length)$.ToArray();
+	}
+}
+";
+			ResolveResult rr = Resolve<ResolveResult>(program);
+			Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.Type.FullName);
+			Assert.AreEqual("System.Int32", ((ParameterizedType)rr.Type).TypeArguments[0].FullName);
+		}
+		
+		[Test]
+		public void LinqSelectReturnTypeTest()
+		{
+			string program = @"using System;
+class TestClass { static void M() {
+	$(from a in new XYZ() select a.ToUpper())$.ToString();
+}}
+class XYZ {
+	public int Select<U>(Func<string, U> f) { return 42; }
+}";
+			ResolveResult rr = Resolve<ResolveResult>(program);
+			Assert.AreEqual("System.Int32", rr.Type.FullName);
+		}
+		
+		[Test]
+		public void LinqQueryContinuationTest()
+		{
+			string program = @"using System; using System.Linq;
+class TestClass {
+	void Test(string[] input) {
+		var r = from x in input
+			select x.GetHashCode() into x
+			where x == 42
+			select x * x;
+		r.ToString();
+	}
+}
+";
+			LocalResolveResult lrr = Resolve<LocalResolveResult>(program.Replace("from x", "from $x$"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("select x.G", "select $x$.G"));
+			Assert.AreEqual("System.String", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("into x", "into $x$"));
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("where x", "where $x$"));
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+			lrr = Resolve<LocalResolveResult>(program.Replace("select x * x", "select x * $x$"));
+			Assert.AreEqual("System.Int32", lrr.Type.ReflectionName);
+			
+			lrr = Resolve<LocalResolveResult>(program.Replace("r.ToString", "$r$.ToString"));
+			Assert.AreEqual("System.Collections.Generic.IEnumerable`1[[System.Int32]]", lrr.Type.ReflectionName);
+		}
+	}
+}

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

@@ -0,0 +1,55 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture]
+	public class LocalTypeInferenceTests : ResolverTestBase
+	{
+		[Test]
+		public void TypeInferenceTest()
+		{
+			string program = @"class TestClass {
+	static void Test() {
+		var a = 3;
+		$a$.ToString();
+	}
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Int32", lrr.Type.FullName);
+		}
+		
+		[Test]
+		public void TypeInferenceCycleTest()
+		{
+			string program = @"class TestClass {
+	static void Test() {
+		var a = a;
+		$a$.ToString();
+	}
+}
+";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreSame(SharedTypes.UnknownType, lrr.Type);
+		}
+		
+		[Test]
+		public void InvalidAnonymousTypeDeclaration()
+		{
+			// see SD-1393
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+			var contact = {id = 54321};
+			$contact$.ToString();
+		} }";
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual(SharedTypes.UnknownType, lrr.Type);
+		}
+	}
+}

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

@@ -1,26 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
-
-using System;
-using NUnit.Framework;
-
-namespace ICSharpCode.NRefactory.CSharp.Resolver
-{
-	[TestFixture]
-	public class MemberLookupTests : ResolverTestBase
-	{
-		[Test]
-		public void ShortMaxValueTest()
-		{
-			string program = @"using System;
-class TestClass {
-	object a = $short.MaxValue$;
-}
-";
-			MemberResolveResult rr = Resolve<MemberResolveResult>(program);
-			Assert.AreEqual("System.Int16", rr.Type.FullName);
-			Assert.AreEqual("System.Int16.MaxValue", rr.Member.FullName);
-			Assert.AreEqual(short.MaxValue, rr.ConstantValue);
-		}
-	}
-}

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

@@ -1,16 +1,17 @@
-// Copyright (c) 2010 AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 // This code is distributed under MIT X11 license (for details please see \doc\license.txt)
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using NUnit.Framework;
+
 using ICSharpCode.NRefactory.TypeSystem;
+using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
 	[TestFixture]
-	public class SimpleNameLookupTests : ResolverTestBase
+	public class NameLookupTests : ResolverTestBase
 	{
 		[Test]
 		public void SimpleNameLookupWithoutContext()
@@ -430,5 +431,325 @@ namespace A.B {
 			TypeResolveResult trr = Resolve<TypeResolveResult>(program);
 			Assert.AreEqual("A.B.C", trr.Type.FullName);
 		}
+		
+		[Test]
+		public void ShortMaxValueTest()
+		{
+			string program = @"using System;
+class TestClass {
+	object a = $short.MaxValue$;
+}
+";
+			MemberResolveResult rr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("System.Int16", rr.Type.FullName);
+			Assert.AreEqual("System.Int16.MaxValue", rr.Member.FullName);
+			Assert.AreEqual(short.MaxValue, rr.ConstantValue);
+		}
+		
+		[Test, Ignore("Parser produces incorrect positions for :: operator")]
+		public void ClassWithSameNameAsNamespace()
+		{
+			string program = @"using System; namespace XX {
+	class Test {
+		static void X() {
+			a = $;
+		}
+	}
+	class XX {
+		public static void Test() {}
+	} }";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("$", "$XX$"));
+			Assert.AreEqual("XX.XX", trr.Type.FullName);
+			
+			NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program.Replace("$", "$global::XX$.T"));
+			Assert.AreEqual("XX", nrr.NamespaceName);
+			
+			trr = Resolve<TypeResolveResult>(program.Replace("$", "$global::XX.XX$"));
+			Assert.AreEqual("XX.XX", trr.Type.FullName);
+			
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$XX.Test()$"));
+			Assert.AreEqual("XX.XX.Test", mrr.Member.FullName);
+		}
+		
+		[Test]
+		public void ClassNameLookup1()
+		{
+			string program = @"namespace MainNamespace {
+	using Test.Subnamespace;
+	class Program {
+		static void M($Test.TheClass$ c) {}
+	}
+}
+
+namespace Test { public class TheClass { } }
+namespace Test.Subnamespace {
+	public class Test { public class TheClass { } }
+}
+";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Test.Subnamespace.Test.TheClass", trr.Type.FullName);
+		}
+		
+		[Test]
+		public void ClassNameLookup2()
+		{
+			string program = @"using Test.Subnamespace;
+namespace MainNamespace {
+	class Program {
+		static void M($Test.TheClass$ c) {}
+	}
+}
+
+namespace Test { public class TheClass { } }
+namespace Test.Subnamespace {
+	public class Test { public class TheClass { } }
+}
+";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Test.TheClass", trr.Type.FullName);
+		}
+		
+		[Test]
+		public void ClassNameLookup3()
+		{
+			string program = @"namespace MainNamespace {
+	using Test.Subnamespace;
+	class Program {
+		static void M($Test$ c) {}
+	}
+}
+
+namespace Test { public class TheClass { } }
+namespace Test.Subnamespace {
+	public class Test { public class TheClass { } }
+}
+";
+			TypeResolveResult trr = Resolve<TypeResolveResult>(program);
+			Assert.AreEqual("Test.Subnamespace.Test", trr.Type.FullName);
+		}
+		
+		[Test]
+		public void ClassNameLookup4()
+		{
+			string program = @"using Test.Subnamespace;
+namespace MainNamespace {
+	class Program {
+		static void M($Test$ c) {}
+	}
+}
+
+namespace Test { public class TheClass { } }
+namespace Test.Subnamespace {
+	public class Test { public class TheClass { } }
+}
+";
+			NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program);
+			Assert.AreEqual("Test", nrr.NamespaceName);
+		}
+		
+		[Test]
+		public void ClassNameLookup5()
+		{
+			string program = @"namespace MainNamespace {
+	using A;
+	
+	class M {
+		void X($Test$ a) {}
+	}
+	namespace Test { class B {} }
+}
+
+namespace A {
+	class Test {}
+}";
+			NamespaceResolveResult nrr = Resolve<NamespaceResolveResult>(program);
+			Assert.AreEqual("MainNamespace.Test", nrr.NamespaceName);
+		}
+		
+		[Test, Ignore("Fails because parser does not support base type references")]
+		public void InvocableRule()
+		{
+			string program = @"using System;
+	class DerivedClass : BaseClass {
+		static void X() {
+			a = $;
+		}
+		private static new int Test;
+	}
+	class BaseClass {
+		public static string Test() {}
+	}";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$BaseClass.Test()$"));
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Test$"));
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$"));
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+			
+			// returns BaseClass.Test because DerivedClass.Test is not invocable
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test()$"));
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Fails because parser does not support base type references")]
+		public void InvocableRule2()
+		{
+			string program = @"using System;
+	class DerivedClass : BaseClass {
+		static void X() {
+			a = $;
+		}
+		private static new int Test;
+	}
+	delegate string SomeDelegate();
+	class BaseClass {
+		public static SomeDelegate Test;
+	}";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program.Replace("$", "$BaseClass.Test$()"));
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Test$"));
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$"));
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+			
+			// returns BaseClass.Test because DerivedClass.Test is not invocable
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$DerivedClass.Test$()"));
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Fails because parser does not support base type references")]
+		public void AccessibleRule()
+		{
+			string program = @"using System;
+	class BaseClass {
+		static void X() {
+			a = $DerivedClass.Test$;
+		}
+		public static int Test;
+	}
+	class DerivedClass : BaseClass {
+		private static new int Test;
+	}
+	";
+			// returns BaseClass.Test because DerivedClass.Test is not accessible
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test]
+		public void FieldHidingProperty()
+		{
+			string program = @"using System;
+	class DerivedClass : BaseClass {
+		static void X() {
+			a = $Test$;
+		}
+		public static new int Test;
+	}
+	class BaseClass {
+		public static int Test { get { return 0; } }
+	}
+	";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test]
+		public void PropertyHidingField()
+		{
+			string program = @"using System;
+	class DerivedClass : BaseClass {
+		static void X() {
+			a = $Test$;
+		}
+		public static new int Test { get { return 0; } }
+	}
+	class BaseClass {
+		public static int Test;
+	}
+	";
+			MemberResolveResult mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
+		}
+		
+		[Test, Ignore("Parser doesn't support inheritance")]
+		public void SD_1487()
+		{
+			string program = @"using System;
+class C2 : C1 {
+	public static void M() {
+		a = $;
+	}
+}
+class C1 {
+	protected static int Field;
+}";
+			MemberResolveResult mrr;
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Field$"));
+			Assert.AreEqual("C1.Field", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$C1.Field$"));
+			Assert.AreEqual("C1.Field", mrr.Member.FullName);
+			
+			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$C2.Field$"));
+			Assert.AreEqual("C1.Field", mrr.Member.FullName);
+		}
+		
+		[Test]
+		public void NullableValue()
+		{
+			string program = @"using System;
+class Test {
+	public static void M(int? a) {
+		$a.Value$.ToString();
+	}
+}";
+			MemberResolveResult rr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("System.Nullable.Value", rr.Member.FullName);
+			Assert.AreEqual("System.Int32", rr.Member.ReturnType.Resolve(context).FullName);
+		}
+		
+		[Test, Ignore("Parser doesn't support inheritance")]
+		public void MethodHidesEvent()
+		{
+			// see SD-1542
+			string program = @"using System;
+class Test : Form {
+	public Test() {
+		a = $base.KeyDown$;
+	}
+	void KeyDown(object sender, EventArgs e) {}
+}
+class Form {
+	public event EventHandler KeyDown;
+}";
+			var mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("Form.KeyDown", mrr.Member.FullName);
+			
+			var mgrr = Resolve<MethodGroupResolveResult>(program.Replace("base", "this"));
+			Assert.AreEqual("Test.KeyDown", mgrr.Methods.Single().FullName);
+		}
+		
+		[Test, Ignore("partial classes not yet supported")]
+		public void ProtectedMemberVisibleWhenBaseTypeReferenceIsInOtherPart()
+		{
+			string program = @"using System;
+partial class A {
+	void M1() {
+		$x$ = 0;
+	}
+}
+partial class A : B { }
+class B
+{
+	protected int x;
+}";
+			var mrr = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("B.x", mrr.Member.FullName);
+		}
 	}
 }

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

@@ -0,0 +1,29 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	[TestFixture]
+	public class UnsafeCodeTests : ResolverTestBase
+	{
+		[Test, Ignore("Parser produces parse tree that doesn't match DOM definition??")]
+		public void FixedStatement()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main(byte[] a) {
+		fixed (byte* p = a) {
+			a = $p$;
+		} } }";
+			
+			var lrr = Resolve<LocalResolveResult>(program);
+			Assert.AreEqual("System.Byte*", lrr.Type.ReflectionName);
+			
+			var rr = Resolve<ResolveResult>(program.Replace("$p$", "$*p$"));
+			Assert.AreEqual("System.Byte", lrr.Type.ReflectionName);
+		}
+	}
+}

ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj

@@ -118,17 +118,22 @@
     <Compile Include="CSharp\Parser\Expression\UnaryOperatorExpressionTests.cs" />
     <Compile Include="CSharp\Parser\GeneralScope\AttributeSectionTests.cs" />
     <Compile Include="CSharp\Parser\ParseUtil.cs" />
+    <Compile Include="CSharp\Resolver\AttributeTests.cs" />
     <Compile Include="CSharp\Resolver\BinaryOperatorTests.cs" />
     <Compile Include="CSharp\Resolver\CastTests.cs" />
+    <Compile Include="CSharp\Resolver\ExtensionMethodTests.cs" />
     <Compile Include="CSharp\Resolver\InvocationTests.cs" />
-    <Compile Include="CSharp\Resolver\MemberLookupTests.cs" />
+    <Compile Include="CSharp\Resolver\LambdaTests.cs" />
+    <Compile Include="CSharp\Resolver\LinqTests.cs" />
+    <Compile Include="CSharp\Resolver\LocalTypeInferenceTests.cs" />
+    <Compile Include="CSharp\Resolver\NameLookupTests.cs" />
     <Compile Include="CSharp\Resolver\ObjectCreationTests.cs" />
     <Compile Include="CSharp\Resolver\TypeInferenceTests.cs" />
     <Compile Include="CSharp\Resolver\ConversionsTest.cs" />
     <Compile Include="CSharp\Resolver\OverloadResolutionTests.cs" />
     <Compile Include="CSharp\Resolver\ResolverTestBase.cs" />
-    <Compile Include="CSharp\Resolver\SimpleNameLookupTests.cs" />
     <Compile Include="CSharp\Resolver\UnaryOperatorTests.cs" />
+    <Compile Include="CSharp\Resolver\UnsafeCodeTests.cs" />
     <Compile Include="FormattingTests\TestBraceStlye.cs" />
     <Compile Include="FormattingTests\TestFormattingBugs.cs" />
     <Compile Include="FormattingTests\TestSpacingVisitor.cs" />