Make specifying the form name on [SupplyParameterFromForm] optional. Still needs more test updates.

Author: SteveSandersonMS

src/Components/Endpoints/src/FormMapping/HttpContextFormDataProvider.cs

@@ -2,24 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.Components.Endpoints;
 
 internal sealed class HttpContextFormDataProvider
 {
-    private string? _name;
+    private string? _incomingHandlerName;
     private IReadOnlyDictionary<string, StringValues>? _entries;
 
-    public string? Name => _name;
+    public string? IncomingHandlerName => _incomingHandlerName;
 
     public IReadOnlyDictionary<string, StringValues> Entries => _entries ?? ReadOnlyDictionary<string, StringValues>.Empty;
 
-    public bool IsFormDataAvailable => Name != null;
-
     public void SetFormData(string name, IReadOnlyDictionary<string, StringValues> form)
     {
-        _name = name;
+        _incomingHandlerName = name;
         _entries = form;
     }
+
+    public bool TryGetIncomingHandlerName([NotNullWhen(true)] out string? incomingHandlerName)
+    {
+        incomingHandlerName = _incomingHandlerName;
+        return incomingHandlerName is not null;
+    }
 }

src/Components/Endpoints/src/FormMapping/HttpContextFormValueMapper.cs

@@ -22,26 +22,58 @@ public HttpContextFormValueMapper(HttpContextFormDataProvider formData)
         _formData = formData;
     }
 
-    public bool CanMap(Type valueType, string? formName = null)
+    public bool CanMap(Type valueType, string scopeName, string? formName)
     {
-        if (formName == null)
+        // We must always match on scope
+        if (!_formData.TryGetIncomingHandlerName(out var incomingScopeQualifiedFormName)
+            || !MatchesScope(incomingScopeQualifiedFormName, scopeName, out var incomingFormName))
         {
-            return _options.ResolveConverter(valueType) != null;
+            return false;
         }
-        else
+
+        // Matching on formname is optional, enforced only if a nonempty form name was demanded by the receiver
+        if (formName is not null && !incomingFormName.Equals(formName, StringComparison.Ordinal))
         {
-            var result = _formData.IsFormDataAvailable &&
-                string.Equals(formName, _formData.Name, StringComparison.Ordinal) &&
-                _options.ResolveConverter(valueType) != null;
+            return false;
+        }
+
+        return _options.ResolveConverter(valueType) is not null;
+    }
 
