Merge pull request #64561 from slavapestov/constrained-existential-fixes

Fixes for constrained existential types

Author: slavapestov

lib/AST/ASTContext.cpp

@@ -3761,6 +3761,9 @@ ParameterizedProtocolType *ParameterizedProtocolType::get(const ASTContext &C,
 
   auto size = totalSizeToAlloc<Type>(args.size());
   auto mem = C.Allocate(size, alignof(ParameterizedProtocolType), arena);
+
+  properties |= RecursiveTypeProperties::HasParameterizedExistential;
+
   auto paramTy = new (mem) ParameterizedProtocolType(
         isCanonical ? &C : nullptr, baseTy, args, properties);
   C.getImpl().getArena(arena).ParameterizedProtocolTypes.InsertNode(
@@ -3851,8 +3854,6 @@ ExistentialMetatypeType::get(Type T, Optional<MetatypeRepresentation> repr,
     T = existential->getConstraintType();
 
   auto properties = T->getRecursiveProperties();
-  if (T->is<ParameterizedProtocolType>())
-    properties |= RecursiveTypeProperties::HasParameterizedExistential;
   auto arena = getArena(properties);
 
   unsigned reprKey;
@@ -4722,8 +4723,6 @@ Type ExistentialType::get(Type constraint) {
     printWithAny = false;
 
   auto properties = constraint->getRecursiveProperties();
-  if (constraint->is<ParameterizedProtocolType>())
-    properties |= RecursiveTypeProperties::HasParameterizedExistential;
   auto arena = getArena(properties);
 
   auto &entry = C.getImpl().getArena(arena).ExistentialTypes[constraint];

lib/AST/ASTDemangler.cpp

@@ -674,8 +674,7 @@ Type ASTBuilder::createConstrainedExistentialType(
 
     case RequirementKind::SameType:
       if (auto *DMT = req.getFirstType()->getAs<DependentMemberType>())
-        if (baseDecl->getAssociatedType(DMT->getName()))
-          cmap[DMT->getName()] = req.getSecondType();
+        cmap[DMT->getName()] = req.getSecondType();
     }
   }
   llvm::SmallVector<Type, 4> args;

lib/AST/ASTMangler.cpp

@@ -1411,14 +1411,18 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     }
 
     case TypeKind::ProtocolComposition: {
+      auto *PCT = cast<ProtocolCompositionType>(tybase);
+      if (PCT->hasParameterizedExistential())
+        return appendConstrainedExistential(PCT, sig, forDecl);
+
       // We mangle ProtocolType and ProtocolCompositionType using the
       // same production:
-      auto layout = type->getExistentialLayout();
+      auto layout = PCT->getExistentialLayout();
       return appendExistentialLayout(layout, sig, forDecl);
     }
 
     case TypeKind::ParameterizedProtocol:
-      llvm_unreachable("Handled by generalized existential mangling!");
+      return appendConstrainedExistential(tybase, sig, forDecl);
 
     case TypeKind::Existential: {
       auto *ET = cast<ExistentialType>(tybase);

lib/Demangling/NodePrinter.cpp

@@ -310,7 +310,6 @@ class NodePrinter {
     case Node::Kind::Pack:
     case Node::Kind::SILPackDirect:
     case Node::Kind::SILPackIndirect:
-    case Node::Kind::ConstrainedExistential:
     case Node::Kind::ConstrainedExistentialRequirementList:
     case Node::Kind::ConstrainedExistentialSelf:
     case Node::Kind::Protocol:
@@ -340,6 +339,7 @@ class NodePrinter {
     case Node::Kind::ProtocolListWithAnyObject:
       return Node->getChild(0)->getChild(0)->getNumChildren() == 0;
 
+    case Node::Kind::ConstrainedExistential:
     case Node::Kind::PackExpansion:
     case Node::Kind::ProtocolListWithClass:
     case Node::Kind::AccessorAttachedMacroExpansion:

lib/IRGen/GenExistential.cpp

@@ -1520,22 +1520,18 @@ static const TypeInfo *createExistentialTypeInfo(IRGenModule &IGM, CanType T) {
   }
 
   llvm::StructType *type;
-  if (T->hasParameterizedExistential()) {
-    type = IGM.createNominalType(T);
-  } else {
-    // Note: Protocol composition types are not nominal, but we name them
-    // anyway.
-    if (auto existential = T->getAs<ExistentialType>()) {
-      T = existential->getConstraintType()->getCanonicalType();
-    }
 
-    if (isa<ProtocolType>(T))
-      type = IGM.createNominalType(T);
-    else
-      type =
-          IGM.createNominalType(cast<ProtocolCompositionType>(T.getPointer()));
+  // Note: Protocol composition types are not nominal, but we name them
+  // anyway.
+  if (auto existential = T->getAs<ExistentialType>()) {
+    T = existential->getConstraintType()->getCanonicalType();
   }
 
+  if (isa<ProtocolType>(T) || isa<ParameterizedProtocolType>(T))
+    type = IGM.createNominalType(T);
+  else
+    type = IGM.createNominalType(cast<ProtocolCompositionType>(T.getPointer()));
+
   assert(type->isOpaque() && "creating existential type in concrete struct");
 
   // In an opaque metadata, the first two fields are the fixed buffer

test/TypeDecoder/constrained_existentials.swift

@@ -0,0 +1,45 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-build-swift -emit-executable %s -g -o %t/constrained_existentials -emit-module -Xfrontend -disable-availability-checking
+// RUN: sed -ne '/\/\/ *DEMANGLE: /s/\/\/ *DEMANGLE: *//p' < %s > %t/input
+// RUN: %lldb-moduleimport-test %t/constrained_existentials -type-from-mangled=%t/input | %FileCheck %s
+
+func blackHole(_: Any...) {}
+
+protocol BaseProto<A, B> {
+  associatedtype A
+  associatedtype B
+}
+
+protocol DerivedProto<A, B>: BaseProto {}
+
+protocol OtherProto {}
+
+struct S<A, B>: DerivedProto, OtherProto {}
+
+// We should lift the artificial ban on compositions involving constrained protocol types
+typealias BaseProtoIntStringAndOtherProto = BaseProto<Int, String> & OtherProto
+
+do {
+  let e0: any BaseProto<Int, String> = S<Int, String>()
+  let e1: any BaseProto<Int, String>.Type = S<Int, String>.self
+  let e2: (any BaseProto<Int, String>).Type = (any BaseProto<Int, String>).self
+
+  blackHole(e0, e1, e2)
+}
+
+// DEMANGLE: $s24constrained_existentials9BaseProto_pSi1AAaBPRts_SS1BADRtsXPD
+// DEMANGLE: $s24constrained_existentials9BaseProto_pSi1AAaBPRts_SS1BADRtsXPXmTD
+// DEMANGLE: $s24constrained_existentials9BaseProto_pSi1AAaBPRts_SS1BADRtsXPXMtD
+
+// CHECK: BaseProto<Int, String>
+// CHECK: @thick BaseProto<Int, String>.Type
+// CHECK: @thin BaseProto<Int, String>.Protocol
+
+do {
+  let e0: any DerivedProto<Int, String> = S<Int, String>()
+  let e1: any DerivedProto<Int, String>.Type = S<Int, String>.self
+  let e2: (any DerivedProto<Int, String>).Type = (any DerivedProto<Int, String>).self
+
+  blackHole(e0, e1, e2)
+}