diff options
Diffstat (limited to 'test/Mono.Linker.Tests.Cases/Warnings/WarningSuppression/SuppressWarningsInCompilerGeneratedCode.cs')
| -rw-r--r-- | test/Mono.Linker.Tests.Cases/Warnings/WarningSuppression/SuppressWarningsInCompilerGeneratedCode.cs | 481 |
1 files changed, 481 insertions, 0 deletions
diff --git a/test/Mono.Linker.Tests.Cases/Warnings/WarningSuppression/SuppressWarningsInCompilerGeneratedCode.cs b/test/Mono.Linker.Tests.Cases/Warnings/WarningSuppression/SuppressWarningsInCompilerGeneratedCode.cs new file mode 100644 index 000000000..db0172178 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/Warnings/WarningSuppression/SuppressWarningsInCompilerGeneratedCode.cs @@ -0,0 +1,481 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Threading.Tasks; +using Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Helpers; + +namespace Mono.Linker.Tests.Cases.Warnings.WarningSuppression +{ + [SkipKeptItemsValidation] + [ExpectedNoWarnings] + public class SuppressWarningsInCompilerGeneratedCode + { + public static void Main () + { + SuppressInIteratorBody.Test (); + SuppressInAsyncBody.Test (); + SuppressInLocalFunction.Test (); + SuppressInLambda.Test (); + SuppressInComplex.Test (); + } + class SuppressInIteratorBody + { + [UnconditionalSuppressMessage ("Test", "IL2026")] + static IEnumerable<int> TestCallRUCMethod () + { + RequiresUnreferencedCodeMethod (); + yield return 0; + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static IEnumerable<int> TestReflectionAccessRUCMethod () + { + yield return 0; + typeof (SuppressWarningsInCompilerGeneratedCode) + .GetMethod ("RequiresUnreferencedCodeMethod", System.Reflection.BindingFlags.NonPublic) + .Invoke (null, new object[] { }); + yield return 0; + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static IEnumerable<int> TestLdftnOnRUCMethod () + { + yield return 0; + var _ = new Action (RequiresUnreferencedCodeMethod); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static IEnumerable<int> TestDynamicallyAccessedMethod () + { + typeof (TypeWithRUCMethod).RequiresNonPublicMethods (); + yield return 0; + } + + [UnconditionalSuppressMessage ("Test", "IL2077")] + static IEnumerable<int> TestMethodParameterWithRequirements (Type unknownType = null) + { + unknownType.RequiresNonPublicMethods (); + yield return 0; + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static IEnumerable<int> TestGenericMethodParameterRequirement<TUnknown> () + { + MethodWithGenericWhichRequiresMethods<TUnknown> (); + yield return 0; + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static IEnumerable<int> TestGenericTypeParameterRequirement<TUnknown> () + { + new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); + yield return 0; + } + + public static void Test () + { + TestCallRUCMethod (); + TestReflectionAccessRUCMethod (); + TestLdftnOnRUCMethod (); + TestDynamicallyAccessedMethod (); + TestMethodParameterWithRequirements (); + TestGenericMethodParameterRequirement<TestType> (); + TestGenericTypeParameterRequirement<TestType> (); + } + } + + class SuppressInAsyncBody + { + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestCallRUCMethod () + { + RequiresUnreferencedCodeMethod (); + await MethodAsync (); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestReflectionAccessRUCMethod () + { + await MethodAsync (); + typeof (SuppressWarningsInCompilerGeneratedCode) + .GetMethod ("RequiresUnreferencedCodeMethod", System.Reflection.BindingFlags.NonPublic) + .Invoke (null, new object[] { }); + await MethodAsync (); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestLdftnOnRUCMethod () + { + await MethodAsync (); + var _ = new Action (RequiresUnreferencedCodeMethod); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestDynamicallyAccessedMethod () + { + typeof (TypeWithRUCMethod).RequiresNonPublicMethods (); + await MethodAsync (); + } + + [UnconditionalSuppressMessage ("Test", "IL2077")] + static async void TestMethodParameterWithRequirements (Type unknownType = null) + { + unknownType.RequiresNonPublicMethods (); + await MethodAsync (); + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static async void TestGenericMethodParameterRequirement<TUnknown> () + { + MethodWithGenericWhichRequiresMethods<TUnknown> (); + await MethodAsync (); + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static async void TestGenericTypeParameterRequirement<TUnknown> () + { + new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); + await MethodAsync (); + } + + public static void Test () + { + TestCallRUCMethod (); + TestReflectionAccessRUCMethod (); + TestLdftnOnRUCMethod (); + TestDynamicallyAccessedMethod (); + TestMethodParameterWithRequirements (); + TestGenericMethodParameterRequirement<TestType> (); + TestGenericTypeParameterRequirement<TestType> (); + } + } + + class SuppressInLocalFunction + { + // Suppression currently doesn't propagate to local functions + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestCallRUCMethod () + { + LocalFunction (); + + [ExpectedWarning ("IL2026")] + void LocalFunction () => RequiresUnreferencedCodeMethod (); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestReflectionAccessRUCMethod () + { + LocalFunction (); + + [ExpectedWarning ("IL2026")] + void LocalFunction () => typeof (SuppressWarningsInCompilerGeneratedCode) + .GetMethod ("RequiresUnreferencedCodeMethod", System.Reflection.BindingFlags.NonPublic) + .Invoke (null, new object[] { }); + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestLdftnOnRUCMethod () + { + LocalFunction (); + + [ExpectedWarning ("IL2026")] + void LocalFunction () + { var _ = new Action (RequiresUnreferencedCodeMethod); } + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestDynamicallyAccessedMethod () + { + LocalFunction (); + + [ExpectedWarning ("IL2026")] + void LocalFunction () => typeof (TypeWithRUCMethod).RequiresNonPublicMethods (); + } + + [UnconditionalSuppressMessage ("Test", "IL2077")] + static void TestMethodParameterWithRequirements (Type unknownType = null) + { + LocalFunction (); + + [ExpectedWarning ("IL2077")] + void LocalFunction () => unknownType.RequiresNonPublicMethods (); + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static void TestGenericMethodParameterRequirement<TUnknown> () + { + LocalFunction (); + + [ExpectedWarning ("IL2091")] + void LocalFunction () => MethodWithGenericWhichRequiresMethods<TUnknown> (); + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static void TestGenericTypeParameterRequirement<TUnknown> () + { + LocalFunction (); + + [ExpectedWarning ("IL2091")] + void LocalFunction () => new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); + } + + [UnconditionalSuppressMessage ("Test", "IL2091")] + static void TestGenericLocalFunction<TUnknown> () + { + LocalFunction<TUnknown> (); + + void LocalFunction<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] T> () + { + typeof (T).RequiresPublicMethods (); + } + } + + [UnconditionalSuppressMessage ("Test", "IL2087")] + static void TestGenericLocalFunctionInner<TUnknown> () + { + LocalFunction<TUnknown> (); + + [ExpectedWarning ("IL2087")] + void LocalFunction<TSecond> () + { + typeof (TUnknown).RequiresPublicMethods (); + typeof (TSecond).RequiresPublicMethods (); + } + } + + static void TestGenericLocalFunctionWithAnnotations<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TPublicMethods> () + { + LocalFunction<TPublicMethods> (); + + void LocalFunction<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TInnerPublicMethods> () + { + typeof (TPublicMethods).RequiresPublicMethods (); + typeof (TInnerPublicMethods).RequiresPublicMethods (); + } + } + + static void TestGenericLocalFunctionWithAnnotationsAndClosure<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TPublicMethods> (int p = 0) + { + LocalFunction<TPublicMethods> (); + + void LocalFunction<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] TInnerPublicMethods> () + { + p++; + typeof (TPublicMethods).RequiresPublicMethods (); + typeof (TInnerPublicMethods).RequiresPublicMethods (); + } + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestCallRUCMethodInLtftnLocalFunction () + { + var _ = new Action (LocalFunction); + + [ExpectedWarning ("IL2026")] + void LocalFunction () => RequiresUnreferencedCodeMethod (); + } + + class DynamicallyAccessedLocalFunction + { + [UnconditionalSuppressMessage ("Test", "IL2026")] + public static void TestCallRUCMethodInDynamicallyAccessedLocalFunction () + { + typeof (DynamicallyAccessedLocalFunction).RequiresNonPublicMethods (); + + [ExpectedWarning ("IL2026")] + void LocalFunction () => RequiresUnreferencedCodeMethod (); + } + } + + static void TestSuppressionOnLocalFunction () + { + LocalFunction (); + + [UnconditionalSuppressMessage ("Test", "IL2026")] // This supresses the RequiresUnreferencedCodeMethod + void LocalFunction (Type unknownType = null) + { + RequiresUnreferencedCodeMethod (); + } + } + + [UnconditionalSuppressMessage ("Test", "IL2067")] // This suppresses the unknownType.RequiresNonPublicMethods + static void TestSuppressionOnOuterAndLocalFunction () + { + LocalFunction (); + + [ExpectedWarning ("IL2067")] + [UnconditionalSuppressMessage ("Test", "IL2026")] // This supresses the RequiresUnreferencedCodeMethod + void LocalFunction (Type unknownType = null) + { + RequiresUnreferencedCodeMethod (); + unknownType.RequiresNonPublicMethods (); + } + } + + public static void Test () + { + TestCallRUCMethod (); + TestReflectionAccessRUCMethod (); + TestLdftnOnRUCMethod (); + TestDynamicallyAccessedMethod (); + TestMethodParameterWithRequirements (); + TestGenericMethodParameterRequirement<TestType> (); + TestGenericTypeParameterRequirement<TestType> (); + TestGenericLocalFunction<TestType> (); + TestGenericLocalFunctionInner<TestType> (); + TestCallRUCMethodInLtftnLocalFunction (); + DynamicallyAccessedLocalFunction.TestCallRUCMethodInDynamicallyAccessedLocalFunction (); + TestSuppressionOnLocalFunction (); + TestSuppressionOnOuterAndLocalFunction (); + } + } + + class SuppressInLambda + { + // Suppression currently doesn't propagate to local functions + + [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestCallRUCMethod () + { + Action _ = () => RequiresUnreferencedCodeMethod (); + } + + [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestReflectionAccessRUCMethod () + { + Action _ = () => typeof (SuppressWarningsInCompilerGeneratedCode) + .GetMethod ("RequiresUnreferencedCodeMethod", System.Reflection.BindingFlags.NonPublic) + .Invoke (null, new object[] { }); + } + + [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestLdftnOnRUCMethod () + { + Action _ = () => { var _ = new Action (RequiresUnreferencedCodeMethod); }; + } + + [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2026")] + static void TestDynamicallyAccessedMethod () + { + Action _ = () => typeof (TypeWithRUCMethod).RequiresNonPublicMethods (); + } + + [ExpectedWarning ("IL2077", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2077")] + static void TestMethodParameterWithRequirements (Type unknownType = null) + { + Action _ = () => unknownType.RequiresNonPublicMethods (); + } + + [ExpectedWarning ("IL2091", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2091")] + static void TestGenericMethodParameterRequirement<TUnknown> () + { + Action _ = () => MethodWithGenericWhichRequiresMethods<TUnknown> (); + } + + [ExpectedWarning ("IL2091", CompilerGeneratedCode = true)] + [UnconditionalSuppressMessage ("Test", "IL2091")] + static void TestGenericTypeParameterRequirement<TUnknown> () + { + Action _ = () => new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); + } + + public static void Test () + { + TestCallRUCMethod (); + TestReflectionAccessRUCMethod (); + TestLdftnOnRUCMethod (); + TestDynamicallyAccessedMethod (); + TestMethodParameterWithRequirements (); + TestGenericMethodParameterRequirement<TestType> (); + TestGenericTypeParameterRequirement<TestType> (); + } + } + + class SuppressInComplex + { + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestIteratorLocalFunctionInAsync () + { + await MethodAsync (); + LocalFunction (); + await MethodAsync (); + + [UnconditionalSuppressMessage ("Test", "IL2026")] + IEnumerable<int> LocalFunction () + { + yield return 0; + RequiresUnreferencedCodeMethod (); + yield return 1; + } + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static async void TestIteratorLocalFunctionInAsyncWithoutInner () + { + await MethodAsync (); + LocalFunction (); + await MethodAsync (); + + [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + IEnumerable<int> LocalFunction () + { + yield return 0; + RequiresUnreferencedCodeMethod (); + yield return 1; + } + } + + [UnconditionalSuppressMessage ("Test", "IL2026")] + static IEnumerable<int> TestDynamicallyAccessedMethodViaGenericMethodParameterInIterator () + { + MethodWithGenericWhichRequiresMethods<TypeWithRUCMethod> (); + yield return 0; + } + + public static void Test () + { + TestIteratorLocalFunctionInAsync (); + TestIteratorLocalFunctionInAsyncWithoutInner (); + TestDynamicallyAccessedMethodViaGenericMethodParameterInIterator (); + } + } + + static async Task<int> MethodAsync () + { + return await Task.FromResult (0); + } + + [RequiresUnreferencedCode ("--RequiresUnreferencedCodeMethod--")] + static void RequiresUnreferencedCodeMethod () + { + } + + class TypeWithRUCMethod + { + [RequiresUnreferencedCode ("--TypeWithRUCMethod.RequiresUnreferencedCodeMethod--")] + static void RequiresUnreferencedCodeMethod () + { + } + } + + static void MethodWithGenericWhichRequiresMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods)] T> () + { + } + + class TypeWithGenericWhichRequiresNonPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicFields)] T> { } + + class TestType { } + } +} |