Update RDG to use interceptors feature (#48817)

* Update RDG to use interceptors feature

* Address feedback from review

* Add separator to method name and update same interceptor test

* Use group index to distinguish interceptor methods

Author: captainsafia

eng/Versions.props

@@ -245,7 +245,7 @@
     <Analyzer_MicrosoftCodeAnalysisCSharpWorkspacesVersion>3.3.1</Analyzer_MicrosoftCodeAnalysisCSharpWorkspacesVersion>
     <!-- Pin the version of the M.CA dependencies that we utilize with a cutom version property $(MicrosoftCodeAnalysisVersion_LatestVS) to avoid automatically
     consuming the newest version of the packages when using the $(MicrosoftCodeAnalysisCSharpVersion) properties in source-build. -->
-    <MicrosoftCodeAnalysisVersion_LatestVS>4.5.0</MicrosoftCodeAnalysisVersion_LatestVS>
+    <MicrosoftCodeAnalysisVersion_LatestVS>4.7.0-3.23314.3</MicrosoftCodeAnalysisVersion_LatestVS>
     <MicrosoftCodeAnalysisExternalAccessAspNetCoreVersion>4.7.0-3.23314.3</MicrosoftCodeAnalysisExternalAccessAspNetCoreVersion>
     <MicrosoftCodeAnalysisCommonVersion>4.7.0-3.23314.3</MicrosoftCodeAnalysisCommonVersion>
     <MicrosoftCodeAnalysisCSharpVersion>4.7.0-3.23314.3</MicrosoftCodeAnalysisCSharpVersion>

src/Http/Http.Extensions/gen/Microsoft.AspNetCore.Http.RequestDelegateGenerator.csproj

@@ -30,6 +30,7 @@
     <Compile Include="$(SharedSourceRoot)RoslynUtils\SyntaxTreeExtensions.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)RoslynUtils\ParsabilityHelper.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)RoslynUtils\CodeWriter.cs" LinkBase="Shared" />
+    <Compile Include="$(SharedSourceRoot)RoslynUtils\IncrementalValuesProviderExtensions.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)Diagnostics\AnalyzerDebug.cs" LinkBase="Shared" />
   </ItemGroup>
 

src/Http/Http.Extensions/gen/RequestDelegateGenerator.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Text;
@@ -21,7 +22,8 @@ internal static class RequestDelegateGeneratorSources
 #nullable enable
 """;
 
-    public static string GeneratedCodeAttribute => $@"[System.CodeDom.Compiler.GeneratedCodeAttribute(""{typeof(RequestDelegateGeneratorSources).Assembly.FullName}"", ""{typeof(RequestDelegateGeneratorSources).Assembly.GetName().Version}"")]";
+    public static string GeneratedCodeConstructor => $@"System.CodeDom.Compiler.GeneratedCodeAttribute(""{typeof(RequestDelegateGeneratorSources).Assembly.FullName}"", ""{typeof(RequestDelegateGeneratorSources).Assembly.GetName().Version}"")";
+    public static string GeneratedCodeAttribute => $"[{GeneratedCodeConstructor}]";
 
     public static string ContentTypeConstantsType => $$"""
     {{GeneratedCodeAttribute}}
@@ -439,25 +441,19 @@ public override bool IsDefined(Type attributeType, bool inherit)
     }
 """;
 
-    public static string GetGeneratedRouteBuilderExtensionsSource(string genericThunks, string thunks, string endpoints, string helperMethods, string helperTypes, ImmutableHashSet<string> verbs) => $$"""
+    public static string GetGeneratedRouteBuilderExtensionsSource(string endpoints, string helperMethods, string helperTypes, ImmutableHashSet<string> verbs) => $$"""
 {{SourceHeader}}
 
-namespace Microsoft.AspNetCore.Builder
+namespace System.Runtime.CompilerServices
 {
     {{GeneratedCodeAttribute}}
-    internal sealed class SourceKey
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+    file sealed class InterceptsLocationAttribute : Attribute
     {
-        public string Path { get; init; }
-        public int Line { get; init; }
-
-        public SourceKey(string path, int line)
+        public InterceptsLocationAttribute(string filePath, int line, int column)
         {
-            Path = path;
-            Line = line;
         }
     }
-
-{{GetEndpoints(endpoints, verbs)}}
 }
 
 namespace Microsoft.AspNetCore.Http.Generated
@@ -471,6 +467,7 @@ namespace Microsoft.AspNetCore.Http.Generated
     using System.Globalization;
     using System.Linq;
     using System.Reflection;
+    using System.Runtime.CompilerServices;
     using System.Text.Json;
     using System.Text.Json.Serialization.Metadata;
     using System.Threading.Tasks;
@@ -493,8 +490,24 @@ namespace Microsoft.AspNetCore.Http.Generated
     {{GeneratedCodeAttribute}}
     file static class GeneratedRouteBuilderExtensionsCore
     {
-{{GetGenericThunks(genericThunks)}}
-{{GetThunks(thunks)}}
+        {{GetVerbs(verbs)}}
+        {{endpoints}}
+
+        internal static RouteHandlerBuilder MapCore(
+            this IEndpointRouteBuilder routes,
+            string pattern,
+            Delegate handler,
+            IEnumerable<string>? httpMethods,
+            MetadataPopulator populateMetadata,
+            RequestDelegateFactoryFunc createRequestDelegate)
+        {
+            return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate);
+        }
+
+        private static T Cast<T>(Delegate d, T _) where T : Delegate
+        {
+            return (T)d;
+        }
 
         private static EndpointFilterDelegate BuildFilterDelegate(EndpointFilterDelegate filteredInvocation, EndpointBuilder builder, MethodInfo mi)
         {
@@ -557,84 +570,16 @@ private static bool ShouldUseWith(this JsonTypeInfo jsonTypeInfo, [NotNullWhen(f
 {{LogOrThrowExceptionHelperClass}}
 }
 """;
