Merge pull request #72808 from slavapestov/fix-existential-metatype-to-any-6.0

[6.0] Sema: Fix existential-metatype-to-Any conversion

Author: slavapestov

include/swift/AST/Type.h

@@ -126,17 +126,6 @@ class MakeAbstractConformanceForGenericType {
                                     ProtocolDecl *conformedProtocol) const;
 };
 
-/// Functor class suitable for use as a \c LookupConformanceFn that provides
-/// only abstract conformances, or builtin conformances for invertible protocols
-/// for generic types. Asserts that the replacement
-/// type is an opaque generic type.
-class MakeAbstractOrBuiltinConformanceForGenericType {
-public:
-  ProtocolConformanceRef operator()(CanType dependentType,
-                                    Type conformingReplacementType,
-                                    ProtocolDecl *conformedProtocol) const;
-};
-
 /// Functor class suitable for use as a \c LookupConformanceFn that fetches
 /// conformances from a generic signature.
 class LookUpConformanceInSignature {

include/swift/SIL/SILCloner.h

@@ -196,7 +196,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
         // If we found a type containing a local archetype, substitute
         // open existentials throughout the substitution map.
         Subs = Subs.subst(QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
-                          MakeAbstractOrBuiltinConformanceForGenericType());
+                          MakeAbstractConformanceForGenericType());
       }
     }
 
@@ -219,7 +219,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
     return Ty.subst(
       Builder.getModule(),
       QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
-      MakeAbstractOrBuiltinConformanceForGenericType(),
+      MakeAbstractConformanceForGenericType(),
       CanGenericSignature());
   }
   SILType getOpType(SILType Ty) {
@@ -239,7 +239,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
     return ty.subst(
       QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
-      MakeAbstractOrBuiltinConformanceForGenericType()
+      MakeAbstractConformanceForGenericType()
     )->getCanonicalType();
   }
 
@@ -352,7 +352,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
         conformance.subst(ty,
                           QueryTypeSubstitutionMapOrIdentity{
                                                         LocalArchetypeSubs},
-                          MakeAbstractOrBuiltinConformanceForGenericType());
+                          MakeAbstractConformanceForGenericType());
     }
 
     return asImpl().remapConformance(getASTTypeInClonedContext(ty),

lib/AST/SubstitutionMap.cpp

@@ -355,16 +355,6 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
   if (!type->isTypeParameter())
     return ProtocolConformanceRef::forInvalid();
 
-  // If the protocol is invertible, just do a global lookup. This avoids an
-  // infinite substitution issue by recognizing that these protocols are
-  // very simple (see rdar://119950540 for the general issue).
-  if (proto->getInvertibleProtocolKind()) {
-    auto substType = type.subst(*this);
-    if (!substType->isTypeParameter())
-      return proto->getModuleContext()->lookupConformance(substType, proto);
-    return ProtocolConformanceRef(proto);
-  }
-
   auto genericSig = getGenericSignature();
 
   auto getSignatureConformance =
@@ -396,6 +386,15 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
     return ProtocolConformanceRef::forMissingOrInvalid(substType, proto);
   }
 
+  // If the protocol is invertible, fall back to a global lookup instead of
+  // evaluating a conformance path, to avoid an infinite substitution issue.
+  if (proto->getInvertibleProtocolKind()) {
+    auto substType = type.subst(*this);
+    if (!substType->isTypeParameter())
+      return proto->getModuleContext()->lookupConformance(substType, proto);
+    return ProtocolConformanceRef(proto);
+  }
+
   auto path = genericSig->getConformancePath(type, proto);
 
   ProtocolConformanceRef conformance;

lib/AST/TypeSubstitution.cpp

@@ -230,22 +230,6 @@ operator()(CanType dependentType, Type conformingReplacementType,
   return Subs.lookupConformance(dependentType, conformedProtocol);
 }
 
-ProtocolConformanceRef MakeAbstractOrBuiltinConformanceForGenericType::
-operator()(CanType dependentType, Type conformingReplacementType,
-           ProtocolDecl *conformedProtocol) const {
-  // Workaround for rdar://125460667
-  if (conformedProtocol->getInvertibleProtocolKind()) {
-    auto &ctx = conformedProtocol->getASTContext();
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(conformingReplacementType, conformedProtocol,
-                                  BuiltinConformanceKind::Synthesized));
-  }
-
-  return MakeAbstractConformanceForGenericType()(dependentType,
-                                                 conformingReplacementType,
-                                                 conformedProtocol);
-}
-
 ProtocolConformanceRef MakeAbstractConformanceForGenericType::
 operator()(CanType dependentType, Type conformingReplacementType,
            ProtocolDecl *conformedProtocol) const {

lib/SIL/IR/SILInstructions.cpp

@@ -2185,14 +2185,24 @@ ObjCMethodInst::create(SILDebugLocation DebugLoc, SILValue Operand,
                                        Member, Ty);
 }
 
