[NarrowedAny] Cross-spelling container reshape: full diagnostic + auto-fix-it

Implements proposal §"Containers and extensions" + decision row swiftlang#21 / swiftlang#33
for the container axis. `let xs: [String|Int] = zs` (with
`zs: [Int|String]`) now reports

  error: cannot assign value of type '[Int | String]' to type '[String | Int]'
    note: arguments to generic parameter 'Element' ('Int | String' and
          'String | Int') are expected to be equal
    fix-it:                                          ^ as [String | Int]

with an `as` (not `as!`) fix-it, since cross-spelling reshape is a
runtime-free relabel — both sides erase to the same Any-singleton element
layout, so SIL emits a single `unchecked_addr_cast` for the coercion.

Two changes:

  - `matchDeepEqualityTypes`'s NarrowedAnyType branch detects the
    cross-spelling case (canonical leaf sets equal but spellings
    differ) before the leaf-by-leaf Bind. When the locator path
    carries an `AnyRequirement` element (e.g. `extension Array where
    Element == X | Y` dispatch checking a substituted `Element` of a
    different spelling), fix the same-type requirement directly via
    `fixRequirementFailure` so SameTypeRequirementFailure prints the
    full narrowed-Any spellings instead of the buggy `any Int` /
    `any String` fallout from the previous malformed-wrap path. For
    the plain conversion case, fall through to the leaf-by-leaf Bind
    but tag each leaf locator with a fresh `GenericArgument` element
    so `repairFailures` doesn't inherit `ExistentialConstraintType`
    from the enclosing existential match (which used to construct the
    malformed `ExistentialType::get(<concrete leaf>)` wrap that
    defeated upstream `GenericArgumentsMismatch` recording).

  - `ContextualFailure::tryTypeCoercionFixIt` recognises cross-spelling
    NarrowedAnyType at container position structurally (same generic
    decl, every generic arg either equal or cross-spelling-equal
    NarrowedAnyType) and emits the ` as <toType>` fix-it directly,
    bypassing the generic `typeCheckCheckedCast` path which would
    classify it as ArrayDowncast (and suggest the wrong `as!`
    direction). Restricted to the `BoundGenericType` case so the
    value-level `Int|String → String|Int` path keeps using the
    existing `typeCheckCheckedCast → Coercion` flow with both `as`
    and `as!` fix-its preserved unchanged.

`diagnostics.swift §13` locks the full diagnostic text, the
generic-parameter-mismatch note, and the fix-it insertion. lit 13/13.

Author: Tao Zhuang

lib/Sema/CSDiagnostics.cpp

@@ -3950,6 +3950,66 @@ bool ContextualFailure::tryTypeCoercionFixIt(
     }
   }
 
