Avoid warnings due to RUC on type when marking assembly as library (#84620)

Marking an assembly as "library" will mark all public APIs. If some of the marked members have RUC on them we decided we don't want to produce warnings, since there's nothing especially wrong with the library. The callers of those members would still get the right warnings.

Currently linker implements this correctly for methods and properties, but it fails for fields and events and it still produces some warnings, especially if the RUC is on the parent type.

This change fixes those cases and adds a special test for the library marked assembly in combination with several RUCs.

Fixes #81864

Author: vitek-karas

src/tools/illink/src/linker/Linker.Steps/MarkStep.cs

@@ -1775,9 +1775,19 @@ void ProcessAnalysisAnnotationsForField (FieldDefinition field, DependencyKind d
 					(origin.Provider is MethodDefinition originMethod && CompilerGeneratedState.IsNestedFunctionOrStateMachineMember (originMethod)));
 			}
 
-			if (dependencyKind == DependencyKind.DynamicallyAccessedMemberOnType) {
+			switch (dependencyKind) {
+			// Marked through things like descriptor - don't want to warn as it's intentional choice
+			case DependencyKind.AlreadyMarked:
+			case DependencyKind.TypePreserve:
+			case DependencyKind.PreservedMethod:
+				return;
+
+			case DependencyKind.DynamicallyAccessedMemberOnType:
 				ReportWarningsForTypeHierarchyReflectionAccess (field, origin);
 				return;
+
+			default:
+				break;
 			}
 
 			if (Annotations.ShouldSuppressAnalysisWarningsForRequiresUnreferencedCode (origin.Provider, out _))
@@ -3189,9 +3199,10 @@ protected virtual void ProcessMethod (MethodDefinition method, in DependencyInfo
 				if (!Annotations.ProcessSatelliteAssemblies && KnownMembers.IsSatelliteAssemblyMarker (method))
 					Annotations.ProcessSatelliteAssemblies = true;
 			} else if (method.TryGetProperty (out PropertyDefinition? property))
-				MarkProperty (property, new DependencyInfo (DependencyKind.PropertyOfPropertyMethod, method));
-			else if (method.TryGetEvent (out EventDefinition? @event))
-				MarkEvent (@event, new DependencyInfo (DependencyKind.EventOfEventMethod, method));
+				MarkProperty (property, new DependencyInfo (PropagateDependencyKindToAccessors (reason.Kind, DependencyKind.PropertyOfPropertyMethod), method));
+			else if (method.TryGetEvent (out EventDefinition? @event)) {
+				MarkEvent (@event, new DependencyInfo (PropagateDependencyKindToAccessors(reason.Kind, DependencyKind.EventOfEventMethod), method));
+			}
 
 			if (method.HasMetadataParameters ()) {
 #pragma warning disable RS0030 // MethodReference.Parameters is banned. It's easiest to leave the code as is for now
@@ -3270,6 +3281,20 @@ protected virtual void DoAdditionalMethodProcessing (MethodDefinition method)
 		{
 		}
 
+		static DependencyKind PropagateDependencyKindToAccessors(DependencyKind parentDependencyKind, DependencyKind kind)
+		{
+			switch (parentDependencyKind) {
+			// If the member is marked due to descriptor or similar, propagate the original reason to suppress some warnings correctly
+			case DependencyKind.AlreadyMarked:
+			case DependencyKind.TypePreserve:
+			case DependencyKind.PreservedMethod:
+				return parentDependencyKind;
+
+			default:
+				return kind;
+			}
+		}
+
 		void MarkImplicitlyUsedFields (TypeDefinition type)
 		{
 			if (type?.HasFields != true)
@@ -3506,9 +3531,12 @@ protected internal virtual void MarkEvent (EventDefinition evt, in DependencyInf
 			using var eventScope = ScopeStack.PushScope (new MessageOrigin (evt));
 
 			MarkCustomAttributes (evt, new DependencyInfo (DependencyKind.CustomAttribute, evt));
-			MarkMethodIfNotNull (evt.AddMethod, new DependencyInfo (DependencyKind.EventMethod, evt), ScopeStack.CurrentScope.Origin);
-			MarkMethodIfNotNull (evt.InvokeMethod, new DependencyInfo (DependencyKind.EventMethod, evt), ScopeStack.CurrentScope.Origin);
-			MarkMethodIfNotNull (evt.RemoveMethod, new DependencyInfo (DependencyKind.EventMethod, evt), ScopeStack.CurrentScope.Origin);
+
+			DependencyKind dependencyKind = PropagateDependencyKindToAccessors(reason.Kind, DependencyKind.EventMethod);
+			MarkMethodIfNotNull (evt.AddMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
+			MarkMethodIfNotNull (evt.InvokeMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
+			MarkMethodIfNotNull (evt.RemoveMethod, new DependencyInfo (dependencyKind, evt), ScopeStack.CurrentScope.Origin);
+
 			DoAdditionalEventProcessing (evt);
 		}
 

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/RequiresCapabilityTests.cs

@@ -58,6 +58,12 @@ public Task RequiresInCompilerGeneratedCodeRelease ()
 			return RunTest ();
 		}
 
+		[Fact]
+		public Task RequiresInLibraryAssembly ()
+		{
+			return RunTest ();
+		}
+
 		[Fact]
 		public Task RequiresOnAttribute ()
 		{
@@ -112,4 +118,4 @@ public Task SuppressRequires ()
 			return RunTest (nameof (SuppressRequires));
 		}
 	}
-}
+}

src/tools/illink/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresInLibraryAssembly.cs

@@ -0,0 +1,62 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Mono.Linker.Tests.Cases.Expectations.Assertions;
+using Mono.Linker.Tests.Cases.Expectations.Metadata;
+
+namespace Mono.Linker.Tests.Cases.RequiresCapability
+{
+	[SetupLinkerArgument ("-a", "test.exe", "library")]
+
+	[SkipKeptItemsValidation]
+	[ExpectedNoWarnings]
+	public class RequiresInLibraryAssembly
+	{
+		public static void Main ()
+		{
+		}
+
+		[RequiresDynamicCode ("--MethodWhichRequires--")]
+		public static void MethodWhichRequires () { }
+
+		[RequiresDynamicCode ("--InstanceMethodWhichRequires--")]
+		public void InstanceMethodWhichRequires () { }
+	}
+
+	[ExpectedNoWarnings]
+	public sealed class ClassWithDAMAnnotatedMembers
+	{
+		public static void Method ([DynamicallyAccessedMembers (DynamicallyAccessedMemberTypes.PublicMethods)] Type type) { }
+
+		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
+		public static Type Field;
+	}
+
+	[ExpectedNoWarnings]
+	[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)]
+	public sealed class ClassWithDAMAnnotation
+	{
+		public void Method () { }
+	}
+
+	[ExpectedNoWarnings]
+	[RequiresUnreferencedCode ("--ClassWithRequires--")]
+	public sealed class ClassWithRequires
+	{
+		public static int Field;
+
+		internal static int InternalField;
+
+		private static int PrivateField;
+
+		public static void Method () { }
+
+		public void InstanceMethod () { }
+
+		public static int Property { get; set; }
+
+		public static event EventHandler PropertyChanged;
+	}
+}

src/tools/illink/test/Mono.Linker.Tests.Cases/RequiresCapability/RequiresViaXml.cs

@@ -17,8 +17,6 @@ namespace Mono.Linker.Tests.Cases.RequiresCapability
 	[SetupLinkerDescriptorFile ("RequiresViaXml.descriptor.xml")]
 	[SkipKeptItemsValidation]
 	[ExpectedNoWarnings]
-	// [LogContains ("--RequiresOnlyViaDescriptor--")]  // https://github.com/dotnet/linker/issues/2103
-	[ExpectedWarning ("IL2026", "RequiresOnFieldOnlyViaDescriptor.Field", FileName = "RequiresViaXml.descriptor.xml", ProducedBy = Tool.Trimmer)]
 	class RequiresViaXml
 	{