Phase 2a: Hot path items annotated.

Author: tillig

src/Autofac/Builder/ConcreteReflectionActivatorData.cs

@@ -3,6 +3,7 @@
 
 using Autofac.Core;
 using Autofac.Core.Activators.Reflection;
+using Autofac.Util;
 
 namespace Autofac.Builder;
 
@@ -15,7 +16,7 @@ public class ConcreteReflectionActivatorData : ReflectionActivatorData, IConcret
     /// Initializes a new instance of the <see cref="ConcreteReflectionActivatorData"/> class.
     /// </summary>
     /// <param name="implementer">Type that will be activated.</param>
-    public ConcreteReflectionActivatorData(Type implementer)
+    public ConcreteReflectionActivatorData([DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementer)
         : base(implementer)
     {
     }

src/Autofac/Builder/ReflectionActivatorData.cs

@@ -3,6 +3,7 @@
 
 using Autofac.Core;
 using Autofac.Core.Activators.Reflection;
+using Autofac.Util;
 
 namespace Autofac.Builder;
 
@@ -14,6 +15,7 @@ public class ReflectionActivatorData
     private static readonly IConstructorFinder _defaultConstructorFinder = new DefaultConstructorFinder();
     private static readonly IConstructorSelector _defaultConstructorSelector = new MostParametersConstructorSelector();
 
+    [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)]
     private Type _implementer = default!;
     private IConstructorFinder _constructorFinder;
     private IConstructorSelector _constructorSelector;
@@ -22,7 +24,7 @@ public class ReflectionActivatorData
     /// Initializes a new instance of the <see cref="ReflectionActivatorData"/> class.
     /// </summary>
     /// <param name="implementer">Type that will be activated.</param>
