Add ExcludeStatics support to trimming tools (#117904)

Adds ILLink/ILC/analyzer implementation
for ExcludeStatics on RequiresUnreferencedCode
and RequiresDynamicCode.

---------

Co-authored-by: Copilot <[email protected]>

Author: sbomer

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/DiagnosticUtilities.cs

@@ -101,7 +101,13 @@ internal static bool IsInRequiresScope(this MethodDesc method, string requiresAt
                 return true;
 
             if (method.OwningType is TypeDesc type && TryGetRequiresAttribute(type, requiresAttribute, out attribute))
-                return true;
+            {
+                if (!ExcludeStatics(attribute.Value))
+                    return true;
+
+                if (!method.Signature.IsStatic)
+                    return true;
+            }
 
             if (method.GetPropertyForAccessor() is PropertyPseudoDesc property && TryGetRequiresAttribute(property, requiresAttribute, out attribute))
                 return true;
@@ -123,7 +129,13 @@ internal static bool DoesMethodRequire(this MethodDesc method, string requiresAt
 
             if ((method.Signature.IsStatic || method.IsConstructor) && method.OwningType is TypeDesc owningType &&
                 !owningType.IsArray && TryGetRequiresAttribute(owningType, requiresAttribute, out attribute))
-                return true;
+            {
+                if (!ExcludeStatics(attribute.Value))
+                    return true;
+
+                if (method.IsConstructor)
+                    return true;
+            }
 
             if (method.GetPropertyForAccessor() is PropertyPseudoDesc @property
                 && TryGetRequiresAttribute(@property, requiresAttribute, out attribute))
@@ -144,7 +156,7 @@ internal static bool DoesFieldRequire(this FieldDesc field, string requiresAttri
                 return false;
             }
 
-            return TryGetRequiresAttribute(field.OwningType, requiresAttribute, out attribute);
+            return TryGetRequiresAttribute(field.OwningType, requiresAttribute, out attribute) && !ExcludeStatics(attribute.Value);
         }
 
         internal static bool DoesPropertyRequire(this PropertyPseudoDesc property, string requiresAttribute, [NotNullWhen(returnValue: true)] out CustomAttributeValue<TypeDesc>? attribute) =>
@@ -174,6 +186,20 @@ internal static bool DoesMemberRequire(this TypeSystemEntity member, string requ
             };
         }
 
+        private static bool ExcludeStatics(CustomAttributeValue<TypeDesc> attribute)
+        {
+            foreach (var namedArgument in attribute.NamedArguments)
+            {
+                if (namedArgument.Name == "ExcludeStatics" &&
+                    namedArgument.Value is bool excludeStatics &&
+                    excludeStatics)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         internal const string RequiresUnreferencedCodeAttribute = nameof(RequiresUnreferencedCodeAttribute);
         internal const string RequiresDynamicCodeAttribute = nameof(RequiresDynamicCodeAttribute);
         internal const string RequiresAssemblyFilesAttribute = nameof(RequiresAssemblyFilesAttribute);

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCasesRunner/AssemblyChecker.cs

@@ -60,6 +60,8 @@ class LinkedMethodEntity : LinkedEntity
             "<Module>.MainMethodWrapper()",
             "<Module>.MainMethodWrapper(String[])",
             "System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.__GetFieldHelper(Int32,MethodTable*&)",
+            "System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute.__GetFieldHelper(Int32,MethodTable*&)",
+            "System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute.__GetFieldHelper(Int32,MethodTable*&)",
             "System.Runtime.InteropServices.TypeMapping",
             "System.Runtime.InteropServices.TypeMapping.GetOrCreateExternalTypeMapping<TTypeMapGroup>()",
             "System.Runtime.InteropServices.TypeMapping.GetOrCreateProxyTypeMapping<TTypeMapGroup>()",

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCasesRunner/TestCaseCompilationMetadataProvider.cs

@@ -138,6 +138,12 @@ public IEnumerable<NPath> GetCommonSourceFiles()
                 .Combine("Support")
                 .Combine("DynamicallyAccessedMembersAttribute.cs");
             yield return dam;
+
+            var sharedDir = _testCase.RootCasesDirectory.Parent.Parent
+                .Combine("src")
+                .Combine("ILLink.Shared");
+            yield return sharedDir.Combine("RequiresDynamicCodeAttribute.cs");
+            yield return sharedDir.Combine("RequiresUnreferencedCodeAttribute.cs");
         }
 
         public virtual IEnumerable<string> GetCommonReferencedAssemblies(NPath workingDirectory)

src/tools/illink/src/ILLink.RoslynAnalyzer/RequiresISymbolExtensions.cs

@@ -22,8 +22,14 @@ public static bool DoesMemberRequire(this ISymbol member, string requiresAttribu
                 return true;
 
             // Also check the containing type
-            if (member.IsStatic || member.IsConstructor())
-                return member.ContainingType.TryGetAttribute(requiresAttribute, out requiresAttributeData);
+            if ((member.IsStatic || member.IsConstructor()) && member.ContainingType.TryGetAttribute(requiresAttribute, out requiresAttributeData))
+            {
+                if (!ExcludeStatics(requiresAttributeData))
+                    return true;
+
+                if (member.IsConstructor())
+                    return true;
+            }
 
             return false;
         }
@@ -33,6 +39,18 @@ public static bool IsInRequiresScope(this ISymbol member, string attributeName)
             return member.IsInRequiresScope(attributeName, out _);
         }
 
+        private static bool ExcludeStatics(AttributeData attributeData)
+        {
+            foreach (var namedArg in attributeData.NamedArguments)
+            {
+                if (namedArg.Key == "ExcludeStatics" && namedArg.Value.Value is bool b)
+                {
+                    return b;
+                }
+            }
+            return false;
+        }
+
         // TODO: Consider sharing with ILLink IsInRequiresScope method
         /// <summary>
         /// True if the source of a call is considered to be annotated with the Requires... attribute
@@ -58,7 +76,13 @@ public static bool IsInRequiresScope(this ISymbol member, string attributeName,
             }
 
             if (member.ContainingType is ITypeSymbol containingType && containingType.TryGetAttribute(attributeName, out requiresAttribute))
-                return true;
+            {
+                if (!ExcludeStatics(requiresAttribute))
+                        return true;
+
+                if (!member.IsStatic)
+                    return true;
+            }
 
             if (member is IMethodSymbol { AssociatedSymbol: { } associated } && associated.TryGetAttribute(attributeName, out requiresAttribute))
                 return true;

src/tools/illink/src/ILLink.Shared/RequiresDynamicCodeAttribute.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if INCLUDE_EXPECTATIONS
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+#endif
+
+#nullable enable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Indicates that the specified method requires the ability to generate new code at runtime,
+    /// for example through <see cref="Reflection"/>.
+    /// </summary>
+    /// <remarks>
+    /// This allows tools to understand which methods are unsafe to call when compiling ahead of time.
+    /// </remarks>
+#if INCLUDE_EXPECTATIONS
+    [SkipKeptItemsValidation]
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+    sealed class RequiresDynamicCodeAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequiresDynamicCodeAttribute"/> class
+        /// with the specified message.
+        /// </summary>
+        /// <param name="message">
+        /// A message that contains information about the usage of dynamic code.
+        /// </param>
+        public RequiresDynamicCodeAttribute(string message)
+        {
+            Message = message;
+        }
+
+        /// <summary>
+        /// Indicates whether the attribute should apply to static members.
+        /// </summary>
+        public bool ExcludeStatics { get; set; }
+
+        /// <summary>
+        /// Gets a message that contains information about the usage of dynamic code.
+        /// </summary>
+        public string Message { get; }
+
+        /// <summary>
+        /// Gets or sets an optional URL that contains more information about the method,
+        /// why it requires dynamic code, and what options a consumer has to deal with it.
+        /// </summary>
+        public string? Url { get; set; }
+    }
+}

