Trim analyzer: Implement intrinsics handling of object.GetType (#93732)

This fixes #86921.

Analyzer so far didn't handle correct data flow around `object.GetType` and `DynamicallyAccessedMembersAttribute` on types. This change implements that behavior.

Main changes:
* Move `IValueWithStaticType` to the shared code and refactor its existing usage in trimmer/AOT to use the shared code instead. Also implement it for the analyzer.
* Refactor method call handling in the analyzer to a single static method which is called both from the visitor and from the patterns.
* In order to get same behavior, start tracking values for all fields and method parameters.

Outside of the actual fix, the other main change is that analyzer now tracks values for all fields and method parameters, regardless if their type is interesting to analysis. This is necessary because the static type now matterns, even if it's something else than `System.Type`.

The effect of that is that the analyzer now recognizes lot more invalid cases because it can determine if the value is something unrecognizable. Before the change such values where tracked as "empty", and thus anslysis ignored them. Now they're track as "value of a field, without annotations" which can lead to producing more warnings.

That means this effectively fixes dotnet/linker#2755. At least all the test cases which were added because of that bug, or which expected different behavior because of it now produce consistent behavior with trimmer/NativeAOT.

Author: vitek-karas

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using ILCompiler;
-using ILCompiler.Dataflow;
 using ILLink.Shared.DataFlow;
 using Internal.TypeSystem;
 
@@ -16,7 +15,7 @@ namespace ILLink.Shared.TrimAnalysis
     /// <summary>
     /// A representation of a field. Typically a result of ldfld.
     /// </summary>
-    internal sealed partial record FieldValue : IValueWithStaticType
+    internal sealed partial record FieldValue
     {
         public FieldValue(FieldDesc field, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes)
         {
@@ -32,8 +31,6 @@ public FieldValue(FieldDesc field, DynamicallyAccessedMemberTypes dynamicallyAcc
         public override IEnumerable<string> GetDiagnosticArgumentsForAnnotationMismatch()
             => new string[] { Field.GetDisplayName() };
 
-        public TypeDesc? StaticType { get; }
-
         public override SingleValue DeepCopy() => this; // This value is immutable
 
         public override string ToString() => this.ValueToString(Field, DynamicallyAccessedMemberTypes);

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

@@ -1041,7 +1041,7 @@ when GetMethodParameterValue(parameterReference.Parameter) is MethodParameterVal
                         HandleStoreField(method, offset, fieldValue, DereferenceValue(method, offset, source, locals, ref ipState));
                         break;
                     case IValueWithStaticType valueWithStaticType:
-                        if (valueWithStaticType.StaticType is not null && FlowAnnotations.IsTypeInterestingForDataflow(valueWithStaticType.StaticType))
+                        if (valueWithStaticType.StaticType is not null && FlowAnnotations.IsTypeInterestingForDataflow(valueWithStaticType.StaticType.Value.Type))
                             throw new InvalidOperationException(MessageContainer.CreateErrorMessage(
                                 $"Unhandled StoreReference call. Unhandled attempt to store a value in {value} of type {value.GetType()}.",
                                 (int)DiagnosticId.LinkerUnexpectedError,

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

@@ -2,9 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
-using ILCompiler.Dataflow;
 using ILLink.Shared.TypeSystemProxy;
-using Internal.TypeSystem;
 
 #nullable enable
 
@@ -14,7 +12,7 @@ namespace ILLink.Shared.TrimAnalysis
     /// <summary>
     /// A value that came from a method parameter - such as the result of a ldarg.
     /// </summary>
-    internal partial record MethodParameterValue : IValueWithStaticType
+    internal partial record MethodParameterValue
     {
         public MethodParameterValue(ParameterProxy param, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false)
         {
@@ -25,7 +23,5 @@ public MethodParameterValue(ParameterProxy param, DynamicallyAccessedMemberTypes
         }
 
         public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes { get; }
-
-        public TypeDesc? StaticType { get; }
     }
 }

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

@@ -14,7 +14,7 @@ namespace ILLink.Shared.TrimAnalysis
     /// <summary>
     /// Return value from a method
     /// </summary>
-    internal partial record MethodReturnValue : IValueWithStaticType
+    internal partial record MethodReturnValue
     {
         public MethodReturnValue(MethodDesc method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes)
         {
@@ -30,8 +30,6 @@ public MethodReturnValue(MethodDesc method, DynamicallyAccessedMemberTypes dynam
         public override IEnumerable<string> GetDiagnosticArgumentsForAnnotationMismatch()
             => new string[] { DiagnosticUtilities.GetMethodSignatureDisplayName(Method) };
 
-        public TypeDesc? StaticType { get; }
-
         public override SingleValue DeepCopy() => this; // This value is immutable
 
         public override string ToString() => this.ValueToString(Method, DynamicallyAccessedMemberTypes);

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

@@ -538,7 +538,7 @@ public static bool HandleCall(
                             // In this case to get correct results, trimmer would have to mark all public methods on Derived. Which
                             // currently it won't do.
 
-                            TypeDesc? staticType = (valueNode as IValueWithStaticType)?.StaticType;
+                            TypeDesc? staticType = (valueNode as IValueWithStaticType)?.StaticType?.Type;
                             if (staticType is null || (!staticType.IsDefType && !staticType.IsArray))
                             {
                                 // We don't know anything about the type GetType was called on. Track this as a usual "result of a method call without any annotations"

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

@@ -377,7 +377,6 @@
     <Compile Include="Compiler\Dataflow\HandleCallAction.cs" />
     <Compile Include="Compiler\Dataflow\HoistedLocalKey.cs" />
     <Compile Include="Compiler\Dataflow\InterproceduralState.cs" />
-    <Compile Include="Compiler\Dataflow\IValueWithStaticType.cs" />
     <Compile Include="Compiler\Dataflow\LocalVariableReferenceValue.cs" />
     <Compile Include="Compiler\Dataflow\MethodBodyScanner.cs" />
     <Compile Include="Compiler\Dataflow\MethodParameterValue.cs" />

src/coreclr/tools/aot/ILCompiler.Compiler/ILCompiler.Compiler.csproj

@@ -11,7 +11,11 @@ namespace ILLink.Shared.TrimAnalysis
 {
 	internal partial record FieldValue
 	{
-		public FieldValue (IFieldSymbol fieldSymbol) => FieldSymbol = fieldSymbol;
+		public FieldValue (IFieldSymbol fieldSymbol)
+		{
+			FieldSymbol = fieldSymbol;
+			StaticType = new (fieldSymbol.Type);
+		}
 
 		public readonly IFieldSymbol FieldSymbol;
 

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

@@ -78,6 +78,23 @@ public static DynamicallyAccessedMemberTypes GetMethodReturnValueAnnotation (IMe
 			return returnDamt;
 		}
 
+		public static DynamicallyAccessedMemberTypes GetTypeAnnotation(ITypeSymbol type)
+		{
+			var typeAnnotation = type.GetDynamicallyAccessedMemberTypes ();
+
+			ITypeSymbol? baseType = type.BaseType;
+			while (baseType != null) {
+				typeAnnotation |= baseType.GetDynamicallyAccessedMemberTypes ();
+				baseType = baseType.BaseType;
+			}
+
+			foreach (var interfaceType in type.AllInterfaces) {
+				typeAnnotation |= interfaceType.GetDynamicallyAccessedMemberTypes ();
+			}
+
+			return typeAnnotation;
+		}
+
 #pragma warning disable CA1822 // Mark members as static - the other partial implementations might need to be instance methods
 
 		// TODO: This is relatively expensive on the analyzer since it doesn't cache the annotation information

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

@@ -21,6 +21,7 @@ public MethodParameterValue (ParameterProxy parameter, DynamicallyAccessedMember
 		{
 			Parameter = parameter;
 			DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes;
+			StaticType = parameter.ParameterType;
 			_overrideIsThis = overrideIsThis;
 		}