-    public ReflectionActivatorData(Type implementer)
+    public ReflectionActivatorData([DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementer)
     {
         ImplementationType = implementer;
 
@@ -33,6 +35,7 @@ public ReflectionActivatorData(Type implementer)
     /// <summary>
     /// Gets or sets the implementation type.
     /// </summary>
+    [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)]
     public Type ImplementationType
     {
         get

src/Autofac/Builder/RegistrationBuilder.cs

@@ -59,7 +59,7 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
     /// </summary>
     /// <typeparam name="TImplementer">Implementation type to register.</typeparam>
     /// <returns>A registration builder.</returns>
-    public static IRegistrationBuilder<TImplementer, ConcreteReflectionActivatorData, SingleRegistrationStyle> ForType<TImplementer>()
+    public static IRegistrationBuilder<TImplementer, ConcreteReflectionActivatorData, SingleRegistrationStyle> ForType<[DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] TImplementer>()
         where TImplementer : notnull
     {
         // Open generics can't be generic type parameters so we don't have to check for that here.
@@ -79,7 +79,7 @@ public static IRegistrationBuilder<TImplementer, ConcreteReflectionActivatorData
     /// </summary>
     /// <param name="implementationType">Implementation type to register.</param>
     /// <returns>A registration builder.</returns>
-    public static IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> ForType(Type implementationType)
+    public static IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> ForType([DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementationType)
     {
         if (implementationType is null)
         {

src/Autofac/Core/Activators/Reflection/ReflectionActivator.cs

@@ -15,6 +15,7 @@ namespace Autofac.Core.Activators.Reflection;
 /// </summary>
 public class ReflectionActivator : InstanceActivator, IInstanceActivator
 {
+    [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)]
     private readonly Type _implementationType;
     private readonly Parameter[] _configuredProperties;
     private readonly Parameter[] _defaultParameters;
@@ -33,7 +34,7 @@ public class ReflectionActivator : InstanceActivator, IInstanceActivator
     /// <param name="configuredParameters">Parameters configured explicitly for this instance.</param>
     /// <param name="configuredProperties">Properties configured explicitly for this instance.</param>
     public ReflectionActivator(
-        Type implementationType,
+        [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementationType,
         IConstructorFinder constructorFinder,
         IConstructorSelector constructorSelector,
         IEnumerable<Parameter> configuredParameters,
@@ -51,9 +52,14 @@ public ReflectionActivator(
         }
 
         _implementationType = implementationType;
+
+        // The cache key is the (already annotated) implementation type; the factory
+        // ignores the dictionary's unannotated key parameter and reads the annotated
+        // local instead, so the [DynamicallyAccessedMembers] contract flows correctly
+        // into UsesServiceKeyAttribute.
         _requiresServiceKeyParameter = ReflectionCacheSet.Shared.Internal.ServiceKeyUsageByType.GetOrAdd(
             _implementationType,
-            static t => UsesServiceKeyAttribute(t));
+            _ => UsesServiceKeyAttribute(implementationType));
         ConstructorFinder = constructorFinder ?? throw new ArgumentNullException(nameof(constructorFinder));
         ConstructorSelector = constructorSelector ?? throw new ArgumentNullException(nameof(constructorSelector));
         _configuredProperties = configuredProperties.ToArray();
@@ -123,7 +129,11 @@ public void ConfigurePipeline(IComponentRegistryServices componentRegistryServic
     /// </summary>
     /// <param name="implementationType">The type to inspect.</param>
     /// <returns><see langword="true"/> if the type uses the <see cref="ServiceKeyAttribute"/>; otherwise, <see langword="false"/>.</returns>
-    private static bool UsesServiceKeyAttribute(Type implementationType)
+    [UnconditionalSuppressMessage(
+        "Trimming",
+        "IL2070:UnrecognizedReflectionPattern",
+        Justification = "This is a best-effort scan for [ServiceKey] across all constructors and properties, including non-public ones. Autofac's trim/AOT contract preserves only public constructors and properties (see ActivatorMemberTypes); if a non-public member is trimmed away, it simply is not found here, which matches the documented behavior that non-public activation is not trim/AOT-safe. No public member that drives activation is missed.")]
+    private static bool UsesServiceKeyAttribute([DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementationType)
     {
         // Intentionally not picky about _which_ constructor or property has the
         // attribute. If a different constructor is picked via constructor
@@ -347,6 +357,10 @@ private bool HasAnyRequiredMembers()
             });
     }
 
+    [UnconditionalSuppressMessage(
+        "Trimming",
+        "IL2077:UnrecognizedReflectionPattern",
+        Justification = "GetRuntimeProperties enumerates non-public properties as well, but Autofac's trim/AOT contract preserves only public properties (see ActivatorMemberTypes). The injectable set is filtered down to required members and explicitly-configured properties; non-public properties that the trimmer removes are not part of the supported (public) property-injection surface.")]
     private void InitializeInjectablePropertySet()
     {
         if (!_anyRequiredMembers && _configuredProperties.Length == 0)

src/Autofac/Core/Resolving/Pipeline/ResolvePipelineBuilder.cs

@@ -390,9 +390,14 @@ private void VerifyPhase(PipelinePhase middlewarePhase)
     {
         static string DescribeValidEnumRange(PipelinePhase start, PipelinePhase end)
         {
+#if NET5_0_OR_GREATER
+            var enumValues = Enum.GetValues<PipelinePhase>()
+                                 .Where(value => value >= start && value <= end);
+#else
             var enumValues = Enum.GetValues(typeof(PipelinePhase))
                                  .Cast<PipelinePhase>()
                                  .Where(value => value >= start && value <= end);
+#endif
 
             return string.Join(", ", enumValues);
         }

src/Autofac/Diagnostics/DiagnosticSourceExtensions.cs

@@ -22,7 +22,7 @@ public static void MiddlewareStart(this DiagnosticListener diagnosticSource, Res
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.MiddlewareStart))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.MiddlewareStart, new MiddlewareDiagnosticData(requestContext, middleware));
+            Write(diagnosticSource, DiagnosticEventKeys.MiddlewareStart, new MiddlewareDiagnosticData(requestContext, middleware));
         }
     }
 
@@ -36,7 +36,7 @@ public static void MiddlewareFailure(this DiagnosticListener diagnosticSource, R
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.MiddlewareFailure))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.MiddlewareFailure, new MiddlewareDiagnosticData(requestContext, middleware));
+            Write(diagnosticSource, DiagnosticEventKeys.MiddlewareFailure, new MiddlewareDiagnosticData(requestContext, middleware));
         }
     }
 
@@ -50,7 +50,7 @@ public static void MiddlewareSuccess(this DiagnosticListener diagnosticSource, R
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.MiddlewareSuccess))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.MiddlewareSuccess, new MiddlewareDiagnosticData(requestContext, middleware));
+            Write(diagnosticSource, DiagnosticEventKeys.MiddlewareSuccess, new MiddlewareDiagnosticData(requestContext, middleware));
         }
     }
 
