Refactor ParseReflectionName to return IType instead of ITypeReference

ICSharpCode.BamlDecompiler/XamlContext.cs

@@ -27,10 +27,9 @@ using System.Reflection.Metadata;
 using System.Threading;
 using System.Xml.Linq;
 
-using ICSharpCode.Decompiler.TypeSystem;
-
 using ICSharpCode.BamlDecompiler.Baml;
 using ICSharpCode.BamlDecompiler.Xaml;
+using ICSharpCode.Decompiler.TypeSystem;
 
 namespace ICSharpCode.BamlDecompiler
 {
@@ -123,7 +122,7 @@ namespace ICSharpCode.BamlDecompiler
 			{
 				var typeRec = Baml.TypeIdMap[id];
 				(fullAssemblyName, assembly) = Baml.ResolveAssembly(typeRec.AssemblyId);
-				type = ReflectionHelper.ParseReflectionName(typeRec.TypeFullName).Resolve(new SimpleTypeResolveContext(TypeSystem));
+				type = ReflectionHelper.ParseReflectionName(typeRec.TypeFullName, new SimpleTypeResolveContext(TypeSystem));
 			}
 
 			var clrNs = type.Namespace;

ICSharpCode.Decompiler.Tests/TypeSystem/ReflectionHelperTests.cs

@@ -159,138 +159,157 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		public void ParseReflectionName()
 		{
 			var context = new SimpleTypeResolveContext(compilation.MainModule);
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32").Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32", context).ReflectionName, Is.EqualTo("System.Int32"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32&"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&", context).ReflectionName, Is.EqualTo("System.Int32&"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32*&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32*&"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32*&", context).ReflectionName, Is.EqualTo("System.Int32*&"));
-			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));
+			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName, context).ReflectionName, Is.EqualTo("System.Int32"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]", context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]", context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
-			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));
+			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName, context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder").Resolve(context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder", context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));
 		}
 
 		[Test]
 		public void ParseOpenGenericReflectionName()
 		{
-			ITypeReference typeRef = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]");
+			IType converter = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]", new SimpleTypeResolveContext(compilation.MainModule));
-			Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainModule)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
+			Assert.That(converter.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
 			IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();
-			Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
+			IType converter2 = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]", new SimpleTypeResolveContext(convertAll));
+			Assert.That(converter2.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
 		}
 
 		[Test]
 		public void ArrayOfTypeParameter()
 		{
 			var context = new SimpleTypeResolveContext(compilation.MainModule);
-			Assert.That(ReflectionHelper.ParseReflectionName("`0[,]").Resolve(context).ReflectionName, Is.EqualTo("`0[,]"));
+			Assert.That(ReflectionHelper.ParseReflectionName("`0[,]", context).ReflectionName, Is.EqualTo("`0[,]"));
 		}
 
 		[Test]
 		public void ParseNullReflectionName()
 		{
-			Assert.Throws<ArgumentNullException>(() => ReflectionHelper.ParseReflectionName(null));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ArgumentNullException>(() => ReflectionHelper.ParseReflectionName(null, context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName1()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName(string.Empty));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName(string.Empty, context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName2()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("`"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("`", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName3()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("``"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("``", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName4()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`A"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`A", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName5()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName5b()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+`"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+`", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName6()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32["));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName7()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[`]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[`]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName8()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[,"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[,", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName9()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName10()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32*a"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32*a", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName11()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[]]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[]]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName12()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]a]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]a]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName13()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName14()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName15()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32", context));
 		}
 
 		[Test]
 		public void ParseInvalidReflectionName16()
 		{
-			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],[System.String"));
+			var context = new SimpleTypeResolveContext(compilation.MainModule);
+			Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],[System.String", context));
 		}
 	}
 }

ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs

@@ -1952,8 +1952,8 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem
 		{
 			var compilationWithSystemCore = new SimpleCompilation(SystemCore, Mscorlib);
 
-			var typeRef = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core");
+			var type = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core", new SimpleTypeResolveContext(compilationWithSystemCore));
-			ITypeDefinition c = typeRef.Resolve(new SimpleTypeResolveContext(compilationWithSystemCore)).GetDefinition();
+			ITypeDefinition c = type.GetDefinition();
 			Assert.That(c, Is.Not.Null, "System.Func<,> not found");
 			Assert.That(c.ParentModule.AssemblyName, Is.EqualTo("mscorlib"));
 		}

ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs

@@ -78,7 +78,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// Constructs a FullTypeName by parsing the given reflection name.
 		/// Note that FullTypeName can only represent type definition names. If the reflection name
 		/// might refer to a parameterized type or array etc., use
-		/// <see cref="ReflectionHelper.ParseReflectionName(string)"/> instead.
+		/// <see cref="ReflectionHelper.ParseReflectionName(string, ITypeResolveContext)"/> instead.
 		/// </summary>
 		/// <remarks>
 		/// Expected syntax: <c>NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] }</c>

ICSharpCode.Decompiler/TypeSystem/INamedElement.cs

@@ -46,8 +46,8 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// Gets the full reflection name of the element.
 		/// </summary>
 		/// <remarks>
-		/// For types, the reflection name can be parsed back into a ITypeReference by using
+		/// For types, the reflection name can be parsed back into a IType by using
-		/// <see cref="ReflectionHelper.ParseReflectionName(string)"/>.
+		/// <see cref="ReflectionHelper.ParseReflectionName(string, ITypeResolveContext)"/>.
 		/// </remarks>
 		/// <returns>
 		/// "System.Int32[]" for int[]<br/>

ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs

@@ -260,12 +260,12 @@ namespace ICSharpCode.Decompiler.TypeSystem
 		/// it will look in all other assemblies of the compilation.
 		/// </remarks>
 		/// <seealso cref="FullTypeName(string)"/>
-		public static ITypeReference ParseReflectionName(string reflectionTypeName)
+		public static IType ParseReflectionName(string reflectionTypeName, ITypeResolveContext resolveContext)
 		{
 			if (reflectionTypeName == null)
 				throw new ArgumentNullException(nameof(reflectionTypeName));
 			int pos = 0;
-			ITypeReference r = ParseReflectionName(reflectionTypeName, ref pos);
+			IType r = ParseReflectionName(reflectionTypeName, ref pos).Resolve(resolveContext);
 			if (pos < reflectionTypeName.Length)
 				throw new ReflectionNameParseException(pos, "Expected end of type name");
 			return r;

ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs

@@ -168,8 +168,7 @@ namespace ICSharpCode.Decompiler.TypeSystem
 			}
 			try
 			{
-				return ReflectionHelper.ParseReflectionName(name)
+				return ReflectionHelper.ParseReflectionName(name, module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));
-					.Resolve(module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));
 			}
 			catch (ReflectionNameParseException ex)
 			{

ICSharpCode.ILSpyX/Analyzers/Builtin/FindTypeInAttributeDecoder.cs

@@ -112,8 +112,7 @@ namespace ICSharpCode.ILSpyX.Analyzers.Builtin
 			}
 			try
 			{
-				IType type = ReflectionHelper.ParseReflectionName(name)
+				IType type = ReflectionHelper.ParseReflectionName(name, new SimpleTypeResolveContext(currentModule));
-					.Resolve(new SimpleTypeResolveContext(currentModule));
 				return GetResultFromResolvedType(type);
 			}
 			catch (ReflectionNameParseException)