From 577952be5ab3ed01a5715002dd4fed604f67ade4 Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Mon, 15 Jul 2024 21:42:06 +0000 Subject: [PATCH 1/2] Fix warning for MakeGenericType annotation mismatch --- .../Compiler/Dataflow/FlowAnnotations.cs | 17 ++++---- .../Compiler/Dataflow/MethodParameterValue.cs | 3 +- .../TrimAnalysis/FlowAnnotations.cs | 11 ++--- .../TrimAnalysis/GenericParameterValue.cs | 13 +++++- .../TrimAnalysis/MethodParameterValue.cs | 3 +- .../TrimAnalysis/FlowAnnotations.cs | 2 + .../TrimAnalysis/HandleCallAction.cs | 11 ++--- .../TrimAnalysis/MethodParameterValue.cs | 5 +-- .../linker/Linker.Dataflow/FlowAnnotations.cs | 15 +++---- .../Linker.Dataflow/MethodParameterValue.cs | 3 +- .../AnnotatedMembersAccessedViaReflection.cs | 3 +- .../DataFlow/ExponentialDataFlow.cs | 42 +++++++++---------- .../DataFlow/MakeGenericDataFlow.cs | 30 +++++++------ 13 files changed, 77 insertions(+), 81 deletions(-) diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs index fd8094bc702831..13b736436cfab1 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System; @@ -958,6 +958,11 @@ internal partial MethodReturnValue GetMethodReturnValue(MethodProxy method, bool internal partial MethodReturnValue GetMethodReturnValue(MethodProxy method, bool isNewObj) => GetMethodReturnValue(method, isNewObj, GetReturnParameterAnnotation(method.Method)); +#pragma warning disable CA1822 // Other partial implementations are not in the ilc project + internal partial GenericParameterValue GetGenericParameterValue(GenericParameterProxy genericParameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) +#pragma warning restore CA1822 // Mark members as static + => new GenericParameterValue(genericParameter.GenericParameter, dynamicallyAccessedMemberTypes); + internal partial GenericParameterValue GetGenericParameterValue(GenericParameterProxy genericParameter) => new GenericParameterValue(genericParameter.GenericParameter, GetGenericParameterAnnotation(genericParameter.GenericParameter)); @@ -970,18 +975,14 @@ internal partial MethodParameterValue GetMethodParameterValue(ParameterProxy par => GetMethodParameterValue(param, GetParameterAnnotation(param)); #pragma warning disable CA1822 // Mark members as static - Should be an instance method for consistency - // overrideIsThis is needed for backwards compatibility with MakeGenericType/Method https://github.com/dotnet/linker/issues/2428 - internal MethodParameterValue GetMethodThisParameterValue(MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) + internal partial MethodParameterValue GetMethodThisParameterValue(MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) { - if (!method.HasImplicitThis() && !overrideIsThis) + if (!method.HasImplicitThis()) throw new InvalidOperationException($"Cannot get 'this' parameter of method {method.GetDisplayName()} with no 'this' parameter."); - return new MethodParameterValue(new ParameterProxy(method, (ParameterIndex)0), dynamicallyAccessedMemberTypes, overrideIsThis); + return new MethodParameterValue(new ParameterProxy(method, (ParameterIndex)0), dynamicallyAccessedMemberTypes); } #pragma warning restore CA1822 // Mark members as static - internal partial MethodParameterValue GetMethodThisParameterValue(MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) - => GetMethodThisParameterValue(method, dynamicallyAccessedMemberTypes, false); - internal partial MethodParameterValue GetMethodThisParameterValue(MethodProxy method) { if (!method.HasImplicitThis()) diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/MethodParameterValue.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/MethodParameterValue.cs index 0b6c0c11d9f2fe..492c81ead56431 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/MethodParameterValue.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/MethodParameterValue.cs @@ -14,12 +14,11 @@ namespace ILLink.Shared.TrimAnalysis /// internal partial record MethodParameterValue { - public MethodParameterValue(ParameterProxy param, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) + public MethodParameterValue(ParameterProxy param, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) { StaticType = param.ParameterType; Parameter = param; DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes; - _overrideIsThis = overrideIsThis; } public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes { get; } diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/FlowAnnotations.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/FlowAnnotations.cs index 2fa967fdc9405d..8e5f60179dcd71 100644 --- a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/FlowAnnotations.cs +++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/FlowAnnotations.cs @@ -109,6 +109,9 @@ internal partial MethodReturnValue GetMethodReturnValue (MethodProxy method, boo internal partial MethodReturnValue GetMethodReturnValue (MethodProxy method, bool isNewObj) => GetMethodReturnValue (method, isNewObj, GetMethodReturnValueAnnotation (method.Method)); + internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) + => new GenericParameterValue (genericParameter.TypeParameterSymbol, dynamicallyAccessedMemberTypes); + internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter) => new GenericParameterValue (genericParameter.TypeParameterSymbol); @@ -119,14 +122,6 @@ internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy m return GetMethodParameterValue (new ParameterProxy (method, (ParameterIndex) 0), dynamicallyAccessedMemberTypes); } - // overrideIsThis is needed for backwards compatibility with MakeGenericType/Method https://github.com/dotnet/linker/issues/2428 - internal MethodParameterValue GetMethodThisParameterValue (MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) - { - if (!method.HasImplicitThis () && !overrideIsThis) - throw new InvalidOperationException ($"Cannot get 'this' parameter of method {method.GetDisplayName ()} with no 'this' parameter."); - return new MethodParameterValue (new ParameterProxy (method, (ParameterIndex) 0), dynamicallyAccessedMemberTypes, overrideIsThis); - } - internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method) { if (!method.HasImplicitThis ()) diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/GenericParameterValue.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/GenericParameterValue.cs index 2156d7176a25ba..ec7fd155bd3c81 100644 --- a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/GenericParameterValue.cs +++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/GenericParameterValue.cs @@ -15,9 +15,18 @@ namespace ILLink.Shared.TrimAnalysis /// internal partial record GenericParameterValue { - public GenericParameterValue (ITypeParameterSymbol typeParameterSymbol) => GenericParameter = new (typeParameterSymbol); + public GenericParameterValue (ITypeParameterSymbol typeParameterSymbol, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) + { + GenericParameter = new (typeParameterSymbol); + DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes; + } - public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes => GenericParameter.TypeParameterSymbol.GetDynamicallyAccessedMemberTypes (); + public GenericParameterValue (ITypeParameterSymbol typeParameterSymbol) + : this (typeParameterSymbol, typeParameterSymbol.GetDynamicallyAccessedMemberTypes ()) + { + } + + public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes { get; } public override IEnumerable GetDiagnosticArgumentsForAnnotationMismatch () => new string[] { GenericParameter.TypeParameterSymbol.Name, GenericParameter.TypeParameterSymbol.ContainingSymbol.GetDisplayName () }; diff --git a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/MethodParameterValue.cs b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/MethodParameterValue.cs index 051fa54302369f..4e9ebe5aa6a2d2 100644 --- a/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/MethodParameterValue.cs +++ b/src/tools/illink/src/ILLink.RoslynAnalyzer/TrimAnalysis/MethodParameterValue.cs @@ -17,12 +17,11 @@ public MethodParameterValue (IMethodSymbol methodSymbol, ParameterIndex paramete public MethodParameterValue (ParameterProxy parameter) : this (parameter, FlowAnnotations.GetMethodParameterAnnotation (parameter)) { } - public MethodParameterValue (ParameterProxy parameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) + public MethodParameterValue (ParameterProxy parameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) { Parameter = parameter; DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes; StaticType = parameter.ParameterType; - _overrideIsThis = overrideIsThis; } public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes { get; } diff --git a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/FlowAnnotations.cs b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/FlowAnnotations.cs index 4ef9a9ce61a41f..2a9b4fdd6904c3 100644 --- a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/FlowAnnotations.cs +++ b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/FlowAnnotations.cs @@ -25,6 +25,8 @@ partial class FlowAnnotations internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter); + internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes); + internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes); internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method); diff --git a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/HandleCallAction.cs b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/HandleCallAction.cs index 31d01fa7d4a288..902103f4af9444 100644 --- a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/HandleCallAction.cs +++ b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/HandleCallAction.cs @@ -909,7 +909,7 @@ ValueWithDynamicallyAccessedMembers valueWithDynamicallyAccessedMembers } else { // Any other type - perform generic parameter validation var genericParameterValues = GetGenericParameterValues (typeValue.RepresentedType.GetGenericParameters ()); - if (!AnalyzeGenericInstantiationTypeArray (argumentValues[0], calledMethod, genericParameterValues)) { + if (!AnalyzeGenericInstantiationTypeArray (argumentValues[0], genericParameterValues)) { _diagnosticContext.AddDiagnostic (DiagnosticId.MakeGenericType, calledMethod.GetDisplayName ()); } } @@ -1242,7 +1242,7 @@ private IEnumerable ProcessGetMethodByName (TypeProxy type, string m yield return NullValue.Instance; } - private bool AnalyzeGenericInstantiationTypeArray (in MultiValue arrayParam, in MethodProxy calledMethod, ImmutableArray genericParameters) + private bool AnalyzeGenericInstantiationTypeArray (in MultiValue arrayParam, ImmutableArray genericParameters) { bool hasRequirements = false; foreach (var genericParameter in genericParameters) { @@ -1280,10 +1280,7 @@ private bool AnalyzeGenericInstantiationTypeArray (in MultiValue arrayParam, in for (int i = 0; i < size.Value; i++) { if (array.TryGetValueByIndex (i, out MultiValue value)) { - // https://github.com/dotnet/linker/issues/2428 - // We need to report the target as "this" - as that was the previous behavior - // but with the annotation from the generic parameter. - var targetValue = _annotations.GetMethodThisParameterValue (calledMethod, GetGenericParameterEffectiveMemberTypes (genericParameters[i]), overrideIsThis: true); + var targetValue = _annotations.GetGenericParameterValue (genericParameters[i].GenericParameter, GetGenericParameterEffectiveMemberTypes (genericParameters[i])); _requireDynamicallyAccessedMembersAction.Invoke (value, targetValue); } } @@ -1315,7 +1312,7 @@ private void ValidateGenericMethodInstantiation ( } var genericParameterValues = GetGenericParameterValues (genericMethod.GetGenericParameters ()); - if (!AnalyzeGenericInstantiationTypeArray (genericParametersArray, reflectionMethod, genericParameterValues)) { + if (!AnalyzeGenericInstantiationTypeArray (genericParametersArray, genericParameterValues)) { _diagnosticContext.AddDiagnostic (DiagnosticId.MakeGenericMethod, reflectionMethod.GetDisplayName ()); } } diff --git a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/MethodParameterValue.cs b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/MethodParameterValue.cs index acc42b376f74b6..8528bfc7b1022f 100644 --- a/src/tools/illink/src/ILLink.Shared/TrimAnalysis/MethodParameterValue.cs +++ b/src/tools/illink/src/ILLink.Shared/TrimAnalysis/MethodParameterValue.cs @@ -13,9 +13,6 @@ namespace ILLink.Shared.TrimAnalysis { internal sealed partial record MethodParameterValue : ValueWithDynamicallyAccessedMembers, IValueWithStaticType { - // _overrideIsThis is needed for backwards compatibility with MakeGenericType/Method https://github.com/dotnet/linker/issues/2428 - private readonly bool _overrideIsThis; - public TypeProxy? StaticType { get; } public ParameterProxy Parameter { get; } @@ -26,7 +23,7 @@ public override IEnumerable GetDiagnosticArgumentsForAnnotationMismatch public override string ToString () => this.ValueToString (Parameter.Method.Method, Parameter.Index, DynamicallyAccessedMemberTypes); - public bool IsThisParameter () => _overrideIsThis || Parameter.IsImplicitThis; + public bool IsThisParameter () => Parameter.IsImplicitThis; public override SingleValue DeepCopy () => this; // This value is immutable diff --git a/src/tools/illink/src/linker/Linker.Dataflow/FlowAnnotations.cs b/src/tools/illink/src/linker/Linker.Dataflow/FlowAnnotations.cs index 3b148cf3a1ac59..61cbc8cc5816f7 100644 --- a/src/tools/illink/src/linker/Linker.Dataflow/FlowAnnotations.cs +++ b/src/tools/illink/src/linker/Linker.Dataflow/FlowAnnotations.cs @@ -688,6 +688,11 @@ internal partial MethodReturnValue GetMethodReturnValue (MethodProxy method, boo internal partial MethodReturnValue GetMethodReturnValue (MethodProxy method, bool isNewObj) => GetMethodReturnValue (method, isNewObj, GetReturnParameterAnnotation (method.Method)); +#pragma warning disable CA1822 // Mark members as static - Should be an instance method for consistency + internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) + => new GenericParameterValue (genericParameter.GenericParameter, dynamicallyAccessedMemberTypes); +#pragma warning restore CA1822 // Mark members as static + internal partial GenericParameterValue GetGenericParameterValue (GenericParameterProxy genericParameter) => new GenericParameterValue (genericParameter.GenericParameter, GetGenericParameterAnnotation (genericParameter.GenericParameter)); @@ -698,18 +703,14 @@ internal partial MethodParameterValue GetMethodParameterValue (ParameterProxy pa => GetMethodParameterValue (param, GetParameterAnnotation (param)); #pragma warning disable CA1822 // Mark members as static - Should be an instance method for consistency - // overrideIsThis is needed for backwards compatibility with MakeGenericType/Method https://github.com/dotnet/linker/issues/2428 - internal MethodParameterValue GetMethodThisParameterValue (MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) + internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) { - if (!method.HasImplicitThis () && !overrideIsThis) + if (!method.HasImplicitThis ()) throw new InvalidOperationException ($"Cannot get 'this' parameter of method {method.GetDisplayName ()} with no 'this' parameter."); - return new MethodParameterValue (method.Method.DeclaringType, new ParameterProxy (method, (ParameterIndex) 0), dynamicallyAccessedMemberTypes, overrideIsThis); + return new MethodParameterValue (method.Method.DeclaringType, new ParameterProxy (method, (ParameterIndex) 0), dynamicallyAccessedMemberTypes); } #pragma warning restore CA1822 // Mark members as static - internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) - => GetMethodThisParameterValue (method, dynamicallyAccessedMemberTypes, false); - internal partial MethodParameterValue GetMethodThisParameterValue (MethodProxy method) { if (!method.HasImplicitThis ()) diff --git a/src/tools/illink/src/linker/Linker.Dataflow/MethodParameterValue.cs b/src/tools/illink/src/linker/Linker.Dataflow/MethodParameterValue.cs index 5bc43b2a153ca0..0c9599aaf3c7e0 100644 --- a/src/tools/illink/src/linker/Linker.Dataflow/MethodParameterValue.cs +++ b/src/tools/illink/src/linker/Linker.Dataflow/MethodParameterValue.cs @@ -15,12 +15,11 @@ namespace ILLink.Shared.TrimAnalysis /// internal partial record MethodParameterValue { - public MethodParameterValue (TypeDefinition? staticType, ParameterProxy param, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes, bool overrideIsThis = false) + public MethodParameterValue (TypeDefinition? staticType, ParameterProxy param, DynamicallyAccessedMemberTypes dynamicallyAccessedMemberTypes) { StaticType = staticType == null ? null : new (staticType); DynamicallyAccessedMemberTypes = dynamicallyAccessedMemberTypes; Parameter = param; - _overrideIsThis = overrideIsThis; } public override DynamicallyAccessedMemberTypes DynamicallyAccessedMemberTypes { get; } diff --git a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/AnnotatedMembersAccessedViaReflection.cs b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/AnnotatedMembersAccessedViaReflection.cs index 616e392ecae3ee..33e7171a3e9ce8 100644 --- a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/AnnotatedMembersAccessedViaReflection.cs +++ b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/AnnotatedMembersAccessedViaReflection.cs @@ -743,8 +743,7 @@ static void DynamicallyAccessedMembers () typeof (AnnotatedGenerics).RequiresPublicMethods (); } - // This should produce IL2071 https://github.com/dotnet/linker/issues/2144 - [ExpectedWarning ("IL2070", "MakeGenericMethod")] + [ExpectedWarning ("IL2071", "'T'")] static void InstantiateGeneric (Type type = null) { // This should warn due to MakeGenericMethod - in this case the generic parameter is unannotated type diff --git a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/ExponentialDataFlow.cs b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/ExponentialDataFlow.cs index ae3ffecd1aea93..dcd3ab55297158 100644 --- a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/ExponentialDataFlow.cs +++ b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/ExponentialDataFlow.cs @@ -59,7 +59,7 @@ class GenericTypeWithRequires<[DynamicallyAccessedMembers (DynamicallyAccessedMe } [ExpectedWarning ("IL3050", Tool.Analyzer, "")] - [ExpectedWarning ("IL2090", "'T'")] + [ExpectedWarning ("IL2091", "'T'")] public static void Test () { Type[] types = new Type[1] { typeof (int) }; @@ -100,26 +100,26 @@ class GenericTypeWithRequires< // When this happens, we replace the ValueSet with an unknown value, producing // this warning. [ExpectedWarning ("IL2055", Tool.Analyzer, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] - [ExpectedWarning ("IL2090", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] + [ExpectedWarning ("IL2091", "'T'", Tool.Trimmer | Tool.NativeAot, "")] public static void Test () { Type[] types = new Type[20] { diff --git a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs index 34ae3994f667c7..94713ad5af7e46 100644 --- a/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs +++ b/src/tools/illink/test/Mono.Linker.Tests.Cases/DataFlow/MakeGenericDataFlow.cs @@ -125,8 +125,7 @@ static void TestWithRequirementsFromParam ( typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (type); } - [ExpectedWarning ("IL2071", "'T'", Tool.None, "https://github.com/dotnet/linker/issues/2428")] - [ExpectedWarning ("IL2070", "'this'")] + [ExpectedWarning ("IL2071", "'T'")] static void TestWithRequirementsFromParamWithMismatch ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type type) { @@ -139,8 +138,7 @@ static void TestWithRequirementsFromGenericParam< typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (typeof (T)); } - [ExpectedWarning ("IL2091", "'T'", Tool.None,"https://github.com/dotnet/linker/issues/2428")] - [ExpectedWarning ("IL2090", "'this'")] // Note that this actually produces a warning which should not be possible to produce right now + [ExpectedWarning ("IL2091", "'T'")] static void TestWithRequirementsFromGenericParamWithMismatch< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TInput> () { @@ -191,7 +189,7 @@ static void SpecificType () typeof (GenericWithNewConstraint<>).MakeGenericType (typeof (TestType)); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void UnknownType (Type unknownType = null) { typeof (GenericWithNewConstraint<>).MakeGenericType (unknownType); @@ -202,7 +200,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem typeof (GenericWithNewConstraint<>).MakeGenericType (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (GenericWithNewConstraint<>).MakeGenericType (withPublicMethods); @@ -213,7 +211,7 @@ static void AnnotationAndConstraintMatch ([DynamicallyAccessedMembers (Dynamical typeof (GenericWithNewConstraintAndAnnotations<>).MakeGenericType (withMethodsAndCtors); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationAndConstraintMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withMethods = null) { typeof (GenericWithNewConstraintAndAnnotations<>).MakeGenericType (withMethods); @@ -246,7 +244,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem typeof (GenericWithStructConstraint<>).MakeGenericType (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (GenericWithStructConstraint<>).MakeGenericType (withPublicMethods); @@ -276,7 +274,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem typeof (GenericWithUnmanagedConstraint<>).MakeGenericType (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (GenericWithUnmanagedConstraint<>).MakeGenericType (withPublicMethods); @@ -753,7 +751,7 @@ static MethodInfo KnownType () => typeof (IFoo).GetMethod ("Method") .MakeGenericMethod (new Type[] { typeof (int) }); - [ExpectedWarning ("IL2090", "T", "PublicMethods")] + [ExpectedWarning ("IL2091", "T", "PublicMethods")] static MethodInfo UnannotatedGenericParam () => typeof (IFoo).GetMethod ("Method") .MakeGenericMethod (new Type[] { typeof (T) }); @@ -787,7 +785,7 @@ static void SpecificType () .MakeGenericMethod (typeof (TestType)); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void UnknownType (Type unknownType = null) { typeof (NewConstraint).GetMethod (nameof (GenericWithNewConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -800,7 +798,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem .MakeGenericMethod (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (NewConstraint).GetMethod (nameof (GenericWithNewConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -813,7 +811,7 @@ static void AnnotationAndConstraintMatch ([DynamicallyAccessedMembers (Dynamical .MakeGenericMethod (withMethodsAndCtors); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationAndConstraintMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withMethods = null) { typeof (NewConstraint).GetMethod (nameof (GenericWithNewConstraintAndAnnotations), BindingFlags.Static | BindingFlags.NonPublic) @@ -850,7 +848,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem .MakeGenericMethod (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (StructConstraint).GetMethod (nameof (GenericWithStructConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -884,7 +882,7 @@ static void AnnotationMatch ([DynamicallyAccessedMembers (DynamicallyAccessedMem .MakeGenericMethod (withCtor); } - [ExpectedWarning ("IL2070")] + [ExpectedWarning ("IL2071")] static void AnnotationMismatch ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type withPublicMethods = null) { typeof (UnmanagedConstraint).GetMethod (nameof (GenericWithUnmanagedConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -906,7 +904,7 @@ static void TestGetMethodFromHandle (Type unknownType = null) m.MakeGenericMethod (unknownType); } - [ExpectedWarning ("IL2070", nameof (MethodInfo.MakeGenericMethod))] + [ExpectedWarning ("IL2071", nameof (MethodInfo.MakeGenericMethod))] static void TestGetMethodFromHandleWithWarning ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type publicMethodsType = null) { MethodInfo m = (MethodInfo) MethodInfo.GetMethodFromHandle (typeof (MakeGenericMethod).GetMethod (nameof (GenericWithRequirements)).MethodHandle); From e9334d7308bfe5bd0d7ef3c67eca5ad1a871c352 Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Mon, 15 Jul 2024 22:33:15 +0000 Subject: [PATCH 2/2] Fix suppressions --- .../System.Data.Common/src/System/Data/DataRowExtensions.cs | 2 +- .../Json/Serialization/Converters/Value/EnumConverterFactory.cs | 2 +- .../Serialization/Converters/Value/NullableConverterFactory.cs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libraries/System.Data.Common/src/System/Data/DataRowExtensions.cs b/src/libraries/System.Data.Common/src/System/Data/DataRowExtensions.cs index bb5c624f0abf6b..5899d1cfd10b2c 100644 --- a/src/libraries/System.Data.Common/src/System/Data/DataRowExtensions.cs +++ b/src/libraries/System.Data.Common/src/System/Data/DataRowExtensions.cs @@ -155,7 +155,7 @@ private static class UnboxT } return NonNullableField; - [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2090:MakeGenericMethod", + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2091:MakeGenericMethod", Justification = "'NullableField where TElem : struct' implies 'TElem : new()'. Nullable does not make use of new() so it is safe." + "The warning is only issued when IsDynamicCodeSupported is true.")] static Func CreateWhenDynamicCodeSupported() diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverterFactory.cs index ed49845dcfb70b..22f28f8813a336 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverterFactory.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverterFactory.cs @@ -31,7 +31,7 @@ internal static JsonConverter Create(Type enumType, EnumConverterOptions convert new object?[] { converterOptions, namingPolicy, options })!; } - [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2071:UnrecognizedReflectionPattern", Justification = "'EnumConverter where T : struct' implies 'T : new()', so the trimmer is warning calling MakeGenericType here because enumType's constructors are not annotated. " + "But EnumConverter doesn't call new T(), so this is safe.")] [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/NullableConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/NullableConverterFactory.cs index f64544379b3df6..2d93b693340361 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/NullableConverterFactory.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/NullableConverterFactory.cs @@ -43,7 +43,7 @@ public static JsonConverter CreateValueConverter(Type valueTypeToConvert, JsonCo culture: null)!; } - [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern", + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2071:UnrecognizedReflectionPattern", Justification = "'NullableConverter where T : struct' implies 'T : new()', so the trimmer is warning calling MakeGenericType here because valueTypeToConvert's constructors are not annotated. " + "But NullableConverter doesn't call new T(), so this is safe.")] [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]