TypeParameterReference now resolves to a dummy type parameter instead of UnknownType when no ITypeParameter is available in the resolve context.

ICSharpCode.NRefactory.Tests/TypeSystem/ReflectionHelperTests.cs

@@ -155,12 +155,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			MethodInfo convertAllInfo = typeof(List<>).GetMethod("ConvertAll");
 			ITypeReference parameterType = convertAllInfo.GetParameters()[0].ParameterType.ToTypeReference(); // Converter[[`0],[``0]]
 			// cannot resolve generic types without knowing the parent entity:
-			Assert.AreEqual("System.Converter`2[[?],[?]]",
-			                parameterType.Resolve(compilation.TypeResolveContext).ReflectionName);
+			IType resolvedWithoutEntity = parameterType.Resolve(compilation.TypeResolveContext);
+			Assert.AreEqual("System.Converter`2[[`0],[``0]]", resolvedWithoutEntity.ReflectionName);
+			Assert.IsNull(((ITypeParameter)((ParameterizedType)resolvedWithoutEntity).GetTypeArgument(0)).Owner);
 			// now try with parent entity:
 			IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();
-			Assert.AreEqual("System.Converter`2[[`0],[``0]]",
-			                parameterType.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName);
+			IType resolvedWithEntity = parameterType.Resolve(new SimpleTypeResolveContext(convertAll));
+			Assert.AreEqual("System.Converter`2[[`0],[``0]]", resolvedWithEntity.ReflectionName);
+			Assert.AreSame(convertAll.DeclaringTypeDefinition, ((ITypeParameter)((ParameterizedType)resolvedWithEntity).GetTypeArgument(0)).Owner);
 		}
 		
 		[Test]
@@ -181,7 +183,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		public void ParseOpenGenericReflectionName()
 		{
 			ITypeReference typeRef = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]");
-			Assert.AreEqual("System.Converter`2[[?],[?]]", typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).ReflectionName);
+			Assert.AreEqual("System.Converter`2[[`0],[``0]]", typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)).ReflectionName);
 			IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();
 			Assert.AreEqual("System.Converter`2[[`0],[``0]]", typeRef.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName);
 		}

ICSharpCode.NRefactory/TypeSystem/Implementation/DummyTypeParameter.cs

@@ -71,7 +71,15 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		public override string Name {
-			get { return "!" + index; }
+			get {
+				return (ownerType == EntityType.Method ? "!!" : "!") + index;
+			}
+		}
+		
+		public override string ReflectionName {
+			get {
+				return (ownerType == EntityType.Method ? "``" : "`") + index;
+			}
 		}
 		
 		public override bool? IsReferenceType {

ICSharpCode.NRefactory/TypeSystem/Implementation/TypeParameterReference.cs

@@ -39,13 +39,16 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 				if (method != null && index < method.TypeParameters.Count) {
 					return method.TypeParameters[index];
 				}
+				return DummyTypeParameter.GetMethodTypeParameter(index);
 			} else if (ownerType == EntityType.TypeDefinition) {
 				ITypeDefinition typeDef = context.CurrentTypeDefinition;
 				if (typeDef != null && index < typeDef.TypeParameters.Count) {
 					return typeDef.TypeParameters[index];
 				}
+				return DummyTypeParameter.GetClassTypeParameter(index);
+			} else {
+				return SpecialType.UnknownType;
 			}
-			return SpecialType.UnknownType;
 		}
 		
 		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)