Fixed NRefactory C# parser bug with method calls on InnerClassTypeReferences ("A<T>.B.C<U>.Foo();")

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@4986 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

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

@@ -551,8 +551,9 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 				TypeReference targetType = GetTypeReferenceFromExpression(member.TargetObject);
 				if (targetType != null) {
 					if (targetType.GenericTypes.Count == 0 && targetType.IsArrayType == false) {
-						TypeReference tr = new TypeReference(targetType.Type + "." + member.MemberName, member.TypeArguments);
-						tr.IsGlobal = targetType.IsGlobal;
+						TypeReference tr = targetType.Clone();
+						tr.Type = tr.Type + "." + member.MemberName;
+						tr.GenericTypes.AddRange(member.TypeArguments);
 						return tr;
 					} else {
 						return new InnerClassTypeReference(targetType, member.MemberName, member.TypeArguments);

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

@@ -117,6 +117,47 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(new Location(4, 1), mre.TargetObject.StartLocation);
 			Assert.AreEqual(new Location(6, 1), mre.TargetObject.EndLocation);
 		}
+		
+		[Test]
+		public void InvocationOnGenericType()
+		{
+			InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			TypeReferenceExpression tre = (TypeReferenceExpression)mre.TargetObject;
+			Assert.AreEqual("A", tre.TypeReference.Type);
+			Assert.AreEqual("T", tre.TypeReference.GenericTypes[0].Type);
+		}
+		
+		[Test]
+		public void InvocationOnInnerClassInGenericType()
+		{
+			InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.B.Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject;
+			Assert.AreEqual("B", mre2.MemberName);
+			TypeReferenceExpression tre = (TypeReferenceExpression)mre2.TargetObject;
+			Assert.AreEqual("A", tre.TypeReference.Type);
+			Assert.AreEqual("T", tre.TypeReference.GenericTypes[0].Type);
+		}
+		
+		[Test]
+		public void InvocationOnGenericInnerClassInGenericType()
+		{
+			InvocationExpression expr = ParseUtilCSharp.ParseExpression<InvocationExpression>("A<T>.B.C<U>.Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			TypeReferenceExpression tre = (TypeReferenceExpression)mre.TargetObject;
+			InnerClassTypeReference ictr = (InnerClassTypeReference)tre.TypeReference;
+			Assert.AreEqual("B.C", ictr.Type);
+			Assert.AreEqual(1, ictr.GenericTypes.Count);
+			Assert.AreEqual("U", ictr.GenericTypes[0].Type);
+			
+			Assert.AreEqual("A", ictr.BaseType.Type);
+			Assert.AreEqual(1, ictr.BaseType.GenericTypes.Count);
+			Assert.AreEqual("T", ictr.BaseType.GenericTypes[0].Type);
+		}
 		#endregion
 		
 		#region VB.NET
@@ -145,6 +186,49 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual(0, ie.Arguments.Count);
 		}
 		
+		[Test]
+		public void VBInvocationOnGenericType()
+		{
+			InvocationExpression expr = ParseUtilVBNet.ParseExpression<InvocationExpression>("A(Of T).Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			IdentifierExpression tre = (IdentifierExpression)mre.TargetObject;
+			Assert.AreEqual("A", tre.Identifier);
+			Assert.AreEqual("T", tre.TypeArguments[0].Type);
+		}
+		
+		[Test]
+		public void VBInvocationOnInnerClassInGenericType()
+		{
+			InvocationExpression expr = ParseUtilVBNet.ParseExpression<InvocationExpression>("A(Of T).B.Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject;
+			Assert.AreEqual("B", mre2.MemberName);
+			IdentifierExpression tre = (IdentifierExpression)mre2.TargetObject;
+			Assert.AreEqual("A", tre.Identifier);
+			Assert.AreEqual("T", tre.TypeArguments[0].Type);
+		}
+		
+		[Test]
+		public void VBInvocationOnGenericInnerClassInGenericType()
+		{
+			InvocationExpression expr = ParseUtilVBNet.ParseExpression<InvocationExpression>("A(Of T).B.C(Of U).Foo()");
+			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
+			Assert.AreEqual("Foo", mre.MemberName);
+			
+			MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject;
+			Assert.AreEqual("C", mre2.MemberName);
+			Assert.AreEqual("U", mre2.TypeArguments[0].Type);
+			
+			MemberReferenceExpression mre3 = (MemberReferenceExpression)mre2.TargetObject;
+			Assert.AreEqual("B", mre3.MemberName);
+			
+			IdentifierExpression tre = (IdentifierExpression)mre3.TargetObject;
+			Assert.AreEqual("A", tre.Identifier);
+			Assert.AreEqual("T", tre.TypeArguments[0].Type);
+		}
+		
 		#endregion
 	}
 }