Add ILLink/ILCompiler support for feature checks (#99267)

This will substitute static boolean properties with `false` when
decorated with `[FeatureGuard(typeof(SomeFeature))]`, where
`SomeFeature` is known to be disabled.

The "feature" of unreferenced code, represented by
`RequiresUnreferencedCodeAttribute`, is always considered
disabled. For ILC, `RequiresDynamicCodeAttribute` and
`RequiresAssemblyFilesAttribute` are also disabled. ILLink also
respects the feature switch for `IsDynamicCodeSupported` to
disable the `RequiresDynamicCodeAttribute` feature.

We don't want this kicking in when trimming in library mode, so
this adds an ILLink option to disable the optimization.

Additionally, a property is substituted if it has
`[FeatureSwitchDefinition("SomeFeatureName")]` and
`"SomeFeatureName"` is set in the command-line arguments.

XML substitutions take precedence over this behavior.

Includes a few tweaks and cleanup to the analyzer logic.

Author: sbomer

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/SubstitutionProvider.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using System.Resources;
@@ -33,11 +34,84 @@ public BodySubstitution GetSubstitution(MethodDesc method)
                 AssemblyFeatureInfo info = _hashtable.GetOrCreateValue(ecmaMethod.Module);
                 if (info.BodySubstitutions != null && info.BodySubstitutions.TryGetValue(ecmaMethod, out BodySubstitution result))
                     return result;
+
+                if (TryGetFeatureCheckValue(ecmaMethod, out bool value))
+                    return BodySubstitution.Create(value ? 1 : 0);
             }
 
             return null;
         }
 
+        private bool TryGetFeatureCheckValue(EcmaMethod method, out bool value)
+        {
+            value = false;
+
+            if (!method.Signature.IsStatic)
+                return false;
+
+            if (!method.Signature.ReturnType.IsWellKnownType(WellKnownType.Boolean))
+                return false;
+
+            if (FindProperty(method) is not PropertyPseudoDesc property)
+                return false;
+
+            if (property.SetMethod != null)
+                return false;
+
+            foreach (var featureSwitchDefinitionAttribute in property.GetDecodedCustomAttributes("System.Diagnostics.CodeAnalysis", "FeatureSwitchDefinitionAttribute"))
+            {
+                if (featureSwitchDefinitionAttribute.FixedArguments is not [CustomAttributeTypedArgument<TypeDesc> { Value: string switchName }])
+                    continue;
+
+                // If there's a FeatureSwitchDefinition, don't continue looking for FeatureGuard.
+                // We don't want to infer feature switch settings from FeatureGuard.
+                return _hashtable._switchValues.TryGetValue(switchName, out value);
+            }
+
+            foreach (var featureGuardAttribute in property.GetDecodedCustomAttributes("System.Diagnostics.CodeAnalysis", "FeatureGuardAttribute"))
+            {
+                if (featureGuardAttribute.FixedArguments is not [CustomAttributeTypedArgument<TypeDesc> { Value: EcmaType featureType }])
+                    continue;
+
+                if (featureType.Namespace == "System.Diagnostics.CodeAnalysis") {
+                    switch (featureType.Name) {
+                    case "RequiresAssemblyFilesAttribute":
+                    case "RequiresUnreferencedCodeAttribute":
+                        return true;
+                    case "RequiresDynamicCodeAttribute":
+                        if (_hashtable._switchValues.TryGetValue(
+                                "System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported",
+                                out bool isDynamicCodeSupported)
+                            && !isDynamicCodeSupported)
+                            return true;
+                        break;
+                    }
+                }
+            }
+
+            return false;
+
+            static PropertyPseudoDesc FindProperty(EcmaMethod method)
+            {
+                if ((method.Attributes & MethodAttributes.SpecialName) == 0)
+                    return null;
+
+                if (method.OwningType is not EcmaType declaringType)
+                    return null;
+
+                var reader = declaringType.MetadataReader;
+                foreach (PropertyDefinitionHandle propertyHandle in reader.GetTypeDefinition(declaringType.Handle).GetProperties())
+                {
+                    PropertyDefinition propertyDef = reader.GetPropertyDefinition(propertyHandle);
+                    var property = new PropertyPseudoDesc(declaringType, propertyHandle);
+                    if (property.GetMethod == method)
+                        return property;
+                }
+
+                return null;
+            }
+        }
+
         public object GetSubstitution(FieldDesc field)
         {
             if (field.GetTypicalFieldDefinition() is EcmaField ecmaField)

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

@@ -69,6 +69,11 @@ public static IEnumerable<object[]> SingleFile ()
 			return TestNamesBySuiteName ();
 		}
 
