Added a few unit tests.

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

@@ -0,0 +1,164 @@
+// 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 InvocationTests : ResolverTestBase
+	{
+		// TODO: do we want to return the MemberResolveResult for the InvocationExpression, or only for it's target?
+		
+		[Test]
+		public void MethodCallTest()
+		{
+			string program = @"class A {
+	void Method() {
+		$TargetMethod()$;
+	}
+	
+	int TargetMethod() {
+		return 3;
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("A.TargetMethod", result.Member.FullName);
+			Assert.AreEqual("System.Int32", result.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void InvalidMethodCall()
+		{
+			string program = @"class A {
+	void Method(string b) {
+		$b.ThisMethodDoesNotExistOnString(b)$;
+	}
+}
+";
+			UnknownMethodResolveResult result = Resolve<UnknownMethodResolveResult>(program);
+			Assert.AreEqual("ThisMethodDoesNotExistOnString", result.MemberName);
+			Assert.AreEqual("System.String", result.TargetType.FullName);
+			Assert.AreEqual(1, result.Parameters.Count);
+			Assert.AreEqual("b", result.Parameters[0].Name);
+			Assert.AreEqual("System.String", result.Parameters[0].Type.Resolve(context).ReflectionName);
+			
+			Assert.AreSame(SharedTypes.UnknownType, result.Type);
+		}
+		
+		[Test, Ignore("Resolving type references is not implemented")]
+		public void OverriddenMethodCall()
+		{
+			string program = @"class A {
+	void Method() {
+		$new B().GetRandomNumber()$;
+	}
+	
+	public abstract int GetRandomNumber();
+}
+class B : A {
+	public override int GetRandomNumber() {
+		return 4; // chosen by fair dice roll.
+		          // guaranteed to be random
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("B.GetRandomNumber", result.Member.FullName);
+		}
+		
+		[Test, Ignore("Resolving type references is not implemented")]
+		public void OverriddenMethodCall2()
+		{
+			string program = @"class A {
+	void Method() {
+		$new B().GetRandomNumber(""x"", this)$;
+	}
+	
+	public abstract int GetRandomNumber(string a, A b);
+}
+class B : A {
+	public override int GetRandomNumber(string b, A a) {
+		return 4; // chosen by fair dice roll.
+		          // guaranteed to be random
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("B.GetRandomNumber", result.Member.FullName);
+		}
+		
+		[Test]
+		public void ThisMethodCallTest()
+		{
+			string program = @"class A {
+	void Method() {
+		$this.TargetMethod()$;
+	}
+	
+	int TargetMethod() {
+		return 3;
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("A.TargetMethod", result.Member.FullName);
+			Assert.AreEqual("System.Int32", result.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void VoidTest()
+		{
+			string program = @"using System;
+class A {
+	void TestMethod() {
+		$TestMethod()$;
+	}
+}
+";
+			Assert.AreEqual("System.Void", Resolve(program).Type.ReflectionName);
+		}
+		
+		[Test, Ignore("Type references cannot be resolved")]
+		public void EventCallTest()
+		{
+			string program = @"using System;
+class A {
+	void Method() {
+		$TestEvent(this, EventArgs.Empty)$;
+	}
+	
+	public event EventHandler TestEvent;
+}
+";
+			Assert.AreEqual("System.Void", Resolve(program).Type.ReflectionName);
+		}
+		
+		/* TODO
+		[Test]
+		public void MethodGroupResolveTest()
+		{
+			string program = @"class A {
+	void Method() {
+		
+	}
+	
+	void TargetMethod(int a) { }
+	void TargetMethod<T>(T a) { }
+}
+";
+			MethodGroupResolveResult result = Resolve<MethodGroupResolveResult>(program, "TargetMethod", 3);
+			Assert.AreEqual("TargetMethod", result.Name);
+			Assert.AreEqual(2, result.Methods.Count);
+			
+			result = Resolve<MethodGroupResolveResult>(program, "TargetMethod<string>", 3);
+			Assert.AreEqual("TargetMethod", result.Name);
+			Assert.AreEqual(1, result.Methods[0].Count);
+			Assert.AreEqual("System.String", result.GetMethodIfSingleOverload().Parameters[0].ReturnType.FullyQualifiedName);
+		}
+		 */
+	}
+}

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

@@ -0,0 +1,56 @@
+// 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 ObjectCreationTests : ResolverTestBase
+	{
+		[Test, Ignore("Resolving type references is not implemented")]
+		public void GenericObjectCreation()
+		{
+			string program = @"using System.Collections.Generic;
+class A {
+	static void Main() {
+		var a = $new List<string>()$;
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program);
+			Assert.AreEqual("System.Collections.Generic.List.#ctor", result.Member.FullName);
+			
+			Assert.AreEqual("System.Collections.Generic.List`1{System.String}", result.Type.ReflectionName);
+		}
+		
+		[Test]
+		public void NonExistingClass()
+		{
+			string program = @"class A {
+	void Method() {
+		var a = $new ThisClassDoesNotExist()$;
+	}
+}
+";
+			ResolveResult result = Resolve<ResolveResult>(program);
+			Assert.AreSame(SharedTypes.UnknownType, result.Type);
+		}
+		
+		[Test]
+		public void NonExistingClassTypeName()
+		{
+			string program = @"class A {
+	void Method() {
+		var a = new $ThisClassDoesNotExist$();
+	}
+}
+";
+			UnknownIdentifierResolveResult result = Resolve<UnknownIdentifierResolveResult>(program);
+			Assert.AreEqual("ThisClassDoesNotExist", result.Identifier);
+			Assert.AreSame(SharedTypes.UnknownType, result.Type);
+		}
+	}
+}

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

@@ -120,6 +120,8 @@
     <Compile Include="CSharp\Parser\ParseUtil.cs" />
     <Compile Include="CSharp\Resolver\BinaryOperatorTests.cs" />
     <Compile Include="CSharp\Resolver\CastTests.cs" />
+    <Compile Include="CSharp\Resolver\InvocationTests.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" />

ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -593,6 +593,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				foreach (var a in c.ArraySpecifiers.Reverse()) {
 					t = ArrayTypeReference.Create(t, a.Dimensions);
 				}
+				return t;
 			}
 			Debug.WriteLine("Unknown node used as type: " + node);
 			return SharedTypes.UnknownType;

ICSharpCode.NRefactory/CSharp/Resolver/UnknownMemberResolveResult.cs

@@ -27,6 +27,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			this.typeArguments = new ReadOnlyCollection<IType>(typeArguments.ToArray());
 		}
 		
+		/// <summary>
+		/// The type on which the method is being called.
+		/// </summary>
 		public IType TargetType {
 			get { return targetType; }
 		}