src/tools/illink/src/ILLink.Shared/RequiresUnreferencedCodeAttribute.cs

@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if INCLUDE_EXPECTATIONS
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+#endif
+
+#nullable enable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Indicates that the specified method requires dynamic access to code that is not referenced
+    /// statically, for example through <see cref="Reflection"/>.
+    /// </summary>
+    /// <remarks>
+    /// This allows tools to understand which methods are unsafe to call when removing unreferenced
+    /// code from an application.
+    /// </remarks>
+#if INCLUDE_EXPECTATIONS
+    [SkipKeptItemsValidation]
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+        sealed class RequiresUnreferencedCodeAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequiresUnreferencedCodeAttribute"/> class
+        /// with the specified message.
+        /// </summary>
+        /// <param name="message">
+        /// A message that contains information about the usage of unreferenced code.
+        /// </param>
+        public RequiresUnreferencedCodeAttribute(string message)
+        {
+            Message = message;
+        }
+
+        /// <summary>
+        /// Indicates whether the attribute should apply to static members.
+        /// </summary>
+        public bool ExcludeStatics { get; set; }
+
+        /// <summary>
+        /// Gets a message that contains information about the usage of unreferenced code.
+        /// </summary>
+        public string Message { get; }
+
+        /// <summary>
+        /// Gets or sets an optional URL that contains more information about the method,
+        /// why it requires unreferenced code, and what options a consumer has to deal with it.
+        /// </summary>
+        public string? Url { get; set; }
+    }
+}