+static void checkExistentialPreconditions(SILType ExistentialType,
+                                          CanType ConcreteType,
+                                ArrayRef<ProtocolConformanceRef> Conformances) {
+#ifndef NDEBUG
+  auto layout = ExistentialType.getASTType().getExistentialLayout();
+  assert(layout.getProtocols().size() == Conformances.size());
+
+  for (auto conformance : Conformances) {
+    assert(!conformance.isAbstract() || isa<ArchetypeType>(ConcreteType));
+  }
+#endif
+}
+
 InitExistentialAddrInst *InitExistentialAddrInst::create(
     SILDebugLocation Loc, SILValue Existential, CanType ConcreteType,
     SILType ConcreteLoweredType, ArrayRef<ProtocolConformanceRef> Conformances,
     SILFunction *F) {
-#ifndef NDEBUG
-  auto layout = Existential->getType().getASTType().getExistentialLayout();
-  assert(layout.getProtocols().size() == Conformances.size());
-#endif
+  checkExistentialPreconditions(Existential->getType(), ConcreteType, Conformances);
 
   SILModule &Mod = F->getModule();
   SmallVector<SILValue, 8> TypeDependentOperands;
@@ -2212,10 +2222,7 @@ InitExistentialValueInst *InitExistentialValueInst::create(
     SILDebugLocation Loc, SILType ExistentialType, CanType ConcreteType,
     SILValue Instance, ArrayRef<ProtocolConformanceRef> Conformances,
     SILFunction *F) {
-#ifndef NDEBUG
-  auto layout = ExistentialType.getASTType().getExistentialLayout();
-  assert(layout.getProtocols().size() == Conformances.size());
-#endif
+  checkExistentialPreconditions(ExistentialType, ConcreteType, Conformances);
 
   SILModule &Mod = F->getModule();
   SmallVector<SILValue, 8> TypeDependentOperands;
@@ -2233,10 +2240,7 @@ InitExistentialRefInst *InitExistentialRefInst::create(
     SILDebugLocation Loc, SILType ExistentialType, CanType ConcreteType,
     SILValue Instance, ArrayRef<ProtocolConformanceRef> Conformances,
     SILFunction *F, ValueOwnershipKind forwardingOwnershipKind) {
-#ifndef NDEBUG
-  auto layout = ExistentialType.getASTType().getExistentialLayout();
-  assert(layout.getProtocols().size() == Conformances.size());
-#endif
+  checkExistentialPreconditions(ExistentialType, ConcreteType, Conformances);
 
   SILModule &Mod = F->getModule();
   SmallVector<SILValue, 8> TypeDependentOperands;

lib/SILGen/SILGenConvert.cpp

@@ -833,9 +833,6 @@ ManagedValue SILGenFunction::emitExistentialErasure(
     [&, concreteFormalType, F](SGFContext C) -> ManagedValue {
       auto concreteValue = F(SGFContext());
       assert(concreteFormalType->isBridgeableObjectType());
-      auto *M = SGM.M.getSwiftModule();
-      auto conformances = M->collectExistentialConformances(
-          concreteFormalType, anyObjectTy);
       return B.createInitExistentialRef(
           loc, SILType::getPrimitiveObjectType(anyObjectTy), concreteFormalType,
           concreteValue, conformances);
@@ -844,6 +841,12 @@ ManagedValue SILGenFunction::emitExistentialErasure(
     if (this->F.getLoweredFunctionType()->isPseudogeneric()) {
       if (anyObjectTy && concreteFormalType->is<ArchetypeType>()) {
         concreteFormalType = anyObjectTy;
+
+        // The original conformances are no good because they have the wrong
+        // (pseudogeneric) subject type.
+        auto *M = SGM.M.getSwiftModule();
+        conformances = M->collectExistentialConformances(
+            concreteFormalType, anyObjectTy);
         F = eraseToAnyObject;
       }
     }

lib/Sema/CSApply.cpp

@@ -6688,13 +6688,24 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
   Type fromInstanceType = fromType;
   Type toInstanceType = toType;
 
-  // Look through metatypes
+  // For existential-to-existential coercions, open the source existential.
+  Type openedFromType;
+  if (fromType->isAnyExistentialType()) {
+    openedFromType = OpenedArchetypeType::getAny(fromType->getCanonicalType(),
+                                                 dc->getGenericSignatureOfContext());
+  }
+
+  Type openedFromInstanceType = openedFromType;
+
+  // Look through metatypes.
   while ((fromInstanceType->is<UnresolvedType>() ||
           fromInstanceType->is<AnyMetatypeType>()) &&
          toInstanceType->is<ExistentialMetatypeType>()) {
     if (!fromInstanceType->is<UnresolvedType>())
-      fromInstanceType = fromInstanceType->castTo<AnyMetatypeType>()->getInstanceType();
-    toInstanceType = toInstanceType->castTo<ExistentialMetatypeType>()->getExistentialInstanceType();
+      fromInstanceType = fromInstanceType->getMetatypeInstanceType();
+    if (openedFromInstanceType && !openedFromInstanceType->is<UnresolvedType>())
+      openedFromInstanceType = openedFromInstanceType->getMetatypeInstanceType();
+    toInstanceType = toInstanceType->getMetatypeInstanceType();
   }
 
   ASTContext &ctx = cs.getASTContext();
@@ -6758,20 +6769,13 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
   }
 
   // For existential-to-existential coercions, open the source existential.
-  if (fromType->isAnyExistentialType()) {
-    fromType = OpenedArchetypeType::getAny(fromType->getCanonicalType(),
-                                           dc->getGenericSignatureOfContext());
-
+  if (openedFromType) {
     auto *archetypeVal = cs.cacheType(
-        new (ctx) OpaqueValueExpr(expr->getSourceRange(), fromType));
-
-    fromInstanceType = fromType;
-    while (auto *metatypeType = fromInstanceType->getAs<MetatypeType>())
-      fromInstanceType = metatypeType->getInstanceType();
+        new (ctx) OpaqueValueExpr(expr->getSourceRange(), openedFromType));
 
     auto conformances =
         dc->getParentModule()
-          ->collectExistentialConformances(fromInstanceType->getCanonicalType(),
+          ->collectExistentialConformances(openedFromInstanceType->getCanonicalType(),
                                            toInstanceType->getCanonicalType(),
                                            /*allowMissing=*/true);
 

test/Generics/rdar124697829.swift

@@ -0,0 +1,41 @@
+// RUN: %target-swift-frontend -emit-ir %s -disable-availability-checking
+
+// This is a generics test, but only IRGen exercised the substitution of
+// an abstract conformance with a type parameter -- in the type checker and
+// SIL, we only deal with archetypes.
+
+public protocol IteratorProtocol {
+  associatedtype Element
+}
+
+public protocol Sequence {
+  associatedtype Iterator: IteratorProtocol
+  associatedtype Element where Element == Iterator.Element
+}
+
+public struct IndexingIterator<S: Sequence>: IteratorProtocol {
+  public typealias Element = S.Element
+}
+
+public struct Array<Element>: Sequence {
+  public typealias Iterator = IndexingIterator<Self>
+}
+
+public protocol Publisher {
+  associatedtype Output
+}
+
+public struct SequencePublisher<Elements: Sequence>: Publisher {
+  public typealias Output = Elements.Element
+}
+
+public struct Map<Pub: Publisher, Output>: Publisher {}
+
+public func foo<T>(_: T) -> some Publisher {
+  bar(SequencePublisher<Array<T>>())
+}
+
+public func bar<Pub: Publisher>(_: Pub) -> some Publisher {
+  Map<Pub, Pub.Output>()
+}
+

test/SILOptimizer/rdar125460667.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -emit-sil %s
+
+@_transparent func f(a: Any.Type) -> Any {
+  return a
+}
+
+func g(a: Any.Type) {
+  f(a: a)
+}

test/Serialization/Inputs/protocol_with_self_conforming_existential_other.swift

@@ -0,0 +1,5 @@
+public protocol P1 {
+  associatedtype A: Sendable
+}
+
+public protocol P2: P1, Sendable where A == any P2 {}

test/Serialization/protocol_with_self_conforming_existential.swift

@@ -0,0 +1,11 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module %S/Inputs/protocol_with_self_conforming_existential_other.swift -emit-module-path %t/protocol_with_self_conforming_existential_other.swiftmodule
+// RUN: %target-swift-frontend -emit-silgen %s -I %t
+
+import protocol_with_self_conforming_existential_other
+
+// Declare a type conforming to P2, to force deserializing its
+// requirement signature.
+
+struct MyP2: P2 {}
+