+  // Cross-spelling narrowed-`Any` reshape at *container* position
+  // (proposal §"Containers and extensions"; row #21 + #33). The
+  // value-level case (`a as String | Int` where `a: Int | String`)
+  // is already handled by the typeCheckCheckedCast → Coercion path
+  // below, so we only short-circuit when the mismatch is anchored on
+  // a `BoundGenericType` whose generic args are cross-spelling-equal
+  // narrowed-Any. Without this, the typeCheckCheckedCast call below
+  // classifies it as ArrayDowncast (suggesting `as!`), but the
+  // proposal classifies cross-spelling reshape as a runtime-free `as`
+  // relabel (single `unchecked_addr_cast` at SIL level — both sides
+  // erase to the same Any-singleton element layout).
+  std::function<bool(Type, Type)> isCrossSpellingReshape =
+      [&](Type a, Type b) -> bool {
+    if (a->getCanonicalType() == b->getCanonicalType())
+      return true;
+    Type aInner = a;
+    if (auto *ext = a->getAs<ExistentialType>())
+      aInner = ext->getConstraintType();
+    Type bInner = b;
+    if (auto *ext = b->getAs<ExistentialType>())
+      bInner = ext->getConstraintType();
+    if (auto *naA = aInner->getAs<NarrowedAnyType>()) {
+      auto *naB = bInner->getAs<NarrowedAnyType>();
+      if (!naB)
+        return false;
+      auto canSet = [](ArrayRef<Type> alts) {
+        llvm::SmallVector<CanType, 4> canon;
+        for (Type t : alts)
+          canon.push_back(t->getCanonicalType());
+        llvm::sort(canon, [](CanType x, CanType y) {
+          return x.getPointer() < y.getPointer();
+        });
+        return canon;
+      };
+      return canSet(naA->getAlternatives()) == canSet(naB->getAlternatives());
+    }
+    auto *boundA = a->getAs<BoundGenericType>();
+    auto *boundB = b->getAs<BoundGenericType>();
+    if (!boundA || !boundB || boundA->getDecl() != boundB->getDecl())
+      return false;
+    auto argsA = boundA->getGenericArgs();
+    auto argsB = boundB->getGenericArgs();
+    if (argsA.size() != argsB.size())
+      return false;
+    for (unsigned i = 0, e = argsA.size(); i < e; ++i)
+      if (!isCrossSpellingReshape(argsA[i], argsB[i]))
+        return false;
+    return true;
+  };
+  if (toType->hasTypeRepr() && fromType->is<BoundGenericType>() &&
+      toType->is<BoundGenericType>() &&
+      isCrossSpellingReshape(fromType, toType)) {
+    auto attachToType = bothOptional ? OptionalType::get(toType) : toType;
+    diagnostic.fixItInsert(
+        Lexer::getLocForEndOfToken(getASTContext().SourceMgr,
+                                   getSourceRange().End),
+        diag::insert_type_coercion, /*canUseAs=*/true, attachToType);
+    return true;
+  }
+
   CheckedCastKind Kind = TypeChecker::typeCheckCheckedCast(
       fromType, toType, CheckedCastContextKind::None, getDC());
 

lib/Sema/CSSimplify.cpp

@@ -3999,9 +3999,79 @@ ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
     auto alts2 = na2->getAlternatives();
     if (alts1.size() != alts2.size())
       return getTypeMatchFailure(locator);
+    // Cross-spelling detection (decision row #21 / row #33): same leaf
+    // SET in different order is "spelling-as-identity unequal" but
+    // value-flow leaf-set-equal. For type identity it must fail; for
+    // user-facing diagnostics we want a clean fix anchored at the
+    // appropriate level (requirement-failure if the path carries one,
+    // otherwise the conversion locator), not the leaf-by-leaf Bind
+    // path which inherits `ExistentialConstraintType` and routes
+    // `repairFailures` through the malformed `ExistentialType::get(Int)`
+    // wrap (defensive layout fallback only stops the crash; it doesn't
+    // synthesise a useful fix).
+    auto canonicalLeafSet = [](ArrayRef<Type> alts) {
+      llvm::SmallVector<CanType, 4> canon;
+      for (Type t : alts)
+        canon.push_back(t->getCanonicalType());
+      llvm::sort(canon, [](CanType a, CanType b) {
+        return a.getPointer() < b.getPointer();
+      });
+      return canon;
+    };
+    auto sortedSet1 = canonicalLeafSet(alts1);
+    auto sortedSet2 = canonicalLeafSet(alts2);
+    bool sameLeafSet = (sortedSet1 == sortedSet2);
+    if (sameLeafSet && shouldAttemptFixes()) {
+      // Record a fix anchored at the right level. Walk path looking
+      // for an `AnyRequirement` element — if present, this is a
+      // requirement-failure context (e.g. extension-where-clause
+      // matching), and the right diagnostic is
+      // SameTypeRequirementFailure ("requires the types <NA1> and
+      // <NA2> be equivalent"). Otherwise this is a plain
+      // conversion / generic-argument mismatch and the right anchor
+      // is the conversion locator (yielding "cannot convert value of
+      // type <X> to type <Y>" + cross-shape `as` fix-it via the
+      // GenericArgumentsMismatch path at the BoundGenericType match
+      // level above us).
+      llvm::SmallVector<LocatorPathElt, 4> path;
+      auto anchor = locator.getLocatorParts(path);
+      // Scan for the deepest AnyRequirement element.
+      int reqIdx = -1;
+      for (int i = (int)path.size() - 1; i >= 0; --i) {
+        if (path[i].is<LocatorPathElt::AnyRequirement>()) {
+          reqIdx = i;
+          break;
+        }
+      }
+      if (reqIdx >= 0) {
+        // Truncate path to end at the requirement element so the fix
+        // is recorded at the requirement locator (the requirement
+        // diagnoser walks up from there to the extension / call site).
+        ArrayRef<LocatorPathElt> reqPath(path.data(), reqIdx + 1);
+        if (auto *fix =
+                fixRequirementFailure(*this, type1, type2, anchor, reqPath)) {
+          if (!recordFix(fix))
+            return getTypeMatchSuccess();
+        }
+      }
+      // Fall through to the leaf-by-leaf Bind path; the BoundGenericType
+      // match above will record a `GenericArgumentsMismatch` fix and
+      // the constraint solver salvages the proper "cannot convert"
+      // diagnostic with cross-shape fix-it.
+    }
+    // Push a fresh GenericArgument element so leaf-level Bind failures
+    // don't inherit `ExistentialConstraintType` from the enclosing
+    // ExistentialType match (which would route `repairFailures`
+    // through the malformed `ExistentialType::get(<concrete leaf>)`
+    // wrap; the defensive fallback in
+    // `CanType::getExistentialLayout` stops the crash but the wrap
+    // also defeats upstream `GenericArgumentsMismatch` fix recording
+    // for cross-spelling container assignment).
     for (unsigned i = 0, e = alts1.size(); i < e; ++i) {
+      auto leafLocator = locator.withPathElement(
+                            LocatorPathElt::GenericArgument(i));
       auto result = matchTypes(alts1[i], alts2[i],
-                               ConstraintKind::Bind, subflags, locator);
+                               ConstraintKind::Bind, subflags, leafLocator);
       if (result.isFailure())
         return result;
     }

