diff options
author | Sven Boemer <sbomer@gmail.com> | 2022-02-01 03:27:48 +0300 |
---|---|---|
committer | Sven Boemer <sbomer@gmail.com> | 2022-02-01 03:27:48 +0300 |
commit | 9130ef7d551e0c97b152fe592327108889cb45b0 (patch) | |
tree | 6bbd3b7461c04b7bb4fc5abaa8b8cd1cb2ed3a1d /test/Mono.Linker.Tests.Cases | |
parent | 3f704bb49eb2fb2847ceaecfbabe8d5f3e0c86c9 (diff) | |
parent | f6fde401e2841726ac04fcc37a34ce402ac800c6 (diff) |
Merge remote-tracking branch 'origin/feature/damAnalyzer' into mergeFromMain
Diffstat (limited to 'test/Mono.Linker.Tests.Cases')
61 files changed, 1708 insertions, 1143 deletions
diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs index 5863cf4a4..5770bdfa4 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/ApplyTypeAnnotations.cs @@ -9,6 +9,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { + [ExpectedNoWarnings] public class ApplyTypeAnnotations { public static void Main () @@ -50,6 +51,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow } [Kept] + // Analyzer doesn't support intrinsics: https://github.com/dotnet/linker/issues/2374 + [ExpectedWarning ("IL2026", "System.Type.GetType(String)", + ProducedBy = ProducedBy.Analyzer)] + // Analyzer doesn't track known types: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2072", "'type'", nameof (ApplyTypeAnnotations) + "." + nameof (RequireCombination) + "(Type)", "System.Type.GetType(String)", + ProducedBy = ProducedBy.Analyzer)] static void TestFromTypeGetTypeOverConstant () { RequireCombination (Type.GetType ("Mono.Linker.Tests.Cases.DataFlow.ApplyTypeAnnotations+FromTypeGetTypeOverConstantTestType")); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AssemblyQualifiedNameDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AssemblyQualifiedNameDataflow.cs index 8761da610..4a478e2a6 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/AssemblyQualifiedNameDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/AssemblyQualifiedNameDataflow.cs @@ -7,8 +7,9 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] class AssemblyQualifiedNameDataflow { static void Main () @@ -19,8 +20,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestUnqualifiedTypeNameWarns (); } - [UnrecognizedReflectionAccessPattern (typeof (AssemblyQualifiedNameDataflow), nameof (RequirePublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (AssemblyQualifiedNameDataflow), nameof (RequireNonPublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RequirePublicConstructors))] + [ExpectedWarning ("IL2072", nameof (RequireNonPublicConstructors))] static void TestPublicParameterlessConstructor () { string type = GetTypeWithPublicParameterlessConstructor ().AssemblyQualifiedName; @@ -30,7 +31,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (type); } - [UnrecognizedReflectionAccessPattern (typeof (AssemblyQualifiedNameDataflow), nameof (RequireNonPublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RequireNonPublicConstructors))] static void TestPublicConstructors () { string type = GetTypeWithPublicConstructors ().AssemblyQualifiedName; @@ -40,8 +41,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (type); } - [UnrecognizedReflectionAccessPattern (typeof (AssemblyQualifiedNameDataflow), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (AssemblyQualifiedNameDataflow), nameof (RequirePublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RequirePublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", nameof (RequirePublicConstructors))] static void TestConstructors () { string type = GetTypeWithNonPublicConstructors ().AssemblyQualifiedName; diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs index 3b5aff228..76e31e833 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeConstructorDataflow.cs @@ -11,6 +11,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { [Kept] + [ExpectedNoWarnings] class AttributeConstructorDataflow { [KeptAttributeAttribute (typeof (KeepsPublicConstructorAttribute))] @@ -73,7 +74,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow class AllOnSelf { [Kept] - [RecognizedReflectionAccessPattern] public static void Test () { var t = typeof (KeepAllOnSelf); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs index 7da1ed05b..75b619a21 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributeFieldDataflow.cs @@ -11,6 +11,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { [Kept] + [ExpectedNoWarnings] class AttributeFieldDataflow { [KeptAttributeAttribute (typeof (KeepsPublicConstructorsAttribute))] diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs index 8c4dac3b2..4f1e84123 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/AttributePropertyDataflow.cs @@ -11,6 +11,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { [Kept] + [ExpectedNoWarnings] class AttributePropertyDataflow { [KeptAttributeAttribute (typeof (KeepsPublicConstructorsAttribute))] diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs index 6cb0409cf..6b088291e 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/ByRefDataflow.cs @@ -12,6 +12,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow { [SetupCompileArgument ("/langversion:7.3")] [Kept] + [ExpectedNoWarnings] class ByRefDataflow { public static void Main () @@ -40,14 +41,18 @@ namespace Mono.Linker.Tests.Cases.DataFlow static Type s_typeWithPublicParameterlessConstructor; [Kept] - [UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string[] { "Type&" }, messageCode: "IL2077")] + // Trimmer and analyzer use different formats for ref parameters: https://github.com/dotnet/linker/issues/2406 + [ExpectedWarning ("IL2077", nameof (ByRefDataflow) + "." + nameof (MethodWithRefParameter) + "(Type&)", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2077", nameof (ByRefDataflow) + "." + nameof (MethodWithRefParameter) + "(ref Type)", ProducedBy = ProducedBy.Analyzer)] public static void PassRefToField () { MethodWithRefParameter (ref s_typeWithPublicParameterlessConstructor); } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (ByRefDataflow), nameof (MethodWithRefParameter), new string[] { "Type&" }, messageCode: "IL2067")] + // Trimmer and analyzer use different formats for ref parameters: https://github.com/dotnet/linker/issues/2406 + [ExpectedWarning ("IL2067", nameof (ByRefDataflow) + "." + nameof (MethodWithRefParameter) + "(Type&)", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2067", nameof (ByRefDataflow) + "." + nameof (MethodWithRefParameter) + "(ref Type)", ProducedBy = ProducedBy.Analyzer)] public static void PassRefToParameter (Type parameter) { MethodWithRefParameter (ref parameter); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ComplexTypeHandling.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ComplexTypeHandling.cs index 7bcfbc70c..858d40088 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/ComplexTypeHandling.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/ComplexTypeHandling.cs @@ -99,6 +99,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow } [Kept] + // Analyzer doesn't support intrinsics: https://github.com/dotnet/linker/issues/2374 + [ExpectedWarning ("IL2072", "'type'", nameof (ComplexTypeHandling) + "." + nameof (RequirePublicMethods) + "(Type)", "System.Object.GetType()", + ProducedBy = ProducedBy.Analyzer)] static void TestArrayGetTypeFromMethodParamHelper (ArrayGetTypeFromMethodParamElement[] p) { RequirePublicMethods (p.GetType ()); @@ -121,6 +124,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow static ArrayGetTypeFromFieldElement[] _arrayGetTypeFromField; [Kept] + // Analyzer doesn't support intrinsics: https://github.com/dotnet/linker/issues/2374 + [ExpectedWarning ("IL2072", "'type'", nameof (ComplexTypeHandling) + "." + nameof (RequirePublicMethods) + "(Type)", "System.Object.GetType()", + ProducedBy = ProducedBy.Analyzer)] static void TestArrayGetTypeFromField () { RequirePublicMethods (_arrayGetTypeFromField.GetType ()); @@ -134,6 +140,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow } [Kept] + // Analyzer doesn't support intrinsics: https://github.com/dotnet/linker/issues/2374 + [ExpectedWarning ("IL2026", "System.Type.GetType(String)", + ProducedBy = ProducedBy.Analyzer)] + // Analyzer doesn't track known types: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2072", "'type'", nameof (ComplexTypeHandling) + "." + nameof (RequirePublicMethods) + "(Type)", "System.Type.GetType(String)", + ProducedBy = ProducedBy.Analyzer)] static void TestArrayTypeGetType () { RequirePublicMethods (Type.GetType ("Mono.Linker.Tests.Cases.DataFlow.ComplexTypeHandling+ArrayTypeGetTypeElement[]")); @@ -148,6 +160,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow } [Kept] + // Analyzer doesn't support intrinsics: https://github.com/dotnet/linker/issues/2374 + [ExpectedWarning ("IL2026", "Activator.CreateInstance(String, String)", + ProducedBy = ProducedBy.Analyzer)] static void TestArrayCreateInstanceByName () { Activator.CreateInstance ("test", "Mono.Linker.Tests.Cases.DataFlow.ComplexTypeHandling+ArrayCreateInstanceByNameElement[]"); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/DynamicDependencyDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/DynamicDependencyDataflow.cs index 1fe9a13be..029e5848b 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/DynamicDependencyDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/DynamicDependencyDataflow.cs @@ -5,6 +5,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { + [ExpectedNoWarnings] public class DynamicDependencyDataflow { public static void Main () @@ -18,7 +19,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow static Type TypeWithPublicMethods; [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), "GetField", new Type[] { typeof (string) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetField))] [DynamicDependency ("DynamicDependencyTo")] static void DynamicDependencyFrom () { @@ -26,7 +27,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), "GetProperty", new Type[] { typeof (string) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetProperty))] static void DynamicDependencyTo () { _ = TypeWithPublicMethods.GetProperty ("p"); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/EmptyArrayIntrinsicsDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/EmptyArrayIntrinsicsDataFlow.cs index 34e524215..2e89e0c7e 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/EmptyArrayIntrinsicsDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/EmptyArrayIntrinsicsDataFlow.cs @@ -8,8 +8,9 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] class EmptyArrayIntrinsicsDataFlow { static void Main () @@ -20,27 +21,27 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestGetConstructorOverloads (); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetMethod))] static void TestGetPublicParameterlessConstructorWithEmptyTypes () { s_typeWithKeptPublicParameterlessConstructor.GetConstructor (Type.EmptyTypes); s_typeWithKeptPublicParameterlessConstructor.GetMethod ("Foo"); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetMethod))] static void TestGetPublicParameterlessConstructorWithArrayEmpty () { s_typeWithKeptPublicParameterlessConstructor.GetConstructor (Array.Empty<Type> ()); s_typeWithKeptPublicParameterlessConstructor.GetMethod ("Foo"); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetConstructor))] static void TestGetPublicParameterlessConstructorWithUnknownArray () { s_typeWithKeptPublicParameterlessConstructor.GetConstructor (s_localEmptyArrayInvisibleToAnalysis); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) }, messageCode: "IL2080")] + [ExpectedWarning ("IL2080", nameof (Type.GetMethod))] static void TestGetConstructorOverloads () { s_typeWithKeptPublicParameterlessConstructor.GetConstructor (BindingFlags.Public, null, Type.EmptyTypes, null); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/ExceptionalDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/ExceptionalDataFlow.cs new file mode 100644 index 000000000..40bf18ca7 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/DataFlow/ExceptionalDataFlow.cs @@ -0,0 +1,814 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using Mono.Linker.Tests.Cases.Expectations.Assertions; + +namespace Mono.Linker.Tests.Cases.DataFlow +{ + [SkipKeptItemsValidation] + public class ExceptionalDataFlow + { + public static void Main () + { + TryFlowsToFinally (); + TryFlowsToAfterFinally (); + MultipleTryExits (); + MultipleFinallyPaths (); + FinallyChain (); + FinallyChainWithPostFinallyState (); + TryFlowsToCatch (); + CatchFlowsToFinally (); + CatchFlowsToAfterTry (); + CatchFlowsToAfterFinally (); + FinallyFlowsToAfterFinally (); + TryFlowsToMultipleCatchAndFinally (); + NestedWithFinally (); + ControlFlowsOutOfMultipleFinally (); + NestedWithCatch (); + CatchInTry (); + CatchInTryWithFinally (); + TestCatchesHaveSeparateState (); + FinallyWithBranchToFirstBlock (); + FinallyWithBranchToFirstBlockAndEnclosingTryCatchState (); + CatchWithBranchToFirstBlock (); + CatchWithBranchToFirstBlockAndReassignment (); + CatchWithNonSimplePredecessor (); + FinallyWithNonSimplePredecessor (); + FinallyInTryWithPredecessor (); + NestedFinally (); + NestedFinallyWithPredecessor (); + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void TryFlowsToFinally () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } finally { + // methods/fields/properties + RequireAll (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void TryFlowsToAfterFinally () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } finally { + // prevent optimizing this away + _ = string.Empty; + } + // properties + RequireAll (t); + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void MultipleTryExits () + { + Type t = GetWithPublicConstructors (); + for (int i = 0; i < 10; i++) { + try { + if (string.Empty.Length == 0) { + t = GetWithPublicMethods (); + return; + } + if (string.Empty.Length == 1) { + t = GetWithPublicFields (); + continue; + } + if (string.Empty.Length == 2) { + t = GetWithPublicProperties (); + break; + } + } finally { + RequireAll (t); + } + } + } + + // There are multiple paths through the finally to different subsequent blocks. + // On each path, only one state is possible, but we conservatively merge the (non-exceptional) + // finally states for each path and expect the warnings to reflect this merged state. + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicEvents) + "()", + ProducedBy = ProducedBy.Analyzer)] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicEvents) + "()")] + + [ExpectedWarning ("IL2073", nameof (MultipleFinallyPaths) + "()", nameof (GetWithPublicEvents) + "()")] + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] + public static Type MultipleFinallyPaths () + { + Type t = GetWithPublicMethods (); // reaches RequireAll1 and RequireAll2 + while (true) { + RequireAll1 (t); + try { + if (string.Empty.Length == 1) { + t = GetWithPublicFields (); // reaches RequireAll1 and RequireAll2 + continue; + } + if (string.Empty.Length == 0) { + t = GetWithPublicProperties (); // reaches RequireAll2 only, but the finally mergig means + // the analysis thinks it can reach RequireAll1. + break; + } + if (string.Empty.Length == 2) { + t = GetWithPublicEvents (); // reaches return only, but the finally merging means + // the analysis thinks it can reach RequireAll1 (and hence RequireAll2). + return t; + } + } finally { + _ = string.Empty; + } + } + RequireAll2 (t); // properties + + throw new Exception (); + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void FinallyChain () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + try { + t = GetWithPublicProperties (); + } finally { + RequireAll1 (t); // fields/properties + } + } finally { + RequireAll2 (t); // methods/fields/properties + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll4) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void FinallyChainWithPostFinallyState () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + try { + t = GetWithPublicProperties (); + } finally { + // normal: properties + // exception: fields/properties + RequireAll1 (t); // fields/properties + } + RequireAll2 (t); // properties + } finally { + // normal: properties + // exception: methods/fields/properties + RequireAll3 (t); // methods/fields/properties + } + RequireAll4 (t); + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void TryFlowsToCatch () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } catch { + // methods/fields/properties + RequireAll (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void CatchFlowsToFinally () + { + Type t = GetWithPublicMethods (); + try { + } catch { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } finally { + // methods/fields/properties + RequireAll (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void CatchFlowsToAfterTry () + { + Type t = GetWithPublicMethods (); + try { + } catch { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } + // methods/properties, not fields + RequireAll (t); + } + + + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void CatchFlowsToAfterFinally () + { + Type t = GetWithPublicMethods (); + try { + } catch { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } finally { } + // methods/properties, not fields + RequireAll (t); + } + + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void FinallyFlowsToAfterFinally () + { + Type t = GetWithPublicMethods (); + try { + } finally { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + } + // properties only + RequireAll (t); + } + + public class Exception1 : Exception { } + public class Exception2 : Exception { } + + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll4) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll4) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + + [ExpectedWarning ("IL2072", nameof (RequireAll5) + "(Type)", nameof (GetWithPublicEvents) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll6) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll6) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll6) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll6) + "(Type)", nameof (GetWithPublicEvents) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll7) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + + + public static void TryFlowsToMultipleCatchAndFinally () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + RequireAll1 (t); // fields only + } catch (Exception1) { + RequireAll2 (t); // methods/fields + t = GetWithPublicProperties (); + RequireAll3 (t); // properties only + } catch (Exception2) { + RequireAll4 (t); // methods/fields + t = GetWithPublicEvents (); + RequireAll5 (t); // events only + } finally { + RequireAll6 (t); // methods/fields/properties/events + t = GetWithPublicConstructors (); + RequireAll7 (t); // ctors only + } + RequireAll (t); + } + + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicEvents) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicConstructors) + "()", + ProducedBy = ProducedBy.Analyzer)] + + public static void NestedWithFinally () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + try { + // fields + t = GetWithPublicProperties (); + } finally { + // fields/properties + RequireAll1 (t); + t = GetWithPublicEvents (); + t = GetWithPublicConstructors (); + } + // ctors + RequireAll2 (t); + } finally { + // methods/fields/properties/events/constructors + RequireAll3 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicEvents) + "()")] + public static void ControlFlowsOutOfMultipleFinally () + { + Type t = GetWithPublicMethods (); + try { + try { + try { + t = GetWithPublicFields (); + } finally { + // methods/fields + RequireAll1 (t); + t = GetWithPublicProperties (); + } + } finally { + // methods/fields/properties + RequireAll2 (t); + t = GetWithPublicEvents (); + } + } finally { + // methods/fields/propreties/events + RequireAll3 (t); + } + } + + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicEvents) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + + public static void NestedWithCatch () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + try { + // fields + t = GetWithPublicProperties (); + } catch { + // fields/properties + RequireAll1 (t); + t = GetWithPublicEvents (); + t = GetWithPublicConstructors (); + } + // properties/ctors + RequireAll2 (t); + } catch { + // methods/fields/properties/events/constructors + RequireAll3 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()")] + public static void CatchInTry () + { + try { + Type t = GetWithPublicMethods (); + try { + } catch { + t = GetWithPublicFields (); + RequireAll (t); + } + } catch { + } + } + + // This tests a case where the catch state was being merged with the containing try state incorrectly. + // In the bug, the exceptional catch state, which is used in the finally, had too much in it. + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()")] + // The bug was producing this warning: + // [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicConstructors) + "()")] + public static void CatchInTryWithFinally () + { + Type t = GetWithPublicConstructors (); + try { + t = GetWithPublicMethods (); + // methods + // ex: ctors/methods + try { + // methods + // ex: methods + } catch { + // methods + t = GetWithPublicFields (); + // fields + // ex: methods/fields + RequireAll1 (t); + } finally { + // normal state: fields + // exceptional state: methods/fields + RequireAll2 (t); + } + } catch { + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + + public static void TestCatchesHaveSeparateState () + { + Type t = GetWithPublicMethods (); + try { + } catch (Exception1) { + t = GetWithPublicFields (); + } catch (Exception2) { + // methods only! + RequireAll (t); + } finally { + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + public static void FinallyWithBranchToFirstBlock () + { + Type t = GetWithPublicMethods (); + try { + } finally { + FinallyStart: + RequireAll (t); + t = GetWithPublicFields (); + goto FinallyStart; + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + public static void FinallyWithBranchToFirstBlockAndEnclosingTryCatchState () + { + try { + Type t = GetWithPublicProperties (); + t = GetWithPublicMethods (); + try { + } finally { + FinallyStart: + // methods/fields + RequireAll (t); + t = GetWithPublicFields (); + goto FinallyStart; + } + } finally { + // An operation just to prevent optimizing away + // the try/finally. + _ = String.Empty; + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + public static void CatchWithBranchToFirstBlock () + { + Type t = GetWithPublicMethods (); + try { + } catch { + CatchStart: + RequireAll (t); + t = GetWithPublicFields (); + goto CatchStart; + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (RequireAll) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + public static void CatchWithBranchToFirstBlockAndReassignment () + { + Type t = GetWithPublicMethods (); + try { + } catch { + CatchStart: + RequireAll (t); // methods/fields, but not properties! + t = GetWithPublicProperties (); + t = GetWithPublicFields (); + goto CatchStart; + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void CatchWithNonSimplePredecessor () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + try { + // properties only + } catch { + // properties only. + RequireAll1 (t); + } + } catch { + // methods/fields/properties + RequireAll2 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void FinallyWithNonSimplePredecessor () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + try { + // properties only + } catch { + // properties only. + RequireAll1 (t); + } + } finally { + // methods/fields/properties + RequireAll2 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void FinallyInTryWithPredecessor () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + t = GetWithPublicProperties (); + try { + // properties only + } finally { + // properties only. + RequireAll1 (t); + } + } finally { + // methods/fields/properties + RequireAll2 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void NestedFinally () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + } finally { + try { + RequireAll1 (t); + t = GetWithPublicProperties (); + } finally { + RequireAll2 (t); + } + RequireAll3 (t); + } + } + + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll1) + "(Type)", nameof (GetWithPublicFields) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (RequireAll2) + "(Type)", nameof (GetWithPublicProperties) + "()")] + + [ExpectedWarning ("IL2072", nameof (RequireAll3) + "(Type)", nameof (GetWithPublicProperties) + "()")] + public static void NestedFinallyWithPredecessor () + { + Type t = GetWithPublicMethods (); + try { + t = GetWithPublicFields (); + } finally { + _ = 0; // add an operation so that the try isn't the start of the finally. + try { + RequireAll1 (t); + t = GetWithPublicProperties (); + } finally { + RequireAll2 (t); + } + RequireAll3 (t); + } + } + + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] + public static Type GetWithPublicMethods () + { + return null; + } + + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] + public static Type GetWithPublicFields () + { + return null; + } + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicProperties)] + public static Type GetWithPublicProperties () + { + return null; + } + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicEvents)] + public static Type GetWithPublicEvents () + { + return null; + } + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] + public static Type GetWithPublicConstructors () + { + return null; + } + + public static void RequirePublicMethods ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] + Type type) + { + } + + public static void RequirePublicFields ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] + Type type) + { + } + public static void RequirePublicProperties ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] + Type type) + { + } + + + public static void RequireFieldsAndProperties ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties)] + Type type) + { + } + + public static void RequireAll ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll1 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll2 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll3 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll4 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll5 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll6 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + public static void RequireAll7 ( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] + Type type) + { + } + } +}
\ No newline at end of file diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs index cb36d87a3..51d21f1f2 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/FieldDataFlow.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; @@ -10,8 +10,9 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] public class FieldDataFlow { public static void Main () @@ -43,13 +44,15 @@ namespace Mono.Linker.Tests.Cases.DataFlow static Type _staticTypeWithoutRequirements; - [ExpectedWarning ("IL2097", nameof (_annotationOnWrongType))] + // TODO: warn about annotation on wrong type in analyzer: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2097", nameof (_annotationOnWrongType), + ProducedBy = ProducedBy.Trimmer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] static object _annotationOnWrongType; - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, - messageCode: "IL2077", message: new string[] { "_typeWithPublicParameterlessConstructor", "type", "RequirePublicConstructors(Type)" })] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (RequirePublicConstructors), + "_typeWithPublicParameterlessConstructor", "type", "RequirePublicConstructors(Type)")] + [ExpectedWarning ("IL2077", nameof (RequireNonPublicConstructors))] private void ReadFromInstanceField () { RequirePublicParameterlessConstructor (_typeWithPublicParameterlessConstructor); @@ -58,22 +61,18 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (_typeWithPublicParameterlessConstructor); } - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (_typeWithPublicParameterlessConstructor), - messageCode: "IL2074", message: new string[] { - nameof (GetUnkownType), - nameof (_typeWithPublicParameterlessConstructor) - })] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (_typeWithPublicParameterlessConstructor), messageCode: "IL2074")] + [ExpectedWarning ("IL2074", nameof (FieldDataFlow) + "." + nameof (_typeWithPublicParameterlessConstructor), nameof (GetUnknownType))] + [ExpectedWarning ("IL2074", nameof (FieldDataFlow) + "." + nameof (_typeWithPublicParameterlessConstructor), nameof (GetTypeWithNonPublicConstructors))] private void WriteToInstanceField () { _typeWithPublicParameterlessConstructor = GetTypeWithPublicParameterlessConstructor (); _typeWithPublicParameterlessConstructor = GetTypeWithPublicConstructors (); _typeWithPublicParameterlessConstructor = GetTypeWithNonPublicConstructors (); - _typeWithPublicParameterlessConstructor = GetUnkownType (); + _typeWithPublicParameterlessConstructor = GetUnknownType (); } - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (RequirePublicConstructors))] + [ExpectedWarning ("IL2077", nameof (RequireNonPublicConstructors))] private void ReadFromInstanceFieldOnADifferentClass () { var store = new TypeStore (); @@ -84,8 +83,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (store._typeWithPublicParameterlessConstructor); } - [UnrecognizedReflectionAccessPattern (typeof (TypeStore), nameof (TypeStore._typeWithPublicParameterlessConstructor), messageCode: "IL2074")] - [UnrecognizedReflectionAccessPattern (typeof (TypeStore), nameof (TypeStore._typeWithPublicParameterlessConstructor), messageCode: "IL2074")] + [ExpectedWarning ("IL2074", nameof (TypeStore) + "." + nameof (TypeStore._typeWithPublicParameterlessConstructor), nameof (GetUnknownType))] + [ExpectedWarning ("IL2074", nameof (TypeStore) + "." + nameof (TypeStore._typeWithPublicParameterlessConstructor), nameof (GetTypeWithNonPublicConstructors))] private void WriteToInstanceFieldOnADifferentClass () { var store = new TypeStore (); @@ -93,11 +92,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow store._typeWithPublicParameterlessConstructor = GetTypeWithPublicParameterlessConstructor (); store._typeWithPublicParameterlessConstructor = GetTypeWithPublicConstructors (); store._typeWithPublicParameterlessConstructor = GetTypeWithNonPublicConstructors (); - store._typeWithPublicParameterlessConstructor = GetUnkownType (); + store._typeWithPublicParameterlessConstructor = GetUnknownType (); } - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (RequirePublicConstructors))] + [ExpectedWarning ("IL2077", nameof (RequireNonPublicConstructors))] private void ReadFromStaticField () { RequirePublicParameterlessConstructor (_staticTypeWithPublicParameterlessConstructor); @@ -106,24 +105,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (_staticTypeWithPublicParameterlessConstructor); } - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (_staticTypeWithPublicParameterlessConstructor), messageCode: "IL2074")] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (_staticTypeWithPublicParameterlessConstructor), messageCode: "IL2074")] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (_staticTypeWithPublicParameterlessConstructor), - messageCode: "IL2079", message: new string[] { - nameof(_staticTypeWithoutRequirements), - nameof(_staticTypeWithPublicParameterlessConstructor) - })] + [ExpectedWarning ("IL2074", nameof (FieldDataFlow) + "." + nameof (_staticTypeWithPublicParameterlessConstructor), nameof (GetUnknownType))] + [ExpectedWarning ("IL2074", nameof (FieldDataFlow) + "." + nameof (_staticTypeWithPublicParameterlessConstructor), nameof (GetTypeWithNonPublicConstructors))] + [ExpectedWarning ("IL2079", nameof (FieldDataFlow) + "." + nameof (_staticTypeWithPublicParameterlessConstructor), nameof (_staticTypeWithoutRequirements))] private void WriteToStaticField () { _staticTypeWithPublicParameterlessConstructor = GetTypeWithPublicParameterlessConstructor (); _staticTypeWithPublicParameterlessConstructor = GetTypeWithPublicConstructors (); _staticTypeWithPublicParameterlessConstructor = GetTypeWithNonPublicConstructors (); - _staticTypeWithPublicParameterlessConstructor = GetUnkownType (); + _staticTypeWithPublicParameterlessConstructor = GetUnknownType (); _staticTypeWithPublicParameterlessConstructor = _staticTypeWithoutRequirements; } - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] - [UnrecognizedReflectionAccessPattern (typeof (FieldDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (RequirePublicConstructors))] + [ExpectedWarning ("IL2077", nameof (RequireNonPublicConstructors))] private void ReadFromStaticFieldOnADifferentClass () { RequirePublicParameterlessConstructor (TypeStore._staticTypeWithPublicParameterlessConstructor); @@ -132,17 +127,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow RequireNothing (TypeStore._staticTypeWithPublicParameterlessConstructor); } - [UnrecognizedReflectionAccessPattern (typeof (TypeStore), nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), messageCode: "IL2074")] - [UnrecognizedReflectionAccessPattern (typeof (TypeStore), nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), messageCode: "IL2074")] + [ExpectedWarning ("IL2074", nameof (TypeStore) + "." + nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), nameof (GetUnknownType))] + [ExpectedWarning ("IL2074", nameof (TypeStore) + "." + nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), nameof (GetTypeWithNonPublicConstructors))] private void WriteToStaticFieldOnADifferentClass () { TypeStore._staticTypeWithPublicParameterlessConstructor = GetTypeWithPublicParameterlessConstructor (); TypeStore._staticTypeWithPublicParameterlessConstructor = GetTypeWithPublicConstructors (); TypeStore._staticTypeWithPublicParameterlessConstructor = GetTypeWithNonPublicConstructors (); - TypeStore._staticTypeWithPublicParameterlessConstructor = GetUnkownType (); + TypeStore._staticTypeWithPublicParameterlessConstructor = GetUnknownType (); } - [UnrecognizedReflectionAccessPattern (typeof (TypeStore), nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), messageCode: "IL2064", message: new string[] { nameof (TypeStore._staticTypeWithPublicParameterlessConstructor) })] + // TODO: warn about unknown types in analyzer: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2064", nameof (TypeStore) + "." + nameof (TypeStore._staticTypeWithPublicParameterlessConstructor), + ProducedBy = ProducedBy.Trimmer)] private void WriteUnknownValue () { var array = new object[1]; @@ -191,7 +188,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow return null; } - private static Type GetUnkownType () + private static Type GetUnknownType () { return null; } diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/GenericParameterDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/GenericParameterDataFlow.cs index 979275897..1b22b25f5 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/GenericParameterDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/GenericParameterDataFlow.cs @@ -71,12 +71,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeRequiresPublicFields< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> { - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, - messageCode: "IL2087", message: new string[] { - nameof (T), - nameof (TypeRequiresPublicFields <T>), - nameof (DataFlowTypeExtensions.RequiresPublicMethods) - })] + [ExpectedWarning ("IL2087", "'" + nameof (T) + "'", nameof (TypeRequiresPublicFields<T>), nameof (DataFlowTypeExtensions.RequiresPublicMethods))] public static void Test () { typeof (T).RequiresPublicFields (); @@ -90,12 +85,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (T).RequiresPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (GenericParameterDataFlow), nameof (FieldRequiresPublicMethods), - messageCode: "IL2089", message: new string[] { - nameof (T), - nameof (TypeRequiresPublicFields <T>), - nameof (FieldRequiresPublicMethods) - })] + [ExpectedWarning ("IL2089", "'" + nameof (T) + "'", nameof (TypeRequiresPublicFields<T>), nameof (FieldRequiresPublicMethods))] public static void TestFields () { FieldRequiresPublicFields = typeof (T); @@ -104,7 +94,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } - [RecognizedReflectionAccessPattern] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] public static Type ReturnRequiresPublicFields () { @@ -112,12 +101,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow } - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicFields<>), nameof (ReturnRequiresPublicMethods), new Type[] { }, returnType: typeof (Type), - messageCode: "IL2088", message: new string[] { - nameof (T), - nameof (TypeRequiresPublicFields<T>), - nameof (ReturnRequiresPublicMethods) - })] + [ExpectedWarning ("IL2088", "'" + nameof (T) + "'", nameof (TypeRequiresPublicFields<T>), nameof (ReturnRequiresPublicMethods))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] public static Type ReturnRequiresPublicMethods () { @@ -133,7 +117,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeRequiresPublicMethods< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> { - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] public static void Test () { typeof (T).RequiresPublicFields (); @@ -144,8 +128,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeRequiresNothing<T> { - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] public static void Test () { typeof (T).RequiresPublicFields (); @@ -157,12 +141,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeRequiresPublicFieldsPassThrough< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TSource> { - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - nameof(TSource), + [ExpectedWarning ("IL2091", nameof (TSource), "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeRequiresPublicFieldsPassThrough<TSource>", "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeRequiresPublicMethods<T>" })] + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeRequiresPublicMethods<T>")] public static void Test () { TypeRequiresPublicFields<TSource>.Test (); @@ -173,8 +155,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeRequiresNothingPassThrough<T> { - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicFields<>), null, genericParameter: "T", messageCode: "IL2091")] - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicFields<T>))] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<T>))] public static void Test () { TypeRequiresPublicFields<T>.Test (); @@ -198,7 +180,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicMethods)] TBoth, TNothing> { - [RecognizedReflectionAccessPattern] public static void TestMultiple () { typeof (TFields).RequiresPublicFields (); @@ -211,7 +192,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TNothing).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] public static void TestFields () { typeof (TFields).RequiresPublicFields (); @@ -219,7 +200,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TFields).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] public static void TestMethods () { typeof (TMethods).RequiresPublicFields (); @@ -227,7 +208,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TMethods).RequiresNone (); } - [RecognizedReflectionAccessPattern] public static void TestBoth () { typeof (TBoth).RequiresPublicFields (); @@ -235,8 +215,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TBoth).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] public static void TestNothing () { typeof (TNothing).RequiresPublicFields (); @@ -245,7 +225,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [RecognizedReflectionAccessPattern] static void TestBaseTypeGenericRequirements () { new DerivedTypeWithInstantiatedGenericOnBase (); @@ -256,14 +235,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow class GenericBaseTypeWithRequirements<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> { - [RecognizedReflectionAccessPattern] public GenericBaseTypeWithRequirements () { typeof (T).RequiresPublicFields (); } } - [RecognizedReflectionAccessPattern] class DerivedTypeWithInstantiatedGenericOnBase : GenericBaseTypeWithRequirements<TestType> { } @@ -272,19 +249,17 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] class DerivedTypeWithInstantiationOverSelfOnBase : GenericBaseTypeWithRequirements<DerivedTypeWithInstantiationOverSelfOnBase> { } - [UnrecognizedReflectionAccessPattern (typeof (GenericBaseTypeWithRequirements<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (GenericBaseTypeWithRequirements<T>))] class DerivedTypeWithOpenGenericOnBase<T> : GenericBaseTypeWithRequirements<T> { - [UnrecognizedReflectionAccessPattern (typeof (GenericBaseTypeWithRequirements<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (GenericBaseTypeWithRequirements<T>))] public DerivedTypeWithOpenGenericOnBase () { } } - [RecognizedReflectionAccessPattern] class DerivedTypeWithOpenGenericOnBaseWithRequirements<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> : GenericBaseTypeWithRequirements<T> { @@ -302,7 +277,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] class InterfaceImplementationTypeWithInstantiatedGenericOnBase : IGenericInterfaceTypeWithRequirements<TestType> { } @@ -311,23 +285,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] class InterfaceImplementationTypeWithInstantiationOverSelfOnBase : IGenericInterfaceTypeWithRequiresAll<InterfaceImplementationTypeWithInstantiationOverSelfOnBase> { } - [UnrecognizedReflectionAccessPattern (typeof (IGenericInterfaceTypeWithRequirements<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (IGenericInterfaceTypeWithRequirements<T>))] class InterfaceImplementationTypeWithOpenGenericOnBase<T> : IGenericInterfaceTypeWithRequirements<T> { } - [RecognizedReflectionAccessPattern] class InterfaceImplementationTypeWithOpenGenericOnBaseWithRequirements<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> : IGenericInterfaceTypeWithRequirements<T> { } - [RecognizedReflectionAccessPattern] static void TestDeepNestedTypesWithGenerics () { RootTypeWithRequirements<TestType>.InnerTypeWithNoAddedGenerics.TestAccess (); @@ -339,12 +310,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow { // The message is not ideal since we report the TRoot to come from RootTypeWithRequirements/InnerTypeWIthNoAddedGenerics // while it originates on RootTypeWithRequirements, but it's correct from IL's point of view. - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, - messageCode: "IL2087", message: new string[] { - nameof(TRoot), + [ExpectedWarning ("IL2087", nameof (TRoot), "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.RootTypeWithRequirements<TRoot>.InnerTypeWithNoAddedGenerics", "type", - "DataFlowTypeExtensions.RequiresPublicMethods(Type)" })] + "DataFlowTypeExtensions.RequiresPublicMethods(Type)")] public static void TestAccess () { typeof (TRoot).RequiresPublicFields (); @@ -353,7 +322,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [RecognizedReflectionAccessPattern] static void TestTypeGenericRequirementsOnMembers () { // Basically just root everything we need to test @@ -379,50 +347,44 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeGenericRequirementsOnMembers<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TOuter> { - [RecognizedReflectionAccessPattern] public TypeRequiresPublicFields<TOuter> PublicFieldsField; - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] public TypeRequiresPublicMethods<TOuter> PublicMethodsField; public TypeRequiresPublicFields<TOuter> PublicFieldsProperty { - [RecognizedReflectionAccessPattern] get; - [RecognizedReflectionAccessPattern] set; } public TypeRequiresPublicMethods<TOuter> PublicMethodsProperty { - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] get => null; - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] set { } } - [RecognizedReflectionAccessPattern] public void PublicFieldsMethodParameter (TypeRequiresPublicFields<TOuter> param) { } - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] public void PublicMethodsMethodParameter (TypeRequiresPublicMethods<TOuter> param) { } - [RecognizedReflectionAccessPattern] public TypeRequiresPublicFields<TOuter> PublicFieldsMethodReturnValue () { return null; } - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] // Return value - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] // Compiler generated local variable + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] // Return value + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] // Compiler generated local variable public TypeRequiresPublicMethods<TOuter> PublicMethodsMethodReturnValue () { return null; } - [RecognizedReflectionAccessPattern] public void PublicFieldsMethodLocalVariable () { TypeRequiresPublicFields<TOuter> t = null; } - [UnrecognizedReflectionAccessPattern (typeof (TypeRequiresPublicMethods<>), null, genericParameter: "T", messageCode: "IL2091")] + + [ExpectedWarning ("IL2091", nameof (TypeRequiresPublicMethods<TOuter>))] public void PublicMethodsMethodLocalVariable () { TypeRequiresPublicMethods<TOuter> t = null; } } - [RecognizedReflectionAccessPattern] static void TestPartialInstantiationTypes () { _ = new PartialyInstantiatedFields<TestType> (); @@ -437,27 +399,24 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] class PartialyInstantiatedFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TOuter> : BaseForPartialInstantiation<TOuter, TestType> { } - [RecognizedReflectionAccessPattern] class FullyInstantiatedOverPartiallyInstantiatedFields : PartialyInstantiatedFields<TestType> { } - [UnrecognizedReflectionAccessPattern (typeof (BaseForPartialInstantiation<,>), null, genericParameter: "TMethods", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (BaseForPartialInstantiation<TestType, TOuter>), "'TMethods'")] class PartialyInstantiatedMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TOuter> : BaseForPartialInstantiation<TestType, TOuter> { - [UnrecognizedReflectionAccessPattern (typeof (BaseForPartialInstantiation<,>), null, genericParameter: "TMethods", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (BaseForPartialInstantiation<TestType, TOuter>), "'TMethods'")] public PartialyInstantiatedMethods () { } } - [RecognizedReflectionAccessPattern] class FullyInstantiatedOverPartiallyInstantiatedMethods : PartialyInstantiatedMethods<TestType> { @@ -472,7 +431,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow MethodRequiresNothingPassThrough<TestType> (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void MethodRequiresPublicFields< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () { @@ -481,7 +440,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (T).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] static void MethodRequiresPublicMethods< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> () { @@ -497,8 +456,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (T).RequiresPublicFields (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void MethodRequiresNothing<T> () { typeof (T).RequiresPublicFields (); @@ -506,7 +465,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (T).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (GenericParameterDataFlow), nameof (MethodRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (MethodRequiresPublicMethods), "'T'")] static void MethodRequiresPublicFieldsPassThrough< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () { @@ -515,8 +474,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow MethodRequiresNothing<T> (); } - [UnrecognizedReflectionAccessPattern (typeof (GenericParameterDataFlow), nameof (MethodRequiresPublicFields) + "<T>", new Type[0] { }, genericParameter: "T", messageCode: "IL2091")] - [UnrecognizedReflectionAccessPattern (typeof (GenericParameterDataFlow), nameof (MethodRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", messageCode: "IL2091")] + [ExpectedWarning ("IL2091", nameof (MethodRequiresPublicFields), "'T'")] + [ExpectedWarning ("IL2091", nameof (MethodRequiresPublicMethods), "'T'")] static void MethodRequiresNothingPassThrough<T> () { MethodRequiresPublicFields<T> (); @@ -549,27 +508,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow class BaseTypeWithGenericMethod { - [RecognizedReflectionAccessPattern] public static void StaticRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () => typeof (T).RequiresPublicFields (); - [RecognizedReflectionAccessPattern] public void InstanceRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () => typeof (T).RequiresPublicFields (); - [RecognizedReflectionAccessPattern] public virtual void VirtualRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () => typeof (T).RequiresPublicFields (); - [RecognizedReflectionAccessPattern] public static void StaticRequiresPublicMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> () => typeof (T).RequiresPublicMethods (); - [RecognizedReflectionAccessPattern] public void InstanceRequiresPublicMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)]T> () => typeof (T).RequiresPublicMethods (); - [RecognizedReflectionAccessPattern] public virtual void VirtualRequiresPublicMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)]T> () => typeof (T).RequiresPublicMethods (); - [RecognizedReflectionAccessPattern] public static void StaticRequiresMultipleGenericParams< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TFields, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TMethods> () @@ -588,101 +540,90 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TypeWithInstantiatedGenericMethodViaGenericParameter<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TOuter> : BaseTypeWithGenericMethod, IInterfaceWithGenericMethod { - [UnrecognizedReflectionAccessPattern (typeof (BaseTypeWithGenericMethod), nameof (BaseTypeWithGenericMethod.StaticRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - "TInner", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>.StaticRequiresPublicFields<TInner>()", - "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresPublicMethods<T>()" })] + [ExpectedWarning ("IL2091", + "'TInner'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>.StaticRequiresPublicFields<TInner>()", + "'T'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresPublicMethods<T>()")] public static void StaticRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TInner> () { StaticRequiresPublicFields<TInner> (); StaticRequiresPublicMethods<TInner> (); } - [UnrecognizedReflectionAccessPattern (typeof (BaseTypeWithGenericMethod), nameof (BaseTypeWithGenericMethod.StaticRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - "TOuter", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", - "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresPublicMethods<T>()" })] + [ExpectedWarning ("IL2091", + "'TOuter'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", + "'T'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresPublicMethods<T>()")] public static void StaticRequiresPublicFieldsNonGeneric () { StaticRequiresPublicFields<TOuter> (); StaticRequiresPublicMethods<TOuter> (); } - [RecognizedReflectionAccessPattern] public static void StaticPartialInstantiation () { StaticRequiresMultipleGenericParams<TOuter, TestType> (); } - [UnrecognizedReflectionAccessPattern (typeof (BaseTypeWithGenericMethod), nameof (BaseTypeWithGenericMethod.StaticRequiresMultipleGenericParams) + "<TFields,TMethods>", new Type[0] { }, genericParameter: "TMethods", - messageCode: "IL2091", message: new string[] { - "TOuter", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", - "TMethods", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresMultipleGenericParams<TFields,TMethods>()" })] + [ExpectedWarning ("IL2091", + "'TOuter'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", + "'TMethods'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.StaticRequiresMultipleGenericParams<TFields,TMethods>()")] public static void StaticPartialInstantiationUnrecognized () { StaticRequiresMultipleGenericParams<TestType, TOuter> (); } - [UnrecognizedReflectionAccessPattern (typeof (BaseTypeWithGenericMethod), nameof (BaseTypeWithGenericMethod.InstanceRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - "TInner", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>.InstanceRequiresPublicFields<TInner>()", - "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.InstanceRequiresPublicMethods<T>()" })] + [ExpectedWarning ("IL2091", + "'TInner'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>.InstanceRequiresPublicFields<TInner>()", + "'T'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.InstanceRequiresPublicMethods<T>()")] public void InstanceRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TInner> () { InstanceRequiresPublicFields<TInner> (); InstanceRequiresPublicMethods<TInner> (); } - [UnrecognizedReflectionAccessPattern (typeof (BaseTypeWithGenericMethod), nameof (BaseTypeWithGenericMethod.InstanceRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - "TOuter", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", - "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.InstanceRequiresPublicMethods<T>()" })] + [ExpectedWarning ("IL2091", + "'TOuter'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", + "'T'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.BaseTypeWithGenericMethod.InstanceRequiresPublicMethods<T>()")] public void InstanceRequiresPublicFieldsNonGeneric () { InstanceRequiresPublicFields<TOuter> (); InstanceRequiresPublicMethods<TOuter> (); } - [RecognizedReflectionAccessPattern] public override void VirtualRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () { typeof (T).RequiresPublicFields (); } - [RecognizedReflectionAccessPattern] public override void VirtualRequiresPublicMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> () { typeof (T).RequiresPublicMethods (); } - [RecognizedReflectionAccessPattern] public void InterfaceRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () { typeof (T).RequiresPublicFields (); ; } - [RecognizedReflectionAccessPattern] public void InterfaceRequiresPublicMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> () { typeof (T).RequiresPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (IInterfaceWithGenericMethod), nameof (IInterfaceWithGenericMethod.InterfaceRequiresPublicMethods) + "<T>", new Type[0] { }, genericParameter: "T", - messageCode: "IL2091", message: new string[] { - "TOuter", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", - "T", - "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.IInterfaceWithGenericMethod.InterfaceRequiresPublicMethods<T>()" })] + [ExpectedWarning ("IL2091", + "'TOuter'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.TypeWithInstantiatedGenericMethodViaGenericParameter<TOuter>", + "'T'", + "Mono.Linker.Tests.Cases.DataFlow.GenericParameterDataFlow.IInterfaceWithGenericMethod.InterfaceRequiresPublicMethods<T>()")] public void CallInterface () { IInterfaceWithGenericMethod interfaceInstance = (IInterfaceWithGenericMethod) this; @@ -701,7 +642,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow MethodMultipleWithDifferentRequirements_TestNothing<TestType, TestType, TestType, TestType> (); } - [RecognizedReflectionAccessPattern] static void MethodMultipleWithDifferentRequirements_TestMultiple< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TFields, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TMethods, @@ -718,7 +658,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TNothing).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void MethodMultipleWithDifferentRequirements_TestFields< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TFields, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TMethods, @@ -730,7 +670,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TFields).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] static void MethodMultipleWithDifferentRequirements_TestMethods< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TFields, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TMethods, @@ -753,8 +693,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (TBoth).RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicFields), new Type[] { typeof (Type) }, messageCode: "IL2087")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) }, messageCode: "IL2087")] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + [ExpectedWarning ("IL2087", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void MethodMultipleWithDifferentRequirements_TestNothing< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] TFields, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TMethods, @@ -797,29 +737,25 @@ namespace Mono.Linker.Tests.Cases.DataFlow // This is OK since we know it's null, so MakeGenericType is effectively a no-op (will throw) // so no validation necessary. - [RecognizedReflectionAccessPattern] static void TestNullType () { Type nullType = null; nullType.MakeGenericType (typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.MakeGenericType), new Type[] { typeof (Type[]) }, - messageCode: "IL2055")] + [ExpectedWarning ("IL2055", nameof (Type.MakeGenericType))] static void TestUnknownInput (Type inputType) { inputType.MakeGenericType (typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.MakeGenericType), new Type[] { typeof (Type[]) }, - messageCode: "IL2055")] + [ExpectedWarning ("IL2055", nameof (Type.MakeGenericType))] static void TestWithUnknownTypeArray (Type[] types) { typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (types); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.MakeGenericType), new Type[] { typeof (Type[]) }, - messageCode: "IL2055")] + [ExpectedWarning ("IL2055", nameof (Type.MakeGenericType))] static void TestWithArrayUnknownIndexSet (int indexToSet) { Type[] types = new Type[1]; @@ -827,8 +763,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (types); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.MakeGenericType), new Type[] { typeof (Type[]) }, - messageCode: "IL2055")] + [ExpectedWarning ("IL2055", nameof (Type.MakeGenericType))] static void TestWithArrayUnknownLengthSet (int arrayLen) { Type[] types = new Type[arrayLen]; @@ -836,7 +771,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (types); } - [RecognizedReflectionAccessPattern] static void TestNoArguments () { typeof (TypeMakeGenericNoArguments).MakeGenericType (); @@ -846,7 +780,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithRequirements () { // Currently this is not analyzable since we don't track array elements. @@ -854,7 +787,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (typeof (TestType)); } - [RecognizedReflectionAccessPattern] static void TestWithRequirementsFromParam ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] Type type) { @@ -870,7 +802,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow typeof (GenericWithPublicFieldsArgument<>).MakeGenericType (type); } - [RecognizedReflectionAccessPattern] static void TestWithRequirementsFromGenericParam< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> () { @@ -890,13 +821,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithNoRequirements () { typeof (GenericWithNoRequirements<>).MakeGenericType (typeof (TestType)); } - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsFromParam (Type type) { typeof (GenericWithNoRequirements<>).MakeGenericType (type); @@ -906,7 +835,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithMultipleArgumentsWithRequirements () { typeof (GenericWithMultipleArgumentsWithRequirements<,>).MakeGenericType (typeof (TestType), typeof (TestType)); @@ -918,7 +846,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithNewConstraint () { typeof (GenericWithNewConstraint<>).MakeGenericType (typeof (TestType)); @@ -928,7 +855,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithStructConstraint () { typeof (GenericWithStructConstraint<>).MakeGenericType (typeof (TestType)); @@ -938,7 +864,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithUnmanagedConstraint () { typeof (GenericWithUnmanagedConstraint<>).MakeGenericType (typeof (TestType)); @@ -948,7 +873,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithNullable () { typeof (Nullable<>).MakeGenericType (typeof (TestType)); @@ -995,38 +919,33 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestWithUnmanagedConstraint (); } - [RecognizedReflectionAccessPattern] static void TestNullMethod () { MethodInfo mi = null; mi.MakeGenericMethod (typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestUnknownMethod (MethodInfo mi) { mi.MakeGenericMethod (typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestUnknownMethodButNoTypeArguments (MethodInfo mi) { // Thechnically linker could figure this out, but it's not worth the complexity - such call will always fail at runtime. mi.MakeGenericMethod (Type.EmptyTypes); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithUnknownTypeArray (Type[] types) { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithRequirements), BindingFlags.Static) .MakeGenericMethod (types); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithArrayUnknownIndexSet (int indexToSet) { Type[] types = new Type[1]; @@ -1035,8 +954,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow .MakeGenericMethod (types); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithArrayUnknownIndexSetByRef (int indexToSet) { Type[] types = new Type[1]; @@ -1047,8 +965,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow .MakeGenericMethod (types); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithArrayUnknownLengthSet (int arrayLen) { Type[] types = new Type[arrayLen]; @@ -1061,8 +978,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithArrayPassedToAnotherMethod () { Type[] types = new Type[1]; @@ -1072,7 +988,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow .MakeGenericMethod (types); } - [RecognizedReflectionAccessPattern] static void TestWithNoArguments () { typeof (MakeGenericMethod).GetMethod (nameof (NonGenericMethod), BindingFlags.Static | BindingFlags.NonPublic) @@ -1082,7 +997,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow // This should not warn since we can't be always sure about the exact overload as we don't support // method parameter signature matching, and thus the GetMethod may return multiple potential methods. // It can happen that some are generic and some are not. The analysis should not fail on this. - [RecognizedReflectionAccessPattern] static void TestWithArgumentsButNonGenericMethod () { typeof (MakeGenericMethod).GetMethod (nameof (NonGenericMethod), BindingFlags.Static | BindingFlags.NonPublic) @@ -1093,14 +1007,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithRequirements () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithRequirements), BindingFlags.Static) .MakeGenericMethod (typeof (TestType)); } - [RecognizedReflectionAccessPattern] static void TestWithRequirementsFromParam ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] Type type) { @@ -1116,15 +1028,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow } - [RecognizedReflectionAccessPattern] static void TestWithRequirementsViaRuntimeMethod () { typeof (MakeGenericMethod).GetRuntimeMethod (nameof (GenericWithRequirements), Type.EmptyTypes) .MakeGenericMethod (typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithRequirementsButNoTypeArguments () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithRequirements), BindingFlags.Static) @@ -1135,23 +1045,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithMultipleKnownGenericParameters () { typeof (MakeGenericMethod).GetMethod (nameof (GenericMultipleParameters), BindingFlags.Static) .MakeGenericMethod (typeof (TestType), typeof (TestType), typeof (TestType)); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithOneUnknownGenericParameter (Type[] types) { typeof (MakeGenericMethod).GetMethod (nameof (GenericMultipleParameters), BindingFlags.Static) .MakeGenericMethod (typeof (TestType), typeof (TestStruct), types[0]); } - [UnrecognizedReflectionAccessPattern (typeof (MethodInfo), nameof (MethodInfo.MakeGenericMethod), new Type[] { typeof (Type[]) }, - messageCode: "IL2060")] + [ExpectedWarning ("IL2060", nameof (MethodInfo.MakeGenericMethod))] static void TestWithPartiallyInitializedGenericTypeArray () { Type[] types = new Type[3]; @@ -1161,7 +1068,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow .MakeGenericMethod (types); } - [RecognizedReflectionAccessPattern] static void TestWithConditionalGenericTypeSet (bool thirdParameterIsStruct) { Type[] types = new Type[3]; @@ -1183,21 +1089,18 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithNoRequirements () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithNoRequirements), BindingFlags.Static) .MakeGenericMethod (typeof (TestType)); } - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsFromParam (Type type) { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithNoRequirements), BindingFlags.Static) .MakeGenericMethod (type); } - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsViaRuntimeMethod () { typeof (MakeGenericMethod).GetRuntimeMethod (nameof (GenericWithNoRequirements), Type.EmptyTypes) @@ -1205,7 +1108,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } // There are no requirements, so no warnings - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsUnknownType (Type type) { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithNoRequirements)) @@ -1213,7 +1115,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } // There are no requirements, so no warnings - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsWrongNumberOfTypeParameters () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithNoRequirements)) @@ -1221,7 +1122,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } // There are no requirements, so no warnings - [RecognizedReflectionAccessPattern] static void TestWithNoRequirementsUnknownArrayElement () { Type[] types = new Type[1]; @@ -1234,7 +1134,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow } - [RecognizedReflectionAccessPattern] static void TestWithMultipleArgumentsWithRequirements () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithMultipleArgumentsWithRequirements), BindingFlags.Static | BindingFlags.NonPublic) @@ -1247,7 +1146,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } - [RecognizedReflectionAccessPattern] static void TestWithNewConstraint () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithNewConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -1259,7 +1157,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow var t = new T (); } - [RecognizedReflectionAccessPattern] static void TestWithStructConstraint () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithStructConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -1271,7 +1168,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow var t = new T (); } - [RecognizedReflectionAccessPattern] static void TestWithUnmanagedConstraint () { typeof (MakeGenericMethod).GetMethod (nameof (GenericWithUnmanagedConstraint), BindingFlags.Static | BindingFlags.NonPublic) @@ -1284,19 +1180,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [RecognizedReflectionAccessPattern] static void TestNewConstraintSatisfiesParameterlessConstructor<T> () where T : new() { RequiresParameterlessConstructor<T> (); } - [RecognizedReflectionAccessPattern] static void TestStructConstraintSatisfiesParameterlessConstructor<T> () where T : struct { RequiresParameterlessConstructor<T> (); } - [RecognizedReflectionAccessPattern] static void TestUnmanagedConstraintSatisfiesParameterlessConstructor<T> () where T : unmanaged { RequiresParameterlessConstructor<T> (); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/GetNestedTypeOnAllAnnotatedType.cs b/test/Mono.Linker.Tests.Cases/DataFlow/GetNestedTypeOnAllAnnotatedType.cs index e7da76ae9..fbf1c966a 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/GetNestedTypeOnAllAnnotatedType.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/GetNestedTypeOnAllAnnotatedType.cs @@ -13,68 +13,62 @@ using Mono.Linker.Tests.Cases.Expectations.Helpers; namespace Mono.Linker.Tests.Cases.DataFlow { - [RecognizedReflectionAccessPattern] + [ExpectedNoWarnings] [SkipKeptItemsValidation] class GetNestedTypeOnAllAnnotatedType { - [RecognizedReflectionAccessPattern] static void Main () { - TestOnAllAnnotatedParameter (typeof (GetNestedTypeOnAllAnnotatedType)); - TestOnNonAllAnnotatedParameter (typeof (GetNestedTypeOnAllAnnotatedType)); - TestWithBindingFlags (typeof (GetNestedTypeOnAllAnnotatedType)); - TestWithUnknownBindingFlags (BindingFlags.Public, typeof (GetNestedTypeOnAllAnnotatedType)); - TestUnsupportedBindingFlags (typeof (GetNestedTypeOnAllAnnotatedType)); + TestOnAllAnnotatedParameter (typeof (TestType)); + TestOnNonAllAnnotatedParameter (typeof (TestType)); + TestWithBindingFlags (typeof (TestType)); + TestWithUnknownBindingFlags (BindingFlags.Public, typeof (TestType)); + TestUnsupportedBindingFlags (typeof (TestType)); TestWithNull (); - TestIfElse (1, typeof (GetNestedTypeOnAllAnnotatedType), typeof (GetNestedTypeOnAllAnnotatedType)); - TestSwitchAllValid (1, typeof (GetNestedTypeOnAllAnnotatedType)); + TestIfElse (1, typeof (TestType), typeof (TestType)); + TestSwitchAllValid (1, typeof (TestType)); TestOnKnownTypeOnly (); } - [RecognizedReflectionAccessPattern] static void TestOnAllAnnotatedParameter ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentType) { - var nestedType = parentType.GetNestedType (nameof (NestedType)); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType)); nestedType.RequiresAll (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresAll), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresAll))] static void TestOnNonAllAnnotatedParameter ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicNestedTypes)] Type parentType) { - var nestedType = parentType.GetNestedType (nameof (NestedType)); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType)); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestWithBindingFlags ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentType) { - var nestedType = parentType.GetNestedType (nameof (NestedType), BindingFlags.Public); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType), BindingFlags.Public); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestWithUnknownBindingFlags (BindingFlags bindingFlags, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentType) { - var nestedType = parentType.GetNestedType (nameof (NestedType), bindingFlags); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType), bindingFlags); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestUnsupportedBindingFlags ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentType) { - var nestedType = parentType.GetNestedType (nameof (NestedType), BindingFlags.IgnoreCase); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType), BindingFlags.IgnoreCase); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestWithNull () { Type parentType = null; - var nestedType = parentType.GetNestedType (nameof (NestedType)); + var nestedType = parentType.GetNestedType (nameof (TestType.NestedType)); nestedType.RequiresAll (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresAll), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresAll))] static void TestIfElse (int number, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentWithAll, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicNestedTypes)] Type parentWithoutAll) { Type typeOfParent; @@ -83,35 +77,36 @@ namespace Mono.Linker.Tests.Cases.DataFlow } else { typeOfParent = parentWithoutAll; } - var nestedType = typeOfParent.GetNestedType (nameof (NestedType)); + var nestedType = typeOfParent.GetNestedType (nameof (TestType.NestedType)); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestSwitchAllValid (int number, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type parentWithAll) { Type typeOfParent = number switch { 1 => parentWithAll, 2 => null, - 3 => typeof (GetNestedTypeOnAllAnnotatedType) + 3 => typeof (TestType) }; - var nestedType = typeOfParent.GetNestedType (nameof (NestedType)); + var nestedType = typeOfParent.GetNestedType (nameof (TestType.NestedType)); nestedType.RequiresAll (); } - [RecognizedReflectionAccessPattern] static void TestOnKnownTypeOnly () { - typeof (GetNestedTypeOnAllAnnotatedType).GetNestedType (nameof (NestedType)).RequiresAll (); + typeof (TestType).GetNestedType (nameof (TestType.NestedType)).RequiresAll (); } - private class NestedType + class TestType { - NestedType () { } - public static int PublicStaticInt; - public void Method () { } - int Prop { get; set; } + public class NestedType + { + NestedType () { } + public static int PublicStaticInt; + public void Method () { } + int Prop { get; set; } + } } } } diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs index 5dc272f0f..289916c27 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeDataFlow.cs @@ -6,12 +6,14 @@ using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Text; using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] public class GetTypeDataFlow { public static void Main () @@ -35,59 +37,59 @@ namespace Mono.Linker.Tests.Cases.DataFlow // Type.GetType over two params } - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] static void TestPublicParameterlessConstructor () { Type type = Type.GetType (GetStringTypeWithPublicParameterlessConstructor ()); - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); - RequireNonPublicConstructors (type); - RequireNothing (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type.RequiresNonPublicConstructors (); + type.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] static void TestPublicConstructors () { Type type = Type.GetType (GetStringTypeWithPublicConstructors ()); - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); - RequireNonPublicConstructors (type); - RequireNothing (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type.RequiresNonPublicConstructors (); + type.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] static void TestConstructors () { Type type = Type.GetType (GetStringTypeWithNonPublicConstructors ()); - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); - RequireNonPublicConstructors (type); - RequireNothing (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type.RequiresNonPublicConstructors (); + type.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (GetType), new Type[] { typeof (string) }, messageCode: "IL2057")] + [ExpectedWarning ("IL2057", nameof (GetType))] static void TestUnknownType () { Type type = Type.GetType (GetStringUnkownType ()); } - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] static void TestTypeNameFromParameter ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] string typeName) { - RequirePublicConstructors (Type.GetType (typeName)); + Type.GetType (typeName).RequiresPublicConstructors (); } [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] static string _typeNameWithPublicParameterlessConstructor; - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] static void TestTypeNameFromField () { - RequirePublicConstructors (Type.GetType (_typeNameWithPublicParameterlessConstructor)); + Type.GetType (_typeNameWithPublicParameterlessConstructor).RequiresPublicConstructors (); } static int _switchOnField; @@ -113,16 +115,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type.GetType (typeName); } - [RecognizedReflectionAccessPattern] static void TestStringEmpty () { Type.GetType (string.Empty); } - [UnrecognizedReflectionAccessPattern (typeof (GetTypeDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, - messageCode: "IL2072", message: new string[] { "GetType" })] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetType), new Type[] { typeof (string) }, - messageCode: "IL2057", message: new string[] { "System.Type.GetType(String)" })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), nameof (Type.GetType))] + [ExpectedWarning ("IL2057", "System.Type.GetType(String)")] static void TestMultipleMixedValues () { string typeName = null; @@ -141,29 +140,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow break; } - RequireNonPublicConstructors (Type.GetType (typeName)); - } - - private static void RequirePublicParameterlessConstructor ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] - Type type) - { - } - - private static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - Type type) - { - } - - private static void RequireNonPublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] - Type type) - { - } - - private static void RequireNothing (Type type) - { + Type.GetType (typeName).RequiresNonPublicConstructors (); } [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeInfoDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeInfoDataFlow.cs new file mode 100644 index 000000000..e99d87bc5 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/DataFlow/GetTypeInfoDataFlow.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Diagnostics.CodeAnalysis; +using System.Reflection; +using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; + +namespace Mono.Linker.Tests.Cases.DataFlow +{ + [SkipKeptItemsValidation] + [ExpectedNoWarnings] + class GetTypeInfoDataFlow + { + public static void Main () + { + TestNoAnnotations (typeof (TestType)); + TestWithAnnotations (typeof (TestType)); + } + + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] + static void TestNoAnnotations (Type t) + { + t.GetTypeInfo ().RequiresPublicMethods (); + t.GetTypeInfo ().RequiresNone (); + } + + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + static void TestWithAnnotations ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type t) + { + t.GetTypeInfo ().RequiresPublicMethods (); + t.GetTypeInfo ().RequiresPublicFields (); + t.GetTypeInfo ().RequiresNone (); + } + + class TestType { } + } +} diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/IReflectDataflow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/IReflectDataflow.cs index 2a12479a1..9506cf0db 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/IReflectDataflow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/IReflectDataflow.cs @@ -9,6 +9,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow // Hits what appears to be a bug in the tool // Could not initialize vtable of class(0x02000007) .MyReflect due to VTable setup of type Mono.Linker.Tests.Cases.DataFlow.IReflectDataflow+MyReflect failed assembly:/tmp/linker_tests/output/test.exe type:MyReflect member:(null) [SkipPeVerify] + [ExpectedNoWarnings] class IReflectDataflow { [ExpectBodyModified] diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs index eca6e9368..379ff5293 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlow.cs @@ -1,12 +1,17 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + using System; using System.Diagnostics.CodeAnalysis; using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] public class LocalDataFlow { public static void Main () @@ -18,7 +23,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestBranchMergeSwitch (); TestBranchMergeTry (); TestBranchMergeCatch (); - TestBranchMergeFinally (); // The remaining tests illustrate current limitations of the analysis // that we might be able to lift in the future. @@ -32,6 +36,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestBranchTry (); TestBranchCatch (); TestBranchFinally (); + TestBranchMergeFinally (); // These are missing warnings (potential failure at runtime) TestBackwardsEdgeGoto (); @@ -41,16 +46,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestNoWarningsInRUCType (); } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)"})] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)")] + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)"})] + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)")] public static void TestBranchMergeGoto () { string str = GetWithPublicMethods (); @@ -59,40 +60,32 @@ namespace Mono.Linker.Tests.Cases.DataFlow str = GetWithPublicFields (); End: - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + str.RequiresPublicFields (); // warns for GetWithPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)")] + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)" })] + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)")] public static void TestBranchMergeIf () { string str = GetWithPublicMethods (); if (String.Empty.Length == 0) str = GetWithPublicFields (); - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + str.RequiresPublicFields (); // warns for GetWithPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)")] + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)" })] + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)")] public static void TestBranchMergeIfElse () { string str = null; @@ -101,27 +94,21 @@ namespace Mono.Linker.Tests.Cases.DataFlow } else { str = GetWithPublicMethods (); } - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + str.RequiresPublicFields (); // warns for GetWithPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields } static int _switchOnField; - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireNonPublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequireNonPublicMethods(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireNonPublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresNonPublicMethods) + "(String)")] + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequireNonPublicMethods(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireNonPublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresNonPublicMethods) + "(String)")] + [ExpectedWarning ("IL2072", "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicConstructors()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequireNonPublicMethods(String)" })] + nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresNonPublicMethods) + "(String)")] public static void TestBranchMergeSwitch () { string str = null; @@ -139,19 +126,15 @@ namespace Mono.Linker.Tests.Cases.DataFlow str = GetWithPublicConstructors (); break; } - RequireNonPublicMethods (str); // warns for GetWithPublicFields, GetWithPublicMethods, and GetWithPublicConstructors + + str.RequiresNonPublicMethods (); // warns for GetWithPublicFields, GetWithPublicMethods, and GetWithPublicConstructors } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)" })] + + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicFields) + "()")] public static void TestBranchMergeTry () { string str = GetWithPublicMethods (); @@ -162,20 +145,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow str = GetWithPublicFields (); } catch { } - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + + str.RequiresPublicFields (); // warns for GetWithPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)" })] + + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()")] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicFields) + "()")] public static void TestBranchMergeCatch () { string str = GetWithPublicMethods (); @@ -185,20 +164,17 @@ namespace Mono.Linker.Tests.Cases.DataFlow } catch { str = GetWithPublicFields (); } - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + + str.RequiresPublicFields (); // warns for GetWithPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicMethods()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicFields(String)" })] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, - messageCode: "IL2072", message: new string[] { - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.GetWithPublicFields()", - "type", - "Mono.Linker.Tests.Cases.DataFlow.LocalDataFlow.RequirePublicMethods(String)" })] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicFields) + "()")] + // Linker produces extraneous warnings + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchMergeFinally () { string str = GetWithPublicMethods (); @@ -209,77 +185,93 @@ namespace Mono.Linker.Tests.Cases.DataFlow } finally { str = GetWithPublicFields (); } - RequirePublicFields (str); // warns for GetWithPublicMethods - RequirePublicMethods (str); // warns for GetWithPublicFields + str.RequiresPublicFields (); // should not warn + str.RequiresPublicMethods (); // should warn } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields) + "(String)", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchGoto () { string str = GetWithPublicMethods (); if (String.Empty.Length == 0) goto End; str = GetWithPublicFields (); - RequirePublicFields (str); // produces a warning + str.RequiresPublicFields (); // produces a warning End: return; } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields), + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchIf () { string str = GetWithPublicMethods (); if (String.Empty.Length == 0) { str = GetWithPublicFields (); // dataflow will merge this with the value from the previous basic block - RequirePublicFields (str); // produces a warning (technically it should not) + str.RequiresPublicFields (); // produces a warning (technically it should not) } } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields), + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchIfElse () { string str; if (String.Empty.Length == 0) { // because this branch *happens* to come first in IL, we will only see one value str = GetWithPublicMethods (); - RequirePublicMethods (str); // this works + str.RequiresPublicMethods (); // this works } else { // because this branch *happens* to come second in IL, we will see the merged value for str str = GetWithPublicFields (); - RequirePublicFields (str); // produces a warning + str.RequiresPublicFields (); // produces a warning } } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequireNonPublicMethods), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicMethods), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresNonPublicMethods) + "(String)", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicConstructors) + "(String)", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicConstructors) + "(String)", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicConstructors) + "(String)", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchSwitch () { string str = null; switch (_switchOnField) { case 0: str = GetWithPublicFields (); - RequirePublicFields (str); // success + str.RequiresPublicFields (); // success break; case 1: str = GetWithNonPublicMethods (); - RequireNonPublicMethods (str); // warns for GetWithPublicFields + str.RequiresNonPublicMethods (); // warns for GetWithPublicFields break; case 2: str = GetWithPublicMethods (); - RequirePublicMethods (str); // warns for GetWithPublicFields and GetWithNonPublicMethods + str.RequiresPublicMethods (); // warns for GetWithPublicFields and GetWithNonPublicMethods break; case 3: str = GetWithPublicConstructors (); - RequirePublicConstructors (str); // warns for GetWithPublicFields, GetWithNonPublicMethods, GetWithPublicMethods + str.RequiresPublicConstructors (); // warns for GetWithPublicFields, GetWithNonPublicMethods, GetWithPublicMethods break; } } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields), + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchTry () { string str = GetWithPublicMethods (); @@ -288,12 +280,15 @@ namespace Mono.Linker.Tests.Cases.DataFlow throw null; str = GetWithPublicFields (); - RequirePublicFields (str); // warns for GetWithPublicMethods + str.RequiresPublicFields (); // warns for GetWithPublicMethods } catch { } } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields), + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchCatch () { string str = GetWithPublicMethods (); @@ -302,11 +297,14 @@ namespace Mono.Linker.Tests.Cases.DataFlow throw null; } catch { str = GetWithPublicFields (); - RequirePublicFields (str); // warns for GetWithPublicMethods + str.RequiresPublicFields (); // warns for GetWithPublicMethods } } - [UnrecognizedReflectionAccessPattern (typeof (LocalDataFlow), nameof (RequirePublicFields), new Type[] { typeof (string) }, messageCode: "IL2072")] + // Analyzer gets this right (no warning), but trimmer merges all branches going forward. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicFields), + nameof (LocalDataFlow) + "." + nameof (GetWithPublicMethods) + "()", + ProducedBy = ProducedBy.Trimmer)] public static void TestBranchFinally () { string str = GetWithPublicMethods (); @@ -316,11 +314,14 @@ namespace Mono.Linker.Tests.Cases.DataFlow } catch { } finally { str = GetWithPublicFields (); - RequirePublicFields (str); // warns for GetWithPublicMethods + str.RequiresPublicFields (); // warns for GetWithPublicMethods } } - [RecognizedReflectionAccessPattern] + // Analyzer gets this right, but linker doesn't consider backwards branches. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] public static void TestBackwardsEdgeLoop () { string str = GetWithPublicMethods (); @@ -330,17 +331,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow str = GetWithPublicFields (); // dataflow will merge values to track both possible annotation kinds } - // RequirePublicMethods (str); // this would produce a warning for the value that comes from GetWithPublicFields, as expected - RequirePublicMethods (prev); // this produces no warning, even though "prev" will have the value from GetWithPublicFields! + // str.RequiresPublicMethods (); // this would produce a warning for the value that comes from GetWithPublicFields, as expected + prev.RequiresPublicMethods (); // this produces no warning, even though "prev" will have the value from GetWithPublicFields! } - [RecognizedReflectionAccessPattern] + // Analyzer gets this right, but linker doesn't consider backwards branches. + [ExpectedWarning ("IL2072", nameof (DataFlowStringExtensions) + "." + nameof (DataFlowStringExtensions.RequiresPublicMethods) + "(String)", + nameof (LocalDataFlow) + "." + nameof (GetWithPublicFields) + "()", + ProducedBy = ProducedBy.Analyzer)] public static void TestBackwardsEdgeGoto () { string str = null; goto ForwardTarget; BackwardTarget: - RequirePublicMethods (str); // should warn for the value that comes from GetWithPublicFields, but it doesn't. + str.RequiresPublicMethods (); // should warn for the value that comes from GetWithPublicFields, but it doesn't. return; ForwardTarget: @@ -357,7 +361,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow [RequiresUnreferencedCode ("message")] public static void RUCMethod () { - RequireAll (GetWithPublicMethods ()); + GetWithPublicMethods ().RequiresAll (); } [ExpectedWarning ("IL2026", nameof (RUCType) + "." + nameof (RUCType), "message")] @@ -375,49 +379,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow { public static void StaticMethod () { - RequireAll (GetWithPublicMethods ()); + GetWithPublicMethods ().RequiresAll (); } public void InstanceMethod () { - RequireAll (GetWithPublicMethods ()); + GetWithPublicMethods ().RequiresAll (); } public virtual void VirtualMethod () { - RequireAll (GetWithPublicMethods ()); + GetWithPublicMethods ().RequiresAll (); } } - public static void RequireAll ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] - string type) - { - } - - public static void RequirePublicFields ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] - string type) - { - } - - public static void RequireNonPublicMethods ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicMethods)] - string type) - { - } - public static void RequirePublicMethods ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] - string type) - { - } - - public static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - string type) - { - } - [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] public static string GetWithPublicFields () { diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs index 4c3484013..8e95a6ebc 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/LocalDataFlowKeptMembers.cs @@ -4,6 +4,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.DataFlow { + [ExpectedNoWarnings] public class LocalDataFlowKeptMembers { public static void Main () diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypes.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypes.cs index af1a2c7ee..94b565d39 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypes.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypes.cs @@ -12,8 +12,66 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DataFlow { [SetupCompileArgument ("/optimize+")] + [ExpectedNoWarnings] public class MemberTypes { + // Some of the types below declare delegates and will mark all members on them, this includes the Delegate .ctor(object, string) which has RUC and other members + [ExpectedWarning ("IL2026", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + // Some of the types below declare delegates and will mark all members on them, this includes the Delegate .ctor(Type, string) which has DAM annotations and other members + [ExpectedWarning ("IL2111", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".Delegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate.CreateDelegate), ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (MulticastDelegate) + ".MulticastDelegate", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".BindToMethodName", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".BindToMethodName", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".BindToMethodName", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".BindToMethodName", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2111", nameof (Delegate) + ".BindToMethodName", ProducedBy = ProducedBy.Trimmer)] public static void Main () { RequirePublicParameterlessConstructor (typeof (PublicParameterlessConstructorType)); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypesAllOnCopyAssembly.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypesAllOnCopyAssembly.cs index 8331edaea..dd9bd5cfc 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypesAllOnCopyAssembly.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/MemberTypesAllOnCopyAssembly.cs @@ -13,6 +13,8 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DataFlow { + [ExpectedNoWarnings] + [SetupCompileBefore ("base.dll", new[] { "Dependencies/MemberTypesAllBaseTypeAssembly.cs" })] [KeptAssembly ("base.dll")] [SetupLinkerAction ("link", "base")] diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs index df6e2cd1e..324e75cf2 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodParametersDataFlow.cs @@ -6,13 +6,15 @@ using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Text; using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] [SetupLinkerArgument ("--keep-metadata", "parametername")] public class MethodParametersDataFlow { @@ -41,46 +43,45 @@ namespace Mono.Linker.Tests.Cases.DataFlow } // Validate the error message when annotated parameter is passed to another annotated parameter - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, - messageCode: "IL2067", message: new string[] { "sourceType", "PublicParameterlessConstructorParameter(Type)", "type", "RequirePublicConstructors(Type)" })] - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", "'sourceType'", "PublicParameterlessConstructorParameter(Type)", "'type'", "RequiresPublicConstructors(Type)")] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private static void PublicParameterlessConstructorParameter ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type sourceType) { - RequirePublicParameterlessConstructor (sourceType); - RequirePublicConstructors (sourceType); - RequireNonPublicConstructors (sourceType); + sourceType.RequiresPublicParameterlessConstructor (); + sourceType.RequiresPublicConstructors (); + sourceType.RequiresNonPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private static void PublicConstructorsParameter ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type) { - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); - RequireNonPublicConstructors (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type.RequiresNonPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (Type) }, messageCode: "IL2067")] - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor))] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] private static void NonPublicConstructorsParameter ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type type) { - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); - RequireNonPublicConstructors (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type.RequiresNonPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] private void InstanceMethod ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type) { - RequirePublicParameterlessConstructor (type); - RequirePublicConstructors (type); + type.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); } [ExpectedWarning ("IL2072", "'type'", "argument", nameof (WriteToParameterOnInstanceMethod) + "(Type)", nameof (ReturnThingsWithPublicParameterlessConstructor))] @@ -99,7 +100,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow type = ReturnThingsWithPublicParameterlessConstructor (); } - [ExpectedWarning ("IL2072", "'type'", "argument", nameof (LongWriteToParameterOnInstanceMethod) + "(Int32,Int32,Int32,Int32,Type)", nameof (ReturnThingsWithPublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", "'type'", "argument", nameof (LongWriteToParameterOnInstanceMethod) + "(Int32, Int32, Int32, Int32, Type)", nameof (ReturnThingsWithPublicParameterlessConstructor))] private void LongWriteToParameterOnInstanceMethod ( int a, int b, int c, int d, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] @@ -108,7 +109,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow type = ReturnThingsWithPublicParameterlessConstructor (); } - [ExpectedWarning ("IL2072", "'type'", "argument", nameof (LongWriteToParameterOnStaticMethod) + "(Int32,Int32,Int32,Int32,Type)", nameof (ReturnThingsWithPublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", "'type'", "argument", nameof (LongWriteToParameterOnStaticMethod) + "(Int32, Int32, Int32, Int32, Type)", nameof (ReturnThingsWithPublicParameterlessConstructor))] private static void LongWriteToParameterOnStaticMethod ( int a, int b, int c, int d, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] @@ -123,20 +124,24 @@ namespace Mono.Linker.Tests.Cases.DataFlow return null; } - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] private void TwoAnnotatedParameters ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type2) { - RequirePublicParameterlessConstructor (type); - RequirePublicParameterlessConstructor (type2); - RequirePublicConstructors (type); - RequirePublicConstructors (type2); + type.RequiresPublicParameterlessConstructor (); + type2.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type2.RequiresPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2067")] + // TODO: https://github.com/dotnet/linker/issues/2273 + // (Dataflow analysis is not supported by the analyzer yet) + [ExpectedWarning ("IL2067", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors) + "(Type)", + "'type'")] private void TwoAnnotatedParametersIntoOneValue ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type, @@ -144,80 +149,57 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type type2) { Type t = type == null ? type : type2; - RequirePublicParameterlessConstructor (t); - RequirePublicConstructors (t); + t.RequiresPublicParameterlessConstructor (); + t.RequiresPublicConstructors (); } // Validate the error message for the case of unannotated method return value passed to an annotated parameter. - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (Type) }, - messageCode: "IL2067", message: new string[] { "type", "NoAnnotation(Type)", "type", "RequirePublicParameterlessConstructor(Type)" })] + [ExpectedWarning ("IL2067", "'type'", "NoAnnotation(Type)", "'type'", "RequiresPublicParameterlessConstructor(Type)")] private void NoAnnotation (Type type) { - RequirePublicParameterlessConstructor (type); + type.RequiresPublicParameterlessConstructor (); } // Validate error message when untracable value is passed to an annotated parameter. - [UnrecognizedReflectionAccessPattern (typeof (MethodParametersDataFlow), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (Type) }, - messageCode: "IL2062", message: new string[] { "type", "RequirePublicParameterlessConstructor" })] + [ExpectedWarning ("IL2062", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor) + "(Type)", + "'type'", + ProducedBy = ProducedBy.Trimmer)] private void UnknownValue () { var array = new object[1]; array[0] = this.GetType (); MakeArrayValuesUnknown (array); - RequirePublicParameterlessConstructor ((Type) array[0]); + ((Type) array[0]).RequiresPublicParameterlessConstructor (); static void MakeArrayValuesUnknown (object[] array) { } } - [RecognizedReflectionAccessPattern] private void AnnotatedValueToUnAnnotatedParameter ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type) { - RequireNothing (type); + type.RequiresNone (); } - [RecognizedReflectionAccessPattern] private void UnknownValueToUnAnnotatedParameter () { - RequireNothing (this.GetType ()); + this.GetType ().RequiresNone (); } - [RecognizedReflectionAccessPattern] private void UnknownValueToUnAnnotatedParameterOnInterestingMethod () { RequirePublicParameterlessConstructorAndNothing (typeof (TestType), this.GetType ()); } - [ExpectedWarning ("IL2098", "p1", nameof (UnsupportedParameterType))] + // TODO: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2098", "p1", nameof (UnsupportedParameterType), ProducedBy = ProducedBy.Trimmer)] private void UnsupportedParameterType ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] object p1) { } - private static void RequirePublicParameterlessConstructor ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] - Type type) - { - } - - private static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - Type type) - { - } - - private static void RequireNonPublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] - Type type) - { - } - - private static void RequireNothing (Type type) - { - } - private static void RequirePublicParameterlessConstructorAndNothing ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type, diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs index 28735fd9d..1a2ee9aa3 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodReturnParameterDataFlow.cs @@ -12,7 +12,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] [ExpectedNoWarnings] public class MethodReturnParameterDataFlow @@ -46,8 +46,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow return typeof (TestType); } - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnPublicParameterlessConstructor), - new Type[] { typeof (Type), typeof (Type), typeof (Type) }, returnType: typeof (Type), messageCode: "IL2068")] + [ExpectedWarning ("IL2068", nameof (ReturnPublicParameterlessConstructor))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type ReturnPublicParameterlessConstructor ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] @@ -71,41 +70,35 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnPublicParameterlessConstructorFromUnknownType), - new Type[] { typeof (Type) }, returnType: typeof (Type), messageCode: "IL2068")] + [ExpectedWarning ("IL2068", nameof (ReturnPublicParameterlessConstructorFromUnknownType))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type ReturnPublicParameterlessConstructorFromUnknownType (Type unknownType) { return unknownType; } - [RecognizedReflectionAccessPattern] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type ReturnPublicParameterlessConstructorFromConstant () { return typeof (TestType); } - [RecognizedReflectionAccessPattern] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type ReturnPublicParameterlessConstructorFromNull () { return null; } - [RecognizedReflectionAccessPattern] Type ReturnTypeWithNoRequirements () { return null; } // Validate error message when insufficiently annotated value is returned from a method - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnPublicConstructorsFailure), - new Type[] { typeof (Type) }, returnType: typeof (Type), - messageCode: "IL2068", message: new string[] { + [ExpectedWarning ("IL2068", "publicParameterlessConstructorType", "MethodReturnParameterDataFlow.ReturnPublicConstructorsFailure", - "MethodReturnParameterDataFlow.ReturnPublicConstructorsFailure" })] + "MethodReturnParameterDataFlow.ReturnPublicConstructorsFailure")] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type ReturnPublicConstructorsFailure ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] @@ -114,8 +107,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow return publicParameterlessConstructorType; } - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnNonPublicConstructorsFailure), - new Type[] { typeof (Type) }, returnType: typeof (Type), messageCode: "IL2068")] + [ExpectedWarning ("IL2068", nameof (ReturnNonPublicConstructorsFailure))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type ReturnNonPublicConstructorsFailure ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] @@ -124,9 +116,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow return publicConstructorsType; } - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnUnknownValue), - new Type[] { }, returnType: typeof (Type), - messageCode: "IL2063", message: new string[] { nameof (ReturnUnknownValue) })] + // TODO: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2063", + nameof (MethodReturnParameterDataFlow) + "." + nameof (ReturnUnknownValue) + "()", + ProducedBy = ProducedBy.Trimmer)] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type ReturnUnknownValue () { @@ -140,8 +133,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors) + "(Type)", + nameof (MethodReturnParameterDataFlow) + "." + nameof (ReturnPublicParameterlessConstructor) + "(Type, Type, Type)")] + [ExpectedWarning ("IL2072", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors) + "(Type)", + nameof (MethodReturnParameterDataFlow) + "." + nameof (ReturnPublicParameterlessConstructor) + "(Type, Type, Type)")] void PropagateReturnPublicParameterlessConstructor () { Type t = ReturnPublicParameterlessConstructor (typeof (TestType), typeof (TestType), typeof (TestType)); @@ -151,8 +148,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow t.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors) + "(Type)", + nameof (MethodReturnParameterDataFlow) + "." + nameof (ReturnPublicParameterlessConstructorFromConstant) + "()")] + [ExpectedWarning ("IL2072", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors) + "(Type)", + nameof (MethodReturnParameterDataFlow) + "." + nameof (ReturnPublicParameterlessConstructorFromConstant) + "()")] void PropagateReturnPublicParameterlessConstructorFromConstant () { Type t = ReturnPublicParameterlessConstructorFromConstant (); @@ -162,11 +163,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow t.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (PropagateReturnToReturn), new Type[] { typeof (int) }, returnType: typeof (Type), - messageCode: "IL2073", message: new string[] { + [ExpectedWarning ("IL2073", nameof (ReturnTypeWithNoRequirements), - nameof (PropagateReturnToReturn) - })] + nameof (PropagateReturnToReturn))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type PropagateReturnToReturn (int n) { @@ -180,17 +179,14 @@ namespace Mono.Linker.Tests.Cases.DataFlow return null; } - // https://github.com/dotnet/linker/issues/2025 - // Ideally this should not warn - [UnrecognizedReflectionAccessPattern (typeof (MethodReturnParameterDataFlow), nameof (ReturnWithRequirementsAlwaysThrows), new Type[] { }, returnType: typeof (Type), - messageCode: "IL2063")] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type ReturnWithRequirementsAlwaysThrows () { throw new NotImplementedException (); } - [ExpectedWarning ("IL2106", nameof (UnsupportedReturnType))] + // TODO: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2106", nameof (UnsupportedReturnType), ProducedBy = ProducedBy.Trimmer)] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] static object UnsupportedReturnType () => null; diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs index 5ca8b3181..6a7e8321a 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/MethodThisDataFlow.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; @@ -14,6 +14,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow { [SkipKeptItemsValidation] [SandboxDependency ("Dependencies/TestSystemTypeBase.cs")] + [ExpectedNoWarnings] public class MethodThisDataFlow { public static void Main () @@ -32,11 +33,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow TestFromGenericParameterToThis<MethodThisDataFlow> (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods), new Type[] { }, - messageCode: "IL2075", message: new string[] { + [ExpectedWarning ("IL2075", "Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow.GetWithNonPublicMethods()", - "System.MethodThisDataFlowTypeTest.RequireThisPublicMethods()" })] - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisNonPublicMethods), new Type[] { }, messageCode: "IL2075")] + "System.MethodThisDataFlowTypeTest.RequireThisPublicMethods()")] + [ExpectedWarning ("IL2075", nameof (MethodThisDataFlowTypeTest.RequireThisNonPublicMethods))] static void PropagateToThis () { GetWithPublicMethods ().RequireThisPublicMethods (); @@ -46,11 +46,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow GetWithNonPublicMethods ().RequireThisNonPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods) + ".get", new Type[] { }, - messageCode: "IL2075", message: new string[] { + [ExpectedWarning ("IL2075", "Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow.GetWithNonPublicMethods()", - "System.MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods.get" })] - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.PropertyRequireThisNonPublicMethods) + ".get", new Type[] { }, messageCode: "IL2075")] + "System.MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods.get")] + [ExpectedWarning ("IL2075", nameof (MethodThisDataFlowTypeTest.PropertyRequireThisNonPublicMethods) + ".get")] static void PropagateToThisWithGetters () { _ = GetWithPublicMethods ().PropertyRequireThisPublicMethods; @@ -60,11 +59,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow _ = GetWithNonPublicMethods ().PropertyRequireThisNonPublicMethods; } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods) + ".set", new Type[] { typeof (Object) }, - messageCode: "IL2075", message: new string[] { + [ExpectedWarning ("IL2075", "Mono.Linker.Tests.Cases.DataFlow.MethodThisDataFlow.GetWithNonPublicMethods()", - "System.MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods.set" })] - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.PropertyRequireThisNonPublicMethods) + ".set", new Type[] { typeof (Object) }, messageCode: "IL2075")] + "System.MethodThisDataFlowTypeTest.PropertyRequireThisPublicMethods.set")] + [ExpectedWarning ("IL2075", nameof (MethodThisDataFlowTypeTest.PropertyRequireThisNonPublicMethods) + ".set")] static void PropagateToThisWithSetters () { GetWithPublicMethods ().PropertyRequireThisPublicMethods = null; @@ -85,7 +83,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow return null; } - [RecognizedReflectionAccessPattern] static void TestAnnotationOnNonTypeMethod () { var t = new NonTypeType (); @@ -93,8 +90,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow NonTypeType.StaticMethod (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisNonPublicMethods), new Type[] { }, - messageCode: "IL2065", message: new string[] { nameof (MethodThisDataFlowTypeTest.RequireThisNonPublicMethods) })] + // Analyer doesn't warn about unknown values flowing into annotated locations + // https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2065", nameof (MethodThisDataFlowTypeTest) + "." + nameof (MethodThisDataFlowTypeTest.RequireThisNonPublicMethods), "'this'", + ProducedBy = ProducedBy.Trimmer)] static void TestUnknownThis () { var array = new object[1]; @@ -107,8 +106,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow } } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods), new Type[] { }, - messageCode: "IL2070", message: new string[] { "sourceType", nameof (TestFromParameterToThis), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods) })] + [ExpectedWarning ("IL2070", "sourceType", nameof (TestFromParameterToThis), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods))] static void TestFromParameterToThis (MethodThisDataFlowTypeTest sourceType) { sourceType.RequireThisPublicMethods (); @@ -116,19 +114,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow static MethodThisDataFlowTypeTest _typeField; - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods), new Type[] { }, - messageCode: "IL2080", message: new string[] { nameof (_typeField), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods) })] + [ExpectedWarning ("IL2080", nameof (_typeField), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods))] static void TestFromFieldToThis () { _typeField.RequireThisPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods), new Type[] { }, - messageCode: "IL2090", message: new string[] { + [ExpectedWarning ("IL2090", "TSource", "TestFromGenericParameterToThis<TSource>", - nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods) - })] + nameof (MethodThisDataFlowTypeTest.RequireThisPublicMethods))] static void TestFromGenericParameterToThis<TSource> () { ((MethodThisDataFlowTypeTest) typeof (TSource)).RequireThisPublicMethods (); @@ -143,14 +138,18 @@ namespace Mono.Linker.Tests.Cases.DataFlow class NonTypeType { - [ExpectedWarning ("IL2041")] + // Analyzer doesn't warn about annotations on unsupported types: + // https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2041", ProducedBy = ProducedBy.Trimmer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] public MethodInfo GetMethod (string name) { return null; } - [ExpectedWarning ("IL2041")] + // Analyzer doesn't warn about annotations on unsupported types: + // https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2041", ProducedBy = ProducedBy.Trimmer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] public static void StaticMethod () { @@ -164,10 +163,9 @@ namespace System class MethodThisDataFlowTypeTest : TestSystemTypeBase { [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (RequireNonPublicMethods), new Type[] { typeof (Type) }, - messageCode: "IL2082", message: new string[] { - "'type' argument ", "in call to 'System.MethodThisDataFlowTypeTest.RequireNonPublicMethods(Type)'", - "implicit 'this' argument of method 'System.MethodThisDataFlowTypeTest.RequireThisPublicMethods()'" })] + [ExpectedWarning ("IL2082", nameof (MethodThisDataFlowTypeTest) + "." + nameof (RequireNonPublicMethods) + "(Type)", + "'type' argument ", "in call to 'System.MethodThisDataFlowTypeTest.RequireNonPublicMethods(Type)'", + "implicit 'this' argument of method 'System.MethodThisDataFlowTypeTest.RequireThisPublicMethods()'")] public void RequireThisPublicMethods () { RequirePublicMethods (this); @@ -175,19 +173,16 @@ namespace System } [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods)] - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (RequirePublicMethods), new Type[] { typeof (Type) }, - messageCode: "IL2082")] + [ExpectedWarning ("IL2082", nameof (MethodThisDataFlowTypeTest) + "." + nameof (RequirePublicMethods) + "(Type)")] public void RequireThisNonPublicMethods () { RequirePublicMethods (this); RequireNonPublicMethods (this); } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (PropagateToReturn), new Type[] { }, returnType: typeof (Type), - messageCode: "IL2083", message: new string[] { - nameof(PropagateToReturn), - nameof(PropagateToReturn) - })] + [ExpectedWarning ("IL2083", + nameof (PropagateToReturn), + nameof (PropagateToReturn))] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] public Type PropagateToReturn () @@ -198,22 +193,17 @@ namespace System [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type _requiresPublicConstructors; - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (_requiresPublicConstructors), - messageCode: "IL2084", message: new string[] { - nameof (PropagateToField), - nameof (_requiresPublicConstructors) - })] + [ExpectedWarning ("IL2084", nameof (MethodThisDataFlowTypeTest) + "." + nameof (_requiresPublicConstructors), + nameof (PropagateToField))] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] public void PropagateToField () { _requiresPublicConstructors = this; } - [UnrecognizedReflectionAccessPattern (typeof (MethodThisDataFlowTypeTest), nameof (RequireThisNonPublicMethods), new Type[] { }, - messageCode: "IL2085", message: new string[] { + [ExpectedWarning ("IL2085", nameof (PropagateToThis), - nameof (RequireThisNonPublicMethods) - })] + nameof (RequireThisNonPublicMethods))] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] public void PropagateToThis () { diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs index d1f6d57eb..4f2f329c9 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/PropertyDataFlow.cs @@ -10,8 +10,9 @@ using Mono.Linker.Tests.Cases.Expectations.Helpers; namespace Mono.Linker.Tests.Cases.DataFlow { // Note: this test's goal is to validate that the product correctly reports unrecognized patterns - // - so the main validation is done by the UnrecognizedReflectionAccessPattern attributes. + // - so the main validation is done by the ExpectedWarning attributes. [SkipKeptItemsValidation] + [ExpectedNoWarnings] public class PropertyDataFlow { public static void Main () @@ -42,11 +43,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] static Type StaticPropertyWithPublicConstructor { get; set; } - [ExpectedWarning ("IL2099", nameof (PropertyWithUnsupportedType))] + // Analyzer doesn't warn about annotations on unsupported types + // https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2099", nameof (PropertyWithUnsupportedType), ProducedBy = ProducedBy.Trimmer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] static object PropertyWithUnsupportedType { get; set; } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private void ReadFromInstanceProperty () { PropertyWithPublicConstructor.RequiresPublicParameterlessConstructor (); @@ -55,7 +58,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow PropertyWithPublicConstructor.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private void ReadFromStaticProperty () { StaticPropertyWithPublicConstructor.RequiresPublicParameterlessConstructor (); @@ -64,9 +67,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow StaticPropertyWithPublicConstructor.RequiresNone (); } - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (PropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (PropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (PropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (PropertyWithPublicConstructor) + ".set", nameof (GetTypeWithPublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (PropertyWithPublicConstructor) + ".set", nameof (GetTypeWithNonPublicConstructors))] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (PropertyWithPublicConstructor) + ".set", nameof (GetUnkownType))] private void WriteToInstanceProperty () { PropertyWithPublicConstructor = GetTypeWithPublicParameterlessConstructor (); @@ -75,9 +78,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow PropertyWithPublicConstructor = GetUnkownType (); } - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (StaticPropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (StaticPropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (StaticPropertyWithPublicConstructor) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (StaticPropertyWithPublicConstructor) + ".set", nameof (GetTypeWithPublicParameterlessConstructor))] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (StaticPropertyWithPublicConstructor) + ".set", nameof (GetTypeWithNonPublicConstructors))] + [ExpectedWarning ("IL2072", nameof (PropertyDataFlow) + "." + nameof (StaticPropertyWithPublicConstructor) + ".set", nameof (GetUnkownType))] private void WriteToStaticProperty () { StaticPropertyWithPublicConstructor = GetTypeWithPublicParameterlessConstructor (); @@ -90,13 +93,11 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type _fieldWithPublicConstructors; Type PropertyPublicConstructorsWithExplicitAccessors { - [RecognizedReflectionAccessPattern] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] get { return _fieldWithPublicConstructors; } - [RecognizedReflectionAccessPattern] [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] set { _fieldWithPublicConstructors = value; @@ -104,14 +105,14 @@ namespace Mono.Linker.Tests.Cases.DataFlow } Type PropertyPublicParameterlessConstructorWithExplicitAccessors { - [RecognizedReflectionAccessPattern] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] get { return _fieldWithPublicConstructors; } - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (_fieldWithPublicConstructors), - messageCode: "IL2069", message: new string[] { "value", nameof (PropertyPublicParameterlessConstructorWithExplicitAccessors) + ".set", nameof (_fieldWithPublicConstructors) })] + [ExpectedWarning ("IL2069", nameof (PropertyDataFlow) + "." + nameof (_fieldWithPublicConstructors), + "'value'", + nameof (PropertyPublicParameterlessConstructorWithExplicitAccessors) + ".set")] [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] set { _fieldWithPublicConstructors = value; @@ -119,17 +120,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow } Type PropertyNonPublicConstructorsWithExplicitAccessors { - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (PropertyNonPublicConstructorsWithExplicitAccessors) + ".get", - new Type[] { }, returnType: typeof (Type), messageCode: "IL2078", message: new string[] { - nameof (_fieldWithPublicConstructors), - nameof (PropertyNonPublicConstructorsWithExplicitAccessors) + ".get" - })] + [ExpectedWarning ("IL2078", nameof (PropertyDataFlow) + "." + nameof (PropertyNonPublicConstructorsWithExplicitAccessors) + ".get", + nameof (_fieldWithPublicConstructors))] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] get { return _fieldWithPublicConstructors; } - [UnrecognizedReflectionAccessPattern (typeof (PropertyDataFlow), nameof (_fieldWithPublicConstructors), messageCode: "IL2069")] + [ExpectedWarning ("IL2069", nameof (PropertyDataFlow) + "." + nameof (_fieldWithPublicConstructors), + "'value'", + nameof (PropertyNonPublicConstructorsWithExplicitAccessors) + ".set")] [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] set { _fieldWithPublicConstructors = value; @@ -145,6 +145,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow instance.TestInstancePropertyWithStaticField (); instance.TestPropertyWithDifferentBackingFields (); instance.TestPropertyWithExistingAttributes (); + instance.TestPropertyWithConflictingAttributes (); + instance.TestPropertyWithConflictingNoneAttributes (); instance.TestPropertyWithIndexerWithMatchingAnnotations (null); instance.TestPropertyWithIndexerWithoutMatchingAnnotations (null); } @@ -152,7 +154,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow class TestAutomaticPropagationType { // Fully implicit property should work - [UnrecognizedReflectionAccessPattern (typeof (TestAutomaticPropagationType), nameof (ImplicitProperty) + ".set", new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (TestAutomaticPropagationType) + "." + nameof (ImplicitProperty) + ".set")] public void TestImplicitProperty () { ImplicitProperty.RequiresPublicConstructors (); @@ -165,7 +167,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow } // Simple getter is not enough - we do detect the field, but we require the field to be compiler generated for this to work - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] // Make sure we don't warn about the field in context of property annotation propagation. [LogDoesNotContain ("Could not find a unique backing field for property 'System.Type Mono.Linker.Tests.Cases.DataFlow.PropertyDataFlow/TestAutomaticPropagationType::PropertyWithSimpleGetter()'")] public void TestPropertyWithSimpleGetter () @@ -178,13 +180,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] static Type PropertyWithSimpleGetter { - [UnrecognizedReflectionAccessPattern (typeof (TestAutomaticPropagationType), nameof (PropertyWithSimpleGetter) + ".get", new Type[] { }, returnType: typeof (Type), messageCode: "IL2078")] + [ExpectedWarning ("IL2078", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithSimpleGetter) + ".get")] get { return PropertyWithSimpleGetter_Field; } } - [RecognizedReflectionAccessPattern] + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors) + "(Type)", + nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWhichLooksLikeCompilerGenerated_Field), + ProducedBy = ProducedBy.Analyzer)] public void TestPropertyWhichLooksLikeCompilerGenerated () { // If the property was correctly recognized both the property getter and the backing field should get the annotation. @@ -197,12 +202,16 @@ namespace Mono.Linker.Tests.Cases.DataFlow [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] static Type PropertyWhichLooksLikeCompilerGenerated { + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2078", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWhichLooksLikeCompilerGenerated) + ".get", + nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWhichLooksLikeCompilerGenerated_Field), + ProducedBy = ProducedBy.Analyzer)] get { return PropertyWhichLooksLikeCompilerGenerated_Field; } } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] // Make sure we don't warn about the field in context of property annotation propagation. [LogDoesNotContain ("Could not find a unique backing field for property 'System.Type Mono.Linker.Tests.Cases.DataFlow.PropertyDataFlow/TestAutomaticPropagationType::InstancePropertyWithStaticField()'")] public void TestInstancePropertyWithStaticField () @@ -218,7 +227,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type InstancePropertyWithStaticField { // Nothing to warn about - the "value" is annotated with PublicConstructors and we're assigning // it to unannotated field - that's a perfectly valid operation. - [RecognizedReflectionAccessPattern] set { InstancePropertyWithStaticField_Field = value; } @@ -235,10 +243,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow [CompilerGenerated] private Type PropertyWithDifferentBackingFields_SetterField; + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 [ExpectedWarning ("IL2042", - "Mono.Linker.Tests.Cases.DataFlow.PropertyDataFlow.TestAutomaticPropagationType.PropertyWithDifferentBackingFields")] + "Mono.Linker.Tests.Cases.DataFlow.PropertyDataFlow.TestAutomaticPropagationType.PropertyWithDifferentBackingFields", + ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2078", + nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithDifferentBackingFields) + ".get", + "Type", + ProducedBy = ProducedBy.Analyzer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type PropertyWithDifferentBackingFields { + [ExpectedWarning ("IL2078", + nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithDifferentBackingFields) + ".get", + ProducedBy = ProducedBy.Trimmer)] get { return PropertyWithDifferentBackingFields_GetterField; } @@ -254,23 +271,95 @@ namespace Mono.Linker.Tests.Cases.DataFlow PropertyWithExistingAttributes = null; } - [ExpectedWarning ("IL2056", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes_Field")] + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2056", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes_Field", + ProducedBy = ProducedBy.Trimmer)] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] [CompilerGenerated] Type PropertyWithExistingAttributes_Field; [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type PropertyWithExistingAttributes { - [ExpectedWarning ("IL2043", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes.get")] + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2043", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes.get", + ProducedBy = ProducedBy.Trimmer)] [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] get { return PropertyWithExistingAttributes_Field; } - [ExpectedWarning ("IL2043", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes.set")] + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2043", "PropertyWithExistingAttributes", "PropertyWithExistingAttributes.set", + ProducedBy = ProducedBy.Trimmer)] [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] set { PropertyWithExistingAttributes_Field = value; } } - [RecognizedReflectionAccessPattern] + // When the property annotation conflicts with the getter/setter annotation, + // we issue a warning (IL2043 below) but respect the getter/setter annotations. + [ExpectedWarning ("IL2072", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingAttributes) + ".get", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors) + "(Type)")] + [ExpectedWarning ("IL2072", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingAttributes) + ".set", + nameof (PropertyDataFlow) + "." + nameof (GetTypeWithPublicConstructors) + "()")] + public void TestPropertyWithConflictingAttributes () + { + PropertyWithConflictingAttributes.RequiresPublicConstructors (); + PropertyWithConflictingAttributes.RequiresNonPublicConstructors (); + PropertyWithConflictingAttributes = GetTypeWithPublicConstructors (); + PropertyWithConflictingAttributes = GetTypeWithNonPublicConstructors (); + } + + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2056", "PropertyWithConflictingAttributes", "PropertyWithConflictingAttributes_Field", + ProducedBy = ProducedBy.Trimmer)] + [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] + [CompilerGenerated] + Type PropertyWithConflictingAttributes_Field; + + [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] + Type PropertyWithConflictingAttributes { + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2043", "PropertyWithConflictingAttributes", "PropertyWithConflictingAttributes.get", + ProducedBy = ProducedBy.Trimmer)] + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] + get { return PropertyWithConflictingAttributes_Field; } + + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2043", "PropertyWithConflictingAttributes", "PropertyWithConflictingAttributes.set", + ProducedBy = ProducedBy.Trimmer)] + [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] + set { PropertyWithConflictingAttributes_Field = value; } + } + + // When the property annotation is DAMT.None and this conflicts with the getter/setter annotations, + // we don't produce a warning about the conflict, and just respect the property annotations. + [ExpectedWarning ("IL2072", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingNoneAttributes) + ".get", + nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors) + "(Type)")] + [ExpectedWarning ("IL2072", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingNoneAttributes) + ".set", + nameof (PropertyDataFlow) + "." + nameof (GetTypeWithNonPublicConstructors) + "()")] + public void TestPropertyWithConflictingNoneAttributes () + { + PropertyWithConflictingNoneAttributes.RequiresPublicConstructors (); + PropertyWithConflictingNoneAttributes.RequiresNonPublicConstructors (); + PropertyWithConflictingNoneAttributes = GetTypeWithPublicConstructors (); + PropertyWithConflictingNoneAttributes = GetTypeWithNonPublicConstructors (); + } + + [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)] + [CompilerGenerated] + Type PropertyWithConflictingNoneAttributes_Field; + + [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] + Type PropertyWithConflictingNoneAttributes { + // Analyzer doesn't try to detect backing fields of properties: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2078", nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingNoneAttributes) + ".get", + nameof (TestAutomaticPropagationType) + "." + nameof (PropertyWithConflictingNoneAttributes_Field), + ProducedBy = ProducedBy.Analyzer)] + [return: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)] + get { return PropertyWithConflictingNoneAttributes_Field; } + + [param: DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.None)] + set { PropertyWithConflictingNoneAttributes_Field = value; } + } + public void TestPropertyWithIndexerWithMatchingAnnotations ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type myType) { var propclass = new PropertyWithIndexer (); @@ -278,8 +367,10 @@ namespace Mono.Linker.Tests.Cases.DataFlow propclass[1].RequiresPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (PropertyWithIndexer), "Item.set", new Type[] { typeof (Type) }, messageCode: "IL2067")] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), "RequiresNonPublicConstructors", new Type[] { typeof (Type) }, messageCode: "IL2072")] + // Trimmer and analyzer handle formatting of indexers differently. + [ExpectedWarning ("IL2067", nameof (PropertyWithIndexer) + ".Item.set", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2067", nameof (PropertyWithIndexer) + ".this[Int32].set", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors) + "(Type)")] [LogDoesNotContain ("'Value passed to parameter 'index' of method 'Mono.Linker.Tests.Cases.DataFlow.PropertyDataFlow.TestAutomaticPropagationType.PropertyWithIndexer.Item.set'")] public void TestPropertyWithIndexerWithoutMatchingAnnotations (Type myType) { @@ -295,7 +386,9 @@ namespace Mono.Linker.Tests.Cases.DataFlow [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] public Type this[int index] { - [ExpectedWarning ("IL2063", "PropertyWithIndexer.Item.get")] + // TODO: warn about unknown types in analyzer: https://github.com/dotnet/linker/issues/2273 + [ExpectedWarning ("IL2063", "PropertyWithIndexer.Item.get", + ProducedBy = ProducedBy.Trimmer)] get => Property_Field[index]; set => Property_Field[index] = value; } diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.cs b/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.cs index bb890ae64..5210ab617 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.cs @@ -13,6 +13,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow [SkipKeptItemsValidation] [SetupLinkAttributesFile ("SuppressWarningWithLinkAttributes.xml")] [LogDoesNotContain ("Trim analysis warning IL2067: Mono.Linker.Tests.Cases.DataFlow.SuppressWarningWithLinkAttributes::ReadFromInstanceField()")] + [ExpectedWarning ("IL2031", "System.DoesNotExistAttribute", FileName = "SuppressWarningWithLinkAttributes.xml")] + [ExpectedNoWarnings] class SuppressWarningWithLinkAttributes { public static void Main () @@ -26,9 +28,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type PropertyWithPublicParameterlessConstructor { get; set; } - [UnrecognizedReflectionAccessPattern (typeof (SuppressWarningWithLinkAttributes), nameof (RequirePublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] - [UnrecognizedReflectionAccessPattern (typeof (SuppressWarningWithLinkAttributes), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) }, messageCode: "IL2077")] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2077", nameof (SuppressWarningWithLinkAttributes) + "." + nameof (RequirePublicConstructors))] + [ExpectedWarning ("IL2077", nameof (SuppressWarningWithLinkAttributes) + "." + nameof (RequireNonPublicConstructors))] private void ReadFromInstanceField () { RequirePublicParameterlessConstructor (_typeWithPublicParameterlessConstructor); diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.xml b/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.xml index 699a05d5a..40844528f 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.xml +++ b/test/Mono.Linker.Tests.Cases/DataFlow/SuppressWarningWithLinkAttributes.xml @@ -7,7 +7,7 @@ </attribute> <type fullname="Mono.Linker.Tests.Cases.DataFlow.SuppressWarningWithLinkAttributes"> <field name="_typeWithPublicParameterlessConstructor"> - <attribute fullname="System.DoesNotExistattribute" assembly="Mono.Linker.Tests.Cases.Expectations"> + <attribute fullname="System.DoesNotExistAttribute" assembly="Mono.Linker.Tests.Cases.Expectations"> <argument>0</argument> </attribute> <attribute fullname="System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute"> diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/TypeBaseTypeDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/TypeBaseTypeDataFlow.cs index 68d232252..0667498f6 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/TypeBaseTypeDataFlow.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/TypeBaseTypeDataFlow.cs @@ -13,6 +13,7 @@ using Mono.Linker.Tests.Cases.Expectations.Helpers; namespace Mono.Linker.Tests.Cases.DataFlow { [SkipKeptItemsValidation] + [ExpectedNoWarnings] public class TypeBaseTypeDataFlow { public static void Main () @@ -47,22 +48,19 @@ namespace Mono.Linker.Tests.Cases.DataFlow Mixed_Derived.Test (typeof (TestType), 0); } - [RecognizedReflectionAccessPattern] static void TestAllPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.All)] Type derivedType) { derivedType.BaseType.RequiresAll (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicConstructors), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] static void TestPublicConstructorsAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type derivedType) { derivedType.BaseType.RequiresPublicConstructors (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicEvents), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicEvents))] static void TestPublicEventsPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicEvents)] Type derivedType) { derivedType.BaseType.RequiresPublicEvents (); @@ -74,9 +72,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresNonPublicEvents (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicFields), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicFields))] static void TestPublicFieldsPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] Type derivedType) { derivedType.BaseType.RequiresPublicFields (); @@ -88,9 +85,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresNonPublicFields (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicProperties), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicProperties))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicMethods))] static void TestPublicMethodsPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type derivedType) { derivedType.BaseType.RequiresPublicMethods (); @@ -102,23 +98,20 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresNonPublicMethods (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicNestedTypes), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicNestedTypes))] static void TestPublicNestedTypesAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicNestedTypes)] Type derivedType) { derivedType.BaseType.RequiresPublicNestedTypes (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor))] static void TestPublicParameterlessConstructorIsNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type derivedType) { derivedType.BaseType.RequiresPublicParameterlessConstructor (); } - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicProperties), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicProperties))] static void TestPublicPropertiesPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicProperties)] Type derivedType) { derivedType.BaseType.RequiresPublicProperties (); @@ -130,49 +123,47 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresNonPublicProperties (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] static void TestNonPublicConstructorsAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicConstructors)] Type derivedType) { derivedType.BaseType.RequiresNonPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicEvents), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicEvents))] static void TestNonPublicEventsAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicEvents)] Type derivedType) { derivedType.BaseType.RequiresNonPublicEvents (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicFields), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicFields))] static void TestNonPublicFieldsAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicFields)] Type derivedType) { derivedType.BaseType.RequiresNonPublicFields (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicMethods))] static void TestNonPublicMethodsAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods)] Type derivedType) { derivedType.BaseType.RequiresNonPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicNestedTypes), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicNestedTypes))] static void TestNonPublicNestedTypesAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicNestedTypes)] Type derivedType) { derivedType.BaseType.RequiresNonPublicNestedTypes (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicProperties), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicProperties))] static void TestNonPublicPropertiesAreNotPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicProperties)] Type derivedType) { derivedType.BaseType.RequiresNonPublicProperties (); } - [RecognizedReflectionAccessPattern] static void TestInterfacesPropagated ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.Interfaces)] Type derivedType) { derivedType.BaseType.RequiresInterfaces (); } - [RecognizedReflectionAccessPattern] static void TestCombinationOfPublicsIsPropagated ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)] Type derivedType) { @@ -180,8 +171,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresPublicProperties (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicMethods), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicProperties), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicMethods))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicProperties))] static void TestCombinationOfNonPublicsIsNotPropagated ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type derivedType) { @@ -189,7 +180,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresNonPublicProperties (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresNonPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicMethods))] static void TestCombinationOfPublicAndNonPublicsPropagatesPublicOnly ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)] Type derivedType) { @@ -197,13 +188,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow derivedType.BaseType.RequiresPublicProperties (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void TestNoAnnotation (Type derivedType) { derivedType.BaseType.RequiresPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void TestAnnotatedAndUnannotated ( Type derivedTypeOne, [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type derivedTypeTwo, @@ -213,7 +204,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow type.BaseType.RequiresPublicMethods (); } - [UnrecognizedReflectionAccessPattern (typeof (DataFlowTypeExtensions), nameof (DataFlowTypeExtensions.RequiresPublicMethods), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicMethods))] static void TestNull () { Type type = null; @@ -228,7 +219,6 @@ namespace Mono.Linker.Tests.Cases.DataFlow class Mixed_Derived : Mixed_Base { - [RecognizedReflectionAccessPattern] public static void Test ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type typeWithPublicMethods, int number) diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/TypeInfoAsTypeDataFlow.cs b/test/Mono.Linker.Tests.Cases/DataFlow/TypeInfoAsTypeDataFlow.cs new file mode 100644 index 000000000..d41bcf284 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/DataFlow/TypeInfoAsTypeDataFlow.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Diagnostics.CodeAnalysis; +using System.Reflection; +using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; + +namespace Mono.Linker.Tests.Cases.DataFlow +{ + [SkipKeptItemsValidation] + [ExpectedNoWarnings] + class TypeInfoAsTypeDataFlow + { + public static void Main () + { + TestNoAnnotations (typeof (TestType).GetTypeInfo ()); + TestWithAnnotations (typeof (TestType).GetTypeInfo ()); + } + + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions.RequiresPublicMethods))] + static void TestNoAnnotations (TypeInfo t) + { + t.AsType ().RequiresPublicMethods (); + t.AsType ().RequiresNone (); + } + + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions.RequiresPublicFields))] + static void TestWithAnnotations ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TypeInfo t) + { + t.AsType ().RequiresPublicMethods (); + t.AsType ().RequiresPublicFields (); + t.AsType ().RequiresNone (); + } + + class TestType { } + } +} diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/UnresolvedMembers.cs b/test/Mono.Linker.Tests.Cases/DataFlow/UnresolvedMembers.cs index e65c0e48c..de6707416 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/UnresolvedMembers.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/UnresolvedMembers.cs @@ -15,6 +15,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow [SkipPeVerify] [SetupLinkerArgument ("--skip-unresolved", "true")] [SetupCompileBefore ("UnresolvedLibrary.dll", new[] { "Dependencies/UnresolvedLibrary.cs" }, removeFromLinkerInput: true)] + [ExpectedNoWarnings] class UnresolvedMembers { public static void Main () @@ -42,7 +43,8 @@ namespace Mono.Linker.Tests.Cases.DataFlow { } [Kept] - [ExpectedWarning ("IL2066", "TypeWithUnresolvedGenericArgument")] + [ExpectedWarning ("IL2066", "TypeWithUnresolvedGenericArgument")] // Local variable type + [ExpectedWarning ("IL2066", "TypeWithUnresolvedGenericArgument")] // Called method declaring type [ExpectedWarning ("IL2066", nameof (MethodWithUnresolvedGenericArgument))] static void UnresolvedGenericArgument () { diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/VirtualMethodHierarchyDataflowAnnotationValidation.cs b/test/Mono.Linker.Tests.Cases/DataFlow/VirtualMethodHierarchyDataflowAnnotationValidation.cs index 6d85a8ed4..10b069543 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/VirtualMethodHierarchyDataflowAnnotationValidation.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/VirtualMethodHierarchyDataflowAnnotationValidation.cs @@ -16,8 +16,12 @@ namespace Mono.Linker.Tests.Cases.DataFlow // Suppress warnings about accessing methods with annotations via reflection - the test below does that a LOT // (The test accessed these methods through DynamicallyAccessedMembers annotations which is effectively the same reflection access) [UnconditionalSuppressMessage ("test", "IL2111")] + + [ExpectedNoWarnings] class VirtualMethodHierarchyDataflowAnnotationValidation { + // The code below marks methods which have RUC on them, it's not the point of this test to validate these here + [UnconditionalSuppressMessage ("test", "IL2026")] public static void Main () { // The test uses data flow annotation to mark all public methods on the specified types diff --git a/test/Mono.Linker.Tests.Cases/DataFlow/XmlAnnotations.cs b/test/Mono.Linker.Tests.Cases/DataFlow/XmlAnnotations.cs index ec0c5a0c8..dc3c69ad5 100644 --- a/test/Mono.Linker.Tests.Cases/DataFlow/XmlAnnotations.cs +++ b/test/Mono.Linker.Tests.Cases/DataFlow/XmlAnnotations.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Text; using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.DataFlow @@ -14,6 +15,7 @@ namespace Mono.Linker.Tests.Cases.DataFlow [SetupLinkAttributesFile ("XmlAnnotations.xml")] [ExpectedWarning ("IL2031", "Attribute type 'System.DoesNotExistAttribute' could not be found", FileName = "XmlAnnotations.xml")] [LogDoesNotContain ("IL2067: Mono.Linker.Tests.Cases.DataFlow.XmlAnnotations.ReadFromInstanceField():*", true)] + [ExpectedNoWarnings] class XmlAnnotations { public static void Main () @@ -36,77 +38,55 @@ namespace Mono.Linker.Tests.Cases.DataFlow Type PropertyWithPublicParameterlessConstructor { get; set; } - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) })] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private void ReadFromInstanceField () { - RequirePublicParameterlessConstructor (_typeWithPublicParameterlessConstructor); - RequirePublicConstructors (_typeWithPublicParameterlessConstructor); - RequireNonPublicConstructors (_typeWithPublicParameterlessConstructor); + _typeWithPublicParameterlessConstructor.RequiresPublicParameterlessConstructor (); + _typeWithPublicParameterlessConstructor.RequiresPublicConstructors (); + _typeWithPublicParameterlessConstructor.RequiresNonPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] private void TwoAnnotatedParameters ( Type type, Type type2) { - RequirePublicParameterlessConstructor (type); - RequirePublicParameterlessConstructor (type2); - RequirePublicConstructors (type); - RequirePublicConstructors (type2); + type.RequiresPublicParameterlessConstructor (); + type2.RequiresPublicParameterlessConstructor (); + type.RequiresPublicConstructors (); + type2.RequiresPublicConstructors (); } - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequirePublicParameterlessConstructor), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2067", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicParameterlessConstructor))] private void SpacesBetweenParametersWrongArgument ( Type type, bool nonused) { - RequirePublicParameterlessConstructor (type); + type.RequiresPublicParameterlessConstructor (); } - [RecognizedReflectionAccessPattern] private void GenericMethod<T> ( T input, Type type) { - RequirePublicParameterlessConstructor (type); + type.RequiresPublicParameterlessConstructor (); } - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (ReturnConstructorsFailure), new Type[] { typeof (Type) }, - returnType: typeof (Type))] + [ExpectedWarning ("IL2068", nameof (XmlAnnotations) + "." + nameof (ReturnConstructorsFailure))] private Type ReturnConstructorsFailure ( Type publicParameterlessConstructorType) { return publicParameterlessConstructorType; } - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (XmlAnnotations), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) })] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] + [ExpectedWarning ("IL2072", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private void ReadFromInstanceProperty () { - RequirePublicParameterlessConstructor (PropertyWithPublicParameterlessConstructor); - RequirePublicConstructors (PropertyWithPublicParameterlessConstructor); - RequireNonPublicConstructors (PropertyWithPublicParameterlessConstructor); - } - - private static void RequirePublicParameterlessConstructor ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] - Type type) - { - } - - private static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - Type type) - { - } - - private static void RequireNonPublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] - Type type) - { + PropertyWithPublicParameterlessConstructor.RequiresPublicParameterlessConstructor (); + PropertyWithPublicParameterlessConstructor.RequiresPublicConstructors (); + PropertyWithPublicParameterlessConstructor.RequiresNonPublicConstructors (); } class TestType { } @@ -115,32 +95,13 @@ namespace Mono.Linker.Tests.Cases.DataFlow { Type _typeWithPublicParameterlessConstructor; - [UnrecognizedReflectionAccessPattern (typeof (NestedType), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (NestedType), nameof (RequireConstructors), new Type[] { typeof (Type) })] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] public void ReadFromInstanceField () { - RequirePublicParameterlessConstructor (_typeWithPublicParameterlessConstructor); - RequirePublicConstructors (_typeWithPublicParameterlessConstructor); - RequireConstructors (_typeWithPublicParameterlessConstructor); - } - - private static void RequirePublicParameterlessConstructor ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] - Type type) - { - } - - private static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - Type type) - { - } - - private static void RequireConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] - Type type) - { + _typeWithPublicParameterlessConstructor.RequiresPublicParameterlessConstructor (); + _typeWithPublicParameterlessConstructor.RequiresPublicConstructors (); + _typeWithPublicParameterlessConstructor.RequiresNonPublicConstructors (); } } } diff --git a/test/Mono.Linker.Tests.Cases/LinkAttributes/EmbeddedLinkAttributes.cs b/test/Mono.Linker.Tests.Cases/LinkAttributes/EmbeddedLinkAttributes.cs index 07a2e654a..a798dfa51 100644 --- a/test/Mono.Linker.Tests.Cases/LinkAttributes/EmbeddedLinkAttributes.cs +++ b/test/Mono.Linker.Tests.Cases/LinkAttributes/EmbeddedLinkAttributes.cs @@ -4,6 +4,7 @@ using System; using System.Diagnostics.CodeAnalysis; using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.LinkAttributes @@ -12,6 +13,7 @@ namespace Mono.Linker.Tests.Cases.LinkAttributes [SetupCompileResource ("EmbeddedLinkAttributes.xml", "ILLink.LinkAttributes.xml")] [IgnoreLinkAttributes (false)] [RemovedResourceInAssembly ("test.exe", "ILLink.LinkAttributes.xml")] + [ExpectedNoWarnings] class EmbeddedLinkAttributes { public static void Main () @@ -24,47 +26,22 @@ namespace Mono.Linker.Tests.Cases.LinkAttributes Type _typeWithPublicParameterlessConstructor; - [UnrecognizedReflectionAccessPattern (typeof (EmbeddedLinkAttributes), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [UnrecognizedReflectionAccessPattern (typeof (EmbeddedLinkAttributes), nameof (RequireNonPublicConstructors), new Type[] { typeof (Type) })] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresNonPublicConstructors))] private void ReadFromInstanceField () { - RequirePublicParameterlessConstructor (_typeWithPublicParameterlessConstructor); - RequirePublicConstructors (_typeWithPublicParameterlessConstructor); - RequireNonPublicConstructors (_typeWithPublicParameterlessConstructor); - } - private static void RequirePublicParameterlessConstructor ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] - Type type) - { - } - - private static void RequirePublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] - Type type) - { - } - - private static void RequireNonPublicConstructors ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] - Type type) - { + _typeWithPublicParameterlessConstructor.RequiresPublicParameterlessConstructor (); + _typeWithPublicParameterlessConstructor.RequiresPublicConstructors (); + _typeWithPublicParameterlessConstructor.RequiresNonPublicConstructors (); } Type _typeWithPublicFields; - [UnrecognizedReflectionAccessPattern (typeof (EmbeddedLinkAttributes), nameof (RequirePublicConstructors), new Type[] { typeof (Type) })] - [RecognizedReflectionAccessPattern] + [ExpectedWarning ("IL2077", nameof (DataFlowTypeExtensions) + "." + nameof (DataFlowTypeExtensions.RequiresPublicConstructors))] private void ReadFromInstanceField2 () { - RequirePublicConstructors (_typeWithPublicFields); - RequirePublicFields (_typeWithPublicFields); - } - - private static void RequirePublicFields ( - [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] - Type type) - { + _typeWithPublicFields.RequiresPublicConstructors (); + _typeWithPublicFields.RequiresPublicFields (); } } } diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs b/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs index 7eb814fe1..fb8314f9b 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ActivatorCreateInstance.cs @@ -8,6 +8,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] [KeptMember (".ctor()")] public class ActivatorCreateInstance { @@ -165,8 +166,8 @@ namespace Mono.Linker.Tests.Cases.Reflection public FromParameterOnStaticMethodTypeB (int arg) { } } - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (object[]) }, messageCode: "IL2067")] - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (Activator) + "." + nameof (Activator.CreateInstance) + "(Type, Object[])")] + [ExpectedWarning ("IL2067", nameof (Activator) + "." + nameof (Activator.CreateInstance), nameof (CultureInfo))] [Kept] private void FromParameterOnInstanceMethod ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] @@ -188,8 +189,8 @@ namespace Mono.Linker.Tests.Cases.Reflection public FromParameterOnInstanceMethodType (int arg, int arg2) { } } - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type) }, messageCode: "IL2067")] - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (object[]) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (Activator) + "." + nameof (Activator.CreateInstance) + "(Type)")] + [ExpectedWarning ("IL2067", nameof (Activator) + "." + nameof (Activator.CreateInstance) + "(Type, Object[])")] [Kept] private static void FromParameterWithNonPublicConstructors ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.NonPublicConstructors)] @@ -212,7 +213,7 @@ namespace Mono.Linker.Tests.Cases.Reflection private FromParameterWithNonPublicConstructorsType (int arg, int arg2) { } } - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (Type), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (Activator) + "." + nameof (Activator.CreateInstance))] [Kept] private static void FromParameterWithPublicConstructors ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] @@ -319,16 +320,14 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string) }, - messageCode: "IL2032", message: new string[] { "assemblyName" })] + [ExpectedWarning ("IL2032", nameof (Activator) + "." + nameof (Activator.CreateInstance), "assemblyName")] private static void WithNullAssemblyName () { Activator.CreateInstance (null, "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless1"); } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string) }, - messageCode: "IL2061", message: new string[] { "NonExistingAssembly" })] + [ExpectedWarning ("IL2061", nameof (Activator) + "." + nameof (Activator.CreateInstance), "NonExistingAssembly")] private static void WithNonExistingAssemblyName () { Activator.CreateInstance ("NonExistingAssembly", "Mono.Linker.Tests.Cases.Reflection.ActivatorCreateInstance+WithAssemblyNameParameterless1"); @@ -338,15 +337,13 @@ namespace Mono.Linker.Tests.Cases.Reflection private static string _typeNameField; [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Activator), nameof (Activator.CreateInstance), new Type[] { typeof (string), typeof (string), typeof (object[]) }, - messageCode: "IL2032", message: new string[] { "typeName" })] + [ExpectedWarning ("IL2032", nameof (Activator) + "." + nameof (Activator.CreateInstance), "typeName")] private static void WithAssemblyAndUnknownTypeName () { Activator.CreateInstance ("test", _typeNameField, new object[] { }); } [Kept] - [RecognizedReflectionAccessPattern] private static void WithAssemblyAndNonExistingTypeName () { Activator.CreateInstance ("test", "NonExistingType", new object[] { }); @@ -381,7 +378,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void AppDomainCreateInstance () { // Just a basic test that these are all recognized, we're not testing that it marks correctly as it has the exact same implementation @@ -404,9 +400,9 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string) }, messageCode: "IL2058")] - [UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string), typeof (bool) }, messageCode: "IL2058")] - [UnrecognizedReflectionAccessPattern (typeof (Assembly), nameof (Assembly.CreateInstance), new Type[] { typeof (string), typeof (bool), typeof (BindingFlags), typeof (Binder), typeof (object[]), typeof (CultureInfo), typeof (object[]) }, messageCode: "IL2058")] + [ExpectedWarning ("IL2058", nameof (Assembly) + "." + nameof (Assembly.CreateInstance) + "(String)")] + [ExpectedWarning ("IL2058", nameof (Assembly) + "." + nameof (Assembly.CreateInstance) + "(String, Boolean)")] + [ExpectedWarning ("IL2058", nameof (Assembly) + "." + nameof (Assembly.CreateInstance), nameof (BindingFlags))] private static void UnsupportedCreateInstance () { typeof (ActivatorCreateInstance).Assembly.CreateInstance ("NonExistent"); @@ -428,7 +424,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestCreateInstanceOfTWithConcreteType () { Activator.CreateInstance<TestCreateInstanceOfTWithConcreteTypeType> (); @@ -448,7 +443,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestCreateInstanceOfTWithNewConstraint<T> () where T : new() { Activator.CreateInstance<T> (); @@ -468,6 +462,7 @@ namespace Mono.Linker.Tests.Cases.Reflection [Kept] [ExpectedWarning ("IL2091", nameof (Activator), nameof (Activator.CreateInstance) + "<T>")] + [ExpectedWarning ("IL2091", nameof (Activator), nameof (Activator.CreateInstance) + "<T>")] // Warnings are currently duplicated in NETCORE (annotation and intrinsics) - but they're not identical in this case. // See https://github.com/dotnet/linker/issues/1483 private static void TestCreateInstanceOfTWithNoConstraint<T> () @@ -489,7 +484,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestCreateInstanceOfTWithDataflow< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor), KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))] T> () @@ -507,14 +501,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestNullArgsOnKnownType () { Activator.CreateInstance (typeof (TestNullArgsType), null); } [Kept] - [RecognizedReflectionAccessPattern] private static void TestNullArgsOnAnnotatedType ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor), KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))] Type type) diff --git a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithSweptReferences.cs b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithSweptReferences.cs index 5cecf5e5d..526376526 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithSweptReferences.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/AssemblyImportedViaReflectionWithSweptReferences.cs @@ -5,6 +5,7 @@ using Mono.Linker.Tests.Cases.Reflection.Dependencies; namespace Mono.Linker.Tests.Cases.Reflection { + [ExpectedNoWarnings] [SetupCSharpCompilerToUse ("csc")] [SetupCompileBefore ("unusedreference.dll", new[] { "Dependencies/UnusedAssemblyDependency.cs" })] [SetupCompileBefore ("reference.dll", new[] { "Dependencies/AssemblyDependency.cs" }, addAsReference: false)] @@ -19,7 +20,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void AccessNonExistingTypeInAssembly () { diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs index dde8f46f9..5c28deafe 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorUsedViaReflection.cs @@ -7,6 +7,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] public class ConstructorUsedViaReflection { public static void Main () @@ -58,9 +59,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) }, - typeof (EmptyTypes), nameof (EmptyTypes), new Type[0])] static void TestConstructorWithTypes_EmptyTypes () { var constructor = typeof (EmptyTypes).GetConstructor (new Type[] { }); @@ -68,7 +66,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestConstructorWithTypes_NonEmptyTypes () { var constructor = typeof (GetConstructor_Types).GetConstructor (new Type[] { typeof (int) }); @@ -76,7 +73,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestConstructorWithTypes_EmptyTypes_DataFlow ( [KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))] [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] @@ -87,8 +83,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) }, messageCode: "IL2070")] + [ExpectedWarning ("IL2070", nameof (Type.GetConstructor))] static void TestConstructorWithTypes_NonEmptyTypes_DataFlow ( [KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))] [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] @@ -123,9 +118,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (KnownBindingFlags), nameof (KnownBindingFlags), new Type[0])] public static void TestWithBindingFlags () { var constructor = typeof (KnownBindingFlags).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), new Type[] { }, new ParameterModifier[] { }); @@ -157,8 +149,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (UnknownBindingFlags), nameof (UnknownBindingFlags), new Type[0])] public static void TestWithUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all constructors on the type @@ -187,9 +177,6 @@ namespace Mono.Linker.Tests.Cases.Reflection { } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (GetConstructor_BindingAttr_Binder_CallConvention_Types_Modifiers), nameof (GetConstructor_BindingAttr_Binder_CallConvention_Types_Modifiers), new Type[0])] public static void TestWithCallingConvention () { var constructor = typeof (GetConstructor_BindingAttr_Binder_CallConvention_Types_Modifiers).GetConstructor (BindingFlags.Public, GetNullValue ("some argument", 2, 3), CallingConventions.HasThis, new Type[] { }, new ParameterModifier[] { }); @@ -236,9 +223,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Type[]) }, - typeof (GetConstructor_BindingAttr_Types), nameof (GetConstructor_BindingAttr_Types), new Type[0])] static void TestWithBindingFlagsAndTypes_EmptyTypes () { var constructor = typeof (GetConstructor_BindingAttr_Types).GetConstructor (BindingFlags.Public, new Type[] { }); @@ -246,7 +230,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestWithBindingFlagsAndTypes_NonEmptyTypes () { var constructor = typeof (NonEmptyTypes).GetConstructor (BindingFlags.Public, new Type[] { typeof (TestType) }); @@ -254,7 +237,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestWithBindingFlagsAndTypes_EmptyTypes_DataFlow ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] [KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))] @@ -264,8 +246,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Type[]) }, messageCode: "IL2070")] + [ExpectedWarning ("IL2070", nameof (Type.GetConstructor))] static void TestWithBindingFlagsAndTypes_NonEmptyTypes_DataFlow ( [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] [KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))] @@ -289,8 +270,7 @@ namespace Mono.Linker.Tests.Cases.Reflection return null; } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (Type[]) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetConstructor" })] + [ExpectedWarning ("IL2075", "FindType", "GetConstructor")] [Kept] static void TestDataFlowType () { @@ -342,12 +322,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (IfConstructor), nameof (IfConstructor), new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetConstructor), new Type[] { typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (ElseConstructor), nameof (ElseConstructor), new Type[0])] public static void TestIfElse (bool decision) { Type myType; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorsUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorsUsedViaReflection.cs index be6d2408b..78ed3dad1 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ConstructorsUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ConstructorsUsedViaReflection.cs @@ -21,21 +21,18 @@ namespace Mono.Linker.Tests.Cases.Reflection TestIfElse (true); } - [RecognizedReflectionAccessPattern] [Kept] static void TestGetConstructors () { var constructors = typeof (SimpleGetConstructors).GetConstructors (); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithBindingFlags () { var constructors = typeof (ConstructorsBindingFlags).GetConstructors (BindingFlags.Public | BindingFlags.Static); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithUnknownBindingFlags (BindingFlags bindingFlags) { @@ -44,7 +41,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -57,8 +53,7 @@ namespace Mono.Linker.Tests.Cases.Reflection return null; } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetConstructors), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetConstructors" })] + [ExpectedWarning ("IL2075", "FindType", "GetConstructors")] [Kept] static void TestDataFlowType () { @@ -67,14 +62,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors)] Type type) { var constructors = type.GetConstructors (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (bool decision) { Type myType; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs index 5f93cf879..5dbad0c58 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs @@ -6,6 +6,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] public class EventUsedViaReflection { public static void Main () @@ -31,9 +32,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - typeof (Foo), nameof (Foo.Event), (Type[]) null)] static void TestByName () { var eventInfo = typeof (Foo).GetEvent ("Event"); @@ -111,8 +109,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetEvent" })] + [ExpectedWarning ("IL2075", "FindType", "GetEvent")] static void TestDataFlowType () { Type type = FindType (); @@ -120,15 +117,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - typeof (IfClass), nameof (IfClass.IfEvent), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - typeof (IfClass), nameof (IfClass.ElseEvent), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - typeof (ElseClass), nameof (ElseClass.IfEvent), (Type[]) null)] static void TestIfElse (int i) { Type myType; @@ -147,9 +135,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string) }, - typeof (BaseClass), nameof (BaseClass.PublicEventOnBase), (Type[]) null)] static void TestEventInBaseType () { typeof (DerivedClass).GetEvent ("ProtectedEventOnBase"); // Will not mark anything as it only works on public events @@ -157,9 +142,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetEvent), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (IgnoreCaseBindingFlagsClass), nameof (IgnoreCaseBindingFlagsClass.PublicEvent), (Type[]) null)] static void TestIgnoreCaseBindingFlags () { typeof (IgnoreCaseBindingFlagsClass).GetEvent ("publicevent", BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/EventsUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/EventsUsedViaReflection.cs index 0c2d15582..53a7494f6 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/EventsUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/EventsUsedViaReflection.cs @@ -28,14 +28,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestGetEvents () { var events = typeof (Foo).GetEvents (); } [Kept] - [RecognizedReflectionAccessPattern] // The event will not be kept as it's internal and the behavior of Type.GetEvents() is to only return public events // But we don't mark it as unrecognized access pattern - we did recognize it fully, just didn't find the event being asked for // The behavior of the code will not change by linking it: @@ -47,14 +45,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestBindingFlags () { var events = typeof (Bar).GetEvents (BindingFlags.NonPublic); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all events on the type @@ -62,7 +58,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -76,8 +71,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetEvents), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetEvents" })] + [ExpectedWarning ("IL2075", "FindType", "GetEvents")] static void TestDataFlowType () { Type type = FindType (); @@ -85,14 +79,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicEvents)] Type type) { var events = type.GetEvents (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (int i) { Type myType; @@ -105,14 +97,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnoreCaseBindingFlags () { var events = typeof (IgnoreCaseBindingFlagsClass).GetEvents (BindingFlags.IgnoreCase | BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnsupportedBindingFlags () { var events = typeof (PutRefDispPropertyBindingFlagsClass).GetEvents (BindingFlags.PutRefDispProperty); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs index 699bb9d9d..bb89b436d 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionCallString.cs @@ -118,13 +118,12 @@ namespace Mono.Linker.Tests.Cases.Reflection class TestUnknownType { [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Call), - new Type[] { typeof (Type), typeof (string), typeof (Type[]), typeof (Expression[]) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (Expression) + "." + nameof (Expression.Call))] public static void Test () { // Keep all methods of the type that made the call Expression.Call (GetUnknownType (), "This string will not be reached", Type.EmptyTypes); - // UnrecognizedReflectionAccessPattern + // IL2072 Expression.Call (TriggerUnrecognizedPattern (), "This string will not be reached", Type.EmptyTypes); } diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs index 0a6959ce8..c2399e92c 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionFieldString.cs @@ -7,10 +7,10 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [Reference ("System.Core.dll")] + [ExpectedNoWarnings] public class ExpressionFieldString { - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Field), - new Type[] { typeof (Expression), typeof (Type), typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (Expression) + "." + nameof (Expression.Field))] public static void Main () { Expression.Field (Expression.Parameter (typeof (int), ""), typeof (ExpressionFieldString), "Field"); @@ -18,8 +18,9 @@ namespace Mono.Linker.Tests.Cases.Reflection Expression.Field (null, typeof (Derived), "_protectedFieldOnBase"); Expression.Field (null, typeof (Derived), "_publicFieldOnBase"); UnknownType.Test (); + UnknownTypeNoAnnotation.Test (); UnknownString.Test (); - Expression.Field (null, GetType (), "This string will not be reached"); // UnrecognizedReflectionAccessPattern + Expression.Field (null, GetType (), "This string will not be reached"); // IL2072 } [Kept] @@ -61,6 +62,26 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + class UnknownTypeNoAnnotation + { + public static int Field1; + private int Field2; + + [ExpectedWarning ("IL2072", "'type'")] + [Kept] + public static void Test () + { + Expression.Field (null, GetType (), "This string will not be reached"); + } + + [Kept] + static Type GetType () + { + return typeof (UnknownType); + } + } + + [Kept] class UnknownString { [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs index a137d122c..9e06ccb43 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionNewType.cs @@ -8,6 +8,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [Reference ("System.Core.dll")] + [ExpectedNoWarnings] public class ExpressionNewType { public static void Main () @@ -25,11 +26,6 @@ namespace Mono.Linker.Tests.Cases.Reflection Expression.New (5 + 7 == 12 ? null : typeof (RemovedType)); } - #region RecognizedReflectionAccessPatterns - [RecognizedReflectionAccessPattern ( - typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, typeof (A), "A", new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, typeof (B), "B", new Type[0])] [Kept] static void Branch_SystemTypeValueNode (int i) { @@ -47,25 +43,22 @@ namespace Mono.Linker.Tests.Cases.Reflection Expression.New (T); } - #endregion - #region UnrecognizedReflectionAccessPatterns - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, messageCode: "IL2067")] + [ExpectedWarning ("IL2067", nameof (Expression) + "." + nameof (Expression.New))] [Kept] static void Branch_MethodParameterValueNode (Type T) { Expression.New (T); } - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, messageCode: "IL2072")] - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.New), new Type[] { typeof (Type) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (Expression) + "." + nameof (Expression.New), "'System." + nameof (Type) + "." + nameof (Type.GetType))] + [ExpectedWarning ("IL2072", nameof (Expression) + "." + nameof (Expression.New), nameof (ExpressionNewType) + "." + nameof (ExpressionNewType.GetType))] [Kept] static void Branch_UnrecognizedPatterns () { Expression.New (Type.GetType ("RemovedType")); Expression.New (GetType ()); } - #endregion #region Helpers [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyMethodInfo.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyMethodInfo.cs index 8a0b2b3b0..b4d9613ae 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyMethodInfo.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyMethodInfo.cs @@ -76,7 +76,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void Test () { Expression<Func<int>> staticGetter = () => StaticProperty; @@ -124,7 +123,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void Test () { Expression.Property (null, typeof (PropertySetter).GetMethod ("set_StaticProperty")); @@ -136,7 +134,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNull () { MethodInfo mi = null; @@ -144,16 +141,13 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern ( - typeof (Expression), nameof (Expression.Property), new Type[] { typeof (Expression), typeof (MethodInfo) }, - messageCode: "IL2103")] + [ExpectedWarning ("IL2103", nameof (Expression) + "." + nameof (Expression.Property))] static void TestNonPropertyMethod () { Expression.Property (null, typeof (ExpressionPropertyMethodInfo).GetMethod (nameof (TestNonPropertyMethod), BindingFlags.NonPublic | BindingFlags.Static)); } [Kept] - [RecognizedReflectionAccessPattern] static void TestNonExistentMethod () { Expression.Property (null, typeof (ExpressionPropertyMethodInfo).GetMethod ("NonExistent")); @@ -181,7 +175,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void Test (int p) { MethodInfo mi; @@ -202,9 +195,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern ( - typeof (Expression), nameof (Expression.Property), new Type[] { typeof (Expression), typeof (MethodInfo) }, - messageCode: "IL2103")] + [ExpectedWarning ("IL2103", nameof (Expression) + "." + nameof (Expression.Property))] static void TestUnknownMethod (MethodInfo mi) { Expression.Property (null, mi); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs index 7379710bd..13de4491d 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/ExpressionPropertyString.cs @@ -9,10 +9,10 @@ namespace Mono.Linker.Tests.Cases.Reflection // Explicitly use roslyn to try and get a compiler that supports defining a static property without a setter [SetupCSharpCompilerToUse ("csc")] [Reference ("System.Core.dll")] + [ExpectedNoWarnings] public class ExpressionPropertyString { - [UnrecognizedReflectionAccessPattern (typeof (Expression), nameof (Expression.Property), - new Type[] { typeof (Expression), typeof (Type), typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (Expression) + "." + nameof (Expression.Property))] public static void Main () { Expression.Property (Expression.Parameter (typeof (int), ""), typeof (ExpressionPropertyString), "Property"); @@ -21,7 +21,7 @@ namespace Mono.Linker.Tests.Cases.Reflection Expression.Property (null, typeof (Derived), "PublicPropertyOnBase"); UnknownType.Test (); UnknownString.Test (); - Expression.Property (null, GetType (), "This string will not be reached"); // UnrecognizedReflectionAccessPattern + Expression.Property (null, GetType (), "This string will not be reached"); // IL2072 } [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs index 94535adb1..c0fad7206 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs @@ -6,6 +6,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] public class FieldUsedViaReflection { public static void Main () @@ -29,9 +30,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) }, - typeof (FieldUsedViaReflection), nameof (FieldUsedViaReflection.publicField), (Type[]) null)] static void TestByName () { var field = typeof (FieldUsedViaReflection).GetField ("publicField"); @@ -46,9 +44,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (Foo), nameof (Foo.field), (Type[]) null)] static void TestNameBindingFlags () { var field = typeof (Foo).GetField ("field", BindingFlags.Static); @@ -106,8 +101,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetField" })] + [ExpectedWarning ("IL2075", "FindType", "GetField")] static void TestDataFlowType () { Type type = FindType (); @@ -115,12 +109,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) }, - typeof (IfClass), nameof (IfClass.ifField), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) }, - typeof (ElseClass), nameof (ElseClass.elseField), (Type[]) null)] static void TestIfElse (int i) { Type myType; @@ -139,9 +127,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string) }, - typeof (BaseClass), nameof (BaseClass.publicFieldOnBase), (Type[]) null)] static void TestFieldInBaseType () { var protectedField = typeof (DerivedClass).GetField ("protectedFieldOnBase"); // Will not be marked - only public fields work this way @@ -149,9 +134,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetField), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (IgnoreCaseBindingFlagsClass), nameof (IgnoreCaseBindingFlagsClass.publicField), (Type[]) null)] static void TestIgnoreCaseBindingFlags () { var field = typeof (IgnoreCaseBindingFlagsClass).GetField ("publicfield", BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/FieldsUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/FieldsUsedViaReflection.cs index 7f805345e..ab50a5dac 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/FieldsUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/FieldsUsedViaReflection.cs @@ -24,21 +24,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestGetFields () { var fields = typeof (FieldsUsedViaReflection).GetFields (); } [Kept] - [RecognizedReflectionAccessPattern] static void TestBindingFlags () { var fields = typeof (Foo).GetFields (BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all fields on the type @@ -46,7 +43,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -60,8 +56,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetFields), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetFields" })] + [ExpectedWarning ("IL2075", "FindType", "GetFields")] static void TestDataFlowType () { Type type = FindType (); @@ -69,14 +64,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] Type type) { var fields = type.GetFields (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (int i) { Type myType; @@ -89,14 +82,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnoreCaseBindingFlags () { var fields = typeof (IgnoreCaseBindingFlagsClass).GetFields (BindingFlags.IgnoreCase | BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnsupportedBindingFlags () { var fields = typeof (PutDispPropertyBindingFlagsClass).GetFields (BindingFlags.PutDispProperty); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MemberUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MemberUsedViaReflection.cs index a73ed2d7a..828ce4d77 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MemberUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MemberUsedViaReflection.cs @@ -7,6 +7,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] public class MemberUsedViaReflection { public static void Main () @@ -24,7 +25,6 @@ namespace Mono.Linker.Tests.Cases.Reflection TestIfElse (true); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithName () { @@ -32,21 +32,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithPrefixLookup () { var members = typeof (PrefixLookupType).GetMember ("PrefixLookup*"); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithBindingFlags () { var members = typeof (BindingFlagsType).GetMember ("PrefixLookup*", BindingFlags.Public | BindingFlags.NonPublic); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithUnknownBindingFlags (BindingFlags bindingFlags) { @@ -54,7 +51,6 @@ namespace Mono.Linker.Tests.Cases.Reflection var members = typeof (UnknownBindingFlags).GetMember ("PrefixLookup*", bindingFlags); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithMemberTypes () { @@ -63,7 +59,6 @@ namespace Mono.Linker.Tests.Cases.Reflection var members = typeof (TestMemberTypes).GetMember ("PrefixLookup*", MemberTypes.Method, BindingFlags.Public); } - [RecognizedReflectionAccessPattern] [Kept] static void TestNullType () { @@ -77,8 +72,7 @@ namespace Mono.Linker.Tests.Cases.Reflection return null; } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMember), new Type[] { typeof (string) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetMember" })] + [ExpectedWarning ("IL2075", "FindType", "GetMember")] [Kept] static void TestDataFlowType () { @@ -87,7 +81,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicEvents | @@ -100,7 +93,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (bool decision) { Type myType; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MembersUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MembersUsedViaReflection.cs index 5a7fe375e..8a20f7733 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MembersUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MembersUsedViaReflection.cs @@ -21,21 +21,18 @@ namespace Mono.Linker.Tests.Cases.Reflection TestIfElse (true); } - [RecognizedReflectionAccessPattern] [Kept] static void TestGetMembers () { var members = typeof (SimpleGetMembers).GetMembers (); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithBindingFlags () { var members = typeof (MembersBindingFlags).GetMembers (BindingFlags.Public); } - [RecognizedReflectionAccessPattern] [Kept] static void TestWithUnknownBindingFlags (BindingFlags bindingFlags) { @@ -44,7 +41,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -57,8 +53,7 @@ namespace Mono.Linker.Tests.Cases.Reflection return null; } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMembers), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetMembers" })] + [ExpectedWarning ("IL2075", "FindType", "GetMembers")] [Kept] static void TestDataFlowType () { @@ -67,7 +62,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))] [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicEvents | @@ -80,7 +74,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (bool decision) { Type myType; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs index 7a9475542..116cabad0 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs @@ -7,6 +7,7 @@ namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] [SetupLinkerArgument ("--disable-opt", "unreachablebodies")] public class MethodUsedViaReflection { @@ -73,9 +74,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) }, - typeof (GetMethod_Name), nameof (GetMethod_Name.OnlyCalledViaReflection), new Type[0])] public static void TestName () { var method = typeof (GetMethod_Name).GetMethod ("OnlyCalledViaReflection"); @@ -83,7 +81,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNamePrivate () { // This should fail at runtime, since GetMethod(name) only works on public methods @@ -121,9 +118,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (Type[]) }, - typeof (GetMethod_Name_Types), nameof (GetMethod_Name_Types.OnlyCalledViaReflection), new Type[0])] public static void TestNameAndType () { // Currently linker doesn't analyze the Type[] parameter and thus it marks all methods with the name and matching binding flags (public in this case) @@ -159,9 +153,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (GetMethod_Name_BindingAttr), nameof (GetMethod_Name_BindingAttr.OnlyCalledViaReflection), new Type[0])] public static void TestExplicitBindingFlags () { var method = typeof (GetMethod_Name_BindingAttr).GetMethod ("OnlyCalledViaReflection", BindingFlags.Static | BindingFlags.Public); @@ -197,7 +188,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all methods on the type @@ -216,7 +206,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestUnknownBindingFlagsAndName (BindingFlags bindingFlags, string name) { // Since the binding flags and name are not known linker should mark all methods on the type @@ -253,7 +242,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestUnknownNullBindingFlags (BindingFlags bindingFlags) { // The case here is a pattern which linker doesn't recognize (unlike the test case above, which passes a recognized @@ -364,7 +352,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNameBindingFlagsAndParameterModifier () { var method = typeof (GetMethod_Name_BindingAttr_Binder_Types_Modifiers).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public, null, new Type[] { }, null); @@ -396,9 +383,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (GetMethod_Name_BindingAttr_Binder_CallConvention_Types_Modifiers), nameof (GetMethod_Name_BindingAttr_Binder_CallConvention_Types_Modifiers.OnlyCalledViaReflection), new Type[0])] public static void TestNameBindingFlagsCallingConventionParameterModifier () { var method = typeof (GetMethod_Name_BindingAttr_Binder_CallConvention_Types_Modifiers).GetMethod ("OnlyCalledViaReflection", BindingFlags.NonPublic, null, CallingConventions.Standard, new Type[] { }, null); @@ -432,7 +416,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNameBindingFlagsAndTypes () { var method = typeof (GetMethod_Name_BindingAttr_Types).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public, new Type[] { }); @@ -464,9 +447,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (int), typeof (Type[]) }, - typeof (GetMethod_Name_GenericParameterCount_Types), nameof (GetMethod_Name_GenericParameterCount_Types.OnlyCalledViaReflection), new Type[] { typeof (int), typeof (int) })] public static void TestNameWithIntAndType () { var method = typeof (GetMethod_Name_GenericParameterCount_Types).GetMethod ("OnlyCalledViaReflection", 1, new Type[] { typeof (int) }); @@ -498,9 +478,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (int), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (GetMethod_Name_GenericParameterCount_Types_Modifiers), nameof (GetMethod_Name_GenericParameterCount_Types_Modifiers.OnlyCalledViaReflection), new Type[] { typeof (int), typeof (int) })] public static void TestNameWithIntAndTypeAndModifiers () { var method = typeof (GetMethod_Name_GenericParameterCount_Types_Modifiers).GetMethod ("OnlyCalledViaReflection", 1, new Type[] { typeof (int) }, null); @@ -532,7 +509,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNameWithIntAndBindingFlags () { var method = typeof (GetMethod_Name_GenericParameterCount_BindingAttr_Binder_Types_Modifiers) @@ -566,7 +542,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNameWithIntAndPrivateBindingFlags () { var method = typeof (GetMethod_Name_GenericParameterCount_BindingAttr_Binder_Types_Modifiers_PrivateBinding) @@ -598,9 +573,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (int), typeof (BindingFlags), typeof (Binder), typeof (CallingConventions), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (GetMethod_Name_GenericParameterCount_BindingAttr_Binder_CallConvention_Types_Modifiers), nameof (GetMethod_Name_GenericParameterCount_BindingAttr_Binder_CallConvention_Types_Modifiers.OnlyCalledViaReflection), new Type[0])] public static void TestNameWithIntBindingFlagsCallingConventionParameter () { var method = typeof (GetMethod_Name_GenericParameterCount_BindingAttr_Binder_CallConvention_Types_Modifiers).GetMethod ("OnlyCalledViaReflection", 1, BindingFlags.Static | BindingFlags.NonPublic, null, CallingConventions.Any, new Type[] { }, null); @@ -610,28 +582,24 @@ namespace Mono.Linker.Tests.Cases.Reflection #endif [Kept] - [RecognizedReflectionAccessPattern] static void TestNullName () { var method = typeof (MethodUsedViaReflection).GetMethod (null); } [Kept] - [RecognizedReflectionAccessPattern] static void TestEmptyName () { var method = typeof (MethodUsedViaReflection).GetMethod (string.Empty); } [Kept] - [RecognizedReflectionAccessPattern] static void TestNonExistingName () { var method = typeof (MethodUsedViaReflection).GetMethod ("NonExisting"); } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -645,8 +613,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetMethod" })] + [ExpectedWarning ("IL2075", "FindType", "GetMethod")] static void TestDataFlowType () { Type type = FindType (); @@ -716,21 +683,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (IfClass), nameof (IfClass.OnlyCalledViaReflection), new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (IfClass), nameof (IfClass.ElseIfCall), new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (ElseIfClass), nameof (ElseIfClass.OnlyCalledViaReflection), new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (ElseIfClass), nameof (ElseIfClass.ElseIfCall), new Type[0])] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags), typeof (Binder), typeof (Type[]), typeof (ParameterModifier[]) }, - typeof (ElseClass), nameof (ElseClass.OnlyCalledViaReflection), new Type[0])] public static void TestIfElse (int i) { Type myType; @@ -773,9 +725,6 @@ namespace Mono.Linker.Tests.Cases.Reflection { } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string) }, - typeof (BaseClass), nameof (BaseClass.OnlyCalledViaReflection), new Type[0])] public static void TestMethodInBaseType () { var method = typeof (DerivedClass).GetMethod ("OnlyCalledViaReflection"); @@ -798,9 +747,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetMethod), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (IgnoreCaseBindingFlags), nameof (IgnoreCaseBindingFlags.OnlyCalledViaReflection), new Type[0])] public static void TestIgnoreCaseBindingFlags () { var method = typeof (IgnoreCaseBindingFlags).GetMethod ("onlycalledviareflection", BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs index 5658a1a99..fcede014b 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs @@ -27,21 +27,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestGetMethods () { var methods = typeof (MethodsUsedViaReflection).GetMethods (); } [Kept] - [RecognizedReflectionAccessPattern] static void TestBindingFlags () { var methods = typeof (TestBindingClass).GetMethods (BindingFlags.Static | BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all methods on the type @@ -49,7 +46,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -63,8 +59,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetMethods), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetMethods" })] + [ExpectedWarning ("IL2075", "FindType", "GetMethods")] static void TestDataFlowType () { Type type = FindType (); @@ -72,14 +67,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type type) { var methods = type.GetMethods (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (int i) { Type myType; @@ -94,7 +87,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnoreCaseBindingFlags () { var methods = typeof (IgnoreCaseClass).GetMethods (BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs index 2700a8793..66256ef78 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs @@ -8,6 +8,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { + [ExpectedNoWarnings] public class NestedTypeUsedViaReflection { public static void Main () @@ -28,9 +29,6 @@ namespace Mono.Linker.Tests.Cases.Reflection public static class NestedType { } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string) }, - typeof (NestedTypeUsedViaReflection.NestedType), null, (Type[]) null)] static void TestByName () { _ = typeof (NestedTypeUsedViaReflection).GetNestedType (nameof (NestedType)); @@ -55,15 +53,6 @@ namespace Mono.Linker.Tests.Cases.Reflection protected static class ProtectedNestedType { } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (NestedTypeUsedViaReflection.PrivateNestedType), null, (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (NestedTypeUsedViaReflection.PublicNestedType), null, (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (NestedTypeUsedViaReflection.ProtectedNestedType), null, (Type[]) null)] static void TestByBindingFlags () { _ = typeof (NestedTypeUsedViaReflection).GetNestedType (nameof (PrivateNestedType), BindingFlags.NonPublic); @@ -72,9 +61,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (UnknownBindingFlags.PublicNestedType), null, (Type[]) null)] static void TestByUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all nested types on the type @@ -82,9 +68,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (UnknownBindingFlagsAndName.PublicNestedType), null, (Type[]) null)] static void TestByUnknownBindingFlagsAndName (BindingFlags bindingFlags, string name) { // Since the binding flags and name are not known linker should mark all nested types on the type @@ -105,9 +88,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetNestedType), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (IgnoreCaseClass.IgnoreCasePublicNestedType), null, (Type[]) null)] static void TestIgnoreCaseBindingFlags () { _ = typeof (IgnoreCaseClass).GetNestedType ("ignorecasepublicnestedtype", BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypesUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypesUsedViaReflection.cs index 46c490a29..4d8683aed 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypesUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypesUsedViaReflection.cs @@ -9,6 +9,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { + [ExpectedNoWarnings] public class NestedTypesUsedViaReflection { public static void Main () @@ -27,7 +28,6 @@ namespace Mono.Linker.Tests.Cases.Reflection public static class NestedType { } [Kept] - [RecognizedReflectionAccessPattern] static void TestGetNestedTypes () { _ = typeof (NestedTypesUsedViaReflection).GetNestedType (nameof (NestedType)); @@ -43,14 +43,12 @@ namespace Mono.Linker.Tests.Cases.Reflection protected static class ProtectedNestedType { } [Kept] - [RecognizedReflectionAccessPattern] static void TestByBindingFlags () { _ = typeof (NestedTypesUsedViaReflection).GetNestedTypes (BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestByUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all nested types on the type @@ -58,7 +56,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -71,8 +68,7 @@ namespace Mono.Linker.Tests.Cases.Reflection return null; } - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetNestedTypes), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetNestedTypes" })] + [ExpectedWarning ("IL2075", "FindType", "GetNestedTypes")] [Kept] static void TestDataFlowType () { @@ -81,14 +77,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicNestedTypes)] Type type) { _ = type.GetNestedTypes (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnoreCaseBindingFlags () { _ = typeof (IgnoreCaseClass).GetNestedTypes (BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs index 4f8346b7c..2254d93b6 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs @@ -28,21 +28,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestGetProperties () { var properties = typeof (PropertiesUsedViaReflection).GetProperties (); } [Kept] - [RecognizedReflectionAccessPattern] static void TestBindingFlags () { var properties = typeof (BindingFlagsTest).GetProperties (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all properties on the type @@ -50,14 +47,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestPropertiesOfArray () { var properties = typeof (int[]).GetProperties (BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestNullType () { Type type = null; @@ -71,8 +66,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetProperties), new Type[] { typeof (BindingFlags) }, - messageCode: "IL2075", message: new string[] { "GetProperties" })] + [ExpectedWarning ("IL2075", "GetProperties")] static void TestDataFlowType () { Type type = FindType (); @@ -80,14 +74,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] private static void TestDataFlowWithAnnotation ([KeptAttributeAttribute (typeof (DynamicallyAccessedMembersAttribute))][DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicProperties)] Type type) { var properties = type.GetProperties (BindingFlags.Public | BindingFlags.Static); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElse (int i) { Type myType; @@ -100,21 +92,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnoreCaseBindingFlags () { var properties = typeof (IgnoreCaseBindingFlagsClass).GetProperties (BindingFlags.IgnoreCase | BindingFlags.Public); } [Kept] - [RecognizedReflectionAccessPattern] static void TestIgnorableBindingFlags () { var properties = typeof (ExactBindingBindingFlagsClass).GetProperties (BindingFlags.Public | BindingFlags.ExactBinding); } [Kept] - [RecognizedReflectionAccessPattern] static void TestUnsupportedBindingFlags () { var properties = typeof (ChangeTypeBindingFlagsClass).GetProperties (BindingFlags.Public | BindingFlags.SuppressChangeType); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs index 4004e894b..bdd671987 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs @@ -6,6 +6,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] [SetupLinkerArgument ("--disable-opt", "unreachablebodies")] public class PropertyUsedViaReflection { @@ -33,9 +34,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.OnlyUsedViaReflection), (Type[]) null)] static void TestGetterAndSetter () { var property = typeof (PropertyUsedViaReflection).GetProperty ("OnlyUsedViaReflection"); @@ -51,9 +49,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.SetterOnly), (Type[]) null)] static void TestSetterOnly () { var property = typeof (PropertyUsedViaReflection).GetProperty ("SetterOnly"); @@ -61,9 +56,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (PropertyUsedViaReflection), nameof (PropertyUsedViaReflection.GetterOnly), (Type[]) null)] static void TestGetterOnly () { var property = typeof (PropertyUsedViaReflection).GetProperty ("GetterOnly"); @@ -71,9 +63,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (BindingFlagsTest), nameof (BindingFlagsTest.PublicProperty), (Type[]) null)] static void TestBindingFlags () { var property = typeof (BindingFlagsTest).GetProperty ("PublicProperty", BindingFlags.Public); @@ -81,9 +70,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (UnknownBindingFlags), nameof (UnknownBindingFlags.SomeProperty), (Type[]) null)] static void TestUnknownBindingFlags (BindingFlags bindingFlags) { // Since the binding flags are not known linker should mark all properties on the type @@ -92,9 +78,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (UnknownBindingFlagsAndName), nameof (UnknownBindingFlagsAndName.SomeProperty), (Type[]) null)] static void TestUnknownBindingFlagsAndName (BindingFlags bindingFlags, string name) { // Since the binding flags and name are not known linker should mark all properties on the type @@ -121,9 +104,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (Array), nameof (Array.LongLength))] static void TestPropertyOfArray () { var property = typeof (int[]).GetProperty ("LongLength"); @@ -144,8 +124,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - messageCode: "IL2075", message: new string[] { "FindType", "GetProperty" })] + [ExpectedWarning ("IL2075", "FindType", "GetProperty")] static void TestDataFlowType () { Type type = FindType (); @@ -153,18 +132,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (IfClass), nameof (IfClass.SetterOnly), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (IfClass), nameof (IfClass.GetterOnly), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (ElseClass), nameof (ElseClass.SetterOnly), (Type[]) null)] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (ElseClass), nameof (ElseClass.GetterOnly), (Type[]) null)] static void TestIfElse (int i) { Type myType; @@ -183,18 +150,12 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string) }, - typeof (BaseClass), nameof (BaseClass.GetterSetterOnBaseClass), (Type[]) null)] static void TestPropertyInBaseType () { var property = typeof (DerivedClass).GetProperty ("GetterSetterOnBaseClass"); } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetProperty), new Type[] { typeof (string), typeof (BindingFlags) }, - typeof (IgnoreCaseBindingFlagsClass), nameof (IgnoreCaseBindingFlagsClass.SetterOnly), (Type[]) null)] static void TestIgnoreCaseBindingFlags () { var property = typeof (IgnoreCaseBindingFlagsClass).GetProperty ("setteronly", BindingFlags.IgnoreCase | BindingFlags.Public); diff --git a/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs index e4670746c..0744577ec 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/RunClassConstructorUsedViaReflection.cs @@ -7,6 +7,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] + [ExpectedNoWarnings] public class RunClassConstructorUsedViaReflection { public static void Main () @@ -20,7 +21,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestRunClassConstructor () { RuntimeHelpers.RunClassConstructor (typeof (OnlyUsedViaReflection).TypeHandle); @@ -33,7 +33,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestNull () { Type type = null; @@ -47,8 +46,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type[] { typeof (RuntimeTypeHandle) }, - messageCode: "IL2059", message: new string[] { "RunClassConstructor" })] + [ExpectedWarning ("IL2059", nameof (RuntimeHelpers) + "." + nameof (RuntimeHelpers.RunClassConstructor))] static void TestDataFlowType () { @@ -57,10 +55,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeHelpers), nameof (RuntimeHelpers.RunClassConstructor), new Type[] { typeof (RuntimeTypeHandle) }, - messageCode: "IL2059")] - + [ExpectedWarning ("IL2059", nameof (RuntimeHelpers) + "." + nameof (RuntimeHelpers.RunClassConstructor))] static void TestIfElseUsingRuntimeTypeHandle (int i) { RuntimeTypeHandle myType; @@ -75,7 +70,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] static void TestIfElseUsingType (int i) { Type myType; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs b/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs index 068975d4c..6d71c7ad8 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/RuntimeReflectionExtensionsCalls.cs @@ -6,6 +6,7 @@ using Mono.Linker.Tests.Cases.Expectations.Assertions; namespace Mono.Linker.Tests.Cases.Reflection { #pragma warning disable 67 // The event {event} is not used + [ExpectedNoWarnings] public class RuntimeReflectionExtensionsCalls { public static void Main () @@ -19,8 +20,7 @@ namespace Mono.Linker.Tests.Cases.Reflection #region GetRuntimeEvent [Kept] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeEvent), - new Type[] { typeof (Type), typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RuntimeReflectionExtensions) + "." + nameof (RuntimeReflectionExtensions.GetRuntimeEvent))] public static void TestGetRuntimeEvent () { typeof (ClassWithKeptMembers).GetRuntimeEvent ("PublicEvent"); @@ -28,14 +28,13 @@ namespace Mono.Linker.Tests.Cases.Reflection typeof (ClassWithUnkeptMembers).GetRuntimeEvent ("ProtectedEvent"); GetClassWithEvent ().GetRuntimeEvent ("This string will not be reached"); typeof (Derived).GetRuntimeEvent ("Event"); - GetUnknownType ().GetRuntimeEvent (GetUnknownString ()); // UnrecognizedReflectionAccessPattern + GetUnknownType ().GetRuntimeEvent (GetUnknownString ()); // IL2072 } #endregion #region GetRuntimeField [Kept] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeField), - new Type[] { typeof (Type), typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RuntimeReflectionExtensions) + "." + nameof (RuntimeReflectionExtensions.GetRuntimeField))] public static void TestGetRuntimeField () { typeof (ClassWithKeptMembers).GetRuntimeField ("PublicField"); @@ -43,14 +42,13 @@ namespace Mono.Linker.Tests.Cases.Reflection typeof (ClassWithUnkeptMembers).GetRuntimeField ("ProtectedField"); GetClassWithField ().GetRuntimeField ("This string will not be reached"); typeof (Derived).GetRuntimeField ("Field"); - GetUnknownType ().GetRuntimeField (GetUnknownString ()); // UnrecognizedReflectionAccessPattern + GetUnknownType ().GetRuntimeField (GetUnknownString ()); // IL2072 } #endregion #region GetRuntimeMethod [Kept] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeMethod), - new Type[] { typeof (Type), typeof (string), typeof (Type[]) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RuntimeReflectionExtensions) + "." + nameof (RuntimeReflectionExtensions.GetRuntimeMethod))] public static void TestGetRuntimeMethod () { typeof (ClassWithKeptMembers).GetRuntimeMethod ("PublicMethod", Type.EmptyTypes); @@ -58,14 +56,13 @@ namespace Mono.Linker.Tests.Cases.Reflection typeof (ClassWithUnkeptMembers).GetRuntimeMethod ("ProtectedMethod", Type.EmptyTypes); GetClassWithMethod ().GetRuntimeMethod ("This string will not be reached", Type.EmptyTypes); typeof (Derived).GetRuntimeMethod ("Method", Type.EmptyTypes); - GetUnknownType ().GetRuntimeMethod (GetUnknownString (), Type.EmptyTypes); // UnrecognizedReflectionAccessPattern + GetUnknownType ().GetRuntimeMethod (GetUnknownString (), Type.EmptyTypes); // IL2072 } #endregion #region GetRuntimeProperty [Kept] - [UnrecognizedReflectionAccessPattern (typeof (RuntimeReflectionExtensions), nameof (RuntimeReflectionExtensions.GetRuntimeProperty), - new Type[] { typeof (Type), typeof (string) }, messageCode: "IL2072")] + [ExpectedWarning ("IL2072", nameof (RuntimeReflectionExtensions) + "." + nameof (RuntimeReflectionExtensions.GetRuntimeProperty))] public static void TestGetRuntimeProperty () { typeof (ClassWithKeptMembers).GetRuntimeProperty ("PublicProperty"); @@ -73,7 +70,7 @@ namespace Mono.Linker.Tests.Cases.Reflection typeof (ClassWithUnkeptMembers).GetRuntimeProperty ("ProtectedProperty"); GetClassWithProperty ().GetRuntimeProperty ("This string will not be reached"); typeof (Derived).GetRuntimeProperty ("Property"); - GetUnknownType ().GetRuntimeProperty (GetUnknownString ()); // UnrecognizedReflectionAccessPattern + GetUnknownType ().GetRuntimeProperty (GetUnknownString ()); // IL2072 } #endregion diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs index 0f660e6ed..8cab53e83 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflection.cs @@ -47,7 +47,6 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [RecognizedReflectionAccessPattern] public static void TestNull () { const string reflectionTypeKeptString = null; @@ -133,9 +132,6 @@ namespace Mono.Linker.Tests.Cases.Reflection public class AType { } [Kept] - [RecognizedReflectionAccessPattern ( - typeof (Type), nameof (Type.GetType), new Type[] { typeof (string), typeof (bool) }, - typeof (AType), null, (Type[]) null)] public static void TestType () { const string reflectionTypeKeptString = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+AType"; @@ -267,7 +263,7 @@ namespace Mono.Linker.Tests.Cases.Reflection public class CaseInsensitive { } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Boolean, Boolean)'")] static void TestTypeUsingCaseInsensitiveFlag () { const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseInsensitive, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"; @@ -277,7 +273,7 @@ namespace Mono.Linker.Tests.Cases.Reflection public class CaseUnknown { } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Boolean, Boolean)'")] static void TestTypeUsingCaseUnknownByTheLinker () { bool hideCase = GetCase (); @@ -297,7 +293,7 @@ namespace Mono.Linker.Tests.Cases.Reflection public class CaseUnknown2 { } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Boolean, Boolean)'")] static void TestTypeUsingCaseUnknownByTheLinker2 () { const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseUnknown2, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"; @@ -328,7 +324,7 @@ namespace Mono.Linker.Tests.Cases.Reflection public class OverloadWith5ParametersWithIgnoreCase { } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Func<AssemblyName,Assembly>,Func<Assembly,String,Boolean,Type>,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)'")] static void TestTypeOverloadWith5ParametersWithIgnoreCase () { const string reflectionTypeKeptString = "Mono.Linker.Tests.Cases.Reflection.TypeUsedViaReflection+OverloadWith5ParametersWithIgnoreCase"; @@ -361,15 +357,15 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [ExpectedWarning ("IL2026", "'System.Reflection.Assembly.GetType(String,Boolean)'")] - [ExpectedWarning ("IL2057", "'System.Type.GetType(String,Boolean)'")] + [ExpectedWarning ("IL2026", "'System.Reflection.Assembly.GetType(String, Boolean)'")] + [ExpectedWarning ("IL2057", "'System.Type.GetType(String, Boolean)'")] static Type GetTypeFromAssembly (Assembly assembly, string name, bool caseSensitive) { return assembly == null ? Type.GetType (name, caseSensitive) : assembly.GetType (name, caseSensitive); } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Boolean, Boolean)'")] static void TestUnkownIgnoreCase3Params (int num) { const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseUnknown2, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"; @@ -378,7 +374,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - [ExpectedWarning ("IL2096", "'System.Type.GetType(String,Func<AssemblyName,Assembly>,Func<Assembly,String,Boolean,Type>,Boolean,Boolean)'")] + [ExpectedWarning ("IL2096", "'System.Type.GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)'")] static void TestUnkownIgnoreCase5Params (int num) { const string reflectionTypeKeptString = "mono.linker.tests.cases.reflection.TypeUsedViaReflection+CaseUnknown2, test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"; diff --git a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs index ef69a23e7..3f6244c10 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/TypeUsedViaReflectionTypeDoesntExist.cs @@ -5,7 +5,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.Reflection { [SetupCSharpCompilerToUse ("csc")] - [VerifyAllReflectionAccessPatternsAreValidated] + [ExpectedNoWarnings] public class TypeUsedViaReflectionTypeDoesntExist { public static void Main () diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresAttributeMismatch.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresAttributeMismatch.cs index e519cd9c4..1abc164d3 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresAttributeMismatch.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresAttributeMismatch.cs @@ -285,9 +285,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [RequiresUnreferencedCode ("Message")] [RequiresAssemblyFiles ("Message")] [RequiresDynamicCode ("Message")] - [ExpectedWarning ("IL2046", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()")] - [ExpectedWarning ("IL3003", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] - [ExpectedWarning ("IL3051", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + // Linker member string format includes namespace of explicit interface method. + [ExpectedWarning ("IL2046", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2046", "ExplicitImplementationClassWithRequires.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3003", "ExplicitImplementationClassWithRequires.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3051", "IBaseWithoutRequires.Method()", "ExplicitImplementationClassWithRequires.IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] void IBaseWithoutRequires.Method () { } @@ -356,9 +358,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class ExplicitImplementationClassWithoutRequires : IBaseWithRequires { - [ExpectedWarning ("IL2046", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithRequires.Method()")] - [ExpectedWarning ("IL3003", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] - [ExpectedWarning ("IL3051", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + // Linker member string format includes namespace of explicit interface method. + [ExpectedWarning ("IL2046", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresAttributeMismatch.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2046", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3003", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3051", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] void IBaseWithRequires.Method () { } diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityReflectionAnalysisEnabled.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityReflectionAnalysisEnabled.cs index 87b55c757..856c3d4a8 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityReflectionAnalysisEnabled.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityReflectionAnalysisEnabled.cs @@ -8,6 +8,7 @@ using Mono.Linker.Tests.Cases.Expectations.Metadata; namespace Mono.Linker.Tests.Cases.RequiresCapability { + [ExpectedNoWarnings] public class RequiresCapabilityReflectionAnalysisEnabled { [LogContains ("-- DynamicallyAccessedMembersEnabled --")] @@ -24,7 +25,6 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [Kept] [KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute))] [RequiresUnreferencedCode ("-- DynamicallyAccessedMembersEnabled --")] - [RecognizedReflectionAccessPattern] static void TestRequiresAttributeWithDynamicallyAccessedMembersEnabled () { typeof (TypeWithPublicFieldsAccessed).RequiresPublicFields (); @@ -42,7 +42,6 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [Kept] [KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute))] [RequiresUnreferencedCode ("-- ReflectionPattern --")] - [RecognizedReflectionAccessPattern] static void TestRequiresAttributeWithReflectionPattern () { typeof (TypeWithMethodAccessed).GetMethod ("PublicMethod"); @@ -60,7 +59,6 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [Kept] [KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute))] [RequiresUnreferencedCode ("-- DynamicallyAccessedMembersOnGenericsEnabled --")] - [RecognizedReflectionAccessPattern] static void TestRequiresAttributeWithDynamicallyAccessedMembersOnGenericsEnabled () { TypeRequiresPublicFields<TypeWithPublicFieldsForGenericType>.Method (); @@ -104,13 +102,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [Kept] - [ExpectedNoWarnings] class TestRequiresAndDynamicallyAccessedMembers { [Kept] [KeptAttributeAttribute (typeof (RequiresUnreferencedCodeAttribute))] [RequiresUnreferencedCode ("--- RequiresAndPublicMethods ---")] - [RecognizedReflectionAccessPattern] static void RequiresAndPublicMethods ( [KeptAttributeAttribute(typeof(DynamicallyAccessedMembersAttribute))] [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs index 46f519aec..6020f7d86 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs @@ -999,7 +999,6 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability Action _ = () => MethodWithRequires (); } - // The warning is currently not detected by roslyn analyzer since it doesn't analyze DAM yet [ExpectedWarning ("IL2067", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Suppress in body")] [RequiresAssemblyFiles ("Suppress in body")] @@ -1075,7 +1074,8 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability }; } - // The warning is currently not detected by roslyn analyzer since it doesn't analyze DAM yet + // TODO: Fix the discrepancy between linker and analyzer + // https://github.com/dotnet/linker/issues/2350 [ExpectedWarning ("IL2077", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Suppress in body")] [RequiresAssemblyFiles ("Suppress in body")] diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs index 376309f8e..a9174a456 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresOnClass.cs @@ -636,6 +636,8 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability static int privatefield; } + // Analyzer doesn't implement DAM on type hierarchy yet + [ExpectedWarning ("IL2075", ProducedBy = ProducedBy.Analyzer)] static void TestDAMOnTypeAccess (DAMAnnotatedClass instance) { instance.GetType ().GetField ("publicField"); @@ -787,6 +789,8 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } } + // Analyzer doesn't implement DAM on type hierarchy yet + [ExpectedWarning ("IL2075", ProducedBy = ProducedBy.Analyzer)] static void TestDAMOnTypeAccess (DAMAnnotatedClass instance) { instance.GetType ().GetProperty ("publicProperty"); |