-            return result;
+    private static bool MatchesScope(string incomingScopeQualifiedFormName, string currentMappingScopeName, out ReadOnlySpan<char> incomingFormName)
+    {
+        if (incomingScopeQualifiedFormName.StartsWith('['))
+        {
+            // The scope-qualified name is in the form "[scopename]formname", so validate that the [scopename]
+            // prefix matches and return the formname part
+            var incomingScopeQualifiedFormNameSpan = incomingScopeQualifiedFormName.AsSpan();
+            if (incomingScopeQualifiedFormNameSpan[1..].StartsWith(currentMappingScopeName, StringComparison.Ordinal)
+                && incomingScopeQualifiedFormName.Length >= currentMappingScopeName.Length + 2
+                && incomingScopeQualifiedFormName[currentMappingScopeName.Length + 1] == ']')
+            {
+                incomingFormName = incomingScopeQualifiedFormNameSpan[(currentMappingScopeName.Length + 1)..];
+                return true;
+            }
         }
+        else
+        {
+            // The scope-qualified name is in the form "formname", so validating that the scopename matches
+            // means checking that it's empty
+            if (string.IsNullOrEmpty(currentMappingScopeName))
+            {
+                incomingFormName = incomingScopeQualifiedFormName;
+                return true;
+            }
+        }
+
+        incomingFormName = default;
+        return false;
     }
 
     public void Map(FormValueMappingContext context)
     {
         // This will func to a proper binder
-        if (!CanMap(context.ValueType, context.FormName))
+        if (!CanMap(context.ValueType, context.MappingScopeName, context.RestrictToFormName))
         {
             context.SetResult(null);
         }

src/Components/Web/src/Forms/Mapping/FormMappingContext.cs

@@ -14,16 +14,16 @@ public sealed class FormMappingContext
     private List<KeyValuePair<string, FormMappingError>>? _pendingErrors;
     private Dictionary<string, Dictionary<string, FormMappingError>>? _errorsByFormName;
 
-    internal FormMappingContext(string name)
+    internal FormMappingContext(string mappingScopeName)
     {
-        ArgumentNullException.ThrowIfNull(name);
-        Name = name;
+        ArgumentNullException.ThrowIfNull(mappingScopeName);
+        MappingScopeName = mappingScopeName;
     }
 
     /// <summary>
-    /// The context name.
+    /// The mapping scope name.
     /// </summary>
-    public string Name { get; }
+    public string MappingScopeName { get; }
 
     /// <summary>
     /// Retrieves the list of errors for a given model key.
@@ -92,18 +92,6 @@ public IEnumerable<FormMappingError> GetAllErrors(string formName)
         _errorsByFormName?.TryGetValue(formName, out var formErrors) == true &&
             formErrors.TryGetValue(key, out var mappingError) ? mappingError.AttemptedValue : null;
 
-    internal string GetScopeQualifiedFormName(string? formHandlerName)
-    {
-        if (string.IsNullOrEmpty(Name))
-        {
-            return string.IsNullOrEmpty(formHandlerName) ? string.Empty : formHandlerName;
-        }
-        else
-        {
-            return string.IsNullOrEmpty(formHandlerName) ? Name : $"{Name}.{formHandlerName}";
-        }
-    }
-
     internal void AddError(string key, FormattableString error, string? attemptedValue)
     {
         _errors ??= new Dictionary<string, FormMappingError>();

src/Components/Web/src/Forms/Mapping/FormMappingScope.cs

@@ -43,6 +43,13 @@ Task IComponent.SetParametersAsync(ParameterView parameters)
             {
                 throw new InvalidOperationException($"The {nameof(FormMappingScope)} component requires a nonempty {nameof(Name)} parameter value.");
             }
+            else if (Name.StartsWith('['))
+            {
+                // We use "scope-qualified form name starts with [" as a signal that there's a nonempty scope, so don't let the name itself start that way
+                // Alternatively we could avoid packing both the scope and form name into a single string, or use some encoding. However it's very unlikely
+                // this restriction will affect anyone, and the exact representation is an internal implementation detail.
+                throw new InvalidOperationException($"The mapping scope name '{Name}' starts with a disallowed character.");
+            }
 
             _cascadingValueSupplier = new SupplyParameterFromFormValueProvider(FormValueModelBinder, Name);
         }

src/Components/Web/src/Forms/Mapping/FormValueMappingContext.cs

@@ -13,24 +13,31 @@ public class FormValueMappingContext
     /// <summary>
     /// Initializes a new instance of <see cref="FormValueMappingContext"/>.
     /// </summary>
-    /// <param name="formName">The name of the form to map data from.</param>
+    /// <param name="mappingScopeName">The name of the current <see cref="FormMappingScope"/>. Values will only be mapped if the incoming data corresponds to this scope name.</param>
+    /// <param name="restrictToFormName">If set, indicates that the mapping should only receive values if the incoming form matches this name. If null, the mapping should receive data from any form in the mapping scope.</param>
     /// <param name="valueType">The <see cref="Type"/> of the value to map.</param>
     /// <param name="parameterName">The name of the parameter to map data to.</param>
-    public FormValueMappingContext(string formName, Type valueType, string parameterName)
+    public FormValueMappingContext(string mappingScopeName, string? restrictToFormName, Type valueType, string parameterName)
     {
-        ArgumentNullException.ThrowIfNull(formName, nameof(formName));
+        ArgumentNullException.ThrowIfNull(mappingScopeName, nameof(mappingScopeName));
         ArgumentNullException.ThrowIfNull(valueType, nameof(valueType));
         ArgumentNullException.ThrowIfNull(parameterName, nameof(parameterName));
 
-        FormName = formName;
+        MappingScopeName = mappingScopeName;
+        RestrictToFormName = restrictToFormName;
         ParameterName = parameterName;
         ValueType = valueType;
     }
 
     /// <summary>
-    /// Gets the name of the form to map data from.
+    /// Gets the name of the current <see cref="FormMappingScope"/>.
     /// </summary>
-    public string FormName { get; }
+    public string MappingScopeName { get; }
+
+    /// <summary>
+    /// If set, indicates that the mapping should only receive values if the incoming form matches this name. If null, the mapping should receive data from any form in the mapping scope.
+    /// </summary>
+    public string? RestrictToFormName { get; }
 
     /// <summary>
     /// Gets the name of the parameter to map data to.

src/Components/Web/src/Forms/Mapping/IFormValueMapper.cs

@@ -12,9 +12,10 @@ public interface IFormValueMapper
     /// Determines whether the specified value type can be mapped.
     /// </summary>
     /// <param name="valueType">The <see cref="Type"/> for the value to map.</param>
-    /// <param name="scopeQualifiedFormName">The form name to map data from or null to only validate the type can be mapped.</param>
+    /// <param name="scopeName">The name of the current <see cref="FormMappingScope"/>.</param>
+    /// <param name="formName">The form name, if values should only be provided for that form, or null to allow values from any form within the scope.</param>
     /// <returns><c>true</c> if the value type can be mapped; otherwise, <c>false</c>.</returns>
-    bool CanMap(Type valueType, string? scopeQualifiedFormName = null);
+    bool CanMap(Type valueType, string scopeName, string? formName);
 
     /// <summary>
     /// Maps the form value with the specified name to a value of the specified type.

src/Components/Web/src/Forms/Mapping/SupplyParameterFromFormValueProvider.cs

@@ -40,8 +40,7 @@ public bool CanSupplyValue(in CascadingParameterInfo parameterInfo)
         // We also supply values for [SupplyValueFromForm]
         if (_formValueMapper is not null && parameterInfo.Attribute is SupplyParameterFromFormAttribute supplyParameterFromFormAttribute)
         {
-            var scopeQualifiedFormName = _mappingContext.GetScopeQualifiedFormName(supplyParameterFromFormAttribute.Handler);
-            return _formValueMapper.CanMap(parameterInfo.PropertyType, scopeQualifiedFormName);
+            return _formValueMapper.CanMap(parameterInfo.PropertyType, MappingScopeName, supplyParameterFromFormAttribute.Handler);
         }
 
         return false;
@@ -73,15 +72,14 @@ void ICascadingValueSupplier.Unsubscribe(ComponentState subscriber, in Cascading
     internal static object? GetFormPostValue(IFormValueMapper formValueMapper, FormMappingContext? mappingContext, in CascadingParameterInfo parameterInfo, SupplyParameterFromFormAttribute supplyParameterFromFormAttribute)
     {
         Debug.Assert(mappingContext != null);
-        var scopeQualifiedFormName = mappingContext.GetScopeQualifiedFormName(supplyParameterFromFormAttribute.Handler);
 
         var parameterName = parameterInfo.Attribute.Name ?? parameterInfo.PropertyName;
-        var handler = ((SupplyParameterFromFormAttribute)parameterInfo.Attribute).Handler;
-        Action<string, FormattableString, string?> errorHandler = string.IsNullOrEmpty(handler) ?
+        var restrictToFormName = ((SupplyParameterFromFormAttribute)parameterInfo.Attribute).Handler;
+        Action<string, FormattableString, string?> errorHandler = string.IsNullOrEmpty(restrictToFormName) ?
             mappingContext.AddError :
-            (name, message, value) => mappingContext.AddError(scopeQualifiedFormName, parameterName, message, value);
+            (name, message, value) => mappingContext.AddError(restrictToFormName, parameterName, message, value);
 
-        var context = new FormValueMappingContext(scopeQualifiedFormName, parameterInfo.PropertyType, parameterName)
+        var context = new FormValueMappingContext(mappingContext.MappingScopeName, restrictToFormName, parameterInfo.PropertyType, parameterName)
         {
             OnError = errorHandler,
             MapErrorToContainer = mappingContext.AttachParentValue

src/Components/Web/src/HtmlRendering/StaticHtmlRenderer.HtmlWriting.cs

@@ -194,7 +194,7 @@ protected bool TryGetScopeQualifiedEventName(int componentId, string eventName,
     {
         if (FindFormMappingContext(componentId) is { } formMappingContext)
         {
-            scopeQualifiedEventName = formMappingContext.GetScopeQualifiedFormName(eventName);
+            scopeQualifiedEventName = CreateScopeQualifiedFormName(formMappingContext, eventName);
             return true;
         }
         else
@@ -215,6 +215,19 @@ protected bool TryGetScopeQualifiedEventName(int componentId, string eventName,
         return (FormMappingContext?)supplier?.GetCurrentValue(_findFormMappingContext);
     }
 
+    internal string CreateScopeQualifiedFormName(FormMappingContext mappingContext, string? formHandlerName)
+    {
+        var mappingScopeName = mappingContext.MappingScopeName;
+        if (string.IsNullOrEmpty(mappingScopeName))
+        {
+            return formHandlerName ?? string.Empty;
+        }
+        else
+        {
+            return $"[{mappingScopeName}]{formHandlerName ?? string.Empty}";
+        }
+    }
+
     private static bool TryFindEnclosingElementFrame(ArrayRange<RenderTreeFrame> frames, int frameIndex, out int result)
     {
         while (--frameIndex >= 0)

src/Components/Web/src/PublicAPI.Unshipped.txt

@@ -25,7 +25,7 @@ Microsoft.AspNetCore.Components.Forms.FormMappingContext.GetAttemptedValue(strin
 Microsoft.AspNetCore.Components.Forms.FormMappingContext.GetAttemptedValue(string! key) -> string?
 Microsoft.AspNetCore.Components.Forms.FormMappingContext.GetErrors(string! formName, string! key) -> Microsoft.AspNetCore.Components.Forms.Mapping.FormMappingError?
 Microsoft.AspNetCore.Components.Forms.FormMappingContext.GetErrors(string! key) -> Microsoft.AspNetCore.Components.Forms.Mapping.FormMappingError?
-Microsoft.AspNetCore.Components.Forms.FormMappingContext.Name.get -> string!
+Microsoft.AspNetCore.Components.Forms.FormMappingContext.MappingScopeName.get -> string!
 Microsoft.AspNetCore.Components.Forms.FormMappingScope
 Microsoft.AspNetCore.Components.Forms.FormMappingScope.ChildContent.get -> Microsoft.AspNetCore.Components.RenderFragment<Microsoft.AspNetCore.Components.Forms.FormMappingContext!>!
 Microsoft.AspNetCore.Components.Forms.FormMappingScope.ChildContent.set -> void
@@ -42,18 +42,19 @@ Microsoft.AspNetCore.Components.Forms.Mapping.FormMappingError.ErrorMessages.get
 Microsoft.AspNetCore.Components.Forms.Mapping.FormMappingError.Name.get -> string!
 Microsoft.AspNetCore.Components.Forms.Mapping.FormMappingError.Path.get -> string!
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext
-Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.FormName.get -> string!
-Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.FormValueMappingContext(string! formName, System.Type! valueType, string! parameterName) -> void
+Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.FormValueMappingContext(string! mappingScopeName, string? restrictToFormName, System.Type! valueType, string! parameterName) -> void
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.MapErrorToContainer.get -> System.Action<string!, object!>?
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.MapErrorToContainer.set -> void
+Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.MappingScopeName.get -> string!
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.OnError.get -> System.Action<string!, System.FormattableString!, string?>?
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.OnError.set -> void
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.ParameterName.get -> string!
+Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.RestrictToFormName.get -> string?
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.Result.get -> object?
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.SetResult(object? result) -> void
 Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext.ValueType.get -> System.Type!
 Microsoft.AspNetCore.Components.Forms.Mapping.IFormValueMapper
-Microsoft.AspNetCore.Components.Forms.Mapping.IFormValueMapper.CanMap(System.Type! valueType, string? scopeQualifiedFormName = null) -> bool
+Microsoft.AspNetCore.Components.Forms.Mapping.IFormValueMapper.CanMap(System.Type! valueType, string! scopeName, string? formName) -> bool
 Microsoft.AspNetCore.Components.Forms.Mapping.IFormValueMapper.Map(Microsoft.AspNetCore.Components.Forms.Mapping.FormValueMappingContext! context) -> void
 Microsoft.AspNetCore.Components.Forms.Mapping.SupplyParameterFromFormServiceCollectionExtensions
 Microsoft.AspNetCore.Components.HtmlRendering.Infrastructure.StaticHtmlRenderer

src/Components/Web/test/Forms/Mapping/FormMappingContextTest.cs

@@ -11,13 +11,13 @@ public class FormMappingContextTest
     public void CanCreate_MappingContext_WithDefaultName()
     {
         var context = new FormMappingContext("");
-        Assert.Equal("", context.Name);
+        Assert.Equal("", context.MappingScopeName);
     }
 
     [Fact]
     public void CanCreate_MappingContext_WithName()
     {
         var context = new FormMappingContext("name");
-        Assert.Equal("name", context.Name);
+        Assert.Equal("name", context.MappingScopeName);
     }
 }

src/Components/Web/test/Forms/Mapping/FormMappingScopeTest.cs

@@ -41,7 +41,7 @@ public void SuppliesMappingContext()
 
         // Assert
         Assert.NotNull(capturedContext);
-        Assert.Equal("named-context", capturedContext.Name);
+        Assert.Equal("named-context", capturedContext.MappingScopeName);
     }
 
     [Fact]
@@ -71,7 +71,7 @@ public void CanNestToOverride()
 
         // Assert
         Assert.NotNull(capturedContext);
-        Assert.Equal("child-context", capturedContext.Name);
+        Assert.Equal("child-context", capturedContext.MappingScopeName);
     }
 
     [Theory]

src/Components/test/testassets/Components.TestServer/RazorComponents/Pages/Forms/ActionForm.cs

@@ -46,7 +46,7 @@ RenderFragment RenderWithNamedContext(FormMappingContext context)
         void RenderFormContents(RenderTreeBuilder builder, FormMappingContext? bindingContext)
         {
             builder.OpenElement(0, "form");
-            builder.AddAttribute(1, "name", bindingContext.Name);
+            builder.AddAttribute(1, "name", bindingContext.MappingScopeName);
             builder.AddAttribute(6, "method", "POST");
             builder.AddAttribute(7, "onsubmit", async () => await OnSubmit.InvokeAsync(bindingContext));