Align generic polymorphism failure semantics

Match the refined System.Text.Json behavior by rejecting derived-type registrations that fail for the requested closed base, including specialization mismatches and generic constraint violations. Expand source-generation, reflection, and cross-provider coverage for the runtime regression matrix.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: f5ead997-2f05-463d-acd9-1dbcbd15b13e

Author: eiriktsarpalis

docs/docs/shape-providers.md

@@ -348,42 +348,17 @@ record Mid<T> : Base<List<T>>;
 record Leaf<T>(List<T> Items) : Mid<T>;
 ```
 
-Open generic derived types are rejected at compile-time (for the source generator) or shape-construction time (for the reflection provider) when the registration is *fundamentally* invalid -- that is, no instantiation of the base type could ever satisfy it:
+Open generic derived types are rejected at compile time (for the source generator) or shape-construction time (for the reflection provider) when the registration cannot be resolved for the requested base type:
 
 * The derived type does not derive from or implement *any* instantiation of the base type.
+* The derived type targets a different construction of the generic base — e.g. `Derived<T> : Base<T, int>` registered for `Base<string, string>`.
 * The derived type has type parameters that cannot be inferred from any base specification — e.g. `Derived<T, U> : Base<T>` leaves `U` unbound.
+* The inferred type arguments do not satisfy a generic constraint declared by the derived type.
 * The derived type matches more than one ancestor instantiation of the base — only relevant for interface bases.
 
 The source generator emits diagnostic `PT0013` for these failures with a short message describing the reason; the reflection provider throws `InvalidOperationException` with an equivalent message.
 
-#### Per-instantiation filtering
-
-A registration that is well-formed in isolation but does not apply to the *particular* closed base being resolved is silently filtered rather than reported as an error. This allows a single declaration to span multiple closed instantiations naturally:
-
-```csharp
-// Cat targets Animal<int>; Dog targets Animal<string>. The two attributes coexist:
-// when resolving Animal<int>, Cat is included and Dog is filtered; the converse holds for Animal<string>.
-[DerivedTypeShape(typeof(Cat))]
-[DerivedTypeShape(typeof(Dog))]
-partial class Animal<T>;
-class Cat : Animal<int>;
-class Dog : Animal<string>;
-```
-
-```csharp
-// A constraint on the derived type filters per closed base. For Base<List<int>> the derivation
-// applies; for Base<string> (where string does not implement IEnumerable<int>) it is filtered.
-[DerivedTypeShape(typeof(Derived<>))]
-partial class Base<T>;
-class Derived<T> : Base<T> where T : IEnumerable<int>;
-```
-
-The two failure modes that are silently filtered (rather than diagnosed) are:
-
-* **Unification mismatch** — a closed derived registered for `Base<int>` simply does not apply when resolving `Base<string>`; the same is true for an open derived whose base specification cannot be unified with the requested closed base (e.g. `Wrapped<T> : Base<List<T>>` against `Base<int>`).
-* **Constraint violation** — the resolved substitution does not satisfy a `where T : …` constraint on the derived type for this particular closed base.
-
-In both cases the registration is dropped silently; if all registrations are filtered out, the resulting union shape simply has no derived cases.
+Every declared registration participates in the union configuration. PolyType does not filter registrations that only apply to another closed construction of the base. For example, registering both `Cat : Animal<int>` and `Dog : Animal<string>` on `Animal<T>` makes the configuration invalid for either closed base because one registration is not assignable. Define separate closed base declarations when different constructions require different derived-type sets.
 
 ### PropertyShapeAttribute
 

src/PolyType.SourceGenerator/Helpers/OpenGenericDerivedTypeHelpers.cs

@@ -5,8 +5,8 @@
 // behaviour in sync.
 //
 // The algorithm is a port of the resolver added in dotnet/runtime#127318 (System.Text.Json
-// support for open generic [JsonDerivedType]). See the PR description for the full set of
-// supported and rejected patterns.
+// support for open generic [JsonDerivedType]), with failure semantics aligned to the refinements
+// in dotnet/runtime#130808. See those PRs for the supported and rejected patterns.
 
 using Microsoft.CodeAnalysis;
 using PolyType.Roslyn.Helpers;
@@ -406,15 +406,3 @@ internal enum OpenGenericResolutionFailure
     /// <summary>The derived type matches the base type through multiple distinct ancestors.</summary>
     AmbiguousMatch,
 }
-
-internal static class OpenGenericResolutionFailureExtensions
-{
-    // Returns true when the failure is caused by the registration not matching THIS particular
-    // closed base, but where the same registration could plausibly apply to a different
-    // instantiation of the base. Such failures are silently skipped rather than reported as
-    // diagnostics, allowing a single attribute on an open base to span multiple closed
-    // instantiations naturally.
-    public static bool IsPerInstantiationFailure(this OpenGenericResolutionFailure failure) =>
-        failure is OpenGenericResolutionFailure.UnificationFailed
-            or OpenGenericResolutionFailure.ConstraintViolation;
-}

src/PolyType.SourceGenerator/Parser/Parser.cs

@@ -625,14 +625,6 @@ protected override IEnumerable<DerivedTypeModel> ResolveDerivedTypes(ITypeSymbol
             {
                 if (!TryResolveOpenGenericDerivedType(namedDerivedType, type, out INamedTypeSymbol? specializedDerivedType, out OpenGenericResolutionFailure? failure, out string? failedDetail))
                 {
-                    if (failure!.Value.IsPerInstantiationFailure())
-                    {
-                        // The registration is valid in isolation but does not apply to this
-                        // particular closed base. A different closed instantiation of the
-                        // same base definition may still match it; silently skip.
-                        continue;
-                    }
-
                     ReportDiagnostic(DerivedTypeUnsupportedGenerics, attribute.GetLocation(), derivedType.ToDisplayString(), type.ToDisplayString(), FormatOpenGenericFailureReason(failure!.Value, failedDetail));
                     continue;
                 }
@@ -641,16 +633,6 @@ protected override IEnumerable<DerivedTypeModel> ResolveDerivedTypes(ITypeSymbol
             }
             else if (!type.IsAssignableFrom(derivedType))
             {
-                // The closed derived type does not fit this particular closed base. If the
-                // base is a generic instantiation AND the derived inherits from some other
-                // instantiation of the same base definition, silently skip -- the registration
-                // is targeted at a different closed base. Otherwise treat as a hard error.
-                if (type is INamedTypeSymbol { IsGenericType: true } namedBase &&
-                    derivedType.GetCompatibleGenericBaseTypes(namedBase.OriginalDefinition).Any())
-                {
-                    continue;
-                }
-
                 ReportDiagnostic(DerivedTypeNotAssignableToBase, attribute.GetLocation(), derivedType.ToDisplayString(), type.ToDisplayString());
                 continue;
             }

src/PolyType.TestCases/TestTypes.cs

@@ -612,6 +612,29 @@ public static IEnumerable<ITestCase> GetTestCasesCore()
             (OpenGenericMultiLevelBase<List<int>>)new OpenGenericMultiLevelLeaf<int>([10, 20]),
             isUnion: true,
             provider: p);
+        yield return TestCase.Create(
+            (OpenGenericRepeatedBase<int, int>)new OpenGenericRepeatedDerived<int>(1, 2, "valid"),
+            isUnion: true,
+            provider: p);
+        yield return TestCase.Create(
+            (OpenGenericInterfaceConstraintBase<List<int>>)new OpenGenericInterfaceConstraintDerived<List<int>>([1, 2], "valid"),
+            isUnion: true,
+            provider: p);
+        yield return TestCase.Create(
+            (OpenGenericNewConstraintBase<OpenGenericNewConstraintArgument>)new OpenGenericNewConstraintDerived<OpenGenericNewConstraintArgument>(new() { Value = 42 }, "valid"),
+            isUnion: true,
+            provider: p);
+        yield return TestCase.Create(
+            (OpenGenericDeepJaggedBase<List<int[][][]>>)new OpenGenericDeepJaggedDerived<int>(
+            [
+                [
+                    [
+                        [1, 2],
+                    ],
+                ],
+            ]),
+            isUnion: true,
+            provider: p);
 
         yield return TestCase.Create(new RecordWithoutNamespace(42));
         yield return TestCase.Create(new GenericRecordWithoutNamespace<int>(42), p);
@@ -2771,6 +2794,29 @@ public partial record OpenGenericMultiLevelBase<T>;
 public partial record OpenGenericMultiLevelMid<T> : OpenGenericMultiLevelBase<List<T>>;
 public partial record OpenGenericMultiLevelLeaf<T>(List<T> Items) : OpenGenericMultiLevelMid<T>;
 
+[DerivedTypeShape(typeof(OpenGenericRepeatedDerived<>), Name = "repeated")]
+public partial record OpenGenericRepeatedBase<T1, T2>;
+public partial record OpenGenericRepeatedDerived<T>(T First, T Second, string Marker) : OpenGenericRepeatedBase<T, T>;
+
+[DerivedTypeShape(typeof(OpenGenericInterfaceConstraintDerived<>), Name = "interfaceConstraint")]
+public partial record OpenGenericInterfaceConstraintBase<T>;
+public partial record OpenGenericInterfaceConstraintDerived<T>(T Value, string Marker) : OpenGenericInterfaceConstraintBase<T>
+    where T : IEnumerable<int>;
+
+[DerivedTypeShape(typeof(OpenGenericNewConstraintDerived<>), Name = "newConstraint")]
+public partial record OpenGenericNewConstraintBase<T>;
+public partial record OpenGenericNewConstraintDerived<T>(T Value, string Marker) : OpenGenericNewConstraintBase<T>
+    where T : class, new();
+
+public partial class OpenGenericNewConstraintArgument
+{
+    public int Value { get; set; }
+}
+
+[DerivedTypeShape(typeof(OpenGenericDeepJaggedDerived<>), Name = "deepJagged")]
+public partial record OpenGenericDeepJaggedBase<T>;
+public partial record OpenGenericDeepJaggedDerived<T>(List<T[][][]> Value) : OpenGenericDeepJaggedBase<List<T[][][]>>;
+
 [GenerateShape]
 public partial record PropertyRequiredByAttribute
 {
@@ -3599,6 +3645,10 @@ public delegate Task<int> LargeAsyncDelegate(
 [GenerateShapeFor<OpenGenericArrayBase<int[]>>]
 [GenerateShapeFor<IOpenGenericInterfaceBase<int>>]
 [GenerateShapeFor<OpenGenericMultiLevelBase<List<int>>>]
+[GenerateShapeFor<OpenGenericRepeatedBase<int, int>>]
+[GenerateShapeFor<OpenGenericInterfaceConstraintBase<List<int>>>]
+[GenerateShapeFor<OpenGenericNewConstraintBase<OpenGenericNewConstraintArgument>>]
+[GenerateShapeFor<OpenGenericDeepJaggedBase<List<int[][][]>>>]
 [GenerateShapeFor<GenericRecordWithoutNamespace<int>>]
 [GenerateShapeFor<GenericContainerWithoutNamespace<int>.Record<string>>]
 [GenerateShapeFor<IAsyncEnumerable<int>>]

src/PolyType/ReflectionProvider/OpenGenericDerivedTypeResolver.cs

@@ -5,8 +5,8 @@
 // behaviour in sync.
 //
 // The algorithm is a port of the resolver added in dotnet/runtime#127318 (System.Text.Json
-// support for open generic [JsonDerivedType]). See the PR description for the full set of
-// supported and rejected patterns.
+// support for open generic [JsonDerivedType]), with failure semantics aligned to the refinements
+// in dotnet/runtime#130808. See those PRs for the supported and rejected patterns.
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -176,16 +176,13 @@ public static bool TryResolveOpenGenericDerivedType(
         Type openDerivedType,
         Type baseType,
         [NotNullWhen(true)] out Type? closedDerivedType,
-        [NotNullWhen(false)] out string? failureReason,
-        out OpenGenericResolutionFailureKind failureKind)
+        [NotNullWhen(false)] out string? failureReason)
     {
         closedDerivedType = null;
         failureReason = null;
-        failureKind = default;
 
         if (!baseType.IsGenericType)
         {
-            failureKind = OpenGenericResolutionFailureKind.NotAssignable;
             failureReason = "the derived type is not assignable to the base type";
             return false;
         }
@@ -205,7 +202,6 @@ public static bool TryResolveOpenGenericDerivedType(
 
         if (matchingBases.Count == 0)
         {
-            failureKind = OpenGenericResolutionFailureKind.NotAssignable;
             failureReason = "the derived type is not assignable to the base type";
             return false;
         }
@@ -231,7 +227,6 @@ public static bool TryResolveOpenGenericDerivedType(
         {
             if (!referencedParams.Contains(required))
             {
-                failureKind = OpenGenericResolutionFailureKind.UnboundParameter;
                 failureReason = $"the type parameter '{required.Name}' of the derived type is not bound by the base type's arguments";
                 return false;
             }
@@ -292,15 +287,13 @@ public static bool TryResolveOpenGenericDerivedType(
             }
             else
             {
-                failureKind = OpenGenericResolutionFailureKind.AmbiguousMatch;
                 failureReason = "the derived type matches the base type through multiple ancestors";
                 return false;
             }
         }
 
         if (successCount == 0 || successfulArgs is null)
         {
-            failureKind = OpenGenericResolutionFailureKind.UnificationFailed;
             failureReason = "the base type's arguments do not match the derived type's base specification";
             return false;
         }
@@ -312,41 +305,8 @@ public static bool TryResolveOpenGenericDerivedType(
         }
         catch (Exception ex) when (ex is ArgumentException or TypeLoadException)
         {
-            failureKind = OpenGenericResolutionFailureKind.ConstraintViolation;
             failureReason = "the closed derived type would violate one of its declared generic constraints";
             return false;
         }
     }
 }
-
-// Identifies why an open generic derived type could not be resolved against a constructed base.
-// Mirrors PolyType.SourceGenerator.Helpers.OpenGenericResolutionFailure on the source-gen side.
-internal enum OpenGenericResolutionFailureKind
-{
-    /// <summary>The derived type cannot be assigned to the base type (no matching ancestor at all).</summary>
-    NotAssignable,
-
-    /// <summary>A matching ancestor exists but its type arguments do not unify with this particular closed base.</summary>
-    UnificationFailed,
-
-    /// <summary>One of the derived type's parameters is not referenced by any matching ancestor's base specification.</summary>
-    UnboundParameter,
-
-    /// <summary>The resolved substitution does not satisfy the derived type's declared generic constraints.</summary>
-    ConstraintViolation,
-
-    /// <summary>The derived type unifies with the closed base through more than one ancestor.</summary>
-    AmbiguousMatch,
-}
-
-// Helpers for classifying open generic resolution failures.
-internal static class OpenGenericResolutionFailureKindExtensions
-{
-    // Returns true when the failure is caused by the registration not matching THIS particular
-    // closed base, but where the same registration could plausibly apply to a different
-    // instantiation of the base. Callers that close attributes against a specific base may
-    // silently skip such registrations rather than surfacing them as errors.
-    public static bool IsPerInstantiationFailure(this OpenGenericResolutionFailureKind kind) =>
-        kind is OpenGenericResolutionFailureKind.UnificationFailed
-            or OpenGenericResolutionFailureKind.ConstraintViolation;
-}

src/PolyType/ReflectionProvider/ReflectionTypeShapeProvider.cs

@@ -329,17 +329,8 @@ private IUnionTypeShape CreateUnionTypeShape(Type unionType, FSharpUnionInfo? fS
                         derivedType,
                         unionType,
                         out Type? closedDerivedType,
-                        out string? failureReason,
-                        out OpenGenericResolutionFailureKind failureKind))
+                        out string? failureReason))
                 {
-                    if (failureKind.IsPerInstantiationFailure())
-                    {
-                        // The registration is valid in isolation but does not apply to this
-                        // particular closed base. A different closed instantiation of the
-                        // same base definition may still match it; silently skip.
-                        continue;
-                    }
-
                     throw new InvalidOperationException(
                         $"The declared open generic derived type '{derivedType}' could not be resolved against the polymorphic base type '{unionType}': {failureReason}.");
                 }
@@ -348,17 +339,6 @@ private IUnionTypeShape CreateUnionTypeShape(Type unionType, FSharpUnionInfo? fS
             }
             else if (!unionType.IsAssignableFrom(derivedType))
             {
-                // The closed derived type does not fit this particular closed base. If the
-                // base is a generic instantiation AND the derived inherits from some other
-                // instantiation of the same base definition, silently skip -- the registration
-                // is targeted at a different closed base. Otherwise the registration is a
-                // hard misregistration.
-                if (unionType.IsGenericType &&
-                    derivedType.GetMatchingGenericBaseTypes(unionType.GetGenericTypeDefinition()).Any())
-                {
-                    continue;
-                }
-
                 throw new InvalidOperationException($"The declared derived type '{derivedType}' is not a valid subtype of '{unionType}'.");
             }