Refactor ParseReflectionName to return IType instead of ITypeReference

siegfriedpammer · siegfriedpammer · commit 33e497eb8096 · 2025-08-02T11:39:01.000+02:00
diff --git a/ICSharpCode.BamlDecompiler/XamlContext.cs b/ICSharpCode.BamlDecompiler/XamlContext.cs
@@ -27,10 +27,9 @@ THE SOFTWARE.
 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 @@ public XamlType ResolveType(ushort id)
 			{
 				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;
diff --git a/ICSharpCode.Decompiler.Tests/TypeSystem/ReflectionHelperTests.cs b/ICSharpCode.Decompiler.Tests/TypeSystem/ReflectionHelperTests.cs
@@ -159,138 +159,157 @@ public void TestToTypeReferenceGenericType()
 		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&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32&"));
-			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32*&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32*&"));
-			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName).Resolve(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, mscorlib]]").Resolve(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("System.Environment+SpecialFolder").Resolve(context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32", context).ReflectionName, Is.EqualTo("System.Int32"));
+			Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&", 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, context).ReflectionName, Is.EqualTo("System.Int32"));
+			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]]", context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
+			Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName, context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));
+			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]]");
-			Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainModule)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
+			IType converter = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]", new SimpleTypeResolveContext(compilation.MainModule));
+			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));
 		}
 	}
 }
diff --git a/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs b/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs
@@ -1952,8 +1952,8 @@ public void FindRedirectedType()
 		{
 			var compilationWithSystemCore = new SimpleCompilation(SystemCore, Mscorlib);
 
-			var typeRef = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core");
-			ITypeDefinition c = typeRef.Resolve(new SimpleTypeResolveContext(compilationWithSystemCore)).GetDefinition();
+			var type = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core", new SimpleTypeResolveContext(compilationWithSystemCore));
+			ITypeDefinition c = type.GetDefinition();
 			Assert.That(c, Is.Not.Null, "System.Func<,> not found");
 			Assert.That(c.ParentModule.AssemblyName, Is.EqualTo("mscorlib"));
 		}
diff --git a/ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs b/ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs
@@ -78,7 +78,7 @@ public FullTypeName(TopLevelTypeName topLevelTypeName)
 		/// 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>
diff --git a/ICSharpCode.Decompiler/TypeSystem/INamedElement.cs b/ICSharpCode.Decompiler/TypeSystem/INamedElement.cs
@@ -46,8 +46,8 @@ public interface INamedElement
 		/// Gets the full reflection name of the element.
 		/// </summary>
 		/// <remarks>
-		/// For types, the reflection name can be parsed back into a ITypeReference by using
-		/// <see cref="ReflectionHelper.ParseReflectionName(string)"/>.
+		/// For types, the reflection name can be parsed back into a IType by using
+		/// <see cref="ReflectionHelper.ParseReflectionName(string, ITypeResolveContext)"/>.
 		/// </remarks>
 		/// <returns>
 		/// "System.Int32[]" for int[]<br/>
diff --git a/ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs b/ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs
@@ -260,12 +260,12 @@ public static TypeCode GetTypeCode(this IType type)
 		/// 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;
diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs b/ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs
@@ -168,8 +168,7 @@ public IType GetTypeFromSerializedName(string name)
 			}
 			try
 			{
-				return ReflectionHelper.ParseReflectionName(name)
-					.Resolve(module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));
+				return ReflectionHelper.ParseReflectionName(name, module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));
 			}
 			catch (ReflectionNameParseException ex)
 			{
diff --git a/ICSharpCode.ILSpyX/Analyzers/Builtin/FindTypeInAttributeDecoder.cs b/ICSharpCode.ILSpyX/Analyzers/Builtin/FindTypeInAttributeDecoder.cs
@@ -112,8 +112,7 @@ public TokenSearchResult GetTypeFromSerializedName(string name)
 			}
 			try
 			{
-				IType type = ReflectionHelper.ParseReflectionName(name)
-					.Resolve(new SimpleTypeResolveContext(currentModule));
+				IType type = ReflectionHelper.ParseReflectionName(name, new SimpleTypeResolveContext(currentModule));
 				return GetResultFromResolvedType(type);
 			}
 			catch (ReflectionNameParseException)

Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,9 @@ THE SOFTWARE.`
`27`	`27`	`using System.Threading;`
`28`	`28`	`using System.Xml.Linq;`
`29`	`29`
`30`		`-using ICSharpCode.Decompiler.TypeSystem;`
`31`		`-`
`32`	`30`	`using ICSharpCode.BamlDecompiler.Baml;`
`33`	`31`	`using ICSharpCode.BamlDecompiler.Xaml;`
	`32`	`+using ICSharpCode.Decompiler.TypeSystem;`
`34`	`33`
`35`	`34`	`namespace ICSharpCode.BamlDecompiler`
`36`	`35`	`{`
`@@ -123,7 +122,7 @@ public XamlType ResolveType(ushort id)`
`123`	`122`	`{`
`124`	`123`	`var typeRec = Baml.TypeIdMap[id];`
`125`	`124`	`(fullAssemblyName, assembly) = Baml.ResolveAssembly(typeRec.AssemblyId);`
`126`		`- type = ReflectionHelper.ParseReflectionName(typeRec.TypeFullName).Resolve(new SimpleTypeResolveContext(TypeSystem));`
	`125`	`+ type = ReflectionHelper.ParseReflectionName(typeRec.TypeFullName, new SimpleTypeResolveContext(TypeSystem));`
`127`	`126`	`}`
`128`	`127`
`129`	`128`	`var clrNs = type.Namespace;`
Original file line number	Diff line number	Diff line change
`@@ -159,138 +159,157 @@ public void TestToTypeReferenceGenericType()`
`159`	`159`	`public void ParseReflectionName()`
`160`	`160`	`{`
`161`	`161`	`var context = new SimpleTypeResolveContext(compilation.MainModule);`
`162`		`- Assert.That(ReflectionHelper.ParseReflectionName("System.Int32").Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));`
`163`		`- Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32&"));`
`164`		`- Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&").Resolve(context).ReflectionName, Is.EqualTo("System.Int32&"));`
`165`		`- Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32"));`
`166`		- Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
`167`		- Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]").Resolve(context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
`168`		`- Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName).Resolve(context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));`
`169`		`- Assert.That(ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder").Resolve(context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));`
	`162`	`+ Assert.That(ReflectionHelper.ParseReflectionName("System.Int32", context).ReflectionName, Is.EqualTo("System.Int32"));`
	`163`	`+ Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&", context).ReflectionName, Is.EqualTo("System.Int32&"));`
	`164`	`+ Assert.That(ReflectionHelper.ParseReflectionName("System.Int32&", context).ReflectionName, Is.EqualTo("System.Int32&"));`
	`165`	`+ Assert.That(ReflectionHelper.ParseReflectionName(typeof(int).AssemblyQualifiedName, context).ReflectionName, Is.EqualTo("System.Int32"));`
	`166`	+ Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String]]", context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
	`167`	+ Assert.That(ReflectionHelper.ParseReflectionName("System.Action`1[[System.String, mscorlib]]", context).ReflectionName, Is.EqualTo("System.Action`1[[System.String]]"));
	`168`	`+ Assert.That(ReflectionHelper.ParseReflectionName(typeof(int[,][,,]).AssemblyQualifiedName, context).ReflectionName, Is.EqualTo("System.Int32[,,][,]"));`
	`169`	`+ Assert.That(ReflectionHelper.ParseReflectionName("System.Environment+SpecialFolder", context).ReflectionName, Is.EqualTo("System.Environment+SpecialFolder"));`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`[Test]`