src/tools/illink/src/linker/Linker/Annotations.cs

@@ -626,7 +626,13 @@ internal bool IsInRequiresUnreferencedCodeScope(MethodDefinition method, [NotNul
                 return true;
 
             if (method.DeclaringType is not null && TryGetLinkerAttribute(method.DeclaringType, out attribute))
-                return true;
+            {
+                if (!attribute.ExcludeStatics)
+                    return true;
+
+                if (!method.IsStatic)
+                    return true;
+            }
 
             attribute = null;
             return false;
@@ -676,7 +682,13 @@ internal bool DoesMethodRequireUnreferencedCode(MethodDefinition originalMethod,
 
                 if ((method.IsStatic || method.IsConstructor) && method.DeclaringType is not null &&
                     TryGetLinkerAttribute(method.DeclaringType, out attribute))
-                    return true;
+                {
+                    if (!attribute.ExcludeStatics)
+                        return true;
+
+                    if (method.IsConstructor)
+                        return true;
+                }
             } while (context.CompilerGeneratedState.TryGetOwningMethodForCompilerGeneratedMember(method, out method));
 
             attribute = null;
@@ -691,7 +703,7 @@ internal bool DoesFieldRequireUnreferencedCode(FieldDefinition field, [NotNullWh
                 return false;
             }
 
-            return TryGetLinkerAttribute(field.DeclaringType, out attribute);
+            return TryGetLinkerAttribute(field.DeclaringType, out attribute) && !attribute.ExcludeStatics;
         }
 
         /// <Summary>

src/tools/illink/src/linker/Linker/LinkerAttributesInformation.cs

@@ -120,20 +120,28 @@ public IEnumerable<T> GetAttributes<T>() where T : Attribute
 
             if (customAttribute.HasConstructorArguments && customAttribute.ConstructorArguments[0].Value is string message)
             {
-                var ruca = new RequiresUnreferencedCodeAttribute(message);
+                string? url = null;
+                bool excludeStatics = false;
                 if (customAttribute.HasProperties)
                 {
                     foreach (var prop in customAttribute.Properties)
                     {
                         if (prop.Name == "Url")
                         {
-                            ruca.Url = prop.Argument.Value as string;
-                            break;
+                            url = prop.Argument.Value as string;
+                        }
+                        else if (prop.Name == "ExcludeStatics" && prop.Argument.Value is true)
+                        {
+                            excludeStatics = true;
                         }
                     }
                 }
 
-                return ruca;
+                return new RequiresUnreferencedCodeAttribute(message)
+                {
+                    Url = url,
+                    ExcludeStatics = excludeStatics
+                };
             }
 
             context.LogWarning((IMemberDefinition)provider, DiagnosticId.AttributeDoesntHaveTheRequiredNumberOfParameters, typeof(RequiresUnreferencedCodeAttribute).FullName ?? "");

src/tools/illink/src/linker/Mono.Linker.csproj

@@ -21,6 +21,8 @@
     <RollForward>Major</RollForward>
     <UseAppHost>false</UseAppHost>
     <NoWarn>$(NoWarn);NU5131</NoWarn>
+    <!-- Allow overriding RequiresUnreferencedCodeAttribute -->
+    <NoWarn>$(NoWarn);CS0436</NoWarn>
     <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);_AddReferenceAssemblyToPackage</TargetsForTfmSpecificContentInPackage>
     <DefineConstants>$(DefineConstants);ILLINK</DefineConstants>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

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

@@ -34,6 +34,12 @@ public Task RequiresAttributeMismatch()
             return RunTest(nameof(RequiresAttributeMismatch));
         }
 
+        [Fact]
+        public Task RequiresExcludeStatics()
+        {
+            return RunTest();
+        }
+
         [Fact]
         public Task RequiresCapabilityFromCopiedAssembly()
         {