+		public static IEnumerable<object[]> Substitutions ()
+		{
+			return TestNamesBySuiteName ();
+		}
+
 		public static IEnumerable<object[]> TopLevelStatements ()
 		{
 			return TestNamesBySuiteName ();

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

@@ -103,6 +103,20 @@ public void SingleFile (string t)
 			Run (t);
 		}
 
+		[Theory]
+		[MemberData (nameof (TestDatabase.Substitutions), MemberType = typeof (TestDatabase))]
+		public void Substitutions (string t)
+		{
+			switch (t) {
+			case "FeatureGuardSubstitutions":
+				Run (t);
+				break;
+			default:
+				// Skip the rest for now
+				break;
+			}
+		}
+
 		[Theory]
 		[MemberData (nameof (TestDatabase.TopLevelStatements), MemberType = typeof (TestDatabase))]
 		public void TopLevelStatements (string t)

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

@@ -74,8 +74,8 @@ internal static DynamicallyAccessedMemberTypes GetDynamicallyAccessedMemberTypes
 		internal static ValueSet<string> GetFeatureGuardAnnotations (this IPropertySymbol propertySymbol)
 		{
 			HashSet<string> featureSet = new ();
-			foreach (var attributeData in propertySymbol.GetAttributes (DynamicallyAccessedMembersAnalyzer.FullyQualifiedFeatureGuardAttribute)) {
-				if (attributeData.ConstructorArguments is [TypedConstant { Value: INamedTypeSymbol featureType }])
+			foreach (var featureGuardAttribute in propertySymbol.GetAttributes (DynamicallyAccessedMembersAnalyzer.FullyQualifiedFeatureGuardAttribute)) {
+				if (featureGuardAttribute.ConstructorArguments is [TypedConstant { Value: INamedTypeSymbol featureType }])
 					featureSet.Add (featureType.GetDisplayName ());
 			}
 			return featureSet.Count == 0 ? ValueSet<string>.Empty : new ValueSet<string> (featureSet);

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

@@ -305,7 +305,7 @@ protected virtual bool CreateSpecialIncompatibleMembersDiagnostic (
 		internal static bool IsAnnotatedFeatureGuard (IPropertySymbol propertySymbol, string featureName)
 		{
 			// Only respect FeatureGuardAttribute on static boolean properties.
-			if (!propertySymbol.IsStatic || propertySymbol.Type.SpecialType != SpecialType.System_Boolean)
+			if (!propertySymbol.IsStatic || propertySymbol.Type.SpecialType != SpecialType.System_Boolean || propertySymbol.SetMethod != null)
 				return false;
 
 			ValueSet<string> featureCheckAnnotations = propertySymbol.GetFeatureGuardAnnotations ();

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

@@ -36,8 +36,8 @@ public IEnumerable<Diagnostic> CollectDiagnostics (DataFlowAnalyzerContext conte
 			if (!context.EnableTrimAnalyzer)
 				return diagnosticContext.Diagnostics;
 
-			if (!OwningSymbol.IsStatic || OwningSymbol.Type.SpecialType != SpecialType.System_Boolean) {
-				// Warn about invalid feature checks (non-static or non-bool properties)
+			if (!OwningSymbol.IsStatic || OwningSymbol.Type.SpecialType != SpecialType.System_Boolean || OwningSymbol.SetMethod != null) {
+				// Warn about invalid feature checks (non-static or non-bool properties or properties with setter)
 				diagnosticContext.AddDiagnostic (
 					DiagnosticId.InvalidFeatureGuard);
 				return diagnosticContext.Diagnostics;

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

@@ -43,8 +43,6 @@ public class TrimAnalysisVisitor : LocalDataFlowVisitor<
 
 		FeatureChecksVisitor _featureChecksVisitor;
 
-		DataFlowAnalyzerContext _dataFlowAnalyzerContext;
-
 		public TrimAnalysisVisitor (
 			Compilation compilation,
 			LocalStateAndContextLattice<MultiValue, FeatureContext, ValueSetLattice<SingleValue>, FeatureContextLattice> lattice,
@@ -59,7 +57,6 @@ public TrimAnalysisVisitor (
 			_multiValueLattice = lattice.LocalStateLattice.Lattice.ValueLattice;
 			TrimAnalysisPatterns = trimAnalysisPatterns;
 			_featureChecksVisitor = new FeatureChecksVisitor (dataFlowAnalyzerContext);
-			_dataFlowAnalyzerContext = dataFlowAnalyzerContext;
 		}
 
 		public override FeatureChecksValue GetConditionValue (IOperation branchValueOperation, StateValue state)
@@ -436,7 +433,8 @@ public override void HandleReturnConditionValue (FeatureChecksValue returnCondit
 			if (OwningSymbol is not IMethodSymbol method)
 				return;
 
-			// FeatureGuard validation needs to happen only for properties.
+			// FeatureGuard validation needs to happen only for property getters.
+			// Include properties with setters here because they will get validated later.
 			if (method.MethodKind != MethodKind.PropertyGet)
 				return;
 

src/tools/illink/src/linker/Linker.Steps/RootAssemblyInputStep.cs

@@ -78,7 +78,8 @@ protected override void Process ()
 					CodeOptimizations.RemoveLinkAttributes |
 					CodeOptimizations.RemoveSubstitutions |
 					CodeOptimizations.RemoveDynamicDependencyAttribute |
-					CodeOptimizations.OptimizeTypeHierarchyAnnotations, assembly.Name.Name);
+					CodeOptimizations.OptimizeTypeHierarchyAnnotations |
+					CodeOptimizations.SubstituteFeatureGuards, assembly.Name.Name);
 
 				// Enable EventSource special handling
 				Context.DisableEventSourceSpecialHandling = false;

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

@@ -52,6 +52,14 @@ public bool TryGetEmbeddedXmlInfo (ICustomAttributeProvider provider, [NotNullWh
 			return xmlInfo != null;
 		}
 
+		public IEnumerable<CustomAttribute> GetCustomAttributes (ICustomAttributeProvider provider, string attributeNamespace, string attributeName)
+		{
+			foreach (var attr in GetCustomAttributes (provider)) {
+				if (attr.AttributeType.Namespace == attributeNamespace && attr.AttributeType.Name == attributeName)
+					yield return attr;
+			}
+		}
+
 		public IEnumerable<CustomAttribute> GetCustomAttributes (ICustomAttributeProvider provider)
 		{
 			if (provider.HasCustomAttributes) {

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

@@ -1179,6 +1179,9 @@ protected bool GetOptimizationName (string text, out CodeOptimizations optimizat
 			case "sealer":
 				optimization = CodeOptimizations.Sealer;
 				return true;
+			case "substitutefeatureguards":
+				optimization = CodeOptimizations.SubstituteFeatureGuards;
+				return true;
 			}
 
 			Context.LogError (null, DiagnosticId.InvalidOptimizationValue, text);
@@ -1361,6 +1364,7 @@ static void Usage ()
 			Console.WriteLine ("                               unreachablebodies: Instance methods that are marked but not executed are converted to throws");
 			Console.WriteLine ("                               unusedinterfaces: Removes interface types from declaration when not used");
 			Console.WriteLine ("                               unusedtypechecks: Inlines never successful type checks");
+			Console.WriteLine ("                               substitutefeatureguards: Substitutes properties annotated as FeatureGuard(typeof(RequiresUnreferencedCodeAttribute)) to false");
 			Console.WriteLine ("  --enable-opt NAME [ASM]    Enable one of the additional optimizations globaly or for a specific assembly name");
 			Console.WriteLine ("                               sealer: Any method or type which does not have override is marked as sealed");
 			Console.WriteLine ("  --explicit-reflection      Adds to members never used through reflection DisablePrivateReflection attribute. Defaults to false");