Set EndpointName automatically from method name

Author: captainsafia

src/Http/Routing/src/Builder/MinimalActionEndpointRouteBuilderExtensions.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Routing.Patterns;
@@ -184,6 +185,14 @@ public static MinimalActionEndpointConventionBuilder Map(
             // Add MethodInfo as metadata to assist with OpenAPI generation for the endpoint.
             builder.Metadata.Add(action.Method);
 
+            // Methods defined in a top-level program are generated as statics so the delegate
+            // target will be null. Inline lambdas are compiler generated properties so they can
+            // be filtered that way.
+            if (action.Target == null || !TypeHelper.IsCompilerGenerated(action.Method.Name))
+            {
+                builder.Metadata.Add(new EndpointNameMetadata(action.Method.Name));
+            }
+
             // Add delegate attributes as metadata
             var attributes = action.Method.GetCustomAttributes();
 

src/Http/Routing/src/Microsoft.AspNetCore.Routing.csproj

@@ -24,6 +24,7 @@ Microsoft.AspNetCore.Routing.RouteCollection</Description>
 
   <ItemGroup>
     <Compile Include="$(SharedSourceRoot)PropertyHelper\*.cs" />
+    <Compile Include="$(SharedSourceRoot)TypeHelper.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Http/Routing/test/UnitTests/Builder/MinimalActionEndpointRouteBuilderExtensionsTest.cs

@@ -359,6 +359,55 @@ public void MapFallbackWithoutPath_BuildsEndpointWithLowestRouteOrder()
             Assert.Equal(int.MaxValue, routeEndpointBuilder.Order);
         }
 
+        [Fact]
+        // This test scenario simulates methods defined in a top-level program
+        // which are compiler generated.
+        public void MapMethod_SetsEndpointNameForInnerMethod()
+        {
+            var builder = new DefaultEndpointRouteBuilder(new ApplicationBuilder(new EmptyServiceProvdier()));
+            string InnerGetString() => "TestString";
+            _ = builder.MapDelete("/", InnerGetString);
+
+            var dataSource = GetBuilderEndpointDataSource(builder);
+            // Trigger Endpoint build by calling getter.
+            var endpoint = Assert.Single(dataSource.Endpoints);
+
+            var endpointName = endpoint.Metadata.GetMetadata<IEndpointNameMetadata>();
+            Assert.NotNull(endpointName);
+            Assert.Equal("InnerGetString", endpointName?.EndpointName);
+        }
+
+        [Fact]
+        public void MapMethod_SetsEndpointNameForMethodGroup()
+        {
+            var builder = new DefaultEndpointRouteBuilder(new ApplicationBuilder(new EmptyServiceProvdier()));
+            _ = builder.MapDelete("/", GetString);
+
+            var dataSource = GetBuilderEndpointDataSource(builder);
+            // Trigger Endpoint build by calling getter.
+            var endpoint = Assert.Single(dataSource.Endpoints);
+
+            var endpointName = endpoint.Metadata.GetMetadata<IEndpointNameMetadata>();
+            Assert.NotNull(endpointName);
+            Assert.Equal("GetString", endpointName?.EndpointName);
+        }
+
+        private string GetString() => "TestString";
+
+        [Fact]
+        public void MapMethod_DoesNotSetEndpointNameForLambda()
+        {
+            var builder = new DefaultEndpointRouteBuilder(new ApplicationBuilder(new EmptyServiceProvdier()));
+            _ = builder.MapDelete("/", () => { });
+
+            var dataSource = GetBuilderEndpointDataSource(builder);
+            // Trigger Endpoint build by calling getter.
+            var endpoint = Assert.Single(dataSource.Endpoints);
+
+            var endpointName = endpoint.Metadata.GetMetadata<IEndpointNameMetadata>();
+            Assert.Null(endpointName);
+        }
+
         class FromRoute : Attribute, IFromRouteMetadata
         {
             public string? Name { get; set; }

src/Mvc/Mvc.ApiExplorer/src/EndpointMetadataApiDescriptionProvider.cs

@@ -78,7 +78,7 @@ private ApiDescription CreateApiDescription(RouteEndpoint routeEndpoint, string
             // For now, put all methods defined the same declaring type together.
             string controllerName;
 
-            if (methodInfo.DeclaringType is not null && !IsCompilerGenerated(methodInfo.DeclaringType))
+            if (methodInfo.DeclaringType is not null && !TypeHelper.IsCompilerGenerated(methodInfo.DeclaringType.Name, methodInfo.DeclaringType))
             {
                 controllerName = methodInfo.DeclaringType.Name;
             }
@@ -363,11 +363,5 @@ private static void AddActionDescriptorEndpointMetadata(
                 actionDescriptor.EndpointMetadata = new List<object>(endpointMetadata);
             }
         }
-
-        // The CompilerGeneratedAttribute doesn't always get added so we also check if the type name starts with "<"
-        // For example, "<>c" is a "declaring" type the C# compiler will generate without the attribute for a top-level lambda
-        // REVIEW: Is there a better way to do this?
-        private static bool IsCompilerGenerated(Type type) =>
-            Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute)) || type.Name.StartsWith('<');
     }
 }

src/Mvc/Mvc.ApiExplorer/src/Microsoft.AspNetCore.Mvc.ApiExplorer.csproj

@@ -11,6 +11,7 @@
 
   <ItemGroup>
     <Compile Include="$(SharedSourceRoot)TryParseMethodCache.cs" />
+    <Compile Include="$(SharedSourceRoot)TypeHelper.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/Shared/TypeHelper.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Runtime.CompilerServices
+{
+    internal static class TypeHelper
+    {
+        /// <summary>
+        /// Checks to see if a given type is compiler generated.
+        /// <remarks>
+        /// The compiler doesn't always annotate every time it generates with the
+        /// CompilerGeneratedAttribute so sometimes we have to check if the type's
+        /// identifier represents a generated type. Follows the same heuristics seen
+        /// in https://github.com/dotnet/roslyn/blob/b57c1f89c1483da8704cde7b535a20fd029748db/src/ExpressionEvaluator/Core/Source/ResultProvider/Helpers/GeneratedMetadataNames.cs#L19
+        /// </remarks>
+        /// </summary>
+        /// <param name="type">The type to evaluate. Can be null if evaluating only on name. </param>
+        /// <param name="name">The identifier associated wit the type.</param>
+        /// <returns><see langword="true" /> if <paramref name="type"/> is compiler generated
+        /// or <paramref name="name"/> represents a compiler generated identifier.</returns>
+        internal static bool IsCompilerGenerated(string name, Type? type = null)
+        {
+            return (type is Type  && Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute)))
+                || name.StartsWith("<", StringComparison.Ordinal)
+                || (name.IndexOf('$') >= 0);
+        }
+    }
+}