Update FromKeyedServicesAttribute support for derived types in generators and validation

- Add InheritsFrom extension method to check class inheritance in SymbolExtensions
- Add TryGetAttributeInheritingFrom methods to detect attributes that inherit from base types
- Update IsServiceParameter in ITypeSymbolExtensions to use inheritance checking
- Update EndpointParameter.cs to use TryGetAttributeInheritingFrom for FromKeyedServicesAttribute
- Add CustomFromKeyedServicesAttribute test type and SupportsDerivedFromKeyedServicesAttribute test
- All builds and tests pass successfully

Co-authored-by: captainsafia <[email protected]>

Author: Copilot

src/Http/Http.Extensions/gen/Microsoft.AspNetCore.Http.RequestDelegateGenerator/StaticRouteHandlerModel/EndpointParameter.cs

@@ -147,13 +147,13 @@ private void ProcessEndpointParameterSource(Endpoint endpoint, ISymbol symbol, I
         else if (attributes.HasAttributeImplementingInterface(wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_Metadata_IFromServiceMetadata)))
         {
             Source = EndpointParameterSource.Service;
-            if (attributes.TryGetAttribute(wellKnownTypes.Get(WellKnownType.Microsoft_Extensions_DependencyInjection_FromKeyedServicesAttribute), out var keyedServicesAttribute))
+            if (attributes.TryGetAttributeInheritingFrom(wellKnownTypes.Get(WellKnownType.Microsoft_Extensions_DependencyInjection_FromKeyedServicesAttribute), out var keyedServicesAttribute))
             {
                 var location = endpoint.Operation.Syntax.GetLocation();
                 endpoint.Diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.KeyedAndNotKeyedServiceAttributesNotSupported, location));
             }
         }
-        else if (attributes.TryGetAttribute(wellKnownTypes.Get(WellKnownType.Microsoft_Extensions_DependencyInjection_FromKeyedServicesAttribute), out var keyedServicesAttribute))
+        else if (attributes.TryGetAttributeInheritingFrom(wellKnownTypes.Get(WellKnownType.Microsoft_Extensions_DependencyInjection_FromKeyedServicesAttribute), out var keyedServicesAttribute))
         {
             Source = EndpointParameterSource.KeyedService;
             var constructorArgument = keyedServicesAttribute.ConstructorArguments.FirstOrDefault();

src/Http/Http.Extensions/test/RequestDelegateGenerator/RequestDelegateCreationTests.KeyServices.cs

@@ -252,6 +252,23 @@ public async Task RequestDelegateGeneratesCompilableCodeForKeyedServiceInNamespa
         await VerifyResponseBodyAsync(httpContext, "To be or not to be…");
     }
 
+    [Fact]
+    public async Task SupportsDerivedFromKeyedServicesAttribute()
+    {
+        var source = """
+app.MapGet("/", (HttpContext context, [CustomFromKeyedServices("customKey")] TestService arg) => context.Items["arg"] = arg);
+""";
+        var (_, compilation) = await RunGeneratorAsync(source);
+        var myOriginalService = new TestService();
+        var serviceProvider = CreateServiceProvider((serviceCollection) => serviceCollection.AddKeyedSingleton("customKey", myOriginalService));
+        var endpoint = GetEndpointFromCompilation(compilation, serviceProvider: serviceProvider);
+
+        var httpContext = CreateHttpContext(serviceProvider);
+        await endpoint.RequestDelegate(httpContext);
+
+        Assert.Same(myOriginalService, httpContext.Items["arg"]);
+    }
+
     private class MockServiceProvider : IServiceProvider, ISupportRequiredService
     {
         public object GetService(Type serviceType)

src/Http/Http.Extensions/test/RequestDelegateGenerator/SharedTypes.cs

@@ -110,6 +110,11 @@ public class CustomFromBodyAttribute : Attribute, IFromBodyMetadata
     public bool AllowEmpty { get; set; }
 }
 
+public class CustomFromKeyedServicesAttribute : FromKeyedServicesAttribute
+{
+    public CustomFromKeyedServicesAttribute(object key) : base(key) { }
+}
+
 public enum TodoStatus
 {
     Trap, // A trap for Enum.TryParse<T>!

src/Shared/RoslynUtils/SymbolExtensions.cs

@@ -122,6 +122,46 @@ public static bool TryGetAttributeImplementingInterface(this ImmutableArray<Attr
         return false;
     }
 
+    public static bool HasAttributeInheritingFrom(this ISymbol symbol, INamedTypeSymbol baseType)
+    {
+        return symbol.TryGetAttributeInheritingFrom(baseType, out var _);
+    }
+
+    public static bool TryGetAttributeInheritingFrom(this ISymbol symbol, INamedTypeSymbol baseType, [NotNullWhen(true)] out AttributeData? matchedAttribute)
+    {
+        foreach (var attributeData in symbol.GetAttributes())
+        {
+            if (attributeData.AttributeClass is not null && attributeData.AttributeClass.InheritsFrom(baseType))
+            {
+                matchedAttribute = attributeData;
+                return true;
+            }
+        }
+
+        matchedAttribute = null;
+        return false;
+    }
+
+    public static bool HasAttributeInheritingFrom(this ImmutableArray<AttributeData> attributes, INamedTypeSymbol baseType)
+    {
+        return attributes.TryGetAttributeInheritingFrom(baseType, out var _);
+    }
+
+    public static bool TryGetAttributeInheritingFrom(this ImmutableArray<AttributeData> attributes, INamedTypeSymbol baseType, [NotNullWhen(true)] out AttributeData? matchedAttribute)
+    {
+        foreach (var attributeData in attributes)
+        {
+            if (attributeData.AttributeClass is not null && attributeData.AttributeClass.InheritsFrom(baseType))
+            {
+                matchedAttribute = attributeData;
+                return true;
+            }
+        }
+
+        matchedAttribute = null;
+        return false;
+    }
+
     public static bool Implements(this ITypeSymbol type, ITypeSymbol interfaceType)
     {
         foreach (var t in type.AllInterfaces)
@@ -134,6 +174,18 @@ public static bool Implements(this ITypeSymbol type, ITypeSymbol interfaceType)
         return false;
     }
 
+    public static bool InheritsFrom(this ITypeSymbol type, ITypeSymbol baseType)
+    {
+        foreach (var t in type.GetThisAndBaseTypes())
+        {
+            if (SymbolEqualityComparer.Default.Equals(t, baseType))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public static bool IsType(this INamedTypeSymbol type, string typeName, SemanticModel semanticModel)
         => SymbolEqualityComparer.Default.Equals(type, semanticModel.Compilation.GetTypeByMetadataName(typeName));
 

src/Validation/gen/Extensions/ITypeSymbolExtensions.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.AspNetCore.Analyzers.RouteEmbeddedLanguage.Infrastructure;
 using Microsoft.AspNetCore.App.Analyzers.Infrastructure;
 using Microsoft.CodeAnalysis;
 
@@ -136,7 +137,7 @@ internal static bool IsServiceParameter(this IParameterSymbol parameter, INamedT
         return parameter.GetAttributes().Any(attr =>
             attr.AttributeClass is not null &&
             (attr.AttributeClass.ImplementsInterface(fromServiceMetadataSymbol) ||
-             SymbolEqualityComparer.Default.Equals(attr.AttributeClass, fromKeyedServiceAttributeSymbol)));
+             attr.AttributeClass.InheritsFrom(fromKeyedServiceAttributeSymbol)));
     }
 
     /// <summary>