Trimming: Add tests for handling of annotated string type names representing generic instantiations (#95143)

This change:
* Adds new tests which validate behavior of generic parameter data flow when the type is specified as a string in either an annotated parameter or Type.GetType
  * This found new issues in both the analyzer and NativeAOT
    * #95140
    * #95118
* Adds a test for invalid type name in the same situation - this is basically another test for #94830 (And the related fix in #95109)
* Fixes test names in the NativeAOT test infra for the shared tests
* Enable the generic parameter data flow warnings test full validation in the analyzer
  * This surfaced a lot of issues in the analyzer around generic parameter data flow - #95121

Author: vitek-karas

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestCase.cs

@@ -23,6 +23,8 @@ public TestCase (NPath sourceFile, NPath rootCasesDirectory, NPath originalTestC
 			DisplayName = sourceFile.FileNameWithoutExtension == "Program" && sourceFile.Parent.FileName == originalTestCaseAssemblyPath.FileNameWithoutExtension
 				? displayNameBase
 				: $"{displayNameBase}.{sourceFile.FileNameWithoutExtension}";
+			if (DisplayName.StartsWith("."))
+				DisplayName = DisplayName.Substring(1);
 
 			// A little hacky, but good enough for name.  No reason why namespace & type names
 			// should not follow the directory structure

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestSuites.cs

@@ -37,28 +37,28 @@ public void InlineArrays(string t)
 			Run(t);
 		}
 
-        [Theory]
-        [MemberData(nameof(TestDatabase.Inheritance_Interaces), MemberType = typeof(TestDatabase))]
-        public void Inheritance_Interfaces(string t)
-        {
-            switch (t) {
-            case ".InterfaceWithoutNewSlot":
-                Run (t);
-                break;
-            default:
-                // Skip the rest for now
-                break;
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TestDatabase.Libraries), MemberType = typeof(TestDatabase))]
-        public void Libraries(string t)
-        {
-            Run(t);
-        }
-
-        [Theory]
+		[Theory]
+		[MemberData(nameof(TestDatabase.Inheritance_Interaces), MemberType = typeof(TestDatabase))]
+		public void Inheritance_Interfaces(string t)
+		{
+			switch (t) {
+			case ".InterfaceWithoutNewSlot":
+				Run (t);
+				break;
+			default:
+				// Skip the rest for now
+				break;
+			}
+		}
+
+		[Theory]
+		[MemberData(nameof(TestDatabase.Libraries), MemberType = typeof(TestDatabase))]
+		public void Libraries(string t)
+		{
+			Run(t);
+		}
+
+		[Theory]
 		[MemberData (nameof (TestDatabase.LinkXml), MemberType = typeof (TestDatabase))]
 		public void LinkXml (string t)
 		{
@@ -73,6 +73,7 @@ public void Reflection (string t)
 			case "TypeHierarchyReflectionWarnings":
 			case "ParametersUsedViaReflection":
 			case "UnsafeAccessor":
+			case "TypeUsedViaReflection":
 				Run (t);
 				break;
 			default:

src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/RequireDynamicallyAccessedMembersAction.cs

@@ -24,6 +24,7 @@ public RequireDynamicallyAccessedMembersAction (
 		public partial bool TryResolveTypeNameAndMark (string typeName, bool needsAssemblyName, out TypeProxy type)
 		{
 			// TODO: Implement type name resolution to type symbol
+			// https://github.com/dotnet/runtime/issues/95118
 
 			// Important corner cases:
 			//   IL2105 (see it's occurences in the tests) - non-assembly qualified type name which doesn't resolve warns

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/DataFlowTests.cs

@@ -164,7 +164,13 @@ public Task FileScopedClasses ()
 		[Fact]
 		public Task GenericParameterDataFlow ()
 		{
-			return RunTest (nameof (GenericParameterDataFlow));
+			return RunTest ();
+		}
+
+		[Fact]
+		public Task GenericParameterWarningLocation ()
+		{
+			return RunTest ();
 		}
 
 		[Fact]

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/DataFlowTests.g.cs

@@ -19,12 +19,6 @@ public Task GenericParameterDataFlowMarking ()
 			return RunTest (allowMissingWarnings: true);
 		}
 
-		[Fact]
-		public Task GenericParameterWarningLocation ()
-		{
-			return RunTest (allowMissingWarnings: true);
-		}
-
 		[Fact]
 		public Task MethodByRefParameterDataFlow ()
 		{

src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs

@@ -55,8 +55,8 @@ public static void TestKeepsPublicMethods ()
 
 			[Kept]
 			[KeptAttributeAttribute (typeof (KeepsPublicMethodsAttribute))]
-			// Trimmer/NativeAot only for now - https://github.com/dotnet/linker/issues/2273
-			[ExpectedWarning ("IL2026", "--ClassWithKeptPublicMethodsKeptByName--", ProducedBy = Tool.Trimmer | Tool.NativeAot)]
+            // Trimmer/NativeAot only for now - https://github.com/dotnet/runtime/issues/95118
+            [ExpectedWarning ("IL2026", "--ClassWithKeptPublicMethodsKeptByName--", ProducedBy = Tool.Trimmer | Tool.NativeAot)]
 			[KeepsPublicMethods (TypeName = "Mono.Linker.Tests.Cases.DataFlow.AttributePropertyDataflow+AttributesOnMethod+ClassWithKeptPublicMethodsKeptByName")]
 			public static void TestKeepsPublicMethodsByName ()
 			{

src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/GenericParameterWarningLocation.cs

@@ -41,11 +41,14 @@ public static void Main ()
 			TestTypeOverloadWith5ParametersWithIgnoreCase ();
 			TestTypeOverloadWith5ParametersWithoutIgnoreCase ();
 			TestInvalidTypeName ();
-			TestUnkownIgnoreCase3Params (1);
-			TestUnkownIgnoreCase5Params (1);
+			TestUnknownIgnoreCase3Params (1);
+			TestUnknownIgnoreCase5Params (1);
 			TestGenericTypeWithAnnotations ();
 
 			BaseTypeInterfaces.Test ();
+
+
+			TestInvalidTypeCombination ();
 		}
 
 		[Kept]
@@ -327,8 +330,9 @@ static void TestTypeOverloadWith4Parameters ()
 		public class OverloadWith5ParametersWithIgnoreCase { }
 
 		[Kept]
-		// Small difference in formatting between analyzer/linker
+		// Small difference in formatting between analyzer/NativeAOT/linker
 		[ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)'", ProducedBy = Tool.Trimmer)]
+		[ExpectedWarning ("IL2096", "'System.Type.GetType(String,Func`2<AssemblyName,Assembly>,Func`4<Assembly,String,Boolean,Type>,Boolean,Boolean)'", ProducedBy = Tool.NativeAot)]
 		[ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>, Boolean, Boolean)'", ProducedBy = Tool.Analyzer)]
 		static void TestTypeOverloadWith5ParametersWithIgnoreCase ()
 		{
@@ -371,18 +375,19 @@ static Type GetTypeFromAssembly (Assembly assembly, string name, bool caseSensit
 
 		[Kept]
 		[ExpectedWarning ("IL2096", "'System.Type.GetType(String, Boolean, Boolean)'")]
-		static void TestUnkownIgnoreCase3Params (int num)
+		static void TestUnknownIgnoreCase3Params (int num)
 		{
 			const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseUnknown2, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null";
 			bool unknownValue = num + 1 == 1;
 			var typeKept = Type.GetType (reflectionTypeKeptString, false, unknownValue);
 		}
 
 		[Kept]
-		// Small difference in formatting between analyzer/linker
+		// Small difference in formatting between analyzer/NativeAOT/linker
 		[ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)'", ProducedBy = Tool.Trimmer)]
+		[ExpectedWarning ("IL2096", "'System.Type.GetType(String,Func`2<AssemblyName,Assembly>,Func`4<Assembly,String,Boolean,Type>,Boolean,Boolean)'", ProducedBy = Tool.NativeAot)]
 		[ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName, Assembly>, Func<Assembly, String, Boolean, Type>, Boolean, Boolean)'", ProducedBy = Tool.Analyzer)]
-		static void TestUnkownIgnoreCase5Params (int num)
+		static void TestUnknownIgnoreCase5Params (int num)
 		{
 			const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseUnknown2, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null";
 			bool unknownValue = num + 1 == 1;
@@ -399,9 +404,10 @@ public class GenericTypeWithAnnotations_OuterType<
 		[Kept]
 		public class GenericTypeWithAnnotations_InnerType
 		{
-			[Kept]
+			// NativeAOT: https://github.com/dotnet/runtime/issues/95140
+			[Kept (By = Tool.Trimmer)]
 			[KeptBackingField]
-			private static bool PrivateProperty { [Kept] get; [Kept] set; }
+			private static bool PrivateProperty { [Kept (By = Tool.Trimmer)] get; [Kept (By = Tool.Trimmer)] set; }
 
 			private static void PrivateMethod () { }
 		}
@@ -421,7 +427,7 @@ class BaseTypeInterfaces
 			[Kept]
 			interface ITest
 			{
-				[Kept]
+				[Kept (By = Tool.Trimmer)]
 				void Method ();
 			}
 
@@ -450,5 +456,15 @@ public static void Test ()
 				typeof (DerivedType).GetInterfaces ();
 			}
 		}
+
+		[Kept]
+		static void TestInvalidTypeCombination ()
+		{
+			try {
+				// It's invalid to create an array of Span
+				// This should throw at runtime, but should not warn nor fail the compilation
+				Console.WriteLine (Type.GetType ("System.Span`1[[System.Byte, System.Runtime]][], System.Runtime"));
+			} catch (Exception e) { }
+		}
 	}
 }