-    private static string GetGenericThunks(string genericThunks) => genericThunks != string.Empty ? $$"""
-        private static class GenericThunks<T>
-        {
-            public static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new()
-            {
-                {{genericThunks}}
-            };
-        }
 
-        internal static RouteHandlerBuilder MapCore<T>(
-            this IEndpointRouteBuilder routes,
-            string pattern,
-            Delegate handler,
-            IEnumerable<string> httpMethods,
-            string filePath,
-            int lineNumber)
-        {
-            var (populateMetadata, createRequestDelegate) = GenericThunks<T>.map[(filePath, lineNumber)];
-            return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate);
-        }
-""" : string.Empty;
-
-    private static string GetThunks(string thunks) => thunks != string.Empty ? $$"""
-        private static readonly Dictionary<(string, int), (MetadataPopulator, RequestDelegateFactoryFunc)> map = new()
-        {
-{{thunks}}
-        };
-
-        internal static RouteHandlerBuilder MapCore(
-            this IEndpointRouteBuilder routes,
-            string pattern,
-            Delegate handler,
-            IEnumerable<string>? httpMethods,
-            string filePath,
-            int lineNumber)
-        {
-            var (populateMetadata, createRequestDelegate) = map[(filePath, lineNumber)];
-            return RouteHandlerServices.Map(routes, pattern, handler, httpMethods, populateMetadata, createRequestDelegate);
-        }
-""" : string.Empty;
-
-    private static string GetEndpoints(string endpoints, ImmutableHashSet<string> verbs)
+    public static string GetVerbs(ImmutableHashSet<string> verbs)
     {
-        if (endpoints == string.Empty)
-        {
-            return string.Empty;
-        }
-
         var builder = new StringBuilder();
-        builder.Append($$"""
-    // This class needs to be internal so that the compiled application
-    // has access to the strongly-typed endpoint definitions that are
-    // generated by the compiler so that they will be favored by
-    // overload resolution and opt the runtime in to the code generated
-    // implementation produced here.
-    {{GeneratedCodeAttribute}}
-    internal static class GenerateRouteBuilderEndpoints
-    {
-
-""");
 
-        foreach (string verb in verbs.OrderBy(p => p, System.StringComparer.Ordinal))
+        foreach (string verb in verbs.OrderBy(p => p, StringComparer.Ordinal))
         {
-            builder.AppendLine($$"""
-        private static readonly string[] {{verb}}Verb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.{{verb}} };
-""");
+            builder.AppendLine($$"""private static readonly string[] {{verb}}Verb = new[] { global::Microsoft.AspNetCore.Http.HttpMethods.{{verb}} };""");
         }
 
-        if (verbs.Count > 0)
-        {
-            builder.AppendLine();
-        }
-
-        builder.Append($$"""
-        {{endpoints}}
-    }
-""");
-
         return builder.ToString();
     }
 }

