Fix shared code references in analyzers and address feedback

Author: captainsafia

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

@@ -27,7 +27,7 @@ private static void AtMostOneFromBodyAttribute(
         foreach (var asParameterDecoratedParameter in asParametersDecoratedParameters)
         {
             var fromBodyMetadataInterfaceMembers = asParameterDecoratedParameter.Type.GetMembers().Where(
-                m => m.TryGetAttributeImplementingInterface(fromBodyMetadataInterfaceType)
+                m => m.HasAttributeImplementingInterface(fromBodyMetadataInterfaceType)
                 );
 
             if (fromBodyMetadataInterfaceMembers.Count() >= 2)
@@ -36,7 +36,7 @@ private static void AtMostOneFromBodyAttribute(
             }
         }
 
-        var fromBodyMetadataInterfaceParameters = methodSymbol.Parameters.Where(p => p.TryGetAttributeImplementingInterface(fromBodyMetadataInterfaceType));
+        var fromBodyMetadataInterfaceParameters = methodSymbol.Parameters.Where(p => p.HasAttributeImplementingInterface(fromBodyMetadataInterfaceType));
 
         if (fromBodyMetadataInterfaceParameters.Count() >= 2)
         {

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

@@ -98,7 +98,7 @@ static bool ReportFromAttributeDiagnostic(OperationAnalysisContext context, Well
         {
             var fromMetadataInterfaceTypeSymbol = wellKnownTypes.Get(fromMetadataInterfaceType);
             var parsability = ParsabilityHelper.GetParsability(parameterTypeSymbol, wellKnownTypes);
-            if (parameter.TryGetAttributeImplementingInterface(fromMetadataInterfaceTypeSymbol) && parsability != Parsability.Parsable)
+            if (parameter.HasAttributeImplementingInterface(fromMetadataInterfaceTypeSymbol) && parsability != Parsability.Parsable)
             {
                 context.ReportDiagnostic(Diagnostic.Create(
                     DiagnosticDescriptors.RouteParameterComplexTypeIsNotParsable,

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

@@ -142,16 +142,16 @@ private void ProcessEndpointParameterSource(Endpoint endpoint, ISymbol symbol, I
             }
             if (symbol is IPropertySymbol ||
                 Type is not INamedTypeSymbol namedTypeSymbol ||
-                !TryGetAsParametersConstructor(endpoint, namedTypeSymbol, out var isParameterlessConstructor, out var matchedParameters))
+                !TryGetAsParametersConstructor(endpoint, namedTypeSymbol, out var isDefaultConstructor, out var matchedProperties))
             {
                 if (symbol is IPropertySymbol)
                 {
                     endpoint.Diagnostics.Add(Diagnostic.Create(DiagnosticDescriptors.InvalidAsParametersNested, location));
                 }
                 return;
             }
-            EndpointParameters = matchedParameters.Select(matchedParameter => new EndpointParameter(endpoint, matchedParameter.Property, matchedParameter.Parameter, wellKnownTypes));
-            if (isParameterlessConstructor == true)
+            EndpointParameters = matchedProperties.Select(matchedParameter => new EndpointParameter(endpoint, matchedParameter.Property, matchedParameter.Parameter, wellKnownTypes));
+            if (isDefaultConstructor == true)
             {
                 var parameterList = string.Join(", ", EndpointParameters.Select(p => $"{p.LookupName} = {p.EmitHandlerArgument()}"));
                 AssigningCode = $"new {namedTypeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)} {{ {parameterList} }}";
@@ -471,10 +471,10 @@ private static string GetEscapedParameterName(AttributeData attribute, string pa
         }
     }
 
-    private static bool TryGetAsParametersConstructor(Endpoint endpoint, INamedTypeSymbol type, out bool? isParameterlessConstructor, [NotNullWhen(true)] out IEnumerable<ConstructorParameter>? matchedParameters)
+    private static bool TryGetAsParametersConstructor(Endpoint endpoint, INamedTypeSymbol type, out bool? isDefaultConstructor, [NotNullWhen(true)] out IEnumerable<ConstructorParameter>? matchedProperties)
     {
-        isParameterlessConstructor = null;
-        matchedParameters = null;
+        isDefaultConstructor = null;
+        matchedProperties = null;
         var parameterTypeString = type.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat);
         var location = endpoint.Operation.Syntax.GetLocation();
         if (type.IsAbstract)
@@ -492,7 +492,7 @@ private static bool TryGetAsParametersConstructor(Endpoint endpoint, INamedTypeS
 
         if (numOfConstructors == 1)
         {
-            var targetConstructor = constructors.SingleOrDefault();
+            var targetConstructor = constructors.Single();
             var lookupTable = new Dictionary<ParameterLookupKey, IPropertySymbol>();
             foreach (var property in properties)
             {
@@ -504,8 +504,8 @@ private static bool TryGetAsParametersConstructor(Endpoint endpoint, INamedTypeS
 
             if (parameters.Length == 0)
             {
-                isParameterlessConstructor = true;
-                matchedParameters = writableProperties.Select(property => new ConstructorParameter(property, null));
+                isDefaultConstructor = true;
+                matchedProperties = writableProperties.Select(property => new ConstructorParameter(property, null));
                 return true;
             }
 
@@ -523,15 +523,15 @@ private static bool TryGetAsParametersConstructor(Endpoint endpoint, INamedTypeS
                 }
             }
 
-            isParameterlessConstructor = false;
-            matchedParameters = propertiesWithParameterInfo;
+            isDefaultConstructor = false;
+            matchedProperties = propertiesWithParameterInfo;
             return true;
         }
 
         if (type.IsValueType)
         {
-            isParameterlessConstructor = true;
-            matchedParameters = writableProperties.Select(property => new ConstructorParameter(property, null));
+            isDefaultConstructor = true;
+            matchedProperties = writableProperties.Select(property => new ConstructorParameter(property, null));
             return true;
         }
 

src/Http/Http.Extensions/src/RequestDelegateFactory.cs

@@ -1495,7 +1495,7 @@ private static Expression BindParameterFromProperties(ParameterInfo parameter, R
             for (var i = 0; i < properties.Length; i++)
             {
                 // For parameterless ctor we will init only writable properties.
-                if (properties[i].CanWrite)
+                if (properties[i].CanWrite && properties[i].GetSetMethod(nonPublic: false) != null)
                 {
                     var parameterInfo = new PropertyAsParameterInfo(properties[i], factoryContext.NullabilityContext);
                     bindings.Add(Expression.Bind(properties[i], CreateArgument(parameterInfo, factoryContext)));

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

@@ -290,13 +290,15 @@ void TestAction(HttpContext context, [AsParameters] ParameterListWithReadOnlyPro
         httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.Value)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo);
         httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.ConstantValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo);
         httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.ReadOnlyValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo);
+        httpContext.Request.RouteValues[nameof(ParameterListWithReadOnlyProperties.PrivateSetValue)] = routeParamValue.ToString(NumberFormatInfo.InvariantInfo);
 
         await endpoint.RequestDelegate(httpContext);
 
         var input = Assert.IsType<ParameterListWithReadOnlyProperties>(httpContext.Items["input"]);
         Assert.Equal(expectedInput.Value, input.Value);
         Assert.Equal(expectedInput.ConstantValue, input.ConstantValue);
         Assert.Equal(expectedInput.ReadOnlyValue, input.ReadOnlyValue);
+        Assert.Equal(expectedInput.PrivateSetValue, input.PrivateSetValue);
     }
 
     [Fact]

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

@@ -799,13 +799,16 @@ public class ParameterListWithReadOnlyProperties
     public ParameterListWithReadOnlyProperties()
     {
         ReadOnlyValue = 1;
+        PrivateSetValue = 2;
     }
 
     public int Value { get; set; }
 
     public int ConstantValue => 1;
 
     public int ReadOnlyValue { get; }
+
+    public int PrivateSetValue { get; private set;  }
 }
 
 public record struct SampleParameterList(int Foo);