Documentation signature parser tests and fixes for NativeAOT (#79168)

vitek-karas · web-flow · commit c4b37daf1a18 · 2022-12-06T10:34:01.000-08:00
This ports infra for the "MemberAssertions" tests which linker uses.
It then ports the document signature parser test from linker.

And adds fixes to make the tests pass. After this AOT and Linker are behaving exactly the same with regard to the tests we have for this area.
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logging/DocumentationSignatureGenerator.PartVisitor.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logging/DocumentationSignatureGenerator.PartVisitor.cs
@@ -17,9 +17,9 @@ public sealed partial class DocumentationSignatureGenerator
         ///  Adapted from Roslyn's DocumentattionCommentIDVisitor.PartVisitor:
         ///  https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/DocumentationComments/DocumentationCommentIDVisitor.PartVisitor.cs
         /// </summary>
-        internal sealed class PartVisitor : TypeNameFormatter
+        public sealed class PartVisitor : TypeNameFormatter
         {
-            internal static readonly PartVisitor Instance = new PartVisitor();
+            public static readonly PartVisitor Instance = new PartVisitor();
 
             private PartVisitor()
             {
@@ -146,7 +146,7 @@ public override void AppendName(StringBuilder builder, GenericParameterDesc gene
 
             protected override void AppendNameForNestedType(StringBuilder sb, DefType nestedType, DefType containingType)
             {
-                AppendName(sb, containingType);
+                AppendName(sb, InstantiateContainingType(nestedType));
                 sb.Append('.');
                 sb.Append(nestedType.Name);
             }
@@ -162,10 +162,11 @@ protected override void AppendNameForNamespaceType(StringBuilder sb, DefType typ
             protected override void AppendNameForInstantiatedType(StringBuilder builder, DefType type)
             {
                 int containingArity = 0;
-                DefType containingType = type.ContainingType;
+                DefType containingType = InstantiateContainingType(type);
                 if (containingType != null)
                 {
                     AppendName(builder, containingType);
+                    builder.Append('.');
                     containingArity = containingType.Instantiation.Length;
                 }
                 else
@@ -177,7 +178,8 @@ protected override void AppendNameForInstantiatedType(StringBuilder builder, Def
 
                 string unmangledName = type.Name;
                 int totalArity = type.Instantiation.Length;
-                string expectedSuffix = $"`{totalArity}";
+                int nestedArity = totalArity - containingArity;
+                string expectedSuffix = $"`{nestedArity}";
                 if (unmangledName.EndsWith(expectedSuffix))
                     unmangledName = unmangledName.Substring(0, unmangledName.Length - expectedSuffix.Length);
 
@@ -218,6 +220,20 @@ private static string GetEscapedMetadataName(IMemberDefinition member)
                 return name.Replace('<', '{').Replace('>', '}');
             }
 #endif
+
+            private static DefType InstantiateContainingType(DefType type)
+            {
+                DefType containingType = type.ContainingType;
+                if (containingType is null)
+                    return null;
+
+                // If the type doesn't follow C# scheme where nested types inherit generic parameters from their container type
+                // return the container type as-is.
+                if (!containingType.HasInstantiation || containingType.Instantiation.Length > type.Instantiation.Length)
+                    return containingType;
+
+                return (DefType)containingType.InstantiateAsOpen().InstantiateSignature(type.Instantiation, default);
+            }
         }
     }
 }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logging/DocumentationSignatureParser.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logging/DocumentationSignatureParser.cs
@@ -8,6 +8,7 @@
 using System.Text;
 
 using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
 
 namespace ILCompiler.Logging
 {
@@ -210,21 +211,17 @@ public static void GetMatchingMembers(string id, ref int index, ModuleDesc modul
                 index = startIndex;
             }
 
-#if false
             if (memberTypes.HasFlag(MemberType.Property))
             {
                 GetMatchingProperties(id, ref index, containingType, memberName, results, acceptName);
                 endIndex = index;
                 index = startIndex;
             }
-#endif
 
             index = endIndex;
 
-#if false
             if (memberTypes.HasFlag(MemberType.Event))
                 GetMatchingEvents(containingType, memberName, results);
-#endif
 
             if (memberTypes.HasFlag(MemberType.Field))
                 GetMatchingFields(containingType, memberName, results);
@@ -536,7 +533,7 @@ private static void GetMatchingTypes(ModuleDesc module, TypeDesc declaringType,
                 string namepart;
                 if (indexOfLastDot > 0 && indexOfLastDot < name.Length - 1)
                 {
-                    namespacepart = name.Substring(indexOfLastDot - 1);
+                    namespacepart = name.Substring(0, indexOfLastDot);
                     namepart = name.Substring(indexOfLastDot + 1);
                 }
                 else
@@ -631,10 +628,9 @@ private static void GetMatchingMethods(string id, ref int index, TypeDesc type,
             index = endIndex;
         }
 
-#if false
-        static void GetMatchingProperties(string id, ref int index, TypeDesc type, string memberName, List<TypeSystemEntity> results, bool acceptName = false)
+        private static void GetMatchingProperties(string id, ref int index, TypeDesc typeDesc, string memberName, List<TypeSystemEntity> results, bool acceptName = false)
         {
-            if (type == null)
+            if (typeDesc is not EcmaType type)
                 return;
 
             int startIndex = index;
@@ -643,11 +639,14 @@ static void GetMatchingProperties(string id, ref int index, TypeDesc type, strin
             List<string> parameters = null;
             // Unlike Roslyn, we don't need to decode property names because we are working
             // directly with IL.
-            foreach (var property in type.Properties)
+            foreach (var propertyHandle in type.MetadataReader.GetTypeDefinition(type.Handle).GetProperties())
             {
+                var p = new PropertyPseudoDesc(type, propertyHandle);
+
                 index = startIndex;
-                if (property.Name != memberName)
+                if (p.Name != memberName)
                     continue;
+
                 if (PeekNextChar(id, index) == '(')
                 {
                     if (parameters == null)
@@ -658,23 +657,22 @@ static void GetMatchingProperties(string id, ref int index, TypeDesc type, strin
                     {
                         parameters.Clear();
                     }
-                    if (!ParseParameterList(id, ref index, property.DeclaringType, parameters))
+                    if (!ParseParameterList(id, ref index, p.OwningType, parameters))
                         continue;
-                    if (!AllParametersMatch(property.Parameters, parameters))
+                    if (!AllParametersMatch(p.Signature, parameters))
                         continue;
                 }
                 else
                 {
-                    if (!acceptName && property.Parameters.Count != 0)
+                    if (!acceptName && p.Signature.Length != 0)
                         continue;
                 }
-                results.Add(property);
+                results.Add(p);
                 endIndex = index;
             }
 
             index = endIndex;
         }
-#endif
 
         private static void GetMatchingFields(TypeDesc type, string memberName, List<TypeSystemEntity> results)
         {
@@ -688,19 +686,19 @@ private static void GetMatchingFields(TypeDesc type, string memberName, List<Typ
             }
         }
 
-#if false
-        static void GetMatchingEvents(TypeDesc type, string memberName, List<TypeSystemEntity> results)
+        private static void GetMatchingEvents(TypeDesc typeDesc, string memberName, List<TypeSystemEntity> results)
         {
-            if (type == null)
+            if (typeDesc is not EcmaType type)
                 return;
-            foreach (var evt in type.Events)
+
+            foreach (var eventHandle in type.MetadataReader.GetTypeDefinition(type.Handle).GetEvents())
             {
-                if (evt.Name != memberName)
+                var e = new EventPseudoDesc(type, eventHandle);
+                if (e.Name != memberName)
                     continue;
-                results.Add(evt);
+                results.Add(e);
             }
         }
-#endif
 
         private static bool AllParametersMatch(MethodSignature methodParameters, List<string> expectedParameters)
         {
@@ -716,6 +714,20 @@ private static bool AllParametersMatch(MethodSignature methodParameters, List<st
             return true;
         }
 
+        private static bool AllParametersMatch(PropertySignature propertyParameters, List<string> expectedParameters)
+        {
+            if (propertyParameters.Length != expectedParameters.Count)
+                return false;
+
+            for (int i = 0; i < expectedParameters.Count; i++)
+            {
+                if (GetSignaturePart(propertyParameters[i]) != expectedParameters[i])
+                    return false;
+            }
+
+            return true;
+        }
+
         private static bool ParseParameterList(string id, ref int index, TypeSystemEntity typeParameterContext, List<string> parameters)
         {
             Debug.Assert(typeParameterContext != null);
diff --git a/src/coreclr/tools/aot/Mono.Linker.Tests/TestCases/TestDatabase.cs b/src/coreclr/tools/aot/Mono.Linker.Tests/TestCases/TestDatabase.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using Mono.Linker.Tests.Extensions;
 using Mono.Linker.Tests.TestCasesRunner;
 
@@ -15,17 +16,17 @@ public static class TestDatabase
 
 		public static IEnumerable<object[]> DataFlow ()
 		{
-			return TestNamesBySuiteName ("DataFlow");
+			return TestNamesBySuiteName ();
 		}
 
 		public static IEnumerable<object[]> Repro ()
 		{
-			return TestNamesBySuiteName ("Repro");
+			return TestNamesBySuiteName ();
 		}
 
 		public static IEnumerable<object[]> RequiresCapability ()
 		{
-			return TestNamesBySuiteName ("RequiresCapability");
+			return TestNamesBySuiteName ();
 		}
 
 		public static TestCaseCollector CreateCollector ()
@@ -57,7 +58,7 @@ private static IEnumerable<TestCase> AllCases ()
 			return AllCases ().FirstOrDefault (c => c.Name == name);
 		}
 
-		private static IEnumerable<object[]> TestNamesBySuiteName (string suiteName)
+		private static IEnumerable<object[]> TestNamesBySuiteName ([CallerMemberName] string suiteName = "")
 		{
 			return AllCases ()
 				.Where (c => c.TestSuiteDirectory.FileName == suiteName)
diff --git a/src/coreclr/tools/aot/Mono.Linker.Tests/TestCasesRunner/ILCompilerDriver.cs b/src/coreclr/tools/aot/Mono.Linker.Tests/TestCasesRunner/ILCompilerDriver.cs
@@ -16,7 +16,7 @@ namespace Mono.Linker.Tests.TestCasesRunner
 {
 	public class ILCompilerDriver
 	{
-		private const string DefaultSystemModule = "System.Private.CoreLib";
+		internal const string DefaultSystemModule = "System.Private.CoreLib";
 
 		public ILScanResults Trim (ILCompilerOptions options, ILogWriter logWriter)
 		{
diff --git a/src/coreclr/tools/aot/Mono.Linker.Tests/TestCasesRunner/MemberAssertionsCollector.cs b/src/coreclr/tools/aot/Mono.Linker.Tests/TestCasesRunner/MemberAssertionsCollector.cs
diff --git a/src/coreclr/tools/aot/Mono.Linker.Tests/Tests/DocumentationSignatureParserTests.cs b/src/coreclr/tools/aot/Mono.Linker.Tests/Tests/DocumentationSignatureParserTests.cs

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,9 @@ public sealed partial class DocumentationSignatureGenerator`
`17`	`17`	`/// Adapted from Roslyn's DocumentattionCommentIDVisitor.PartVisitor:`
`18`	`18`	`/// https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/DocumentationComments/DocumentationCommentIDVisitor.PartVisitor.cs`
`19`	`19`	`/// </summary>`
`20`		`- internal sealed class PartVisitor : TypeNameFormatter`
	`20`	`+ public sealed class PartVisitor : TypeNameFormatter`
`21`	`21`	`{`
`22`		`- internal static readonly PartVisitor Instance = new PartVisitor();`
	`22`	`+ public static readonly PartVisitor Instance = new PartVisitor();`
`23`	`23`
`24`	`24`	`private PartVisitor()`
`25`	`25`	`{`
`@@ -146,7 +146,7 @@ public override void AppendName(StringBuilder builder, GenericParameterDesc gene`
`146`	`146`
`147`	`147`	`protected override void AppendNameForNestedType(StringBuilder sb, DefType nestedType, DefType containingType)`
`148`	`148`	`{`
`149`		`- AppendName(sb, containingType);`
	`149`	`+ AppendName(sb, InstantiateContainingType(nestedType));`
`150`	`150`	`sb.Append('.');`
`151`	`151`	`sb.Append(nestedType.Name);`
`152`	`152`	`}`
`@@ -162,10 +162,11 @@ protected override void AppendNameForNamespaceType(StringBuilder sb, DefType typ`
`162`	`162`	`protected override void AppendNameForInstantiatedType(StringBuilder builder, DefType type)`
`163`	`163`	`{`
`164`	`164`	`int containingArity = 0;`
`165`		`- DefType containingType = type.ContainingType;`
	`165`	`+ DefType containingType = InstantiateContainingType(type);`
`166`	`166`	`if (containingType != null)`
`167`	`167`	`{`
`168`	`168`	`AppendName(builder, containingType);`
	`169`	`+ builder.Append('.');`
`169`	`170`	`containingArity = containingType.Instantiation.Length;`
`170`	`171`	`}`
`171`	`172`	`else`
`@@ -177,7 +178,8 @@ protected override void AppendNameForInstantiatedType(StringBuilder builder, Def`
`177`	`178`
`178`	`179`	`string unmangledName = type.Name;`
`179`	`180`	`int totalArity = type.Instantiation.Length;`
`180`		- string expectedSuffix = $"`{totalArity}";
	`181`	`+ int nestedArity = totalArity - containingArity;`
	`182`	+ string expectedSuffix = $"`{nestedArity}";
`181`	`183`	`if (unmangledName.EndsWith(expectedSuffix))`
`182`	`184`	`unmangledName = unmangledName.Substring(0, unmangledName.Length - expectedSuffix.Length);`
`183`	`185`
`@@ -218,6 +220,20 @@ private static string GetEscapedMetadataName(IMemberDefinition member)`
`218`	`220`	`return name.Replace('<', '{').Replace('>', '}');`
`219`	`221`	`}`
`220`	`222`	`#endif`
	`223`	`+`
	`224`	`+ private static DefType InstantiateContainingType(DefType type)`
	`225`	`+ {`
	`226`	`+ DefType containingType = type.ContainingType;`
	`227`	`+ if (containingType is null)`
	`228`	`+ return null;`
	`229`	`+`
	`230`	`+ // If the type doesn't follow C# scheme where nested types inherit generic parameters from their container type`
	`231`	`+ // return the container type as-is.`
	`232`	`+ if (!containingType.HasInstantiation \|\| containingType.Instantiation.Length > type.Instantiation.Length)`
	`233`	`+ return containingType;`
	`234`	`+`
	`235`	`+ return (DefType)containingType.InstantiateAsOpen().InstantiateSignature(type.Instantiation, default);`
	`236`	`+ }`
`221`	`237`	`}`
`222`	`238`	`}`
`223`	`239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using System.Text;`
`9`	`9`
`10`	`10`	`using Internal.TypeSystem;`
	`11`	`+using Internal.TypeSystem.Ecma;`
`11`	`12`
`12`	`13`	`namespace ILCompiler.Logging`
`13`	`14`	`{`
`@@ -210,21 +211,17 @@ public static void GetMatchingMembers(string id, ref int index, ModuleDesc modul`
`210`	`211`	`index = startIndex;`
`211`	`212`	`}`
`212`	`213`
`213`		`-#if false`
`214`	`214`	`if (memberTypes.HasFlag(MemberType.Property))`
`215`	`215`	`{`
`216`	`216`	`GetMatchingProperties(id, ref index, containingType, memberName, results, acceptName);`
`217`	`217`	`endIndex = index;`
`218`	`218`	`index = startIndex;`
`219`	`219`	`}`
`220`		`-#endif`
`221`	`220`
`222`	`221`	`index = endIndex;`
`223`	`222`
`224`		`-#if false`
`225`	`223`	`if (memberTypes.HasFlag(MemberType.Event))`
`226`	`224`	`GetMatchingEvents(containingType, memberName, results);`
`227`		`-#endif`
`228`	`225`
`229`	`226`	`if (memberTypes.HasFlag(MemberType.Field))`
`230`	`227`	`GetMatchingFields(containingType, memberName, results);`
`@@ -536,7 +533,7 @@ private static void GetMatchingTypes(ModuleDesc module, TypeDesc declaringType,`
`536`	`533`	`string namepart;`
`537`	`534`	`if (indexOfLastDot > 0 && indexOfLastDot < name.Length - 1)`
`538`	`535`	`{`
`539`		`- namespacepart = name.Substring(indexOfLastDot - 1);`
	`536`	`+ namespacepart = name.Substring(0, indexOfLastDot);`
`540`	`537`	`namepart = name.Substring(indexOfLastDot + 1);`
`541`	`538`	`}`
`542`	`539`	`else`
`@@ -631,10 +628,9 @@ private static void GetMatchingMethods(string id, ref int index, TypeDesc type,`
`631`	`628`	`index = endIndex;`
`632`	`629`	`}`
`633`	`630`
`634`		`-#if false`
`635`		`- static void GetMatchingProperties(string id, ref int index, TypeDesc type, string memberName, List<TypeSystemEntity> results, bool acceptName = false)`
	`631`	`+ private static void GetMatchingProperties(string id, ref int index, TypeDesc typeDesc, string memberName, List<TypeSystemEntity> results, bool acceptName = false)`
`636`	`632`	`{`
`637`		`- if (type == null)`
	`633`	`+ if (typeDesc is not EcmaType type)`
`638`	`634`	`return;`
`639`	`635`
`640`	`636`	`int startIndex = index;`
`@@ -643,11 +639,14 @@ static void GetMatchingProperties(string id, ref int index, TypeDesc type, strin`
`643`	`639`	`List<string> parameters = null;`
`644`	`640`	`// Unlike Roslyn, we don't need to decode property names because we are working`
`645`	`641`	`// directly with IL.`
`646`		`- foreach (var property in type.Properties)`
	`642`	`+ foreach (var propertyHandle in type.MetadataReader.GetTypeDefinition(type.Handle).GetProperties())`
`647`	`643`	`{`
	`644`	`+ var p = new PropertyPseudoDesc(type, propertyHandle);`
	`645`	`+`
`648`	`646`	`index = startIndex;`
`649`		`- if (property.Name != memberName)`
	`647`	`+ if (p.Name != memberName)`
`650`	`648`	`continue;`
	`649`	`+`
`651`	`650`	`if (PeekNextChar(id, index) == '(')`
`652`	`651`	`{`
`653`	`652`	`if (parameters == null)`
`@@ -658,23 +657,22 @@ static void GetMatchingProperties(string id, ref int index, TypeDesc type, strin`
`658`	`657`	`{`
`659`	`658`	`parameters.Clear();`
`660`	`659`	`}`
`661`		`- if (!ParseParameterList(id, ref index, property.DeclaringType, parameters))`
	`660`	`+ if (!ParseParameterList(id, ref index, p.OwningType, parameters))`
`662`	`661`	`continue;`
`663`		`- if (!AllParametersMatch(property.Parameters, parameters))`
	`662`	`+ if (!AllParametersMatch(p.Signature, parameters))`
`664`	`663`	`continue;`
`665`	`664`	`}`
`666`	`665`	`else`
`667`	`666`	`{`
`668`		`- if (!acceptName && property.Parameters.Count != 0)`
	`667`	`+ if (!acceptName && p.Signature.Length != 0)`
`669`	`668`	`continue;`
`670`	`669`	`}`
`671`		`- results.Add(property);`
	`670`	`+ results.Add(p);`
`672`	`671`	`endIndex = index;`
`673`	`672`	`}`
`674`	`673`
`675`	`674`	`index = endIndex;`
`676`	`675`	`}`
`677`		`-#endif`
`678`	`676`
`679`	`677`	`private static void GetMatchingFields(TypeDesc type, string memberName, List<TypeSystemEntity> results)`
`680`	`678`	`{`
`@@ -688,19 +686,19 @@ private static void GetMatchingFields(TypeDesc type, string memberName, List<Typ`
`688`	`686`	`}`
`689`	`687`	`}`
`690`	`688`
`691`		`-#if false`
`692`		`- static void GetMatchingEvents(TypeDesc type, string memberName, List<TypeSystemEntity> results)`
	`689`	`+ private static void GetMatchingEvents(TypeDesc typeDesc, string memberName, List<TypeSystemEntity> results)`
`693`	`690`	`{`
`694`		`- if (type == null)`
	`691`	`+ if (typeDesc is not EcmaType type)`
`695`	`692`	`return;`
`696`		`- foreach (var evt in type.Events)`
	`693`	`+`
	`694`	`+ foreach (var eventHandle in type.MetadataReader.GetTypeDefinition(type.Handle).GetEvents())`
`697`	`695`	`{`
`698`		`- if (evt.Name != memberName)`
	`696`	`+ var e = new EventPseudoDesc(type, eventHandle);`
	`697`	`+ if (e.Name != memberName)`
`699`	`698`	`continue;`
`700`		`- results.Add(evt);`
	`699`	`+ results.Add(e);`
`701`	`700`	`}`
`702`	`701`	`}`
`703`		`-#endif`
`704`	`702`
`705`	`703`	`private static bool AllParametersMatch(MethodSignature methodParameters, List<string> expectedParameters)`
`706`	`704`	`{`
`@@ -716,6 +714,20 @@ private static bool AllParametersMatch(MethodSignature methodParameters, List<st`
`716`	`714`	`return true;`
`717`	`715`	`}`
`718`	`716`
	`717`	`+ private static bool AllParametersMatch(PropertySignature propertyParameters, List<string> expectedParameters)`
	`718`	`+ {`
	`719`	`+ if (propertyParameters.Length != expectedParameters.Count)`
	`720`	`+ return false;`
	`721`	`+`
	`722`	`+ for (int i = 0; i < expectedParameters.Count; i++)`
	`723`	`+ {`
	`724`	`+ if (GetSignaturePart(propertyParameters[i]) != expectedParameters[i])`
	`725`	`+ return false;`
	`726`	`+ }`
	`727`	`+`
	`728`	`+ return true;`
	`729`	`+ }`
	`730`	`+`
`719`	`731`	`private static bool ParseParameterList(string id, ref int index, TypeSystemEntity typeParameterContext, List<string> parameters)`
`720`	`732`	`{`
`721`	`733`	`Debug.Assert(typeParameterContext != null);`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.IO;`
`6`	`6`	`using System.Linq;`
	`7`	`+using System.Runtime.CompilerServices;`
`7`	`8`	`using Mono.Linker.Tests.Extensions;`
`8`	`9`	`using Mono.Linker.Tests.TestCasesRunner;`
`9`	`10`
`@@ -15,17 +16,17 @@ public static class TestDatabase`
`15`	`16`
`16`	`17`	`public static IEnumerable<object[]> DataFlow ()`
`17`	`18`	`{`
`18`		`- return TestNamesBySuiteName ("DataFlow");`
	`19`	`+ return TestNamesBySuiteName ();`
`19`	`20`	`}`
`20`	`21`
`21`	`22`	`public static IEnumerable<object[]> Repro ()`
`22`	`23`	`{`
`23`		`- return TestNamesBySuiteName ("Repro");`
	`24`	`+ return TestNamesBySuiteName ();`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`public static IEnumerable<object[]> RequiresCapability ()`
`27`	`28`	`{`
`28`		`- return TestNamesBySuiteName ("RequiresCapability");`
	`29`	`+ return TestNamesBySuiteName ();`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`public static TestCaseCollector CreateCollector ()`
`@@ -57,7 +58,7 @@ private static IEnumerable<TestCase> AllCases ()`
`57`	`58`	`return AllCases ().FirstOrDefault (c => c.Name == name);`
`58`	`59`	`}`
`59`	`60`
`60`		`- private static IEnumerable<object[]> TestNamesBySuiteName (string suiteName)`
	`61`	`+ private static IEnumerable<object[]> TestNamesBySuiteName ([CallerMemberName] string suiteName = "")`
`61`	`62`	`{`
`62`	`63`	`return AllCases ()`
`63`	`64`	`.Where (c => c.TestSuiteDirectory.FileName == suiteName)`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace Mono.Linker.Tests.TestCasesRunner`
`16`	`16`	`{`
`17`	`17`	`public class ILCompilerDriver`
`18`	`18`	`{`
`19`		`- private const string DefaultSystemModule = "System.Private.CoreLib";`
	`19`	`+ internal const string DefaultSystemModule = "System.Private.CoreLib";`
`20`	`20`
`21`	`21`	`public ILScanResults Trim (ILCompilerOptions options, ILogWriter logWriter)`
`22`	`22`	`{`