[release/10.0] Add trim analyzer support for C# 14 extensions (#119195)

* Add trim analyzer support for C# 14 extensions (#119017)

Fixes #115949

This adds Roslyn analyzer support for C# 14 extensions. A few notes on
the behavior:

- DAM is supported on method return/params, including on property
  accessor return/param.

- DAM is not supported on extension properties (see
  #119113)

- DAM is not supported on extension methods (this produces IL2041)

- There's still a bug with the behavior for ILLink/ILC due to the
  annotations not being preserved into the implementation when
  lowering: dotnet/roslyn#80017.

Includes an update to Microsoft.CodeAnalysis for new analyzer APIs
involving extension
members. #119159 tracks fixing
new warnings that are suppressed for now.

New tests uncovered an analyzer issue with operators in the (extension
or not): #119110. This change
includes test coverage for non-extension operators.  They also
uncovered an issue that looks like a race condition in ILC:
#119155.

* Fix indentation

Author: sbomer

Directory.Build.props

@@ -269,6 +269,10 @@
     <WarningsNotAsErrors Condition="'$(OfficialBuild)' != 'true' OR '$(NuGetAuditWarnNotError)' == 'true'">$(WarningsNotAsErrors);NU1901;NU1902;NU1903;NU1904</WarningsNotAsErrors>
     <!-- Warnings to always disable -->
     <NoWarn>$(NoWarn);CS8500;CS8969</NoWarn>
+    <!-- Don't warn about redundant equality -->
+    <NoWarn>$(NoWarn);IDE0100</NoWarn>
+    <!-- Don't warn about unused parameters -->
+    <NoWarn>$(NoWarn);IDE0060</NoWarn>
     <!-- Suppress "CS1591 - Missing XML comment for publicly visible type or member" compiler errors for private assemblies. -->
     <NoWarn Condition="'$(IsPrivateAssembly)' == 'true'">$(NoWarn);CS1591</NoWarn>
     <!-- Always pass portable to override arcade sdk which uses embedded for local builds -->

eng/Versions.props

@@ -56,7 +56,7 @@
       Source-build builds the product with the most recent previously source-built release. Thankfully, these two requirements line up nicely
       such that any version that satisfies the VS version requirement will also satisfy the .NET SDK version requirement because of how we ship.
     -->
-    <MicrosoftCodeAnalysisVersion_LatestVS>4.8.0</MicrosoftCodeAnalysisVersion_LatestVS>
+    <MicrosoftCodeAnalysisVersion_LatestVS>4.14.0</MicrosoftCodeAnalysisVersion_LatestVS>
     <!-- Some of the analyzer dependencies used by ILLink project -->
     <MicrosoftCodeAnalysisBannedApiAnalyzersVersion>3.3.5-beta1.23270.2</MicrosoftCodeAnalysisBannedApiAnalyzersVersion>
   </PropertyGroup>

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

@@ -202,6 +202,20 @@ private void VerifyLoggedMessages(AssemblyDefinition original, TrimmingTestLogge
             List<(ICustomAttributeProvider, CustomAttribute)> expectedNoWarningsAttributes = new();
             foreach (var attrProvider in GetAttributeProviders(original))
             {
+                if (attrProvider is IMemberDefinition attrMember &&
+                    attrMember is not TypeDefinition &&
+                    attrMember.DeclaringType is TypeDefinition declaringType &&
+                    declaringType.Name.StartsWith("<G>"))
+                {
+                    // Workaround: C# 14 extension members result in a compiler-generated type
+                    // that has a member for each extension member (this is in addition to the type
+                    // which contains the actual extension member implementation).
+                    // The generated members inherit attributes from the extension members, but
+                    // have empty implementations. We don't want to check inherited ExpectedWarningAttributes
+                    // for these members.
+                    continue;
+                }
+
                 foreach (var attr in attrProvider.CustomAttributes)
                 {
                     if (!IsProducedByNativeAOT(attr))

src/tools/illink/src/ILLink.RoslynAnalyzer/DataFlow/LocalDataFlowVisitor.cs

@@ -305,8 +305,16 @@ bool merge
                         return value;
                     }
 
-                    // Property may be an indexer, in which case there will be one or more index arguments followed by a value argument
                     ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue>();
+
+                    // Handle C# 14 extension property access (see comment in ProcessMethodCall)
+                    if (setMethod.HasExtensionParameterOnType())
+                    {
+                        arguments.Add(instanceValue);
+                        instanceValue = TopValue;
+                    }
+
+                    // Property may be an indexer, in which case there will be one or more index arguments followed by a value argument
                     foreach (var val in propertyRef.Arguments)
                         arguments.Add(Visit(val, state));
                     arguments.Add(value);
@@ -705,14 +713,20 @@ public override TValue VisitPropertyReference(IPropertyReferenceOperation operat
             // Accessing property for reading is really a call to the getter
             // The setter case is handled in assignment operation since here we don't have access to the value to pass to the setter
             TValue instanceValue = Visit(operation.Instance, state);
-            IMethodSymbol? getMethod = operation.Property.GetGetMethod();
+            IMethodSymbol getMethod = operation.Property.GetGetMethod()!;
+            ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue>();
+            // Handle C# 14 extension property access (see comment in ProcessMethodCall)
+            if (getMethod.HasExtensionParameterOnType())
+            {
+                arguments.Add(instanceValue);
+                instanceValue = TopValue;
+            }
 
             // Property may be an indexer, in which case there will be one or more index arguments
-            ImmutableArray<TValue>.Builder arguments = ImmutableArray.CreateBuilder<TValue>();
             foreach (var val in operation.Arguments)
                 arguments.Add(Visit(val, state));
 
-            return HandleMethodCallHelper(getMethod!, instanceValue, arguments.ToImmutableArray(), operation, state);
+            return HandleMethodCallHelper(getMethod, instanceValue, arguments.ToImmutableArray(), operation, state);
         }
 
         public override TValue VisitEventReference(IEventReferenceOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
@@ -890,7 +904,7 @@ private TValue HandleMethodCallHelper(
                 TConditionValue conditionValue = GetConditionValue(argumentOperation, state);
                 var current = state.Current;
                 ApplyCondition(
-                    doesNotReturnIfConditionValue == false
+                    !doesNotReturnIfConditionValue
                         ? conditionValue
                         : conditionValue.Negate(),
                     ref current);
@@ -910,6 +924,16 @@ private TValue ProcessMethodCall(
             TValue instanceValue = Visit(instance, state);
 
             var argumentsBuilder = ImmutableArray.CreateBuilder<TValue>();
+
+            // For calls to C# 14 extensions, treat the instance argument as a regular argument.
+            // The extension method doesn't have an implicit this, yet (unlike for existing extension methods)
+            // the IOperation represents it as having an Instance.
+            if (method.HasExtensionParameterOnType())
+            {
+                argumentsBuilder.Add(instanceValue);
+                instanceValue = TopValue;
+            }
+
             foreach (var argument in arguments)
             {
                 // For __arglist argument there might not be any parameter

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

@@ -322,6 +322,11 @@ private static void VerifyDamOnPropertyAndAccessorMatch(SymbolAnalysisContext co
                 || propertySymbol.GetDynamicallyAccessedMemberTypes() == DynamicallyAccessedMemberTypes.None)
                 return;
 
+            // For C# 14 extension properties, property-level DAM does not propagate to accessors
+            // and we do not consider property vs accessor conflicts meaningful. Skip conflict checks.
+            if (methodSymbol.HasExtensionParameterOnType())
+                return;
+
             // None on the return type of 'get' matches unannotated
             if (methodSymbol.MethodKind == MethodKind.PropertyGet
                 && methodSymbol.GetDynamicallyAccessedMemberTypesOnReturnType() != DynamicallyAccessedMemberTypes.None

src/tools/illink/src/ILLink.RoslynAnalyzer/ILLink.RoslynAnalyzer.csproj

@@ -10,7 +10,7 @@
     <NoWarn Condition="'$(DotNetBuildSourceOnly)' == 'true'">$(NoWarn);CS8524</NoWarn>
     <!-- Type conflicts with imported type. Silence this for source build to allow building with the latest
          source-included type name parser, instead of the one that comes with Roslyn. -->
-    <NoWarn Condition="'$(DotNetBuildSourceOnly)' == 'true'">$(NoWarn);CS0436</NoWarn>
+    <NoWarn>$(NoWarn);CS0436</NoWarn>
     <AnalyzerLanguage>cs</AnalyzerLanguage>
     <!-- The analyzer needs to process deeply nested expressions in corelib.
          This can blow up the stack if using unoptimized code (due to large

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

@@ -58,15 +58,23 @@ public static ParameterProxy GetParameter(this IMethodSymbol method, ParameterIn
         /// </summary>
         public static int GetMetadataParametersCount(this IMethodSymbol method)
         {
-            return method.Parameters.Length;
+            return method.Parameters.Length + (method.HasExtensionParameterOnType() ? 1 : 0);
         }
 
         /// <summary>
         /// Gets the number of parameters pushed onto the stack when the method is called (including the implicit 'this' paramter)
         /// </summary>
         public static int GetParametersCount(this IMethodSymbol method)
         {
-            return method.Parameters.Length + (method.HasImplicitThis() ? 1 : 0);
+            return method.Parameters.Length + (method.HasImplicitThis() ? 1 : 0) + (method.HasExtensionParameterOnType() ? 1 : 0);
+        }
+
+        /// <summary>
+        /// Returns true if the method's containing type has an extension parameter
+        /// </summary>
+        public static bool HasExtensionParameterOnType(this IMethodSymbol method)
+        {
+            return method.ContainingType.ExtensionParameter != null;
         }
     }
 }

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

@@ -165,16 +165,17 @@ internal static DynamicallyAccessedMemberTypes GetMethodParameterAnnotation(Para
 
             var damt = parameter.GetDynamicallyAccessedMemberTypes();
 
-            var parameterMethod = (IMethodSymbol)parameter.ContainingSymbol;
-            Debug.Assert(parameterMethod != null);
+            IMethodSymbol parameterMethod = param.Method.Method;
 
             // If there are conflicts between the setter and the property annotation,
             // the setter annotation wins. (But DAMT.None is ignored)
 
             // Is this a property setter `value` parameter?
             if (parameterMethod!.MethodKind == MethodKind.PropertySet
                 && damt == DynamicallyAccessedMemberTypes.None
-                && parameter.Ordinal == parameterMethod.Parameters.Length - 1)
+                && parameter.Ordinal == parameterMethod.Parameters.Length - 1
+                // Do not propagate property-level DAM for C# 14 extension properties
+                && !parameterMethod.HasExtensionParameterOnType())
             {
                 var property = (IPropertySymbol)parameterMethod.AssociatedSymbol!;
                 Debug.Assert(property != null);
@@ -194,7 +195,10 @@ public static DynamicallyAccessedMemberTypes GetMethodReturnValueAnnotation(IMet
             // Is this a property getter?
             // If there are conflicts between the getter and the property annotation,
             // the getter annotation wins. (But DAMT.None is ignored)
-            if (method.MethodKind is MethodKind.PropertyGet && returnDamt == DynamicallyAccessedMemberTypes.None)
+            if (method.MethodKind is MethodKind.PropertyGet
+                && returnDamt == DynamicallyAccessedMemberTypes.None
+                // Do not propagate property-level DAM for C# 14 extension properties]
+                && !method.HasExtensionParameterOnType())
             {
                 var property = (IPropertySymbol)method.AssociatedSymbol!;
                 Debug.Assert(property != null);

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

@@ -9,11 +9,6 @@ namespace ILLink.Shared.TrimAnalysis
 {
     internal partial record MethodParameterValue
     {
-        public MethodParameterValue(IParameterSymbol parameterSymbol)
-            : this(new ParameterProxy(parameterSymbol)) { }
-        public MethodParameterValue(IMethodSymbol methodSymbol, ParameterIndex parameterIndex, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes)
-            : this(new(new(methodSymbol), parameterIndex), dynamicallyAccessedMemberTypes) { }
-
         public MethodParameterValue(ParameterProxy parameter)
             : this(parameter, FlowAnnotations.GetMethodParameterAnnotation(parameter)) { }
 

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

@@ -9,10 +9,12 @@ namespace ILLink.Shared.TypeSystemProxy
 {
     internal partial struct ParameterProxy
     {
-        public ParameterProxy(IParameterSymbol parameter)
+        public ParameterProxy(IParameterSymbol parameter, IMethodSymbol method)
         {
-            Method = new((IMethodSymbol)parameter.ContainingSymbol);
-            Index = (ParameterIndex)parameter.Ordinal + (Method.HasImplicitThis() ? 1 : 0);
+            Method = new(method);
+            Index = (ParameterIndex)parameter.Ordinal +
+                (Method.HasImplicitThis() ? 1 : 0) +
+                (method.HasExtensionParameterOnType() && parameter.ContainingSymbol is IMethodSymbol ? 1 : 0);
         }
 
         public partial ReferenceKind GetReferenceKind()
@@ -22,32 +24,51 @@ public partial ReferenceKind GetReferenceKind()
                     ? ReferenceKind.Ref
                     : ReferenceKind.None;
 
-            switch (Method.Method.Parameters[MetadataIndex].RefKind)
+            switch (ParameterSymbol!.RefKind)
             {
                 case RefKind.Ref: return ReferenceKind.Ref;
                 case RefKind.In: return ReferenceKind.In;
                 case RefKind.Out: return ReferenceKind.Out;
                 case RefKind.None: return ReferenceKind.None;
                 default:
-                    Debug.Fail($"Unexpected RefKind {Method.Method.Parameters[MetadataIndex].RefKind} found on parameter {GetDisplayName()}");
+                    Debug.Fail($"Unexpected RefKind {ParameterSymbol!.RefKind} found on parameter {GetDisplayName()}");
                     return ReferenceKind.None;
             }
         }
 
         /// <summary>
         /// Returns the IParameterSymbol representing the parameter. Returns null for the implicit this paramter.
         /// </summary>
-        public IParameterSymbol? ParameterSymbol => IsImplicitThis ? null : Method.Method.Parameters[MetadataIndex];
+        public IParameterSymbol? ParameterSymbol
+        {
+            get
+            {
+                if (IsImplicitThis)
+                {
+                    return null;
+                }
+
+                var method = Method.Method;
+                int hasExtensionParameter = 0;
+                if (method.HasExtensionParameterOnType())
+                {
+                    if (MetadataIndex == 0)
+                    {
+                        return method.ContainingType.ExtensionParameter;
+                    }
+                    hasExtensionParameter = 1;
+                }
+
+                return method.Parameters[MetadataIndex - hasExtensionParameter];
+            }
+        }
 
         /// <summary>
         /// Returns the IParameterSymbol.Location[0] for the parameter. Returns null for the implicit this paramter.
         /// </summary>
         public Location? Location => ParameterSymbol?.Locations[0];
 
-        public TypeProxy ParameterType
-            => IsImplicitThis
-                ? new TypeProxy(Method.Method.ContainingType)
-                : new TypeProxy(Method.Method.Parameters[MetadataIndex].Type);
+        public TypeProxy ParameterType => new TypeProxy(ParameterSymbol?.Type ?? Method.Method.ContainingType);
 
         public partial string GetDisplayName()
         {