@@ -64,7 +64,7 @@ public static void OperationStart(this DiagnosticListener diagnosticSource, IRes
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.OperationStart))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.OperationStart, new OperationStartDiagnosticData(operation, initiatingRequest));
+            Write(diagnosticSource, DiagnosticEventKeys.OperationStart, new OperationStartDiagnosticData(operation, initiatingRequest));
         }
     }
 
@@ -78,7 +78,7 @@ public static void OperationFailure(this DiagnosticListener diagnosticSource, IR
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.OperationFailure))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.OperationFailure, new OperationFailureDiagnosticData(operation, operationException));
+            Write(diagnosticSource, DiagnosticEventKeys.OperationFailure, new OperationFailureDiagnosticData(operation, operationException));
         }
     }
 
@@ -92,7 +92,7 @@ public static void OperationSuccess(this DiagnosticListener diagnosticSource, IR
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.OperationSuccess))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.OperationSuccess, new OperationSuccessDiagnosticData(operation, resolvedInstance));
+            Write(diagnosticSource, DiagnosticEventKeys.OperationSuccess, new OperationSuccessDiagnosticData(operation, resolvedInstance));
         }
     }
 
@@ -106,7 +106,7 @@ public static void RequestStart(this DiagnosticListener diagnosticSource, IResol
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.RequestStart))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.RequestStart, new RequestDiagnosticData(operation, requestContext));
+            Write(diagnosticSource, DiagnosticEventKeys.RequestStart, new RequestDiagnosticData(operation, requestContext));
         }
     }
 
@@ -121,7 +121,7 @@ public static void RequestFailure(this DiagnosticListener diagnosticSource, IRes
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.RequestFailure))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.RequestFailure, new RequestFailureDiagnosticData(operation, requestContext, requestException));
+            Write(diagnosticSource, DiagnosticEventKeys.RequestFailure, new RequestFailureDiagnosticData(operation, requestContext, requestException));
         }
     }
 
@@ -135,7 +135,31 @@ public static void RequestSuccess(this DiagnosticListener diagnosticSource, IRes
     {
         if (diagnosticSource.IsEnabled(DiagnosticEventKeys.RequestSuccess))
         {
-            diagnosticSource.Write(DiagnosticEventKeys.RequestSuccess, new RequestDiagnosticData(operation, requestContext));
+            Write(diagnosticSource, DiagnosticEventKeys.RequestSuccess, new RequestDiagnosticData(operation, requestContext));
         }
     }
+
+    /// <summary>
+    /// Centralizes the <see cref="DiagnosticSource.Write(string, object?)"/> call so the
+    /// trimming/AOT suppression for it lives in exactly one place.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="DiagnosticSource.Write(string, object?)"/> is annotated
+    /// <c>[RequiresUnreferencedCode]</c> because a listener may reflect over the
+    /// anonymously-typed payload. Autofac's diagnostics are opt-in: this code path only
+    /// runs when a caller has explicitly attached a <see cref="DiagnosticListener"/>
+    /// subscriber, which is a development/observability scenario rather than part of the
+    /// core resolve behavior. The payload types are concrete, internal
+    /// <c>*DiagnosticData</c> classes that are always referenced from this assembly, so they
+    /// are not trimmed away. Suppressing here keeps the resolve pipeline (which calls these
+    /// methods) free of trim warnings.
+    /// </remarks>
+    [UnconditionalSuppressMessage(
+        "Trimming",
+        "IL2026:RequiresUnreferencedCode",
+        Justification = "Diagnostics are opt-in and only run when a DiagnosticListener subscriber is attached. Payload types are concrete internal types referenced from this assembly and are not trimmed.")]
+    private static void Write(DiagnosticListener diagnosticSource, string name, object value)
+    {
+        diagnosticSource.Write(name, value);
+    }
 }

src/Autofac/RegistrationExtensions.Composite.cs

@@ -5,6 +5,7 @@
 using Autofac.Builder;
 using Autofac.Core;
 using Autofac.Core.Registration;
+using Autofac.Util;
 
 namespace Autofac;
 