test/NarrowedAny/diagnostics.swift

@@ -159,19 +159,22 @@ typealias T11c = (Int | String) & (Int | String)  // expected-error {{non-protoc
 func f12<T>(_ x: T) where T: Int | String, T: Int | Bool {}
                               // expected-error@-1 {{no type for 'T' can satisfy both}}
 
-// §13. Cross-spelling Array assignment — used to crash in
+// §13. Cross-spelling Array assignment (proposal §"Containers and
+// extensions"; row #21 + #33). Implicit cross-spelling container
+// conversion is rejected with `cannot assign value of type ...` plus
+// a generic-argument-mismatch note pointing at the differing
+// `Element` spellings. The user is expected to add an explicit
+// reshape `as [String | Int]` (runtime-free relabel — a single
+// `unchecked_addr_cast` at SIL level — since both sides erase to the
+// same Any-singleton element layout). Used to crash in
 // `repairFailures` via a malformed `ExistentialType(<concrete leaf>)`
-// that reached `CanType::getExistentialLayout`'s
-// `cast<ProtocolCompositionType>` and aborted. The defensive fallback
-// in `getExistentialLayout` (return empty layout when the type is
-// neither a recognised existential constraint nor a protocol
-// composition) stops the crash. The proper diagnostic + fix-it for
-// implicit cross-spelling container conversion (proposal §"Containers
-// and extensions"; §四 第二项) is multi-day Sema work — the current
-// "failed to produce diagnostic" is a known gap, not a goal of this
-// test. Verify-mode locks only the no-crash + the present fallback
-// diagnostic so a regression to the abort path is caught immediately.
+// before the cross-spelling-aware fix in
+// `matchDeepEqualityTypes::NarrowedAnyType` branch (records
+// `GenericArgumentsMismatch` for plain conversion, hands off to
+// `fixRequirementFailure` when a `where`-clause requirement is on
+// the locator).
 do {
     let zs: [Int | String] = [1, "a"]
-    let _: [String | Int] = zs    // expected-error {{failed to produce diagnostic for expression}}
+    let _: [String | Int] = zs    // expected-error {{cannot assign value of type '[Int | String]' to type '[String | Int]'}} {{31-31= as [String | Int]}}
+                                  // expected-note@-1 {{arguments to generic parameter 'Element' ('Int | String' and 'String | Int') are expected to be equal}}
 }