diff options
Diffstat (limited to 'test/Mono.Linker.Tests.Cases')
16 files changed, 927 insertions, 10 deletions
diff --git a/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.Descriptor.xml b/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.Descriptor.xml new file mode 100644 index 000000000..4fa3f75f9 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.Descriptor.xml @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8" ?> +<linker> + <assembly fullname="test" /> +</linker>
\ No newline at end of file diff --git a/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.cs b/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.cs new file mode 100644 index 000000000..c61f1562a --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/LinkAttributes/Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Mono.Linker.Tests.Cases.LinkAttributes.Dependencies +{ + public static class Used + { + public static void Use () { } + } +} diff --git a/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.LinkAttributes.xml b/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.LinkAttributes.xml new file mode 100644 index 000000000..b28401f8a --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.LinkAttributes.xml @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="utf-8" ?> +<linker> + <assembly fullname="*"> + <type fullname="Mono.Linker.Tests.Cases.LinkAttributes.AttributeToRemoveAttribute"> + <attribute internal="RemoveAttributeInstances"/> + </type> + </assembly> +</linker> diff --git a/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.cs b/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.cs new file mode 100644 index 000000000..1e0e34a17 --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/LinkAttributes/LinkerAttributeRemovalAndPreserveAssembly.cs @@ -0,0 +1,48 @@ +// 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 Mono.Linker.Tests.Cases.Expectations.Assertions; +using Mono.Linker.Tests.Cases.Expectations.Metadata; +using Mono.Linker.Tests.Cases.LinkAttributes.Dependencies; + +namespace Mono.Linker.Tests.Cases.LinkAttributes +{ + [IgnoreDescriptors (false)] + + // The test verifies that removed attributes which are later on kept due to descriptors correctly warn. + // The setup is: + // - test assembly with the AttributeToRemoveAttribute type + // - link attributes.xml which marks the attribute for removal (applied early, in this case via command line, but could be a embedded in the test assembly) + // - the attribute is used by the test assembly + // - another assembly lib.dll is added and is referenced (after the attribute is used/marked) + // - This new assembly has a descriptor which marks the entire test assembly (note that it marks the TEST assembly) + // - This marking causes the warning, as it's an explicit request to keep the attribute which was supposed to be removed + + [SetupLinkAttributesFile ("LinkerAttributeRemovalAndPreserveAssembly.LinkAttributes.xml")] + + [SetupCompileBefore ( + "lib.dll", + new[] { "Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.cs" })] + // https://github.com/dotnet/linker/issues/2358 - adding the descriptor currently causes nullref in the linker + // resources: new object[] { new string[] { "Dependencies/LinkerAttributeRemovalAndPreserveAssembly_Lib.Descriptor.xml", "ILLink.Descriptors.xml" } })] + + [ExpectedNoWarnings] + + class LinkerAttributeRemovalAndPreserveAssembly + { + public static void Main () + { + TestAttributeRemoval (); + } + + [AttributeToRemoveAttribute] + [Kept] + static void TestAttributeRemoval () + { + Used.Use (); + } + } + + public class AttributeToRemoveAttribute : Attribute { } +}
\ No newline at end of file diff --git a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs index ba33cdc4e..5f93cf879 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/EventUsedViaReflection.cs @@ -17,6 +17,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestNameBindingFlags (); TestNameWrongBindingFlags (); TestNameUnknownBindingFlags (BindingFlags.Public); + TestNameUnknownBindingFlagsAndName (BindingFlags.Public, "DoesntMatter"); TestNullName (); TestEmptyName (); TestNonExistingName (); @@ -72,6 +73,13 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + static void TestNameUnknownBindingFlagsAndName (BindingFlags bindingFlags, string name) + { + // Since the binding flags are not known linker should mark all events on the type + var eventInfo = typeof (UnknownBindingFlagsAndName).GetEvent (name, bindingFlags); + } + + [Kept] static void TestNullName () { var eventInfo = typeof (EventUsedViaReflection).GetEvent (null); @@ -221,6 +229,30 @@ namespace Mono.Linker.Tests.Cases.Reflection public event EventHandler<EventArgs> PublicEvent; } + class UnknownBindingFlagsAndName + { + [Kept] + [KeptEventAddMethod] + [KeptEventRemoveMethod] + [method: ExpectBodyModified] + internal event EventHandler<EventArgs> InternalEvent; + [Kept] + [KeptBackingField] + [KeptEventAddMethod] + [KeptEventRemoveMethod] + static event EventHandler<EventArgs> Static; + [Kept] + [KeptEventAddMethod] + [KeptEventRemoveMethod] + [method: ExpectBodyModified] + private event EventHandler<EventArgs> PrivateEvent; + [Kept] + [KeptEventAddMethod] + [KeptEventRemoveMethod] + [method: ExpectBodyModified] + public event EventHandler<EventArgs> PublicEvent; + } + class IfClass { [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs index 7d7fc22d3..94535adb1 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/FieldUsedViaReflection.cs @@ -15,6 +15,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestNameBindingFlags (); TestNameWrongBindingFlags (); TestNameUnknownBindingFlags (BindingFlags.Public); + TestNameUnknownBindingFlagsAndName (BindingFlags.Public, "DoesntMatter"); TestNullName (); TestEmptyName (); TestNonExistingName (); @@ -67,6 +68,13 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + static void TestNameUnknownBindingFlagsAndName (BindingFlags bindingFlags, string name) + { + // Since the binding flags and name are not known linker should mark all fields on the type + var field = typeof (UnknownBindingFlagsAndName).GetField (name, bindingFlags); + } + + [Kept] static void TestNullName () { var field = typeof (FieldUsedViaReflection).GetField (null); @@ -187,6 +195,17 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + private class UnknownBindingFlagsAndName + { + [Kept] + public static int field; + [Kept] + public int nonStatic; + [Kept] + private static int privatefield; + } + + [Kept] private class IfClass { [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs index 18e70c058..bff3994a2 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodUsedViaReflection.cs @@ -17,6 +17,7 @@ namespace Mono.Linker.Tests.Cases.Reflection GetMethod_Name_Types.TestNameAndType (); GetMethod_Name_BindingAttr.TestExplicitBindingFlags (); GetMethod_Name_BindingAttr.TestUnknownBindingFlags (BindingFlags.Public); + GetMethod_Name_BindingAttr.TestUnknownBindingFlagsAndName (BindingFlags.Public, "DoesntMatter"); GetMethod_Name_BindingAttr.TestUnknownNullBindingFlags (BindingFlags.Public); GetMethod_Name_BindingAttr_Binder_Types_Modifiers.TestNameBindingFlagsAndParameterModifier (); GetMethod_Name_BindingAttr_Binder_CallConvention_Types_Modifiers.TestNameBindingFlagsCallingConventionParameterModifier (); @@ -37,6 +38,7 @@ namespace Mono.Linker.Tests.Cases.Reflection DerivedAndBase.TestMethodInBaseType (); IgnoreCaseBindingFlags.TestIgnoreCaseBindingFlags (); FailIgnoreCaseBindingFlags.TestFailIgnoreCaseBindingFlags (); + IgnorableBindingFlags.TestIgnorableBindingFlags (); UnsupportedBindingFlags.TestUnsupportedBindingFlags (); } @@ -200,6 +202,25 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + class UnknownBindingFlagsAndName + { + [Kept] + private static int OnlyCalledViaReflection () + { + return 42; + } + } + + [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 + var method = typeof (UnknownBindingFlagsAndName).GetMethod (name, bindingFlags); + method.Invoke (null, new object[] { }); + } + + [Kept] private class NullBindingFlags { [Kept] @@ -732,6 +753,28 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + class IgnorableBindingFlags + { + [Kept] + public int OnlyCalledViaReflection () + { + return 54; + } + + private bool Unmarked () + { + return true; + } + + [Kept] + public static void TestIgnorableBindingFlags () + { + var method = typeof (IgnorableBindingFlags).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public | BindingFlags.InvokeMethod); + method.Invoke (null, new object[] { }); + } + } + + [Kept] class UnsupportedBindingFlags { [Kept] @@ -741,7 +784,7 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] - private bool MarkedDueToInvokeMethod () + private bool MarkedDueToChangeType () { return true; } @@ -749,7 +792,7 @@ namespace Mono.Linker.Tests.Cases.Reflection [Kept] public static void TestUnsupportedBindingFlags () { - var method = typeof (UnsupportedBindingFlags).GetMethod ("OnlyCalledViaReflection", BindingFlags.InvokeMethod); + var method = typeof (UnsupportedBindingFlags).GetMethod ("OnlyCalledViaReflection", BindingFlags.Public | BindingFlags.SuppressChangeType); method.Invoke (null, new object[] { }); } } diff --git a/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs index 9fdbf389a..5658a1a99 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/MethodsUsedViaReflection.cs @@ -22,6 +22,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestDataFlowWithAnnotation (typeof (MyType)); TestIfElse (1); TestIgnoreCaseBindingFlags (); + TestIgnorableBindingFlags (); TestUnsupportedBindingFlags (); } @@ -100,9 +101,15 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + static void TestIgnorableBindingFlags () + { + var methods = typeof (InvokeMethodClass).GetMethods (BindingFlags.Public | BindingFlags.InvokeMethod); + } + + [Kept] static void TestUnsupportedBindingFlags () { - var methods = typeof (InvokeMethodClass).GetMethods (BindingFlags.InvokeMethod); + var methods = typeof (SuppressChangeTypeClass).GetMethods (BindingFlags.Public | BindingFlags.SuppressChangeType); } [Kept] @@ -287,8 +294,23 @@ namespace Mono.Linker.Tests.Cases.Reflection return 54; } + private bool Unmarked () + { + return true; + } + } + + [Kept] + private class SuppressChangeTypeClass + { + [Kept] + public int OnlyCalledViaReflection () + { + return 54; + } + [Kept] - private bool MarkedDueToInvokeMethod () + private bool MarkedDueToSuppressChangeType () { return true; } diff --git a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs index cda87ee85..2700a8793 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/NestedTypeUsedViaReflection.cs @@ -16,6 +16,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestPrivateByName (); TestByBindingFlags (); TestByUnknownBindingFlags (BindingFlags.Public); + TestByUnknownBindingFlagsAndName (BindingFlags.Public, "DoesntMatter"); TestNonExistingName (); TestNullType (); TestIgnoreCaseBindingFlags (); @@ -81,6 +82,16 @@ 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 + _ = typeof (UnknownBindingFlagsAndName).GetNestedType (name, bindingFlags); + } + + [Kept] static void TestNonExistingName () { _ = typeof (NestedTypeUsedViaReflection).GetNestedType ("NonExisting"); @@ -125,6 +136,16 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + private class UnknownBindingFlagsAndName + { + [Kept] + public static class PublicNestedType { } + + [Kept] + private static class PrivateNestedType { } + } + + [Kept] private class IgnoreCaseClass { [Kept] diff --git a/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs index a7b7dbea8..4f8346b7c 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/PropertiesUsedViaReflection.cs @@ -23,6 +23,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestDataFlowWithAnnotation (typeof (MyType)); TestIfElse (1); TestIgnoreCaseBindingFlags (); + TestIgnorableBindingFlags (); TestUnsupportedBindingFlags (); } @@ -107,9 +108,16 @@ namespace Mono.Linker.Tests.Cases.Reflection [Kept] [RecognizedReflectionAccessPattern] + static void TestIgnorableBindingFlags () + { + var properties = typeof (ExactBindingBindingFlagsClass).GetProperties (BindingFlags.Public | BindingFlags.ExactBinding); + } + + [Kept] + [RecognizedReflectionAccessPattern] static void TestUnsupportedBindingFlags () { - var properties = typeof (ExactBindingBindingFlagsClass).GetProperties (BindingFlags.ExactBinding); + var properties = typeof (ChangeTypeBindingFlagsClass).GetProperties (BindingFlags.Public | BindingFlags.SuppressChangeType); } [Kept] @@ -256,8 +264,22 @@ namespace Mono.Linker.Tests.Cases.Reflection set { _field = value; } } + private static int Unmarked { + get { return _field; } + } + } + + [Kept] + class ChangeTypeBindingFlagsClass + { + [Kept] + public static int SetterOnly { + [Kept] + set { _field = value; } + } + [Kept] - private static int MarkedDueToExactBinding { + private static int KeptDueToChangeType { [Kept] get { return _field; } } diff --git a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs index 3971f9108..4004e894b 100644 --- a/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs +++ b/test/Mono.Linker.Tests.Cases/Reflection/PropertyUsedViaReflection.cs @@ -17,6 +17,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestGetterOnly (); TestBindingFlags (); TestUnknownBindingFlags (BindingFlags.Public); + TestUnknownBindingFlagsAndName (BindingFlags.Public, "IrrelevantName"); TestNullName (); TestEmptyName (); TestNonExistingName (); @@ -27,6 +28,7 @@ namespace Mono.Linker.Tests.Cases.Reflection TestPropertyInBaseType (); TestIgnoreCaseBindingFlags (); TestFailIgnoreCaseBindingFlags (); + TestIgnorableBindingFlags (); TestUnsupportedBindingFlags (); } @@ -90,6 +92,17 @@ 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 + var property = typeof (UnknownBindingFlagsAndName).GetProperty (name, bindingFlags); + property.GetValue (null, new object[] { }); + } + + [Kept] static void TestNullName () { var property = typeof (PropertyUsedViaReflection).GetProperty (null); @@ -194,9 +207,15 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + static void TestIgnorableBindingFlags () + { + var property = typeof (ExactBindingBindingFlagsClass).GetProperty ("SetterOnly", BindingFlags.Public | BindingFlags.ExactBinding); + } + + [Kept] static void TestUnsupportedBindingFlags () { - var property = typeof (ExactBindingBindingFlagsClass).GetProperty ("SetterOnly", BindingFlags.ExactBinding); + var property = typeof (ChangeTypeBindingFlagsClass).GetProperty ("SetterOnly", BindingFlags.Public | BindingFlags.SuppressChangeType); } [Kept] @@ -314,6 +333,18 @@ namespace Mono.Linker.Tests.Cases.Reflection } [Kept] + class UnknownBindingFlagsAndName + { + [Kept] + internal static int SomeProperty { + [Kept] + private get { return _field; } + [Kept] + set { _field = value; } + } + } + + [Kept] class IgnoreCaseBindingFlagsClass { [Kept] @@ -346,8 +377,22 @@ namespace Mono.Linker.Tests.Cases.Reflection set { _field = value; } } + public static int Unmarked { + get { return _field; } + } + } + + [Kept] + class ChangeTypeBindingFlagsClass + { + [Kept] + public static int SetterOnly { + [Kept] + set { _field = value; } + } + [Kept] - public static int MarkedDueToExactBinding { + public static int Marked { [Kept] get { return _field; } } diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/ReferenceInterfaces.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/ReferenceInterfaces.cs new file mode 100644 index 000000000..e30fd271c --- /dev/null +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/ReferenceInterfaces.cs @@ -0,0 +1,44 @@ +// 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.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies +{ + public class ReferenceInterfaces + { + public interface IBaseWithRequiresInReference + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + public void Method (); + + public string PropertyAnnotationInAccesor { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get; + set; + } + + [RequiresAssemblyFiles ("Message")] + public string PropertyAnnotationInProperty { get; set; } + } + + public interface IBaseWithoutRequiresInReference + { + public void Method (); + + public string PropertyAnnotationInAccesor { + get; + set; + } + + public string PropertyAnnotationInProperty { get; set; } + } + } +}
\ No newline at end of file diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/RequiresInCopyAssembly.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/RequiresInCopyAssembly.cs index 74cdff268..c121ff4ef 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/RequiresInCopyAssembly.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/Dependencies/RequiresInCopyAssembly.cs @@ -15,24 +15,29 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies } [RequiresUnreferencedCode ("Message for --Method--")] + [RequiresAssemblyFiles ("Message for --Method--")] public void Method () { } [RequiresUnreferencedCode ("Message for --UncalledMethod--")] + [RequiresAssemblyFiles ("Message for --UncalledMethod--")] public void UncalledMethod () { } [RequiresUnreferencedCode ("Message for --MethodCalledThroughReflection--")] + [RequiresAssemblyFiles ("Message for --MethodCalledThroughReflection--")] static void MethodCalledThroughReflection () { } public int UnusedProperty { [RequiresUnreferencedCode ("Message for --getter UnusedProperty--")] + [RequiresAssemblyFiles ("Message for --getter UnusedProperty--")] get { return 42; } + [RequiresAssemblyFiles ("Message for --setter UnusedProperty--")] [RequiresUnreferencedCode ("Message for --setter UnusedProperty--")] set { } } @@ -40,16 +45,19 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies class UnusedBaseType { [RequiresUnreferencedCode ("Message for --UnusedBaseTypeCctor--")] + [RequiresAssemblyFiles ("Message for --UnusedBaseTypeCctor--")] static UnusedBaseType () { } [RequiresUnreferencedCode ("Message for --UnusedVirtualMethod1--")] + [RequiresAssemblyFiles ("Message for --UnusedVirtualMethod1--")] public virtual void UnusedVirtualMethod1 () { } [RequiresUnreferencedCode ("Message for --UnusedVirtualMethod2--")] + [RequiresAssemblyFiles ("Message for --UnusedVirtualMethod2--")] public virtual void UnusedVirtualMethod2 () { } @@ -58,6 +66,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies class UnusedDerivedType : UnusedBaseType { [RequiresUnreferencedCode ("Message for --UnusedVirtualMethod1--")] + [RequiresAssemblyFiles ("Message for --UnusedVirtualMethod1--")] public override void UnusedVirtualMethod1 () { } @@ -71,12 +80,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies interface IUnusedInterface { [RequiresUnreferencedCode ("Message for --IUnusedInterface.UnusedMethod--")] + [RequiresAssemblyFiles ("Message for --IUnusedInterface.UnusedMethod--")] public void UnusedMethod (); } class UnusedImplementationClass : IUnusedInterface { [RequiresUnreferencedCode ("Message for --UnusedImplementationClass.UnusedMethod--")] + [RequiresAssemblyFiles ("Message for --UnusedImplementationClass.UnusedMethod--")] public void UnusedMethod () { } @@ -85,12 +96,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability.Dependencies public interface IBaseInterface { [RequiresUnreferencedCode ("Message for --IBaseInterface.MethodInBaseInterface--")] + [RequiresAssemblyFiles ("Message for --IBaseInterface.MethodInBaseInterface--")] void MethodInBaseInterface (); } public interface IDerivedInterface : IBaseInterface { [RequiresUnreferencedCode ("Message for --IDerivedInterface.MethodInDerivedInterface--")] + [RequiresAssemblyFiles ("Message for --IDerivedInterface.MethodInDerivedInterface--")] void MethodInDerivedInterface (); } } diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapability.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapability.cs index f7155e5fe..40814d2e6 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapability.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapability.cs @@ -19,6 +19,9 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [SetupLinkerAction ("copy", "lib")] [SetupCompileBefore ("lib.dll", new[] { "Dependencies/RequiresInCopyAssembly.cs" })] [KeptAllTypesAndMembersInAssembly ("lib.dll")] + [SetupLinkerAction ("copy", "lib2")] + [SetupCompileBefore ("lib2.dll", new[] { "Dependencies/ReferenceInterfaces.cs" })] + [KeptAllTypesAndMembersInAssembly ("lib2.dll")] [SetupLinkAttributesFile ("RequiresCapability.attributes.xml")] [SetupLinkerDescriptorFile ("RequiresCapability.descriptor.xml")] [SkipKeptItemsValidation] @@ -82,32 +85,38 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability AccessThroughNewConstraint.TestNewConstraintOnTypeParameter (); AccessThroughNewConstraint.TestNewConstraintOnTypeParameterOfStaticType (); AccessThroughLdToken.Test (); + AttributeMismatch.Test (); RequiresOnClass.Test (); } [ExpectedWarning ("IL2026", "Message for --RequiresWithMessageOnly--.")] + [ExpectedWarning ("IL3002", "Message for --RequiresWithMessageOnly--.", ProducedBy = ProducedBy.Analyzer)] static void TestRequiresWithMessageOnlyOnMethod () { RequiresWithMessageOnly (); } [RequiresUnreferencedCode ("Message for --RequiresWithMessageOnly--")] + [RequiresAssemblyFiles ("Message for --RequiresWithMessageOnly--")] static void RequiresWithMessageOnly () { } [ExpectedWarning ("IL2026", "Message for --RequiresWithMessageAndUrl--.", "https://helpurl")] + [ExpectedWarning ("IL3002", "Message for --RequiresWithMessageAndUrl--.", "https://helpurl", ProducedBy = ProducedBy.Analyzer)] static void TestRequiresWithMessageAndUrlOnMethod () { RequiresWithMessageAndUrl (); } [RequiresUnreferencedCode ("Message for --RequiresWithMessageAndUrl--", Url = "https://helpurl")] + [RequiresAssemblyFiles ("Message for --RequiresWithMessageAndUrl--", Url = "https://helpurl")] static void RequiresWithMessageAndUrl () { } [ExpectedWarning ("IL2026", "Message for --ConstructorRequires--.")] + [ExpectedWarning ("IL3002", "Message for --ConstructorRequires--.", ProducedBy = ProducedBy.Analyzer)] static void TestRequiresOnConstructor () { new ConstructorRequires (); @@ -116,6 +125,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class ConstructorRequires { [RequiresUnreferencedCode ("Message for --ConstructorRequires--")] + [RequiresAssemblyFiles ("Message for --ConstructorRequires--")] public ConstructorRequires () { } @@ -123,6 +133,8 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [ExpectedWarning ("IL2026", "Message for --getter PropertyRequires--.")] [ExpectedWarning ("IL2026", "Message for --setter PropertyRequires--.")] + [ExpectedWarning ("IL3002", "Message for --getter PropertyRequires--.", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3002", "Message for --setter PropertyRequires--.", ProducedBy = ProducedBy.Analyzer)] static void TestRequiresOnPropertyGetterAndSetter () { _ = PropertyRequires; @@ -131,9 +143,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability static int PropertyRequires { [RequiresUnreferencedCode ("Message for --getter PropertyRequires--")] + [RequiresAssemblyFiles ("Message for --getter PropertyRequires--")] get { return 42; } [RequiresUnreferencedCode ("Message for --setter PropertyRequires--")] + [RequiresAssemblyFiles ("Message for --setter PropertyRequires--")] set { } } @@ -144,6 +158,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability static Type GetUnknownType () => null; [RequiresUnreferencedCode ("Message for --MethodWithRequires--")] + [RequiresAssemblyFiles ("Message for --MethodWithRequires--")] static void MethodWithRequires () { } @@ -152,6 +167,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability static Type _requiresPublicConstructors; [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestMethodWithRequires () { // Normally this would warn, but with the attribute on this method it should be auto-suppressed @@ -159,24 +175,28 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestParameter () { _unknownType.RequiresPublicMethods (); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestReturnValue () { GetUnknownType ().RequiresPublicEvents (); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestField () { _requiresPublicConstructors = _unknownType; } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestMethodWithRequires (); @@ -196,36 +216,42 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class GenericTypeRequiresPublicFields<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicFields)] T> { } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestGenericMethod () { GenericMethodRequiresPublicMethods<TUnknown> (); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestGenericMethodMismatch () { GenericMethodRequiresPublicMethods<TPublicProperties> (); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestGenericType () { new GenericTypeRequiresPublicFields<TUnknown> (); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestMakeGenericTypeWithStaticTypes () { typeof (GenericTypeRequiresPublicFields<>).MakeGenericType (typeof (TUnknown)); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestMakeGenericTypeWithDynamicTypes () { typeof (GenericTypeRequiresPublicFields<>).MakeGenericType (_unknownType); } [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static void TestMakeGenericMethod () { typeof (SuppressGenericParameters<TUnknown, TPublicProperties>) @@ -234,6 +260,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestGenericMethod (); @@ -292,6 +319,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class BaseType { [RequiresUnreferencedCode ("Message for --BaseType.VirtualMethodRequires--")] + [RequiresAssemblyFiles ("Message for --BaseType.VirtualMethodRequires--")] public virtual void VirtualMethodRequires () { } @@ -300,12 +328,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class TypeWhichOverridesMethod : BaseType { [RequiresUnreferencedCode ("Message for --TypeWhichOverridesMethod.VirtualMethodRequires--")] + [RequiresAssemblyFiles ("Message for --TypeWhichOverridesMethod.VirtualMethodRequires--")] public override void VirtualMethodRequires () { } } [ExpectedWarning ("IL2026", "--BaseType.VirtualMethodRequires--")] + [ExpectedWarning ("IL3002", "--BaseType.VirtualMethodRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestBaseTypeVirtualMethodRequires () { var tmp = new BaseType (); @@ -314,6 +344,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [LogDoesNotContain ("TypeWhichOverridesMethod.VirtualMethodRequires")] [ExpectedWarning ("IL2026", "--BaseType.VirtualMethodRequires--")] + [ExpectedWarning ("IL3002", "--BaseType.VirtualMethodRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestTypeWhichOverridesMethodVirtualMethodRequires () { var tmp = new TypeWhichOverridesMethod (); @@ -322,6 +353,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [LogDoesNotContain ("TypeWhichOverridesMethod.VirtualMethodRequires")] [ExpectedWarning ("IL2026", "--BaseType.VirtualMethodRequires--")] + [ExpectedWarning ("IL3002", "--BaseType.VirtualMethodRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestTypeWhichOverridesMethodVirtualMethodRequiresOnBase () { BaseType tmp = new TypeWhichOverridesMethod (); @@ -330,19 +362,25 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class PropertyBaseType { - public virtual int VirtualPropertyRequires { [RequiresUnreferencedCode ("Message for --PropertyBaseType.VirtualPropertyRequires--")] get; } + public virtual int VirtualPropertyRequires { + [RequiresUnreferencedCode ("Message for --PropertyBaseType.VirtualPropertyRequires--")] + [RequiresAssemblyFiles ("Message for --PropertyBaseType.VirtualPropertyRequires--")] + get; + } } class TypeWhichOverridesProperty : PropertyBaseType { public override int VirtualPropertyRequires { [RequiresUnreferencedCode ("Message for --TypeWhichOverridesProperty.VirtualPropertyRequires--")] + [RequiresAssemblyFiles ("Message for --TypeWhichOverridesProperty.VirtualPropertyRequires--")] get { return 1; } } } [LogDoesNotContain ("TypeWhichOverridesProperty.VirtualPropertyRequires")] [ExpectedWarning ("IL2026", "--PropertyBaseType.VirtualPropertyRequires--")] + [ExpectedWarning ("IL3002", "--PropertyBaseType.VirtualPropertyRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestTypeWhichOverridesVirtualPropertyRequires () { var tmp = new TypeWhichOverridesProperty (); @@ -382,6 +420,8 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability struct StaticCCtorForFieldAccess { + // TODO: Analyzer still allows RUC/RAF on static constructor with no warning + // https://github.com/dotnet/linker/issues/2347 [ExpectedWarning ("IL2116", "StaticCCtorForFieldAccess..cctor()", ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Message for --StaticCCtorForFieldAccess.cctor--")] static StaticCCtorForFieldAccess () { } @@ -397,9 +437,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class TypeIsBeforeFieldInit { [ExpectedWarning ("IL2026", "Message from --TypeIsBeforeFieldInit.AnnotatedMethod--", ProducedBy = ProducedBy.Analyzer)] + [ExpectedWarning ("IL3002", "Message from --TypeIsBeforeFieldInit.AnnotatedMethod--", ProducedBy = ProducedBy.Analyzer)] public static int field = AnnotatedMethod (); [RequiresUnreferencedCode ("Message from --TypeIsBeforeFieldInit.AnnotatedMethod--")] + [RequiresAssemblyFiles ("Message from --TypeIsBeforeFieldInit.AnnotatedMethod--")] public static int AnnotatedMethod () => 42; } @@ -416,19 +458,24 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class StaticCtorTriggeredByMethodCall { + // TODO: Analyzer still allows RUC/RAF on static constructor with no warning + // https://github.com/dotnet/linker/issues/2347 [ExpectedWarning ("IL2116", "StaticCtorTriggeredByMethodCall..cctor()", ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Message for --StaticCtorTriggeredByMethodCall.Cctor--")] + [RequiresAssemblyFiles ("Message for --StaticCtorTriggeredByMethodCall.Cctor--")] static StaticCtorTriggeredByMethodCall () { } [RequiresUnreferencedCode ("Message for --StaticCtorTriggeredByMethodCall.TriggerStaticCtorMarking--")] + [RequiresAssemblyFiles ("Message for --StaticCtorTriggeredByMethodCall.TriggerStaticCtorMarking--")] public void TriggerStaticCtorMarking () { } } [ExpectedWarning ("IL2026", "--StaticCtorTriggeredByMethodCall.TriggerStaticCtorMarking--")] + [ExpectedWarning ("IL3002", "--StaticCtorTriggeredByMethodCall.TriggerStaticCtorMarking--", ProducedBy = ProducedBy.Analyzer)] static void TestStaticCtorTriggeredByMethodCall () { new StaticCtorTriggeredByMethodCall ().TriggerStaticCtorMarking (); @@ -449,6 +496,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [LogDoesNotContain ("ImplementationClass.MethodWithRequires")] [ExpectedWarning ("IL2026", "--IRequires.MethodWithRequires--")] + [ExpectedWarning ("IL3002", "--IRequires.MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestInterfaceMethodWithRequires () { IRequires inst = new ImplementationClass (); @@ -461,12 +509,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability interface IRequires { [RequiresUnreferencedCode ("Message for --IRequires.MethodWithRequires--")] + [RequiresAssemblyFiles ("Message for --IRequires.MethodWithRequires--")] public void MethodWithRequires (); } class ImplementationClass : IRequires { [RequiresUnreferencedCode ("Message for --ImplementationClass.RequiresMethod--")] + [RequiresAssemblyFiles ("Message for --ImplementationClass.RequiresMethod--")] public void MethodWithRequires () { } @@ -475,12 +525,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability abstract class CovariantReturnBase { [RequiresUnreferencedCode ("Message for --CovariantReturnBase.GetRequires--")] + [RequiresAssemblyFiles ("Message for --CovariantReturnBase.GetRequires--")] public abstract BaseReturnType GetRequires (); } class CovariantReturnDerived : CovariantReturnBase { [RequiresUnreferencedCode ("Message for --CovariantReturnDerived.GetRequires--")] + [RequiresAssemblyFiles ("Message for --CovariantReturnDerived.GetRequires--")] public override DerivedReturnType GetRequires () { return null; @@ -489,6 +541,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [LogDoesNotContain ("--CovariantReturnBase.GetRequires--")] [ExpectedWarning ("IL2026", "--CovariantReturnDerived.GetRequires--")] + [ExpectedWarning ("IL3002", "--CovariantReturnDerived.GetRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestCovariantReturnCallOnDerived () { var tmp = new CovariantReturnDerived (); @@ -496,6 +549,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--Method--")] + [ExpectedWarning ("IL3002", "--Method--", ProducedBy = ProducedBy.Analyzer)] static void TestRequiresInMethodFromCopiedAssembly () { var tmp = new RequiresInCopyAssembly (); @@ -516,11 +570,13 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Message for --RequiresInDynamicDependency--")] + [RequiresAssemblyFiles ("Message for --RequiresInDynamicDependency--")] static void RequiresInDynamicDependency () { } [ExpectedWarning ("IL2026", "--RequiresInDynamicDependency--")] + [ExpectedWarning ("IL3002", "--RequiresInDynamicDependency--", ProducedBy = ProducedBy.Analyzer)] [DynamicDependency ("RequiresInDynamicDependency")] static void TestRequiresInDynamicDependency () { @@ -528,22 +584,27 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Linker adds a trailing period to this message")] + [RequiresAssemblyFiles ("Linker adds a trailing period to this message")] static void WarningMessageWithoutEndingPeriod () { } [ExpectedWarning ("IL2026", "Linker adds a trailing period to this message.")] + [ExpectedWarning ("IL3002", "Linker adds a trailing period to this message.", ProducedBy = ProducedBy.Analyzer)] static void TestThatTrailingPeriodIsAddedToMessage () { WarningMessageWithoutEndingPeriod (); } [RequiresUnreferencedCode ("Linker does not add a period to this message.")] + [RequiresAssemblyFiles ("Linker does not add a period to this message.")] static void WarningMessageEndsWithPeriod () { } + [LogDoesNotContain ("Linker does not add a period to this message..")] [ExpectedWarning ("IL2026", "Linker does not add a period to this message.")] + [ExpectedWarning ("IL3002", "Linker does not add a period to this message.", ProducedBy = ProducedBy.Analyzer)] static void TestThatTrailingPeriodIsNotDuplicatedInWarningMessage () { WarningMessageEndsWithPeriod (); @@ -570,6 +631,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class AttributeWhichRequiresAttribute : Attribute { [RequiresUnreferencedCode ("Message for --AttributeWhichRequiresAttribute.ctor--")] + [RequiresAssemblyFiles ("Message for --AttributeWhichRequiresAttribute.ctor--")] public AttributeWhichRequiresAttribute () { } @@ -585,17 +647,20 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability get => false; [RequiresUnreferencedCode ("--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] + [RequiresAssemblyFiles ("--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] set { } } } [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] class GenericTypeWithAttributedParameter<[AttributeWhichRequires] T> { public static void TestMethod () { } } [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] static void GenericMethodWithAttributedParameter<[AttributeWhichRequires] T> () { } static void TestRequiresOnAttributeOnGenericParameter () @@ -605,7 +670,9 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] [ExpectedWarning ("IL2026", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--", ProducedBy = ProducedBy.Analyzer)] [AttributeWhichRequires] [AttributeWhichRequiresOnProperty (PropertyWhichRequires = true)] class TypeWithAttributeWhichRequires @@ -613,19 +680,25 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] [ExpectedWarning ("IL2026", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--", ProducedBy = ProducedBy.Analyzer)] [AttributeWhichRequires] [AttributeWhichRequiresOnProperty (PropertyWhichRequires = true)] static void MethodWithAttributeWhichRequires () { } [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] [ExpectedWarning ("IL2026", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--", ProducedBy = ProducedBy.Analyzer)] [AttributeWhichRequires] [AttributeWhichRequiresOnProperty (PropertyWhichRequires = true)] static int _fieldWithAttributeWhichRequires; [ExpectedWarning ("IL2026", "--AttributeWhichRequiresAttribute.ctor--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresAttribute.ctor--", ProducedBy = ProducedBy.Analyzer)] [ExpectedWarning ("IL2026", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--")] + [ExpectedWarning ("IL3002", "--AttributeWhichRequiresOnPropertyAttribute.PropertyWhichRequires--", ProducedBy = ProducedBy.Analyzer)] [AttributeWhichRequires] [AttributeWhichRequiresOnProperty (PropertyWhichRequires = true)] static bool PropertyWithAttributeWhichRequires { get; set; } @@ -633,9 +706,11 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [AttributeWhichRequires] [AttributeWhichRequiresOnProperty (PropertyWhichRequires = true)] [RequiresUnreferencedCode ("--MethodWhichRequiresWithAttributeWhichRequires--")] + [RequiresAssemblyFiles ("--MethodWhichRequiresWithAttributeWhichRequires--")] static void MethodWhichRequiresWithAttributeWhichRequires () { } [ExpectedWarning ("IL2026", "--MethodWhichRequiresWithAttributeWhichRequires--")] + [ExpectedWarning ("IL3002", "--MethodWhichRequiresWithAttributeWhichRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestMethodWhichRequiresWithAttributeWhichRequires () { MethodWhichRequiresWithAttributeWhichRequires (); @@ -662,10 +737,12 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class GenericWithStaticMethod<T> { [RequiresUnreferencedCode ("Message for --GenericTypeWithStaticMethodWhichRequires--")] + [RequiresAssemblyFiles ("Message for --GenericTypeWithStaticMethodWhichRequires--")] public static void GenericTypeWithStaticMethodWhichRequires () { } } [ExpectedWarning ("IL2026", "--GenericTypeWithStaticMethodWhichRequires--")] + [ExpectedWarning ("IL3002", "--GenericTypeWithStaticMethodWhichRequires--", ProducedBy = ProducedBy.Analyzer)] public static void GenericTypeWithStaticMethodViaLdftn () { var _ = new Action (GenericWithStaticMethod<TestType>.GenericTypeWithStaticMethodWhichRequires); @@ -682,12 +759,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability abstract class Base { [RequiresUnreferencedCode ("Message for --CovariantReturnViaLdftn.Base.GetRequires--")] + [RequiresAssemblyFiles ("Message for --CovariantReturnViaLdftn.Base.GetRequires--")] public abstract BaseReturnType GetRequires (); } class Derived : Base { [RequiresUnreferencedCode ("Message for --CovariantReturnViaLdftn.Derived.GetRequires--")] + [RequiresAssemblyFiles ("Message for --CovariantReturnViaLdftn.Derived.GetRequires--")] public override DerivedReturnType GetRequires () { return null; @@ -695,6 +774,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--CovariantReturnViaLdftn.Derived.GetRequires--")] + [ExpectedWarning ("IL3002", "--CovariantReturnViaLdftn.Derived.GetRequires--", ProducedBy = ProducedBy.Analyzer)] public static void Test () { var tmp = new Derived (); @@ -748,18 +828,22 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability static event EventHandler EventToTestRemove { add { } [RequiresUnreferencedCode ("Message for --EventToTestRemove.remove--")] + [RequiresAssemblyFiles ("Message for --EventToTestRemove.remove--")] remove { } } [ExpectedWarning ("IL2026", "--EventToTestAdd.add--", ProducedBy = ProducedBy.Trimmer)] static event EventHandler EventToTestAdd { [RequiresUnreferencedCode ("Message for --EventToTestAdd.add--")] + [RequiresAssemblyFiles ("Message for --EventToTestAdd.add--")] add { } remove { } } [ExpectedWarning ("IL2026", "--EventToTestRemove.remove--")] + [ExpectedWarning ("IL3002", "--EventToTestRemove.remove--", ProducedBy = ProducedBy.Analyzer)] [ExpectedWarning ("IL2026", "--EventToTestAdd.add--")] + [ExpectedWarning ("IL3002", "--EventToTestAdd.add--", ProducedBy = ProducedBy.Analyzer)] public static void Test () { EventToTestRemove -= (sender, e) => { }; @@ -772,12 +856,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class NewConstraintTestType { [RequiresUnreferencedCode ("Message for --NewConstraintTestType.ctor--")] + [RequiresAssemblyFiles ("Message for --NewConstraintTestType.ctor--")] public NewConstraintTestType () { } } static void GenericMethod<T> () where T : new() { } [ExpectedWarning ("IL2026", "--NewConstraintTestType.ctor--")] + [ExpectedWarning ("IL3002", "--NewConstraintTestType.ctor--", ProducedBy = ProducedBy.Analyzer)] public static void Test () { GenericMethod<NewConstraintTestType> (); @@ -793,12 +879,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--NewConstraintTestType.ctor--")] + [ExpectedWarning ("IL3002", "--NewConstraintTestType.ctor--", ProducedBy = ProducedBy.Analyzer)] public static void TestNewConstraintOnTypeParameter () { _ = new NewConstaintOnTypeParameter<NewConstraintTestType> (); } [ExpectedWarning ("IL2026", "--NewConstraintTestType.ctor--")] + [ExpectedWarning ("IL3002", "--NewConstraintTestType.ctor--", ProducedBy = ProducedBy.Analyzer)] public static void TestNewConstraintOnTypeParameterOfStaticType () { NewConstraintOnTypeParameterOfStaticType<NewConstraintTestType>.DoNothing (); @@ -809,18 +897,283 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability { static bool PropertyWithLdToken { [RequiresUnreferencedCode ("Message for --PropertyWithLdToken.get--")] + [RequiresAssemblyFiles ("Message for --PropertyWithLdToken.get--")] get { return false; } } [ExpectedWarning ("IL2026", "--PropertyWithLdToken.get--")] + [ExpectedWarning ("IL3002", "--PropertyWithLdToken.get--", ProducedBy = ProducedBy.Analyzer)] public static void Test () { Expression<Func<bool>> getter = () => PropertyWithLdToken; } } + class AttributeMismatch + { + static void RequirePublicMethods ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type type) + { + } + + class BaseClassWithRequires + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + public virtual void VirtualMethod () + { + } + + public virtual string VirtualPropertyAnnotationInAccesor { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get; + set; + } + + [RequiresAssemblyFiles ("Message")] + public virtual string VirtualPropertyAnnotationInProperty { get; set; } + } + + class BaseClassWithoutRequires + { + public virtual void VirtualMethod () + { + } + + public virtual string VirtualPropertyAnnotationInAccesor { get; set; } + + public virtual string VirtualPropertyAnnotationInProperty { get; set; } + } + + class DerivedClassWithRequires : BaseClassWithoutRequires + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL2046", "DerivedClassWithRequires.VirtualMethod()", "BaseClassWithoutRequires.VirtualMethod()")] + [ExpectedWarning ("IL3003", "DerivedClassWithRequires.VirtualMethod()", "BaseClassWithoutRequires.VirtualMethod()", ProducedBy = ProducedBy.Analyzer)] + public override void VirtualMethod () + { + } + + private string name; + public override string VirtualPropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "DerivedClassWithRequires.VirtualPropertyAnnotationInAccesor.get", "BaseClassWithoutRequires.VirtualPropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "DerivedClassWithRequires.VirtualPropertyAnnotationInAccesor.get", "BaseClassWithoutRequires.VirtualPropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get { return name; } + set { name = value; } + } + + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL3003", "DerivedClassWithRequires.VirtualPropertyAnnotationInProperty", "BaseClassWithoutRequires.VirtualPropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + public override string VirtualPropertyAnnotationInProperty { get; set; } + } + + class DerivedClassWithoutRequires : BaseClassWithRequires + { + [ExpectedWarning ("IL2046", "DerivedClassWithoutRequires.VirtualMethod()", "BaseClassWithRequires.VirtualMethod()")] + [ExpectedWarning ("IL3003", "DerivedClassWithoutRequires.VirtualMethod()", "BaseClassWithRequires.VirtualMethod()", ProducedBy = ProducedBy.Analyzer)] + public override void VirtualMethod () + { + } + + private string name; + public override string VirtualPropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "DerivedClassWithoutRequires.VirtualPropertyAnnotationInAccesor.get", "BaseClassWithRequires.VirtualPropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "DerivedClassWithoutRequires.VirtualPropertyAnnotationInAccesor.get", "BaseClassWithRequires.VirtualPropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + get { return name; } + set { name = value; } + } + + [ExpectedWarning ("IL3003", "DerivedClassWithoutRequires.VirtualPropertyAnnotationInProperty", "BaseClassWithRequires.VirtualPropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + public override string VirtualPropertyAnnotationInProperty { get; set; } + } + + public interface IBaseWithRequires + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + void Method (); + + string PropertyAnnotationInAccesor { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get; + set; + } + + [RequiresAssemblyFiles ("Message")] + string PropertyAnnotationInProperty { get; set; } + } + + public interface IBaseWithoutRequires + { + void Method (); + + string PropertyAnnotationInAccesor { get; set; } + + string PropertyAnnotationInProperty { get; set; } + } + + class ImplementationClassWithRequires : IBaseWithoutRequires + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL2046", "ImplementationClassWithRequires.Method()", "IBaseWithoutRequires.Method()")] + [ExpectedWarning ("IL3003", "ImplementationClassWithRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + public void Method () + { + } + + private string name; + public string PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "ImplementationClassWithRequires.PropertyAnnotationInAccesor.get", "IBaseWithoutRequires.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "ImplementationClassWithRequires.PropertyAnnotationInAccesor.get", "IBaseWithoutRequires.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get { return name; } + set { name = value; } + } + + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL3003", "ImplementationClassWithRequires.PropertyAnnotationInProperty", "IBaseWithoutRequires.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + public string PropertyAnnotationInProperty { get; set; } + } + + class ExplicitImplementationClassWithRequires : IBaseWithoutRequires + { + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL2046", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()")] + [ExpectedWarning ("IL3003", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithoutRequires.Method()", "IBaseWithoutRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + void IBaseWithoutRequires.Method () + { + } + + private string name; + string IBaseWithoutRequires.PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "PropertyAnnotationInAccesor.get", "IBaseWithoutRequires.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "PropertyAnnotationInAccesor.get", "IBaseWithoutRequires.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get { return name; } + set { name = value; } + } + + [RequiresAssemblyFiles ("Message")] + [ExpectedWarning ("IL3003", "ExplicitImplementationClassWithRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithoutRequires.PropertyAnnotationInProperty", "IBaseWithoutRequires.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + string IBaseWithoutRequires.PropertyAnnotationInProperty { get; set; } + } + + class ImplementationClassWithoutRequires : IBaseWithRequires + { + [ExpectedWarning ("IL2046", "ImplementationClassWithoutRequires.Method()", "IBaseWithRequires.Method()")] + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequires.Method()", "IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + public void Method () + { + } + + private string name; + public string PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "ImplementationClassWithoutRequires.PropertyAnnotationInAccesor.get", "IBaseWithRequires.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequires.PropertyAnnotationInAccesor.get", "IBaseWithRequires.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + get { return name; } + set { name = value; } + } + + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequires.PropertyAnnotationInProperty", "IBaseWithRequires.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + public string PropertyAnnotationInProperty { get; set; } + } + + class ExplicitImplementationClassWithoutRequires : IBaseWithRequires + { + [ExpectedWarning ("IL2046", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithRequires.Method()")] + [ExpectedWarning ("IL3003", "IBaseWithRequires.Method()", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithRequires.Method()", ProducedBy = ProducedBy.Analyzer)] + void IBaseWithRequires.Method () + { + } + + private string name; + string IBaseWithRequires.PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "PropertyAnnotationInAccesor.get", "IBaseWithRequires.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "PropertyAnnotationInAccesor.get", "IBaseWithRequires.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + get { return name; } + set { name = value; } + } + + [ExpectedWarning ("IL3003", "ExplicitImplementationClassWithoutRequires.Mono.Linker.Tests.Cases.RequiresCapability.RequiresCapability.AttributeMismatch.IBaseWithRequires.PropertyAnnotationInProperty", "IBaseWithRequires.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + string IBaseWithRequires.PropertyAnnotationInProperty { get; set; } + } + + class ImplementationClassWithoutRequiresInSource : ReferenceInterfaces.IBaseWithRequiresInReference + { + [ExpectedWarning ("IL2046", "ImplementationClassWithoutRequiresInSource.Method()", "IBaseWithRequiresInReference.Method()")] + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequiresInSource.Method()", "IBaseWithRequiresInReference.Method()", ProducedBy = ProducedBy.Analyzer)] + public void Method () + { + } + + private string name; + public string PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "ImplementationClassWithoutRequiresInSource.PropertyAnnotationInAccesor.get", "IBaseWithRequiresInReference.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequiresInSource.PropertyAnnotationInAccesor.get", "IBaseWithRequiresInReference.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + get { return name; } + set { name = value; } + } + + [ExpectedWarning ("IL3003", "ImplementationClassWithoutRequiresInSource.PropertyAnnotationInProperty", "IBaseWithRequiresInReference.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + public string PropertyAnnotationInProperty { get; set; } + } + + class ImplementationClassWithRequiresInSource : ReferenceInterfaces.IBaseWithoutRequiresInReference + { + [ExpectedWarning ("IL2046", "ImplementationClassWithRequiresInSource.Method()", "IBaseWithoutRequiresInReference.Method()")] + [ExpectedWarning ("IL3003", "ImplementationClassWithRequiresInSource.Method()", "IBaseWithoutRequiresInReference.Method()", ProducedBy = ProducedBy.Analyzer)] + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + public void Method () + { + } + + private string name; + public string PropertyAnnotationInAccesor { + [ExpectedWarning ("IL2046", "ImplementationClassWithRequiresInSource.PropertyAnnotationInAccesor.get", "IBaseWithoutRequiresInReference.PropertyAnnotationInAccesor.get")] + [ExpectedWarning ("IL3003", "ImplementationClassWithRequiresInSource.PropertyAnnotationInAccesor.get", "IBaseWithoutRequiresInReference.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Analyzer)] + [RequiresUnreferencedCode ("Message")] + [RequiresAssemblyFiles ("Message")] + get { return name; } + set { name = value; } + } + + [ExpectedWarning ("IL3003", "ImplementationClassWithRequiresInSource.PropertyAnnotationInProperty", "IBaseWithoutRequiresInReference.PropertyAnnotationInProperty", ProducedBy = ProducedBy.Analyzer)] + [RequiresAssemblyFiles ("Message")] + public string PropertyAnnotationInProperty { get; set; } + } + + [ExpectedWarning ("IL2026", "BaseClassWithRequires.VirtualPropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", "BaseClassWithRequires.VirtualMethod()", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", "IBaseWithRequires.PropertyAnnotationInAccesor.get", ProducedBy = ProducedBy.Trimmer)] + [ExpectedWarning ("IL2026", "IBaseWithRequires.Method()", ProducedBy = ProducedBy.Trimmer)] + public static void Test () + { + RequirePublicMethods (typeof (BaseClassWithRequires)); + RequirePublicMethods (typeof (BaseClassWithoutRequires)); + RequirePublicMethods (typeof (DerivedClassWithRequires)); + RequirePublicMethods (typeof (DerivedClassWithoutRequires)); + RequirePublicMethods (typeof (IBaseWithRequires)); + RequirePublicMethods (typeof (IBaseWithoutRequires)); + RequirePublicMethods (typeof (ImplementationClassWithRequires)); + RequirePublicMethods (typeof (ImplementationClassWithoutRequires)); + RequirePublicMethods (typeof (ExplicitImplementationClassWithRequires)); + RequirePublicMethods (typeof (ExplicitImplementationClassWithoutRequires)); + RequirePublicMethods (typeof (ImplementationClassWithoutRequiresInSource)); + RequirePublicMethods (typeof (ImplementationClassWithRequiresInSource)); + } + } + class RequiresOnClass { [RequiresUnreferencedCode ("Message for --ClassWithRequires--")] @@ -1572,7 +1925,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability public static int field; // `field` cannot be used as named attribute argument because is static, and if accessed via - // a property the property will be the one generating the warning, but then the warning will + // a property the property will be the one generating the warning, but then the warning will // be suppresed by the Requires on the declaring type public int PropertyOnAttribute { get { return field; } diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityFromCopiedAssembly.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityFromCopiedAssembly.cs index b30833564..6036d7044 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityFromCopiedAssembly.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresCapabilityFromCopiedAssembly.cs @@ -11,6 +11,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [SetupCompileBefore ("lib.dll", new[] { "Dependencies/RequiresInCopyAssembly.cs" })] [KeptAllTypesAndMembersInAssembly ("lib.dll")] [LogDoesNotContain ("IL2026")] + [LogDoesNotContain ("IL3002")] [LogDoesNotContain ("IL2027")] public class RequiresCapabilityFromCopiedAssembly { diff --git a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs index 26777a1a8..0adbae0d6 100644 --- a/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs +++ b/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInCompilerGeneratedCode.cs @@ -44,6 +44,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInIteratorBody { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static IEnumerable<int> TestCallBeforeYieldReturn () { MethodWithRequires (); @@ -51,6 +52,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static IEnumerable<int> TestCallAfterYieldReturn () { yield return 0; @@ -68,6 +70,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static IEnumerable<int> TestLdftn () { yield return 0; @@ -75,6 +78,18 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability var action = new Action (MethodWithRequires); } + // Cannot annotate fields either with RUC nor RAF therefore the warning persists + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static IEnumerable<int> TestLazyDelegate () + { + yield return 0; + yield return 1; + _ = _default.Value; + } + [ExpectedWarning ("IL2026", "--TypeWithMethodWithRequires.MethodWithRequires--", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] static IEnumerable<int> TestDynamicallyAccessedMethod () { @@ -89,6 +104,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallAfterYieldReturn (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); } } @@ -96,6 +112,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class SuppressInIteratorBody { [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestCall () { MethodWithRequires (); @@ -105,6 +122,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestReflectionAccess () { yield return 0; @@ -115,6 +133,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestLdftn () { yield return 0; @@ -122,7 +141,20 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability var action = new Action (MethodWithRequires); } + // Cannot annotate fields either with RUC nor RAF therefore the warning persists + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static IEnumerable<int> TestLazyDelegate () + { + yield return 0; + yield return 1; + _ = _default.Value; + } + [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestDynamicallyAccessedMethod () { typeof (TypeWithMethodWithRequires).RequiresNonPublicMethods (); @@ -131,6 +163,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestMethodParameterWithRequirements (Type unknownType = null) { unknownType.RequiresNonPublicMethods (); @@ -138,6 +171,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestGenericMethodParameterRequirement<TUnknown> () { MethodWithGenericWhichRequiresMethods<TUnknown> (); @@ -145,6 +179,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestGenericTypeParameterRequirement<TUnknown> () { new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); @@ -152,11 +187,13 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestCall (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); TestMethodParameterWithRequirements (); TestGenericMethodParameterRequirement<TestType> (); @@ -167,6 +204,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInAsyncBody { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async void TestCallBeforeYieldReturn () { MethodWithRequires (); @@ -174,6 +212,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async void TestCallAfterYieldReturn () { await MethodAsync (); @@ -191,12 +230,23 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async void TestLdftn () { await MethodAsync (); var action = new Action (MethodWithRequires); } + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static async void TestLazyDelegate () + { + await MethodAsync (); + _ = _default.Value; + } + [ExpectedWarning ("IL2026", "--TypeWithMethodWithRequires.MethodWithRequires--", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] static async void TestDynamicallyAccessedMethod () { @@ -210,6 +260,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallAfterYieldReturn (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); } } @@ -217,6 +268,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class SuppressInAsyncBody { [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestCall () { MethodWithRequires (); @@ -226,6 +278,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestReflectionAccess () { await MethodAsync (); @@ -236,13 +289,26 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestLdftn () { await MethodAsync (); var action = new Action (MethodWithRequires); } + // Cannot annotate fields either with RUC nor RAF therefore the warning persists + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static async void TestLazyDelegate () + { + await MethodAsync (); + _ = _default.Value; + } + [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestDynamicallyAccessedMethod () { typeof (TypeWithMethodWithRequires).RequiresNonPublicMethods (); @@ -250,6 +316,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestMethodParameterWithRequirements (Type unknownType = null) { unknownType.RequiresNonPublicMethods (); @@ -257,6 +324,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestGenericMethodParameterRequirement<TUnknown> () { MethodWithGenericWhichRequiresMethods<TUnknown> (); @@ -264,6 +332,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestGenericTypeParameterRequirement<TUnknown> () { new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); @@ -271,11 +340,13 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestCall (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); TestMethodParameterWithRequirements (); TestGenericMethodParameterRequirement<TestType> (); @@ -286,6 +357,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInAsyncIteratorBody { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async IAsyncEnumerable<int> TestCallBeforeYieldReturn () { await MethodAsync (); @@ -294,6 +366,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async IAsyncEnumerable<int> TestCallAfterYieldReturn () { yield return 0; @@ -314,6 +387,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async IAsyncEnumerable<int> TestLdftn () { await MethodAsync (); @@ -321,6 +395,17 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability var action = new Action (MethodWithRequires); } + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static async IAsyncEnumerable<int> TestLazyDelegate () + { + await MethodAsync (); + yield return 0; + _ = _default.Value; + } + [ExpectedWarning ("IL2026", "--TypeWithMethodWithRequires.MethodWithRequires--", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] static async IAsyncEnumerable<int> TestDynamicallyAccessedMethod () { @@ -335,6 +420,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallAfterYieldReturn (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); } } @@ -342,6 +428,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class SuppressInAsyncIteratorBody { [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestCall () { MethodWithRequires (); @@ -352,6 +439,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestReflectionAccess () { await MethodAsync (); @@ -364,6 +452,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestLdftn () { await MethodAsync (); @@ -371,7 +460,20 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability yield return 0; } + // Cannot annotate fields either with RUC nor RAF therefore the warning persists + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static async IAsyncEnumerable<int> TestLazyDelegate () + { + await MethodAsync (); + yield return 0; + _ = _default.Value; + } + [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestDynamicallyAccessedMethod () { typeof (TypeWithMethodWithRequires).RequiresNonPublicMethods (); @@ -380,6 +482,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestMethodParameterWithRequirements (Type unknownType = null) { unknownType.RequiresNonPublicMethods (); @@ -388,6 +491,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestGenericMethodParameterRequirement<TUnknown> () { yield return 0; @@ -396,6 +500,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async IAsyncEnumerable<int> TestGenericTypeParameterRequirement<TUnknown> () { new TypeWithGenericWhichRequiresNonPublicFields<TUnknown> (); @@ -404,11 +509,13 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestCall (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); TestMethodParameterWithRequirements (); TestGenericMethodParameterRequirement<TestType> (); @@ -419,6 +526,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInLocalFunction { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestCall () { LocalFunction (); @@ -427,6 +535,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestCallWithClosure (int p = 0) { LocalFunction (); @@ -449,6 +558,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestLdftn () { LocalFunction (); @@ -459,6 +569,20 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } } + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static void TestLazyDelegate () + { + LocalFunction (); + + void LocalFunction () + { + _ = _default.Value; + } + } + [ExpectedWarning ("IL2026", "--TypeWithMethodWithRequires.MethodWithRequires--", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] static void TestDynamicallyAccessedMethod () { @@ -473,6 +597,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallWithClosure (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); } } @@ -483,20 +608,24 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability // so its suppression effect also doesn't propagate [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCall () { LocalFunction (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () => MethodWithRequires (); } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCallWithClosure (int p = 0) { LocalFunction (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () { p++; @@ -505,38 +634,59 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestReflectionAccess () { LocalFunction (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () => typeof (RequiresInCompilerGeneratedCode) .GetMethod ("MethodWithRequires", System.Reflection.BindingFlags.NonPublic) .Invoke (null, new object[] { }); } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestLdftn () { LocalFunction (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () { var action = new Action (MethodWithRequires); } } + [ExpectedWarning ("IL2026", "Message from --MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "Message from --MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static void TestLazyDelegate () + { + LocalFunction (); + + void LocalFunction () + { + _ = _default.Value; + } + } + [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestDynamicallyAccessedMethod () { LocalFunction (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () => typeof (TypeWithMethodWithRequires).RequiresNonPublicMethods (); } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestMethodParameterWithRequirements (Type unknownType = null) { LocalFunction (); @@ -546,6 +696,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericMethodParameterRequirement<TUnknown> () { LocalFunction (); @@ -555,6 +706,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericTypeParameterRequirement<TUnknown> () { LocalFunction (); @@ -564,6 +716,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericLocalFunction<TUnknown> () { LocalFunction<TUnknown> (); @@ -575,6 +728,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericLocalFunctionInner<TUnknown> () { LocalFunction<TUnknown> (); @@ -611,22 +765,26 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCallMethodWithRequiresInLtftnLocalFunction () { var _ = new Action (LocalFunction); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () => MethodWithRequires (); } class DynamicallyAccessedLocalFunction { [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] public static void TestCallMethodWithRequiresInDynamicallyAccessedLocalFunction () { typeof (DynamicallyAccessedLocalFunction).RequiresNonPublicMethods (); [ExpectedWarning ("IL2026")] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] void LocalFunction () => MethodWithRequires (); } } @@ -640,6 +798,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability LocalFunction (); // This will produce a warning since the location function has Requires on it [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] void LocalFunction (Type unknownType = null) { MethodWithRequires (); @@ -648,11 +807,13 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestSuppressionOnOuterAndLocalFunction () { LocalFunction (); [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] void LocalFunction (Type unknownType = null) { MethodWithRequires (); @@ -661,12 +822,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestCall (); TestCallWithClosure (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestMethodParameterWithRequirements (); TestDynamicallyAccessedMethod (); TestGenericMethodParameterRequirement<TestType> (); @@ -685,12 +848,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInLambda { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestCall () { Action _ = () => MethodWithRequires (); } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestCallWithClosure (int p = 0) { Action _ = () => { @@ -710,6 +875,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static void TestLdftn () { Action _ = () => { @@ -717,6 +883,17 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability }; } + [ExpectedWarning ("IL2026", "--MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static void TestLazyDelegate () + { + Action _ = () => { + var action = _default.Value; + }; + } + [ExpectedWarning ("IL2026", "--TypeWithMethodWithRequires.MethodWithRequires--", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] static void TestDynamicallyAccessedMethod () { @@ -731,6 +908,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallWithClosure (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); } } @@ -744,7 +922,9 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability // - Would be useful for testing - have to use the CompilerGeneratedCode = true trick instead [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCall () { Action _ = () => MethodWithRequires (); @@ -752,6 +932,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [ExpectedWarning ("IL2067", CompilerGeneratedCode = true)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCallWithReflectionAnalysisWarning () { // This should not produce warning because the Requires @@ -759,7 +940,9 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestCallWithClosure (int p = 0) { Action _ = () => { @@ -771,6 +954,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability // Analyzer doesn't recognize reflection access - so doesn't warn in this case [ExpectedWarning ("IL2026", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestReflectionAccess () { Action _ = () => { @@ -781,7 +965,9 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestLdftn () { Action _ = () => { @@ -789,9 +975,21 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability }; } + [ExpectedWarning ("IL2026", "--MethodWithRequiresAndReturns--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequiresAndReturns--", ProducedBy = ProducedBy.Analyzer)] + public static Lazy<string> _default = new Lazy<string> (MethodWithRequiresAndReturns); + + static void TestLazyDelegate () + { + Action _ = () => { + var action = _default.Value; + }; + } + // Analyzer doesn't apply DAM - so won't see this warnings [ExpectedWarning ("IL2026", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestDynamicallyAccessedMethod () { Action _ = () => { @@ -804,6 +1002,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [ExpectedWarning ("IL2077", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [ExpectedWarning ("IL2067", ProducedBy = ProducedBy.Analyzer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestMethodParameterWithRequirements (Type unknownType = null) { Action _ = () => unknownType.RequiresNonPublicMethods (); @@ -811,6 +1010,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability [ExpectedWarning ("IL2091", CompilerGeneratedCode = true)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericMethodParameterRequirement<TUnknown> () { Action _ = () => { @@ -821,6 +1021,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability // The warning is currently not detected by roslyn analyzer since it doesn't analyze DAM yet [ExpectedWarning ("IL2091", CompilerGeneratedCode = true, ProducedBy = ProducedBy.Trimmer)] [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static void TestGenericTypeParameterRequirement<TUnknown> () { Action _ = () => { @@ -829,6 +1030,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestCall (); @@ -836,6 +1038,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability TestCallWithClosure (); TestReflectionAccess (); TestLdftn (); + TestLazyDelegate (); TestDynamicallyAccessedMethod (); TestMethodParameterWithRequirements (); TestGenericMethodParameterRequirement<TestType> (); @@ -846,6 +1049,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class WarnInComplex { [ExpectedWarning ("IL2026", "--MethodWithRequires--", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", "--MethodWithRequires--", ProducedBy = ProducedBy.Analyzer)] static async void TestIteratorLocalFunctionInAsync () { await MethodAsync (); @@ -877,6 +1081,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class SuppressInComplex { [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestIteratorLocalFunctionInAsync () { await MethodAsync (); @@ -884,6 +1089,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability await MethodAsync (); [RequiresUnreferencedCode ("Suppress in local function")] + [RequiresAssemblyFiles ("Suppress in local function")] IEnumerable<int> LocalFunction () { yield return 0; @@ -893,6 +1099,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static async void TestIteratorLocalFunctionInAsyncWithoutInner () { await MethodAsync (); @@ -900,6 +1107,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability await MethodAsync (); [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] IEnumerable<int> LocalFunction () { yield return 0; @@ -909,6 +1117,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Suppress in body")] + [RequiresAssemblyFiles ("Suppress in body")] static IEnumerable<int> TestDynamicallyAccessedMethodViaGenericMethodParameterInIterator () { MethodWithGenericWhichRequiresMethods<TypeWithMethodWithRequires> (); @@ -916,6 +1125,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [UnconditionalSuppressMessage ("Trimming", "IL2026")] + [UnconditionalSuppressMessage ("SingleFile", "IL3002")] public static void Test () { TestIteratorLocalFunctionInAsync (); @@ -927,6 +1137,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class StateMachinesOnlyReferencedViaReflection { [RequiresUnreferencedCode ("Requires to suppress")] + [RequiresAssemblyFiles ("Requires to suppress")] static IEnumerable<int> TestIteratorOnlyReferencedViaReflectionWhichShouldSuppress () { yield return 0; @@ -934,6 +1145,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("Requires to suppress")] + [RequiresAssemblyFiles ("Requires to suppress")] static async void TestAsyncOnlyReferencedViaReflectionWhichShouldSuppress () { await MethodAsync (); @@ -941,6 +1153,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] static IEnumerable<int> TestIteratorOnlyReferencedViaReflectionWhichShouldWarn () { yield return 0; @@ -948,6 +1161,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", CompilerGeneratedCode = true)] + [ExpectedWarning ("IL3002", ProducedBy = ProducedBy.Analyzer)] static async void TestAsyncOnlyReferencedViaReflectionWhichShouldWarn () { await MethodAsync (); @@ -969,12 +1183,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability public class AsyncBodyCallingMethodWithRequires { [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static Task<object> MethodWithRequiresAsync (Type type) { return Task.FromResult (new object ()); } [RequiresUnreferencedCode ("ParentSuppression")] + [RequiresAssemblyFiles ("ParentSuppression")] static async Task<object> AsyncMethodCallingRequires (Type type) { using (var diposable = await GetDisposableAsync ()) { @@ -983,6 +1199,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "ParentSuppression")] + [ExpectedWarning ("IL3002", "ParentSuppression", ProducedBy = ProducedBy.Analyzer)] public static void Test () { AsyncMethodCallingRequires (typeof (object)); @@ -992,12 +1209,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability public class GenericAsyncBodyCallingMethodWithRequires { [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] static ValueTask<TValue> MethodWithRequiresAsync<TValue> () { return ValueTask.FromResult (default (TValue)); } [RequiresUnreferencedCode ("ParentSuppression")] + [RequiresAssemblyFiles ("ParentSuppression")] static async Task<T> AsyncMethodCallingRequires<T> () { using (var disposable = await GetDisposableAsync ()) { @@ -1006,6 +1225,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "ParentSuppression")] + [ExpectedWarning ("IL3002", "ParentSuppression", ProducedBy = ProducedBy.Analyzer)] public static void Test () { AsyncMethodCallingRequires<object> (); @@ -1017,12 +1237,14 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class RequiresOnCtor { [RequiresUnreferencedCode ("")] + [RequiresAssemblyFiles ("")] public RequiresOnCtor () { } } [RequiresUnreferencedCode ("ParentSuppression")] + [RequiresAssemblyFiles ("ParentSuppression")] static IAsyncEnumerable<TValue> AsyncEnumMethodCallingRequires< [DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicProperties)] TValue> () { @@ -1038,6 +1260,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [ExpectedWarning ("IL2026", "ParentSuppression")] + [ExpectedWarning ("IL3002", "ParentSuppression", ProducedBy = ProducedBy.Analyzer)] public static void Test () { AsyncEnumMethodCallingRequires<object> (); @@ -1055,6 +1278,7 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability } [RequiresUnreferencedCode ("--MethodWithRequires--")] + [RequiresAssemblyFiles ("--MethodWithRequires--")] static void MethodWithRequires () { } @@ -1062,11 +1286,19 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability class TypeWithMethodWithRequires { [RequiresUnreferencedCode ("--TypeWithMethodWithRequires.MethodWithRequires--")] + [RequiresAssemblyFiles ("--TypeWithMethodWithRequires.MethodWithRequires--")] static void MethodWithRequires () { } } + [RequiresUnreferencedCode ("Message from --MethodWithRequiresAndReturns--")] + [RequiresAssemblyFiles ("Message from --MethodWithRequiresAndReturns--")] + public static string MethodWithRequiresAndReturns () + { + return "string"; + } + static void MethodWithGenericWhichRequiresMethods<[DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.NonPublicMethods)] T> () { } |