fix: ViewLocatorDispatch contract ordering, thread safety, and defensive improvements

- Group dispatch branches by ViewModel type so contract-specific checks
  are emitted before the default branch (prevents shadowing)
- Escape contract strings with SymbolDisplay.FormatLiteral for safe codegen
- Use Interlocked.CompareExchange for thread-safe singleton view caching
- Fix strategyDoc for SingleInstanceView without parameterless constructor
- Move [ExcludeFromViewRegistration] check inside IViewFor<T> guard to
  prevent EnsureNotNull crash in compilations without ReactiveUI.Binding
- Add tests for grouped dispatch and contract-only dispatch (100% coverage)

Author: glennawatson

src/ReactiveUI.Binding.SourceGenerators/Generators/ViewLocatorDispatchGenerator.cs

@@ -6,6 +6,7 @@
 using System.Text;
 
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 
 using ReactiveUI.Binding.SourceGenerators.Helpers;
 using ReactiveUI.Binding.SourceGenerators.Models;
@@ -145,35 +146,41 @@ private static bool __RegisterViewDispatch()
                               {
                   """);
 
+        // Group registrations by ViewModel FQN so contract-specific checks
+        // are emitted before the default (no-contract) branch within a single
+        // type-switch block. Without grouping, a default branch emitted first
+        // would unconditionally match and shadow contract-specific branches.
+        var vmOrder = new List<string>(registrations.Count);
+        var vmGroupIndices = new Dictionary<string, List<int>>(registrations.Count);
         for (var i = 0; i < registrations.Count; i++)
         {
-            var reg = registrations[i];
-            var resolverMethodName = "__ResolveView_" + i;
+            var vmFqn = registrations[i].ViewModelFullyQualifiedName;
+            if (!vmGroupIndices.TryGetValue(vmFqn, out var indices))
+            {
+                indices = new List<int>();
+                vmGroupIndices[vmFqn] = indices;
+                vmOrder.Add(vmFqn);
+            }
+
+            indices.Add(i);
+        }
+
+        for (var g = 0; g < vmOrder.Count; g++)
+        {
+            var vmFqn = vmOrder[g];
+            var indices = vmGroupIndices[vmFqn];
 
             sb.AppendLine();
 
-            if (reg.Contract is not null)
+            if (indices.Count == 1)
             {
-                sb.Append($$"""
-                                    // {{reg.ViewModelFullyQualifiedName}} -> {{reg.ViewFullyQualifiedName}} [contract: "{{reg.Contract}}"]
-                                    if (instance is {{reg.ViewModelFullyQualifiedName}})
-                                    {
-                                        if (contract == "{{reg.Contract}}")
-                                        {
-                                            return {{resolverMethodName}}(contract);
-                                        }
-                                    }
-                        """);
+                // Single registration per VM: emit the compact form.
+                EmitSingleRegistrationDispatch(sb, registrations, indices[0]);
             }
             else
             {
-                sb.Append($$"""
-                                    // {{reg.ViewModelFullyQualifiedName}} -> {{reg.ViewFullyQualifiedName}}
-                                    if (instance is {{reg.ViewModelFullyQualifiedName}})
-                                    {
-                                        return {{resolverMethodName}}(contract);
-                                    }
-                        """);
+                // Multiple registrations for same VM: group into single type-switch.
+                EmitGroupedDispatch(sb, registrations, vmFqn, indices);
             }
         }
 
@@ -196,6 +203,100 @@ private static bool __RegisterViewDispatch()
                   """);
     }
 