`173`	`173`	`public void ParseOpenGenericReflectionName()`
`174`	`174`	`{`
`175`		- ITypeReference typeRef = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]");
`176`		- Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(compilation.MainModule)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
	`175`	+ IType converter = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]", new SimpleTypeResolveContext(compilation.MainModule));
	`176`	+ Assert.That(converter.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
`177`	`177`	`IMethod convertAll = compilation.FindType(typeof(List<>)).GetMethods(m => m.Name == "ConvertAll").Single();`
`178`		- Assert.That(typeRef.Resolve(new SimpleTypeResolveContext(convertAll)).ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
	`178`	+ IType converter2 = ReflectionHelper.ParseReflectionName("System.Converter`2[[`0],[``0]]", new SimpleTypeResolveContext(convertAll));
	`179`	+ Assert.That(converter2.ReflectionName, Is.EqualTo("System.Converter`2[[`0],[``0]]"));
`179`	`180`	`}`
`180`	`181`
`181`	`182`	`[Test]`
`182`	`183`	`public void ArrayOfTypeParameter()`
`183`	`184`	`{`
`184`	`185`	`var context = new SimpleTypeResolveContext(compilation.MainModule);`
`185`		- Assert.That(ReflectionHelper.ParseReflectionName("`0[,]").Resolve(context).ReflectionName, Is.EqualTo("`0[,]"));
	`186`	+ Assert.That(ReflectionHelper.ParseReflectionName("`0[,]", context).ReflectionName, Is.EqualTo("`0[,]"));
`186`	`187`	`}`
`187`	`188`
`188`	`189`	`[Test]`
`189`	`190`	`public void ParseNullReflectionName()`
`190`	`191`	`{`
`191`		`- Assert.Throws<ArgumentNullException>(() => ReflectionHelper.ParseReflectionName(null));`
	`192`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`193`	`+ Assert.Throws<ArgumentNullException>(() => ReflectionHelper.ParseReflectionName(null, context));`
`192`	`194`	`}`
`193`	`195`
`194`	`196`	`[Test]`
`195`	`197`	`public void ParseInvalidReflectionName1()`
`196`	`198`	`{`
`197`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName(string.Empty));`
	`199`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`200`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName(string.Empty, context));`
`198`	`201`	`}`
`199`	`202`
`200`	`203`	`[Test]`
`201`	`204`	`public void ParseInvalidReflectionName2()`
`202`	`205`	`{`
`203`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("`"));
	`206`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`207`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("`", context));
`204`	`208`	`}`
`205`	`209`
`206`	`210`	`[Test]`
`207`	`211`	`public void ParseInvalidReflectionName3()`
`208`	`212`	`{`
`209`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("``"));
	`213`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`214`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("``", context));
`210`	`215`	`}`
`211`	`216`
`212`	`217`	`[Test]`
`213`	`218`	`public void ParseInvalidReflectionName4()`
`214`	`219`	`{`
`215`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`A"));
	`220`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`221`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`A", context));
`216`	`222`	`}`
`217`	`223`
`218`	`224`	`[Test]`
`219`	`225`	`public void ParseInvalidReflectionName5()`
`220`	`226`	`{`
`221`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+"));`
	`227`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`228`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+", context));`
`222`	`229`	`}`
`223`	`230`
`224`	`231`	`[Test]`
`225`	`232`	`public void ParseInvalidReflectionName5b()`
`226`	`233`	`{`
`227`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+`"));
	`234`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`235`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Environment+`", context));
`228`	`236`	`}`
`229`	`237`
`230`	`238`	`[Test]`
`231`	`239`	`public void ParseInvalidReflectionName6()`
`232`	`240`	`{`
`233`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32["));`
	`241`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`242`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[", context));`
`234`	`243`	`}`
`235`	`244`
`236`	`245`	`[Test]`
`237`	`246`	`public void ParseInvalidReflectionName7()`
`238`	`247`	`{`
`239`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[`]"));
	`248`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`249`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[`]", context));
`240`	`250`	`}`
`241`	`251`
`242`	`252`	`[Test]`
`243`	`253`	`public void ParseInvalidReflectionName8()`
`244`	`254`	`{`
`245`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[,"));`
	`255`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`256`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32[,", context));`
`246`	`257`	`}`
`247`	`258`
`248`	`259`	`[Test]`
`249`	`260`	`public void ParseInvalidReflectionName9()`
`250`	`261`	`{`
`251`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32]"));`
	`262`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`263`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32]", context));`
`252`	`264`	`}`
`253`	`265`
`254`	`266`	`[Test]`
`255`	`267`	`public void ParseInvalidReflectionName10()`
`256`	`268`	`{`
`257`		`- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32*a"));`
	`269`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`270`	`+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Int32*a", context));`
`258`	`271`	`}`
`259`	`272`
`260`	`273`	`[Test]`
`261`	`274`	`public void ParseInvalidReflectionName11()`
`262`	`275`	`{`
`263`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[]]"));
	`276`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`277`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[]]", context));
