Add TrimmingTest and add one more test case in the NativeAOT test app

Author: jkoritzinsky

src/libraries/System.Runtime.InteropServices/tests/TrimmingTests/System.Runtime.InteropServices.TrimmingTests.proj

@@ -19,6 +19,7 @@
     </TestConsoleAppSourceFiles>
 
     <TestConsoleAppSourceFiles Include="TypeMap.cs" NativeAotOnly="true">
+      <EnabledProperties>IlcGenerateMstatFile;IlcGenerateDgmlFile</EnabledProperties>
     </TestConsoleAppSourceFiles>
   </ItemGroup>
 

src/libraries/System.Runtime.InteropServices/tests/TrimmingTests/TypeMap.cs

@@ -58,35 +58,41 @@
     return 4;
 }
 
+if (GetTypeWithoutTrimAnalysis("TrimTarget") is not null)
+{
+    Console.WriteLine("TrimTarget should not be preserved if the only place that would preserve it is a check that is optimized away.");
+    return 5;
+}
+
 if (usedTypeMap.TryGetValue("TrimTargetIsUnreferenced", out _))
 {
     Console.WriteLine("TrimTargetIsUnreferenced should not be found in used type map.");
-    return 5;
+    return 6;
 }
 
 IReadOnlyDictionary<Type, Type> usedProxyTypeMap = TypeMapping.GetOrCreateProxyTypeMapping<UsedTypeMap>();
 if (!usedProxyTypeMap.TryGetValue(typeof(SourceClass), out Type proxyType))
 {
     Console.WriteLine("SourceClass not found in used proxy type map.");
-    return 6;
+    return 7;
 }
 
 if (proxyType != GetTypeWithoutTrimAnalysis("ProxyType"))
 {
     Console.WriteLine("SourceClass proxy type does not match expected type.");
-    return 7;
+    return 8;
 }
 
 if (GetTypeWithoutTrimAnalysis("UnusedTargetType") is not null)
 {
     Console.WriteLine("UnusedTargetType should not be preserved if the external type map is not used and it is not referenced otherwise even if the entry's trim target is kept.");
-    return 8;
+    return 9;
 }
 
 if (GetTypeWithoutTrimAnalysis("UnusedProxyType") is not null)
 {
     Console.WriteLine("UnusedProxyType should not be preserved if the proxy type map is not used and it is not referenced otherwise even if the entry's source type is kept.");
-    return 9;
+    return 10;
 }
 
 return 100;

src/tools/illink/test/Mono.Linker.Tests.Cases/Reflection/TypeMap.cs

@@ -0,0 +1,120 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Reflection;
+
+[assembly: TypeMap<UsedTypeMap> ("TrimTargetIsTarget", typeof (TargetAndTrimTarget), typeof (TargetAndTrimTarget))]
+[assembly: TypeMap<UsedTypeMap> ("TrimTargetIsUnrelated", typeof (TargetType), typeof (TrimTarget))]
+[assembly: TypeMap<UsedTypeMap> ("TrimTargetIsUnreferenced", typeof (UnreferencedTargetType), typeof (UnreferencedTrimTarget))]
+[assembly: TypeMapAssociation<UsedTypeMap> (typeof (SourceClass), typeof (ProxyType))]
+
+[assembly: TypeMap<UnusedTypeMap> ("UnusedName", typeof (UnusedTargetType), typeof (TrimTarget))]
+[assembly: TypeMapAssociation<UsedTypeMap> (typeof (UnusedSourceClass), typeof (UnusedProxyType))]
+
+namespace Mono.Linker.Tests.Cases.Reflection
+{
+	[Kept]
+	[IgnoreTestCase("Trimmer support is currently not implemented", IgnoredBy = Tool.Trimmer)]
+	class TypeMap
+	{
+		[Kept]
+		public static void Main(string[] args)
+		{
+			object t = Activator.CreateInstance (Type.GetType (args[1]));
+			if (t is TargetAndTrimTarget) {
+				Console.WriteLine ("Type deriving from TargetAndTrimTarget instantiated.");
+			} else if (t is TrimTarget) {
+				Console.WriteLine ("Type deriving from TrimTarget instantiated.");
+			}
+
+			Console.WriteLine ("Hash code of SourceClass instance: " + new SourceClass ().GetHashCode ());
+
+			Console.WriteLine (TypeMapping.GetOrCreateExternalTypeMapping<UsedTypeMap> ());
+			Console.WriteLine (TypeMapping.GetOrCreateProxyTypeMapping<UsedTypeMap> ());
+		}
+	}
+
+	[Kept(By = Tool.Trimmer)]
+	class UsedTypeMap;
+
+	[Kept]
+	class TargetAndTrimTarget;
+
+	[Kept]
+	class TargetType;
+
+	[Kept]
+	class TrimTarget;
+
+	class UnreferencedTargetType;
+
+	class UnreferencedTrimTarget;
+
+	[Kept]
+	[KeptMember(".ctor()")]
+	class SourceClass;
+
+	[Kept]
+	class ProxyType;
+
+	class UnusedTypeMap;
+	class UnusedTargetType;
+	class UnusedSourceClass;
+	class UnusedProxyType;
+}
+
+// Polyfill for the type map types until we use an LKG runtime that has it.
+namespace System.Runtime.InteropServices
+{
+	[Kept (By = Tool.Trimmer)]
+	[KeptBaseType (typeof (Attribute), By = Tool.Trimmer)]
+	[KeptAttributeAttribute (typeof (AttributeUsageAttribute), By = Tool.Trimmer)]
+	[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
+	public sealed class TypeMapAttribute<TTypeMapGroup> : Attribute
+	{
+		[Kept (By = Tool.Trimmer)]
+		public TypeMapAttribute (string value, Type target) { }
+
+		[Kept (By = Tool.Trimmer)]
+		[KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute), By = Tool.Trimmer)]
+		[RequiresUnreferencedCode ("Interop types may be removed by trimming")]
+		public TypeMapAttribute (string value, Type target, Type trimTarget) { }
+	}
+
+	[Kept (By = Tool.Trimmer)]
+	[KeptBaseType (typeof (Attribute), By = Tool.Trimmer)]
+	[KeptAttributeAttribute (typeof (AttributeUsageAttribute), By = Tool.Trimmer)]
+	[AttributeUsage (AttributeTargets.Assembly, AllowMultiple = true)]
+	public sealed class TypeMapAssociationAttribute<TTypeMapGroup> : Attribute
+	{
+		[Kept (By = Tool.Trimmer)]
+		public TypeMapAssociationAttribute (Type source, Type proxy) { }
+	}
+
+	[Kept(By = Tool.Trimmer)]
+	public static class TypeMapping
+	{
+		[Kept(By = Tool.Trimmer)]
+		[KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute), By = Tool.Trimmer)]
+		[RequiresUnreferencedCode ("Interop types may be removed by trimming")]
+		public static IReadOnlyDictionary<string, Type> GetOrCreateExternalTypeMapping<TTypeMapGroup> ()
+		{
+			throw new NotImplementedException ();
+		}
+
+		[Kept(By = Tool.Trimmer)]
+		[KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute), By = Tool.Trimmer)]
+		[RequiresUnreferencedCode ("Interop types may be removed by trimming")]
+		public static IReadOnlyDictionary<Type, Type> GetOrCreateProxyTypeMapping<TTypeMapGroup> ()
+		{
+			throw new NotImplementedException ();
+		}
+	}
+}
+