+    /// <summary>
+    /// Emits a dispatch branch for a single registration (one view per VM type).
+    /// Preserves the compact output format used by existing tests.
+    /// </summary>
+    /// <param name="sb">The string builder.</param>
+    /// <param name="registrations">All registrations.</param>
+    /// <param name="index">The registration index.</param>
+    private static void EmitSingleRegistrationDispatch(StringBuilder sb, List<ViewRegistrationInfo> registrations, int index)
+    {
+        var reg = registrations[index];
+        var resolverMethodName = "__ResolveView_" + index;
+
+        if (reg.Contract is not null)
+        {
+            var escapedLiteral = SymbolDisplay.FormatLiteral(reg.Contract, true);
+            sb.Append($$"""
+                                    // {{reg.ViewModelFullyQualifiedName}} -> {{reg.ViewFullyQualifiedName}} [contract: {{escapedLiteral}}]
+                                    if (instance is {{reg.ViewModelFullyQualifiedName}})
+                                    {
+                                        if (contract == {{escapedLiteral}})
+                                        {
+                                            return {{resolverMethodName}}(contract);
+                                        }
+                                    }
+                        """);
+        }
+        else
+        {
+            sb.Append($$"""
+                                    // {{reg.ViewModelFullyQualifiedName}} -> {{reg.ViewFullyQualifiedName}}
+                                    if (instance is {{reg.ViewModelFullyQualifiedName}})
+                                    {
+                                        return {{resolverMethodName}}(contract);
+                                    }
+                        """);
+        }
+    }
+
+    /// <summary>
+    /// Emits a grouped dispatch branch for a VM type with multiple registrations.
+    /// Contract-specific checks are emitted first, with the default (no-contract) branch last.
+    /// </summary>
+    /// <param name="sb">The string builder.</param>
+    /// <param name="registrations">All registrations.</param>
+    /// <param name="vmFqn">The fully qualified VM type name.</param>
+    /// <param name="indices">The registration indices for this VM type.</param>
+    private static void EmitGroupedDispatch(StringBuilder sb, List<ViewRegistrationInfo> registrations, string vmFqn, List<int> indices)
+    {
+        sb.Append($$"""
+                                    // {{vmFqn}} — multiple views
+                                    if (instance is {{vmFqn}})
+                                    {
+                        """);
+
+        // Contract-specific branches first
+        for (var j = 0; j < indices.Count; j++)
+        {
+            var idx = indices[j];
+            var reg = registrations[idx];
+            if (reg.Contract is not null)
+            {
+                var escapedLiteral = SymbolDisplay.FormatLiteral(reg.Contract, true);
+                var resolverMethodName = "__ResolveView_" + idx;
+                sb.AppendLine().Append($$"""
+                                        // -> {{reg.ViewFullyQualifiedName}} [contract: {{escapedLiteral}}]
+                                        if (contract == {{escapedLiteral}})
+                                        {
+                                            return {{resolverMethodName}}(contract);
+                                        }
+                            """);
+            }
+        }
+
+        // Default (no-contract) branch last
+        for (var j = 0; j < indices.Count; j++)
+        {
+            var idx = indices[j];
+            var reg = registrations[idx];
+            if (reg.Contract is null)
+            {
+                var resolverMethodName = "__ResolveView_" + idx;
+                sb.AppendLine().Append($$"""
+                                        // -> {{reg.ViewFullyQualifiedName}} (default)
+                                        return {{resolverMethodName}}(contract);
+                            """);
+                break; // Only one default per VM (deduplicated earlier)
+            }
+        }
+
+        sb.AppendLine().Append("""
+                                    }
+                        """);
+    }
+
     /// <summary>
     /// Generates a per-view-model resolver method.
     /// </summary>