`264`	`278`	`}`
`265`	`279`
`266`	`280`	`[Test]`
`267`	`281`	`public void ParseInvalidReflectionName12()`
`268`	`282`	`{`
`269`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]a]"));
	`283`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`284`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]a]", context));
`270`	`285`	`}`
`271`	`286`
`272`	`287`	`[Test]`
`273`	`288`	`public void ParseInvalidReflectionName13()`
`274`	`289`	`{`
`275`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],]"));
	`290`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`291`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],]", context));
`276`	`292`	`}`
`277`	`293`
`278`	`294`	`[Test]`
`279`	`295`	`public void ParseInvalidReflectionName14()`
`280`	`296`	`{`
`281`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]"));
	`297`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`298`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32]", context));
`282`	`299`	`}`
`283`	`300`
`284`	`301`	`[Test]`
`285`	`302`	`public void ParseInvalidReflectionName15()`
`286`	`303`	`{`
`287`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32"));
	`304`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`305`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32", context));
`288`	`306`	`}`
`289`	`307`
`290`	`308`	`[Test]`
`291`	`309`	`public void ParseInvalidReflectionName16()`
`292`	`310`	`{`
`293`		- Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],[System.String"));
	`311`	`+ var context = new SimpleTypeResolveContext(compilation.MainModule);`
	`312`	+ Assert.Throws<ReflectionNameParseException>(() => ReflectionHelper.ParseReflectionName("System.Action`1[[System.Int32],[System.String", context));
`294`	`313`	`}`
`295`	`314`	`}`
`296`	`315`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1952,8 +1952,8 @@ public void FindRedirectedType()`
`1952`	`1952`	`{`
`1953`	`1953`	`var compilationWithSystemCore = new SimpleCompilation(SystemCore, Mscorlib);`
`1954`	`1954`
`1955`		- var typeRef = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core");
`1956`		`- ITypeDefinition c = typeRef.Resolve(new SimpleTypeResolveContext(compilationWithSystemCore)).GetDefinition();`
	`1955`	+ var type = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core", new SimpleTypeResolveContext(compilationWithSystemCore));
	`1956`	`+ ITypeDefinition c = type.GetDefinition();`
`1957`	`1957`	`Assert.That(c, Is.Not.Null, "System.Func<,> not found");`
`1958`	`1958`	`Assert.That(c.ParentModule.AssemblyName, Is.EqualTo("mscorlib"));`
`1959`	`1959`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,8 +168,7 @@ public IType GetTypeFromSerializedName(string name)`
`168`	`168`	`}`
`169`	`169`	`try`
`170`	`170`	`{`
`171`		`- return ReflectionHelper.ParseReflectionName(name)`
`172`		`- .Resolve(module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));`
	`171`	`+ return ReflectionHelper.ParseReflectionName(name, module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation));`
`173`	`172`	`}`
`174`	`173`	`catch (ReflectionNameParseException ex)`
`175`	`174`	`{`
Original file line number	Diff line number	Diff line change
`@@ -112,8 +112,7 @@ public TokenSearchResult GetTypeFromSerializedName(string name)`
`112`	`112`	`}`
`113`	`113`	`try`
`114`	`114`	`{`
`115`		`- IType type = ReflectionHelper.ParseReflectionName(name)`
`116`		`- .Resolve(new SimpleTypeResolveContext(currentModule));`
	`115`	`+ IType type = ReflectionHelper.ParseReflectionName(name, new SimpleTypeResolveContext(currentModule));`
`117`	`116`	`return GetResultFromResolvedType(type);`
`118`	`117`	`}`
`119`	`118`	`catch (ReflectionNameParseException)`