@@ -31,7 +32,7 @@ public static partial class RegistrationExtensions
     /// <typeparam name="TService">Service type to provide a composite for.</typeparam>
     /// <param name="builder">Container builder.</param>
     /// <returns>The composite registration for continued configuration.</returns>
-    public static IRegistrationBuilder<TComposite, ConcreteReflectionActivatorData, SingleRegistrationStyle> RegisterComposite<TComposite, TService>(this ContainerBuilder builder)
+    public static IRegistrationBuilder<TComposite, ConcreteReflectionActivatorData, SingleRegistrationStyle> RegisterComposite<[DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] TComposite, TService>(this ContainerBuilder builder)
         where TComposite : notnull, TService
         where TService : notnull
     {
@@ -66,7 +67,7 @@ public static IRegistrationBuilder<TComposite, ConcreteReflectionActivatorData,
     /// <returns>The composite registration for continued configuration.</returns>
     public static IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle> RegisterComposite(
         this ContainerBuilder builder,
-        Type compositeType,
+        [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type compositeType,
         Type serviceType)
     {
         if (builder == null)

src/Autofac/RegistrationExtensions.cs

@@ -95,7 +95,7 @@ public static IRegistrationBuilder<T, SimpleActivatorData, SingleRegistrationSty
     /// <param name="builder">Container builder.</param>
     /// <returns>Registration builder allowing the registration to be configured.</returns>
     public static IRegistrationBuilder<TImplementer, ConcreteReflectionActivatorData, SingleRegistrationStyle>
-        RegisterType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TImplementer>(this ContainerBuilder builder)
+        RegisterType<[DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] TImplementer>(this ContainerBuilder builder)
         where TImplementer : notnull
     {
         if (builder == null)
@@ -117,7 +117,7 @@ public static IRegistrationBuilder<TImplementer, ConcreteReflectionActivatorData
     /// <param name="implementationType">The type of the component implementation.</param>
     /// <returns>Registration builder allowing the registration to be configured.</returns>
     public static IRegistrationBuilder<object, ConcreteReflectionActivatorData, SingleRegistrationStyle>
-        RegisterType(this ContainerBuilder builder, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type implementationType)
+        RegisterType(this ContainerBuilder builder, [DynamicallyAccessedMembers(ActivatorMemberTypes.ActivatedType)] Type implementationType)
     {
         if (builder == null)
         {

src/Autofac/Util/ActivatorMemberTypes.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace Autofac.Util;
+
+/// <summary>
+/// Centralizes the <see cref="DynamicallyAccessedMemberTypes"/> contract for implementation
+/// types that Autofac activates through reflection, so that every annotation across the
+/// codebase advertises an identical, trim/AOT-consistent member set.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The contract is <see cref="DynamicallyAccessedMemberTypes.PublicConstructors"/> plus
+/// <see cref="DynamicallyAccessedMemberTypes.PublicProperties"/>:
+/// </para>
+/// <list type="bullet">
+/// <item>
+/// Public constructors back the default activation path (the
+/// <see cref="Core.Activators.Reflection.DefaultConstructorFinder"/>), so they must be
+/// preserved.
+/// </item>
+/// <item>
+/// Public properties back the default property-injection path
+/// (<see cref="Core.DefaultPropertySelector"/> only injects public setters), a
+/// first-class Autofac feature that must keep working under trimming and native AOT.
+/// </item>
+/// </list>
+/// <para>
+/// Non-public constructors (reachable only via a custom
+/// <see cref="Core.Activators.Reflection.IConstructorFinder"/>) and non-public properties
+/// (reachable only via a custom <see cref="Core.IPropertySelector"/>) are
+/// intentionally excluded: those paths are documented as not trim/AOT-safe, and the
+/// custom-selector registration APIs already carry <c>[RequiresUnreferencedCode]</c>.
+/// </para>
+/// </remarks>
+internal static class ActivatorMemberTypes
+{
+    /// <summary>
+    /// The member set preserved for reflection-activated implementation types:
+    /// <see cref="DynamicallyAccessedMemberTypes.PublicConstructors"/> |
+    /// <see cref="DynamicallyAccessedMemberTypes.PublicProperties"/>.
+    /// </summary>
+    public const DynamicallyAccessedMemberTypes ActivatedType =
+        DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties;
+}