@@ -206,11 +307,13 @@ private static void GenerateResolverMethod(StringBuilder sb, ViewRegistrationInf
     {
         var methodName = "__ResolveView_" + index;
 
-        var strategyDoc = reg.IsSingleInstance
-            ? "        /// Returns a cached singleton instance (marked with [SingleInstanceView])."
-            : reg.HasParameterlessConstructor
-                ? "        /// Tries the service locator first, then falls back to direct construction."
-                : "        /// Service locator only — no direct construction available.";
+        var strategyDoc = (reg.IsSingleInstance, reg.HasParameterlessConstructor) switch
+        {
+            (true, true) => "        /// Returns a cached singleton instance (marked with [SingleInstanceView]).",
+            (true, false) => "        /// Service locator only — [SingleInstanceView] without parameterless constructor.",
+            (false, true) => "        /// Tries the service locator first, then falls back to direct construction.",
+            (false, false) => "        /// Service locator only — no direct construction available.",
+        };
 
         sb.AppendLine().Append($$"""
 
@@ -245,7 +348,10 @@ private static void GenerateResolverMethod(StringBuilder sb, ViewRegistrationInf
                                       // Fallback: singleton construction ({{reg.ViewFullyQualifiedName}} has [SingleInstanceView]).
                                       if ({{fieldName}} == null)
                                       {
-                                          {{fieldName}} = new {{reg.ViewFullyQualifiedName}}();
+                                          System.Threading.Interlocked.CompareExchange(
+                                              ref {{fieldName}},
+                                              new {{reg.ViewFullyQualifiedName}}(),
+                                              null);
                                       }
 
                                       return {{fieldName}};

src/ReactiveUI.Binding.SourceGenerators/Helpers/ViewRegistrationExtractor.cs

@@ -33,12 +33,6 @@ internal static class ViewRegistrationExtractor
             return null;
         }
 
-        // Skip types marked with [ExcludeFromViewRegistration]
-        if (HasAttribute(typeSymbol, Constants.ExcludeFromViewRegistrationAttributeMetadataName, semanticModel.Compilation))
-        {
-            return null;
-        }
-
         var iViewForGeneric = semanticModel.Compilation.GetTypeByMetadataName(
             Constants.IViewForGenericMetadataName);
 
@@ -54,6 +48,14 @@ internal static class ViewRegistrationExtractor
                 && SymbolEqualityComparer.Default.Equals(iface.OriginalDefinition, iViewForGeneric)
                 && iface.TypeArguments.Length == 1)
             {
+                // Check [ExcludeFromViewRegistration] only after confirming IViewFor<T> is
+                // resolvable, so attribute resolution via EnsureNotNull cannot throw in
+                // compilations that don't reference ReactiveUI.Binding.
+                if (HasAttribute(typeSymbol, Constants.ExcludeFromViewRegistrationAttributeMetadataName, semanticModel.Compilation))
+                {
+                    return null;
+                }
+
                 var viewModelType = iface.TypeArguments[0];
                 var viewModelFqn = viewModelType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
                 var viewFqn = typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);

src/tests/ReactiveUI.Binding.SourceGenerators.Tests/VDG.DefaultAndContractViewsDispatchCorrectly#GeneratedBinderRegistration.g.verified.cs

@@ -0,0 +1,24 @@
+//HintName: GeneratedBinderRegistration.g.cs
+// <auto-generated/>
+#pragma warning disable
+
+namespace ReactiveUI.Binding.Generated
+{
+    /// <summary>
+    /// Auto-generated binder registration. Registers high-affinity
+    /// ICreatesObservableForProperty implementations detected at compile time.
+    /// </summary>
+    [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    internal static class __GeneratedBinderRegistration
+    {
+        /// <summary>
+        /// Registers all generated binders with the Splat service locator.
+        /// </summary>
+        internal static void Initialize()
+        {
+            // Generated binder registrations will be added here in future phases.
+            // Each per-kind binder provides high-affinity observation for detected types.
+            // Detected types for kind: INPC
+        }
+    }
+}

src/tests/ReactiveUI.Binding.SourceGenerators.Tests/VDG.DefaultAndContractViewsDispatchCorrectly#GeneratedBindingsAttributes.g.verified.cs

@@ -0,0 +1,11 @@
+//HintName: GeneratedBindingsAttributes.g.cs
+// <auto-generated/>
+#pragma warning disable
+
+namespace ReactiveUI.Binding
+{
+    [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    internal static partial class __ReactiveUIGeneratedBindings
+    {
+    }
+}

src/tests/ReactiveUI.Binding.SourceGenerators.Tests/VDG.DefaultAndContractViewsDispatchCorrectly#ViewDispatch.g.verified.cs

@@ -0,0 +1,99 @@
+//HintName: ViewDispatch.g.cs
+// <auto-generated/>
+#pragma warning disable
+
+namespace ReactiveUI.Binding
+{
+    internal static partial class __ReactiveUIGeneratedBindings
+    {
+            /// <summary>
+            /// Triggers view dispatch registration when the generated bindings class is loaded.
+            /// </summary>
+            private static readonly bool __viewDispatchRegistered = __RegisterViewDispatch();
+
+            /// <summary>
+            /// Registers the source-generated view dispatch function with
+            /// <see cref="global::ReactiveUI.Binding.DefaultViewLocator"/>.
+            /// Called once via static field initializer when this class is first accessed.
+            /// </summary>
+            /// <returns>Always returns <see langword="true"/>.</returns>
+            private static bool __RegisterViewDispatch()
+            {
+                global::ReactiveUI.Binding.DefaultViewLocator.SetGeneratedViewDispatch(
+                    __TryResolveView);
+                return true;
+            }
+
+            /// <summary>
+            /// Compile-time generated type-switch dispatch for view resolution.
+            /// Attempts to resolve a view for the given view model instance without reflection.
+            /// </summary>
+            /// <param name="instance">The view model instance to resolve a view for.</param>
+            /// <param name="contract">The contract string (empty string for default).</param>
+            /// <returns>The resolved view, or <see langword="null"/> if no generated mapping exists.</returns>
+            private static global::ReactiveUI.Binding.IViewFor __TryResolveView(
+                object instance, string contract)
+            {
+            // global::TestApp.DashboardViewModel — multiple views
+            if (instance is global::TestApp.DashboardViewModel)
+            {
+            // -> global::TestApp.CompactDashboardView [contract: "compact"]
+            if (contract == "compact")
+            {
+                return __ResolveView_1(contract);
+            }
+            // -> global::TestApp.DashboardView (default)
+            return __ResolveView_0(contract);
+            }
+
+                // No compile-time mapping found; fall back to runtime resolution.
+                return null;
+            }
+
+            /// <summary>
+            /// Resolves a view for <see cref="global::TestApp.DashboardViewModel"/>.
+        /// Tries the service locator first, then falls back to direct construction.
+            /// </summary>
+            /// <param name="contract">The contract string (empty string for default).</param>
+            /// <returns>The resolved view, or <see langword="null"/> if resolution fails.</returns>
+            private static global::ReactiveUI.Binding.IViewFor __ResolveView_0(string contract)
+            {
+                // Normalize contract: empty string means no contract (null for Splat lookup).
+                string svcContract = contract.Length == 0 ? null : contract;
+
+                // Prefer service-locator-registered view (supports DI-configured instances).
+                var view = global::Splat.AppLocator.Current
+                    .GetService<global::ReactiveUI.Binding.IViewFor<global::TestApp.DashboardViewModel>>(
+                        svcContract);
+                if (view != null)
+                {
+                    return view;
+                }
+                    // Fallback: direct construction (global::TestApp.DashboardView has a parameterless constructor).
+                    return new global::TestApp.DashboardView();
+            }
+
+            /// <summary>
+            /// Resolves a view for <see cref="global::TestApp.DashboardViewModel"/>.
+        /// Tries the service locator first, then falls back to direct construction.
+            /// </summary>
+            /// <param name="contract">The contract string (empty string for default).</param>
+            /// <returns>The resolved view, or <see langword="null"/> if resolution fails.</returns>
+            private static global::ReactiveUI.Binding.IViewFor __ResolveView_1(string contract)
+            {
+                // Normalize contract: empty string means no contract (null for Splat lookup).
+                string svcContract = contract.Length == 0 ? null : contract;
+
+                // Prefer service-locator-registered view (supports DI-configured instances).
+                var view = global::Splat.AppLocator.Current
+                    .GetService<global::ReactiveUI.Binding.IViewFor<global::TestApp.DashboardViewModel>>(
+                        svcContract);
+                if (view != null)
+                {
+                    return view;
+                }
+                    // Fallback: direct construction (global::TestApp.CompactDashboardView has a parameterless constructor).
+                    return new global::TestApp.CompactDashboardView();
+            }
+    }
+}

src/tests/ReactiveUI.Binding.SourceGenerators.Tests/VDG.MultipleContractViewsWithoutDefault#GeneratedBinderRegistration.g.verified.cs

@@ -0,0 +1,24 @@
+//HintName: GeneratedBinderRegistration.g.cs
+// <auto-generated/>
+#pragma warning disable
+
+namespace ReactiveUI.Binding.Generated
+{
+    /// <summary>
+    /// Auto-generated binder registration. Registers high-affinity
+    /// ICreatesObservableForProperty implementations detected at compile time.
+    /// </summary>
+    [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    internal static class __GeneratedBinderRegistration
+    {
+        /// <summary>
+        /// Registers all generated binders with the Splat service locator.
+        /// </summary>
+        internal static void Initialize()
+        {
+            // Generated binder registrations will be added here in future phases.
+            // Each per-kind binder provides high-affinity observation for detected types.
+            // Detected types for kind: INPC
+        }
+    }
+}