src/Http/Http.Extensions/gen/RequestDelegateGeneratorSources.cs

@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.AspNetCore.App.Analyzers.Infrastructure;
+using Microsoft.AspNetCore.Http.RequestDelegateGenerator.StaticRouteHandlerModel;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+/*
+ * This class contains the logic for suppressing diagnostics that are
+ * emitted by the linker analyzers when encountering the framework-provided
+ * `Map` invocations. Pending the completion of https://github.com/dotnet/roslyn/issues/68669,
+ * this workaround is necessary to apply these suppressions for `Map` invocations that the RDG
+ * is able to generate code at compile time for that the analyzer is not able to resolve.
+ */
+
+namespace Microsoft.AspNetCore.Http.RequestDelegateGenerator;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class RequestDelegateGeneratorSuppressor : DiagnosticSuppressor
+{
+    private static readonly SuppressionDescriptor SuppressRUCDiagnostic = new(
+        id: "RDGS001",
+        suppressedDiagnosticId: "IL2026",
+        justification: "The target method has been intercepted by a statically generated variant.");
+
+    private static readonly SuppressionDescriptor SuppressRDCDiagnostic = new(
+        id: "RDGS002",
+        suppressedDiagnosticId: "IL3050",
+        justification: "The target method has been intercepted by a statically generated variant.");
+
+    public override void ReportSuppressions(SuppressionAnalysisContext context)
+    {
+        foreach (var diagnostic in context.ReportedDiagnostics)
+        {
+            if (diagnostic.Id != SuppressRDCDiagnostic.SuppressedDiagnosticId && diagnostic.Id != SuppressRUCDiagnostic.SuppressedDiagnosticId)
+            {
+                continue;
+            }
+
+            var location = diagnostic.AdditionalLocations.Count > 0
+                ? diagnostic.AdditionalLocations[0]
+                : diagnostic.Location;
+
+            if (location.SourceTree is not { } sourceTree
+                || sourceTree.GetRoot().FindNode(location.SourceSpan) is not InvocationExpressionSyntax node
+                || !node.TryGetMapMethodName(out var method)
+                || !InvocationOperationExtensions.KnownMethods.Contains(method))
+            {
+                continue;
+            }
+
+            var semanticModel = context.GetSemanticModel(sourceTree);
+            var operation = semanticModel.GetOperation(node, context.CancellationToken);
+            var wellKnownTypes = WellKnownTypes.GetOrCreate(semanticModel.Compilation);
+            if (operation.IsValidOperation(wellKnownTypes, out var invocationOperation))
+            {
+                var endpoint = new Endpoint(invocationOperation, wellKnownTypes, semanticModel);
+                if (endpoint.Diagnostics.Count == 0)
+                {
+                    var targetSuppression = diagnostic.Id == SuppressRUCDiagnostic.SuppressedDiagnosticId
+                        ? SuppressRUCDiagnostic
+                        : SuppressRDCDiagnostic;
+                    context.ReportSuppression(Suppression.Create(targetSuppression, diagnostic));
+                }
+            }
+        }
+    }
+    public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(SuppressRUCDiagnostic, SuppressRDCDiagnostic);
+}

src/Http/Http.Extensions/gen/RequestDelegateGeneratorSuppressor.cs

@@ -95,7 +95,7 @@ public Endpoint(IInvocationOperation operation, WellKnownTypes wellKnownTypes, S
     public EndpointParameter[] Parameters { get; } = Array.Empty<EndpointParameter>();
     public List<Diagnostic> Diagnostics { get; } = new List<Diagnostic>();
 
-    public (string File, int LineNumber) Location { get; }
+    public (string File, int LineNumber, int CharacterNumber) Location { get; }
     public IInvocationOperation Operation { get; }
 
     public override bool Equals(object o) =>
@@ -138,13 +138,16 @@ public static int GetSignatureHashCode(Endpoint endpoint)
         return hashCode.ToHashCode();
     }
 
