Annotate more of CoreLib for trimming

src/libraries/System.Private.CoreLib/src/System/Activator.RuntimeType.cs

@@ -100,6 +100,8 @@ public static partial class Activator
 
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2006:UnrecognizedReflectionPattern",
             Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
+            Justification = "Implementation detail of Activator that linker intrinsically recognizes")]
         private static ObjectHandle? CreateInstanceInternal(string assemblyString,
                                                            string typeName,
                                                            bool ignoreCase,
@@ -143,7 +145,7 @@ public static partial class Activator
         }
 
         [System.Runtime.CompilerServices.Intrinsic]
-        public static T CreateInstance<T>()
+        public static T CreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>()
         {
             return (T)((RuntimeType)typeof(T)).CreateInstanceDefaultCtor(publicOnly: true, skipCheckThis: true, fillCache: true, wrapExceptions: true)!;
         }

src/libraries/System.Private.CoreLib/src/System/Lazy.cs

@@ -153,7 +153,7 @@ internal static LazyHelper Create(LazyThreadSafetyMode mode, bool useDefaultCons
             }
         }
 
-        internal static T CreateViaDefaultConstructor<T>()
+        internal static T CreateViaDefaultConstructor<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>()
         {
             try
             {
@@ -184,7 +184,7 @@ internal static LazyThreadSafetyMode GetModeFromIsThreadSafe(bool isThreadSafe)
     /// </remarks>
     [DebuggerTypeProxy(typeof(LazyDebugView<>))]
     [DebuggerDisplay("ThreadSafetyMode={Mode}, IsValueCreated={IsValueCreated}, IsValueFaulted={IsValueFaulted}, Value={ValueForDebugDisplay}")]
-    public class Lazy<T>
+    public class Lazy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>
     {
         private static T CreateViaDefaultConstructor() => LazyHelper.CreateViaDefaultConstructor<T>();
 

src/libraries/System.Private.CoreLib/src/System/LazyOfTTMetadata.cs

@@ -2,11 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 
 namespace System
 {
-    public class Lazy<T, TMetadata> : Lazy<T>
+    public class Lazy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T, TMetadata> : Lazy<T>
     {
         private readonly TMetadata _metadata;
 

src/libraries/System.Private.CoreLib/src/System/Reflection/Assembly.cs

@@ -25,6 +25,7 @@ protected Assembly() { }
 
         public virtual IEnumerable<TypeInfo> DefinedTypes
         {
+            [RequiresUnreferencedCode("Types might be removed")]
             get
             {
                 Type[] types = GetTypes();
@@ -41,6 +42,7 @@ public virtual IEnumerable<TypeInfo> DefinedTypes
             }
         }
 
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type[] GetTypes()
         {
             Module[] m = GetModules(false);
@@ -70,8 +72,14 @@ public virtual Type[] GetTypes()
             return ret;
         }
 
-        public virtual IEnumerable<Type> ExportedTypes => GetExportedTypes();
+        public virtual IEnumerable<Type> ExportedTypes
+        {
+            [RequiresUnreferencedCode("Types might be removed")]
+            get => GetExportedTypes();
+        }
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type[] GetExportedTypes() { throw NotImplemented.ByDesign; }
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type[] GetForwardedTypes() { throw NotImplemented.ByDesign; }
 
         public virtual string? CodeBase => throw NotImplemented.ByDesign;
@@ -93,8 +101,11 @@ public virtual Type[] GetTypes()
         public virtual AssemblyName GetName() => GetName(copiedName: false);
         public virtual AssemblyName GetName(bool copiedName) { throw NotImplemented.ByDesign; }
 
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type? GetType(string name) => GetType(name, throwOnError: false, ignoreCase: false);
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type? GetType(string name, bool throwOnError) => GetType(name, throwOnError: throwOnError, ignoreCase: false);
+        [RequiresUnreferencedCode("Types might be removed")]
         public virtual Type? GetType(string name, bool throwOnError, bool ignoreCase) { throw NotImplemented.ByDesign; }
 
         public virtual bool IsDefined(Type attributeType, bool inherit) { throw NotImplemented.ByDesign; }
@@ -135,6 +146,7 @@ public virtual Type[] GetTypes()
         public Module[] GetLoadedModules() => GetLoadedModules(getResourceModules: false);
         public virtual Module[] GetLoadedModules(bool getResourceModules) { throw NotImplemented.ByDesign; }
 
+        [RequiresUnreferencedCode("Assembly references might be removed")]
         public virtual AssemblyName[] GetReferencedAssemblies() { throw NotImplemented.ByDesign; }
 
         public virtual Assembly GetSatelliteAssembly(CultureInfo culture) { throw NotImplemented.ByDesign; }

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/AsyncMethodBuilderCore.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Tracing;
 using System.Reflection;
 using System.Threading;
@@ -92,6 +93,8 @@ internal static bool TrackAsyncMethodCompletion
         /// <summary>Gets a description of the state of the state machine object, suitable for debug purposes.</summary>
         /// <param name="stateMachine">The state machine object.</param>
         /// <returns>A description of the state machine.</returns>
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2006:UnrecognizedReflectionPattern",
+            Justification = "It's okay if unused fields disappear from debug views")]
         internal static string GetAsyncStateMachineDescription(IAsyncStateMachine stateMachine)
         {
             Debug.Assert(stateMachine != null);

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConditionalWeakTable.cs

@@ -11,7 +11,7 @@
 
 namespace System.Runtime.CompilerServices
 {
-    public sealed class ConditionalWeakTable<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
+    public sealed class ConditionalWeakTable<TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
         where TKey : class
         where TValue : class?
     {

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.cs

@@ -574,7 +574,7 @@ public static void PtrToStructure<T>(IntPtr ptr, [DisallowNull] T structure)
         }
 
         [return: MaybeNull]
-        public static T PtrToStructure<T>(IntPtr ptr) => (T)PtrToStructure(ptr, typeof(T))!;
+        public static T PtrToStructure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>(IntPtr ptr) => (T)PtrToStructure(ptr, typeof(T))!;
 
         public static void DestroyStructure<T>(IntPtr ptr) => DestroyStructure(ptr, typeof(T));
 

src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs

@@ -710,6 +710,8 @@ private static void OnAssemblyLoad(RuntimeAssembly assembly)
         }
 #endif // !CORERT
 
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
+            Justification = "Satellite assemblies have no code in them and loading is not a problem")]
         private Assembly? ResolveSatelliteAssembly(AssemblyName assemblyName)
         {
             // Called by native runtime when CultureName is not empty

src/libraries/System.Private.CoreLib/src/System/RuntimeType.cs

@@ -72,6 +72,7 @@ public override IList<CustomAttributeData> GetCustomAttributesData()
 
         // GetDefaultMembers
         // This will return a MemberInfo that has been marked with the [DefaultMemberAttribute]
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
         public override MemberInfo[] GetDefaultMembers()
         {
             // See if we have cached the default member name

src/libraries/System.Private.CoreLib/src/System/Threading/LazyInitializer.cs

@@ -48,7 +48,7 @@ public static class LazyInitializer
         /// if an object was not used and to then dispose of the object appropriately.
         /// </para>
         /// </remarks>
-        public static T EnsureInitialized<T>([NotNull] ref T? target) where T : class =>
+        public static T EnsureInitialized<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>([NotNull] ref T? target) where T : class =>
             Volatile.Read(ref target!) ?? EnsureInitializedCore(ref target);
 
         /// <summary>
@@ -57,7 +57,7 @@ public static T EnsureInitialized<T>([NotNull] ref T? target) where T : class =>
         /// <typeparam name="T">The reference type of the reference to be initialized.</typeparam>
         /// <param name="target">The variable that need to be initialized</param>
         /// <returns>The initialized variable</returns>
-        private static T EnsureInitializedCore<T>([NotNull] ref T? target) where T : class
+        private static T EnsureInitializedCore<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>([NotNull] ref T? target) where T : class
         {
             try
             {
@@ -136,7 +136,7 @@ private static T EnsureInitializedCore<T>([NotNull] ref T? target, Func<T> value
         /// <paramref name="target"/>. If <paramref name="syncLock"/> is null, and if the target hasn't already
         /// been initialized, a new object will be instantiated.</param>
         /// <returns>The initialized value of type <typeparamref name="T"/>.</returns>
-        public static T EnsureInitialized<T>([AllowNull] ref T target, ref bool initialized, [NotNullIfNotNull("syncLock")] ref object? syncLock)
+        public static T EnsureInitialized<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>([AllowNull] ref T target, ref bool initialized, [NotNullIfNotNull("syncLock")] ref object? syncLock)
         {
             // Fast path.
             if (Volatile.Read(ref initialized))
@@ -158,7 +158,7 @@ public static T EnsureInitialized<T>([AllowNull] ref T target, ref bool initiali
         /// a new object will be instantiated.
         /// </param>
         /// <returns>The initialized object.</returns>
-        private static T EnsureInitializedCore<T>([AllowNull] ref T target, ref bool initialized, [NotNull] ref object? syncLock)
+        private static T EnsureInitializedCore<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]T>([AllowNull] ref T target, ref bool initialized, [NotNull] ref object? syncLock)
         {
             // Lazily initialize the lock if necessary and then double check if initialization is still required.
             lock (EnsureLockInitialized(ref syncLock))

src/libraries/System.Private.CoreLib/src/System/Type.cs

@@ -339,6 +339,7 @@ public ConstructorInfo? TypeInitializer
         [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
         public abstract PropertyInfo[] GetProperties(BindingFlags bindingAttr);
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
         public virtual MemberInfo[] GetDefaultMembers() => throw NotImplemented.ByDesign;
 
         public virtual RuntimeTypeHandle TypeHandle => throw new NotSupportedException();

src/libraries/System.Runtime/ref/System.Runtime.cs

@@ -4125,6 +4125,7 @@ protected Type() { }
         public System.Reflection.ConstructorInfo[] GetConstructors() { throw null; }
         [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)]
         public abstract System.Reflection.ConstructorInfo[] GetConstructors(System.Reflection.BindingFlags bindingAttr);
+        [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)]
         public virtual System.Reflection.MemberInfo[] GetDefaultMembers() { throw null; }
         public abstract System.Type? GetElementType();
         public virtual string? GetEnumName(object value) { throw null; }
@@ -7499,10 +7500,10 @@ public abstract partial class Assembly : System.Reflection.ICustomAttributeProvi
         protected Assembly() { }
         public virtual string? CodeBase { get { throw null; } }
         public virtual System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData> CustomAttributes { get { throw null; } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.TypeInfo> DefinedTypes { get { throw null; } }
+        public virtual System.Collections.Generic.IEnumerable<System.Reflection.TypeInfo> DefinedTypes { [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")] get { throw null; } }
         public virtual System.Reflection.MethodInfo? EntryPoint { get { throw null; } }
         public virtual string EscapedCodeBase { get { throw null; } }
-        public virtual System.Collections.Generic.IEnumerable<System.Type> ExportedTypes { get { throw null; } }
+        public virtual System.Collections.Generic.IEnumerable<System.Type> ExportedTypes { [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")] get { throw null; } }
         public virtual string? FullName { get { throw null; } }
         public virtual bool GlobalAssemblyCache { get { throw null; } }
         public virtual long HostContext { get { throw null; } }
@@ -7531,10 +7532,12 @@ public virtual event System.Reflection.ModuleResolveEventHandler? ModuleResolve
         public virtual System.Collections.Generic.IList<System.Reflection.CustomAttributeData> GetCustomAttributesData() { throw null; }
         public static System.Reflection.Assembly? GetEntryAssembly() { throw null; }
         public static System.Reflection.Assembly GetExecutingAssembly() { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type[] GetExportedTypes() { throw null; }
         public virtual System.IO.FileStream? GetFile(string name) { throw null; }
         public virtual System.IO.FileStream[] GetFiles() { throw null; }
         public virtual System.IO.FileStream[] GetFiles(bool getResourceModules) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type[] GetForwardedTypes() { throw null; }
         public override int GetHashCode() { throw null; }
         public System.Reflection.Module[] GetLoadedModules() { throw null; }
@@ -7549,12 +7552,17 @@ public virtual event System.Reflection.ModuleResolveEventHandler? ModuleResolve
         public virtual System.Reflection.AssemblyName GetName() { throw null; }
         public virtual System.Reflection.AssemblyName GetName(bool copiedName) { throw null; }
         public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Assembly references might be removed")]
         public virtual System.Reflection.AssemblyName[] GetReferencedAssemblies() { throw null; }
         public virtual System.Reflection.Assembly GetSatelliteAssembly(System.Globalization.CultureInfo culture) { throw null; }
         public virtual System.Reflection.Assembly GetSatelliteAssembly(System.Globalization.CultureInfo culture, System.Version? version) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type? GetType(string name) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type? GetType(string name, bool throwOnError) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type? GetType(string name, bool throwOnError, bool ignoreCase) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types might be removed")]
         public virtual System.Type[] GetTypes() { throw null; }
         public virtual bool IsDefined(System.Type attributeType, bool inherit) { throw null; }
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Types and members the loaded assembly depends on might be removed")]

src/mono/netcore/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs

@@ -21,6 +21,7 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
+using System.Diagnostics.CodeAnalysis;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
@@ -106,6 +107,7 @@ bool IsResource()
             return is_resource;
         }
 
+        [RequiresUnreferencedCode("Types might be removed")]
         public override
         Type[] FindTypes(TypeFilter? filter, object? filterCriteria)
         {
@@ -128,6 +130,7 @@ object[] GetCustomAttributes(Type attributeType, bool inherit)
             return CustomAttribute.GetCustomAttributes(this, attributeType, inherit);
         }
 
+        [RequiresUnreferencedCode("Fields might be removed")]
         public override
         FieldInfo? GetField(string name, BindingFlags bindingAttr)
         {
@@ -141,6 +144,7 @@ public override
             return globalType?.GetField(name, bindingAttr);
         }
 
+        [RequiresUnreferencedCode("Fields might be removed")]
         public override
         FieldInfo[] GetFields(BindingFlags bindingFlags)
         {
@@ -160,6 +164,7 @@ int MetadataToken
             }
         }
 
+        [RequiresUnreferencedCode("Methods might be removed")]
         protected
         override
         MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
@@ -175,6 +180,7 @@ int MetadataToken
             return globalType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
         }
 
+        [RequiresUnreferencedCode("Methods might be removed")]
         public
         override
         MethodInfo[] GetMethods(BindingFlags bindingFlags)

src/mono/netcore/System.Private.CoreLib/src/System/RuntimeType.Mono.cs

@@ -153,6 +153,7 @@ public void Add(T item)
 
         #region Internal
 
+        [RequiresUnreferencedCode("Types might be removed")]
         internal static RuntimeType? GetType(string typeName, bool throwOnError, bool ignoreCase, bool reflectionOnly,
             ref StackCrawlMark stackMark)
         {
@@ -800,11 +801,13 @@ public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
 
         #endregion
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
         protected override MethodInfo? GetMethodImpl(string name, BindingFlags bindingAttr, Binder? binder, CallingConventions callConvention, Type[]? types, ParameterModifier[]? modifiers)
         {
             return GetMethodImpl(name, -1, bindingAttr, binder, callConvention, types, modifiers);
         }
 
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
         protected override MethodInfo? GetMethodImpl(string name, int genericParamCount,
             BindingFlags bindingAttr, Binder? binder, CallingConventions callConv,
             Type[]? types, ParameterModifier[]? modifiers)

src/mono/netcore/System.Private.CoreLib/src/System/RuntimeTypeHandle.cs

@@ -283,6 +283,7 @@ internal static bool IsTypeDefinition(RuntimeType type)
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         private static extern RuntimeType internal_from_name(string name, ref StackCrawlMark stackMark, Assembly? callerAssembly, bool throwOnError, bool ignoreCase, bool reflectionOnly);
 
+        [RequiresUnreferencedCode("Types might be removed")]
         internal static RuntimeType? GetTypeByName(string typeName, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark,
                                                   bool loadTypeFromPartialName)
         {