Add support for handling FromRoute attribute with route parameter renaming.

Author: mitchdenny

src/Framework/AspNetCoreAnalyzers/src/Analyzers/RouteHandlers/DisallowNonParsableComplexTypesOnParameters.cs

@@ -64,8 +64,10 @@ private static void DisallowNonParsableComplexTypesOnParameters(
                 location
                 )) { continue; }
 
+            var routeParameterName = ResolveRouteParameterName(handlerDelegateParameter, wellKnownTypes);
+
             // Match handler parameter against route parameters. If it is a route parameter it needs to be parsable/bindable in some fashion.
-            if (routeUsage.RoutePattern.TryGetRouteParameter(handlerDelegateParameter.Name, out var routeParameter))
+            if (routeUsage.RoutePattern.TryGetRouteParameter(routeParameterName, out var routeParameter))
             {
                 var parsability = ParsabilityHelper.GetParsability(parameterTypeSymbol, wellKnownTypes);
                 var bindability = ParsabilityHelper.GetBindability(parameterTypeSymbol, wellKnownTypes);
@@ -77,7 +79,7 @@ private static void DisallowNonParsableComplexTypesOnParameters(
                     context.ReportDiagnostic(Diagnostic.Create(
                         descriptor,
                         location,
-                        routeParameter.Name,
+                        handlerDelegateParameter.Name,
                         parameterTypeSymbol.Name
                         ));
                 }
@@ -86,10 +88,36 @@ private static void DisallowNonParsableComplexTypesOnParameters(
             }
         }
 
-        static bool HasAttributeImplementingFromMetadataInterfaceType(IParameterSymbol parameter, WellKnownType fromMetadataInterfaceType, WellKnownTypes wellKnownTypes)
+        static string ResolveRouteParameterName(IParameterSymbol parameterSymbol, WellKnownTypes wellKnownTypes)
+        {
+            if (!TryGetFromMetadataInterfaceTypeAttributeData(parameterSymbol, WellKnownType.Microsoft_AspNetCore_Http_Metadata_IFromRouteMetadata, wellKnownTypes, out var attributeData))
+            {
+                return parameterSymbol.Name; // No route metadata attribute!
+            }
+
+            foreach (var namedArgument in attributeData.NamedArguments)
+            {
+                if (namedArgument.Key == "Name")
+                {
+                    var routeParameterNameConstant = namedArgument.Value;
+                    var routeParameterName = (string)routeParameterNameConstant.Value!;
+                    return routeParameterName; // Have attribute & name is specified.
+                }
+            }
+
+            return parameterSymbol.Name; // We have the attribute, but name isn't specified!
+        }
+
+        static bool TryGetFromMetadataInterfaceTypeAttributeData(IParameterSymbol parameterSymbol, WellKnownType fromMetadataInterfaceType, WellKnownTypes wellknowTypes, out AttributeData attributeData)
+        {
+            var fromMetadataInterfaceTypeSymbol = wellknowTypes.Get(fromMetadataInterfaceType);
+            attributeData = parameterSymbol.GetAttributes().SingleOrDefault(ad => ad.AttributeClass.Implements(fromMetadataInterfaceTypeSymbol))!;
+            return attributeData != null;
+        }
+
+        static bool HasAttributeImplementingFromMetadataInterfaceType(IParameterSymbol parameterSymbol, WellKnownType fromMetadataInterfaceType, WellKnownTypes wellKnownTypes)
         {
-            var fromMetadataInterfaceTypeSymbol = wellKnownTypes.Get(fromMetadataInterfaceType);
-            return parameter.GetAttributes().Any(ad => ad.AttributeClass.Implements(fromMetadataInterfaceTypeSymbol));
+            return TryGetFromMetadataInterfaceTypeAttributeData(parameterSymbol, fromMetadataInterfaceType, wellKnownTypes, out var _);
         }
 
         static bool ReportFromAttributeDiagnostic(OperationAnalysisContext context, WellKnownType fromMetadataInterfaceType, WellKnownTypes wellKnownTypes, IParameterSymbol parameter, INamedTypeSymbol parameterTypeSymbol, Location location)

src/Framework/AspNetCoreAnalyzers/test/RouteHandlers/DisallowNonParsableComplexTypesOnParametersTest.cs

@@ -203,6 +203,66 @@ public class Customer
         await VerifyCS.VerifyAnalyzerAsync(source, expectedDiagnostic);
     }
 
+    [Fact]
+    public async Task Route_Parameter_withNameChanged_viaFromRoute_whenNotParsable_Fails()
+    {
+        // Arrange
+        var source = $$"""
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Mvc;
+var webApp = WebApplication.Create();
+webApp.MapGet("/customers/{cust}", ({|#0:[FromRoute(Name = "cust")]Customer customer|}) => {});
+
+public class Customer
+{
+}
+""";
+
+        var expectedDiagnostic = new DiagnosticResult(DiagnosticDescriptors.RouteParameterComplexTypeIsNotParsableOrBindable)
+            .WithArguments("customer", "Customer")
+            .WithLocation(0);
+
+        // Act
+        await VerifyCS.VerifyAnalyzerAsync(source, expectedDiagnostic);
+    }
+
+    [Fact]
+    public async Task Route_Parameter_withNameChanged_viaFromRoute_whenParsable_Works()
+    {
+        // Arrange
+        var source = $$"""
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Mvc;
+var webApp = WebApplication.Create();
+webApp.MapGet("/customers/{cust}", ({|#0:[FromRoute(Name = "cust")]Customer customer|}) => {});
+
+public class Customer : IParsable<Customer>
+{
+    public static Customer Parse(string s, IFormatProvider provider)
+    {
+        if (TryParse(s, provider, out Customer customer))
+        {
+            return customer;
+        }
+        else
+        {
+            throw new ArgumentException(s);
+        }
+    }
+
+    public static bool TryParse(string s, IFormatProvider provider, out Customer result)
+    {
+        result = new Customer();
+        return true;
+    }
+}
+""";
+
+        // Act
+        await VerifyCS.VerifyAnalyzerAsync(source);
+    }
+
     [Fact]
     public async Task Route_Parameter_withBindAsyncMethodThatReturnsTask_of_T_Fails()
     {