-    private static (string, int) GetLocation(IInvocationOperation operation)
+    private static (string, int, int) GetLocation(IInvocationOperation operation)
     {
         var operationSpan = operation.Syntax.Span;
-        var filePath = operation.Syntax.SyntaxTree.GetDisplayPath(operationSpan, operation.SemanticModel?.Compilation.Options.SourceReferenceResolver);
+        var filePath = operation.Syntax.SyntaxTree.GetInterceptorFilePath(operation.SemanticModel?.Compilation.Options.SourceReferenceResolver);
         var span = operation.Syntax.SyntaxTree.GetLineSpan(operationSpan);
         var lineNumber = span.StartLinePosition.Line + 1;
-        return (filePath, lineNumber);
+        // Calculate the character offset to the end of the Map invocation detected
+        var invocationLength = ((MemberAccessExpressionSyntax)((InvocationExpressionSyntax)operation.Syntax).Expression).Expression.Span.Length;
+        var characterNumber = span.StartLinePosition.Character + invocationLength + 2;
+        return (filePath, lineNumber, characterNumber);
     }
 
     private static string GetHttpMethod(IInvocationOperation operation)

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/Endpoint.cs

@@ -23,6 +23,7 @@ public EndpointParameter(Endpoint endpoint, IParameterSymbol parameter, WellKnow
     {
         Ordinal = parameter.Ordinal;
         IsOptional = parameter.IsOptional();
+        HasDefaultValue = parameter.HasExplicitDefaultValue;
         DefaultValue = parameter.GetDefaultValueString();
         ProcessEndpointParameterSource(endpoint, parameter, parameter.GetAttributes(), wellKnownTypes);
     }
@@ -32,6 +33,7 @@ private EndpointParameter(Endpoint endpoint, IPropertySymbol property, IParamete
         Ordinal = parameter?.Ordinal ?? 0;
         IsProperty = true;
         IsOptional = property.IsOptional() || parameter?.IsOptional() == true;
+        HasDefaultValue = parameter?.HasExplicitDefaultValue ?? false;
         DefaultValue = parameter?.GetDefaultValueString() ?? "null";
         // Coalesce attributes on the property and attributes on the matching parameter
         var attributeBuilder = ImmutableArray.CreateBuilder<AttributeData>();
@@ -251,6 +253,7 @@ private static bool ImplementsIEndpointParameterMetadataProvider(ITypeSymbol typ
     public bool IsOptional { get; set; }
     public bool IsArray { get; set; }
     public string DefaultValue { get; set; } = "null";
+    public bool HasDefaultValue { get; set; }
     [MemberNotNullWhen(true, nameof(PropertyAsParameterInfoConstruction))]
     public bool IsProperty { get; set; }
     public EndpointParameterSource Source { get; set; }
@@ -610,17 +613,17 @@ obj is EndpointParameter other &&
         other.SymbolName == SymbolName &&
         other.Ordinal == Ordinal &&
         other.IsOptional == IsOptional &&
-        SymbolEqualityComparer.Default.Equals(other.Type, Type);
+        SymbolEqualityComparer.IncludeNullability.Equals(other.Type, Type);
 
     public bool SignatureEquals(object obj) =>
         obj is EndpointParameter other &&
-        SymbolEqualityComparer.Default.Equals(other.Type, Type);
+        SymbolEqualityComparer.IncludeNullability.Equals(other.Type, Type);
 
     public override int GetHashCode()
     {
         var hashCode = new HashCode();
         hashCode.Add(SymbolName);
-        hashCode.Add(Type, SymbolEqualityComparer.Default);
+        hashCode.Add(Type, SymbolEqualityComparer.IncludeNullability);
         return hashCode.ToHashCode();
     }
 }

src/Http/Http.Extensions/gen/StaticRouteHandlerModel/EndpointParameter.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.App.Analyzers.Infrastructure;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Operations;
@@ -22,6 +23,20 @@ internal static class InvocationOperationExtensions
         "MapFallback"
     };
 
+    public static bool IsValidOperation(this IOperation? operation, WellKnownTypes wellKnownTypes, [NotNullWhen(true)] out IInvocationOperation? invocationOperation)
+    {
+        invocationOperation = null;
+        if (operation is IInvocationOperation targetOperation &&
+            targetOperation.TryGetRouteHandlerArgument(out var routeHandlerParameter) &&
+            routeHandlerParameter is { Parameter.Type: {} delegateType } &&
+            SymbolEqualityComparer.Default.Equals(delegateType, wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_Delegate)))
+        {
+            invocationOperation = targetOperation;
+            return true;
+        }
+        return false;
+    }
+
     public static bool TryGetRouteHandlerMethod(this IInvocationOperation invocation, SemanticModel semanticModel, [NotNullWhen(true)] out IMethodSymbol? method)
     {
         method = null;