[Type System] Use the constraint type of an existential type in

hborla · hborla · commit f357116ed67d · 2022-01-11T12:59:37.000-08:00
various places that expect ProtocolType or ProtocoolCompositionType.
diff --git a/include/swift/AST/ProtocolConformance.h b/include/swift/AST/ProtocolConformance.h
@@ -660,7 +660,7 @@ class SelfProtocolConformance : public RootProtocolConformance {
 public:
   /// Get the protocol being conformed to.
   ProtocolDecl *getProtocol() const {
-    return getType()->castTo<ProtocolType>()->getDecl();
+    return dyn_cast<ProtocolDecl>(getType()->getAnyNominal());
   }
 
   /// Get the declaration context in which this conformance was declared.
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -6301,6 +6301,8 @@ inline NominalTypeDecl *TypeBase::getNominalOrBoundGenericNominal() {
 inline NominalTypeDecl *CanType::getNominalOrBoundGenericNominal() const {
   if (auto Ty = dyn_cast<NominalOrBoundGenericNominalType>(*this))
     return Ty->getDecl();
+  if (auto Ty = dyn_cast<ExistentialType>(*this))
+    return Ty->getConstraintType()->getNominalOrBoundGenericNominal();
   return nullptr;
 }
 
@@ -6309,6 +6311,9 @@ inline NominalTypeDecl *TypeBase::getAnyNominal() {
 }
 
 inline Type TypeBase::getNominalParent() {
+  if (auto existential = getAs<ExistentialType>())
+    return existential->getConstraintType()->getNominalParent();
+
   return castTo<AnyGenericType>()->getParent();
 }
 
diff --git a/lib/APIDigester/ModuleAnalyzerNodes.cpp b/lib/APIDigester/ModuleAnalyzerNodes.cpp
@@ -1017,6 +1017,12 @@ static StringRef getTypeName(SDKContext &Ctx, Type Ty,
   if (auto *NAT = dyn_cast<TypeAliasType>(Ty.getPointer())) {
     return NAT->getDecl()->getNameStr();
   }
+
+  if (auto existential = Ty->getAs<ExistentialType>()) {
+    return getTypeName(Ctx, existential->getConstraintType(),
+                       IsImplicitlyUnwrappedOptional);
+  }
+
   if (Ty->getAnyNominal()) {
     if (IsImplicitlyUnwrappedOptional) {
       assert(Ty->getOptionalObjectType());
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -5151,7 +5151,10 @@ findProtocolSelfReferences(const ProtocolDecl *proto, Type type,
     return SelfReferenceInfo::forSelfRef(SelfReferencePosition::Invariant);
 
   // Protocol compositions preserve variance.
-  if (auto *comp = type->getAs<ProtocolCompositionType>()) {
+  auto constraint = type;
+  if (auto existential = constraint->getAs<ExistentialType>())
+    constraint = existential->getConstraintType();
+  if (auto *comp = constraint->getAs<ProtocolCompositionType>()) {
     // 'Self' may be referenced only in a superclass component.
     if (const auto superclass = comp->getSuperclass()) {
       return findProtocolSelfReferences(proto, superclass, position);
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -104,6 +104,8 @@ NominalTypeDecl *CanType::getAnyNominal() const {
 }
 
 GenericTypeDecl *CanType::getAnyGeneric() const {
+  if (auto existential = dyn_cast<ExistentialType>(*this))
+    return existential->getConstraintType()->getAnyGeneric();
   if (auto Ty = dyn_cast<AnyGenericType>(*this))
     return Ty->getDecl();
   return nullptr;
@@ -2604,14 +2606,17 @@ getForeignRepresentable(Type type, ForeignLanguage language,
   // If type has an error let's fail early.
   if (type->hasError())
     return failure();
-  
+
   // Look through one level of optional type, but remember that we did.
   bool wasOptional = false;
   if (auto valueType = type->getOptionalObjectType()) {
     type = valueType;
     wasOptional = true;
   }
 
+  if (auto existential = type->getAs<ExistentialType>())
+    type = existential->getConstraintType();
+
   // Objective-C object types, including metatypes.
   if (language == ForeignLanguage::ObjectiveC) {
     auto representable = getObjCObjectRepresentable(type, dc);
@@ -3199,9 +3204,14 @@ Type ArchetypeType::getExistentialType() const {
   for (auto proto : getConformsTo()) {
     constraintTypes.push_back(proto->getDeclaredInterfaceType());
   }
-  return ProtocolCompositionType::get(
-     const_cast<ArchetypeType*>(this)->getASTContext(), constraintTypes,
-                                      requiresClass());
+  auto &ctx = const_cast<ArchetypeType*>(this)->getASTContext();
+  auto constraint = ProtocolCompositionType::get(
+     ctx, constraintTypes, requiresClass());
+
+  if (ctx.LangOpts.EnableExplicitExistentialTypes)
+    return ExistentialType::get(constraint);
+
+  return constraint;
 }
 
 PrimaryArchetypeType::PrimaryArchetypeType(const ASTContext &Ctx,
@@ -5356,6 +5366,10 @@ bool Type::isPrivateStdlibType(bool treatNonBuiltinProtocolsAsPublic) const {
   if (!Ty)
     return false;
 
+  if (auto existential = dyn_cast<ExistentialType>(Ty.getPointer()))
+    return existential->getConstraintType()
+        .isPrivateStdlibType(treatNonBuiltinProtocolsAsPublic);
+
   // A 'public' typealias can have an 'internal' type.
   if (auto *NAT = dyn_cast<TypeAliasType>(Ty.getPointer())) {
     auto *AliasDecl = NAT->getDecl();
@@ -5542,7 +5556,7 @@ SILBoxType::SILBoxType(ASTContext &C,
 Type TypeBase::openAnyExistentialType(OpenedArchetypeType *&opened) {
   assert(isAnyExistentialType());
   if (auto metaty = getAs<ExistentialMetatypeType>()) {
-    opened = OpenedArchetypeType::get(metaty->getInstanceType());
+    opened = OpenedArchetypeType::get(metaty->getExistentialInstanceType());
     if (metaty->hasRepresentation())
       return MetatypeType::get(opened, metaty->getRepresentation());
     else
diff --git a/lib/IRGen/DebugTypeInfo.cpp b/lib/IRGen/DebugTypeInfo.cpp
@@ -158,6 +158,8 @@ TypeDecl *DebugTypeInfo::getDecl() const {
     return UBG->getDecl();
   if (auto *BG = dyn_cast<BoundGenericType>(Type))
     return BG->getDecl();
+  if (auto *E = dyn_cast<ExistentialType>(Type))
+    return E->getConstraintType()->getAnyNominal();
   return nullptr;
 }
 
diff --git a/lib/IRGen/IRGenMangler.cpp b/lib/IRGen/IRGenMangler.cpp
@@ -215,6 +215,8 @@ std::string IRGenMangler::mangleTypeForLLVMTypeName(CanType Ty) {
   // To make LLVM IR more readable we always add a 'T' prefix so that type names
   // don't start with a digit and don't need to be quoted.
   Buffer << 'T';
+  if (auto existential = Ty->getAs<ExistentialType>())
+    Ty = existential->getConstraintType()->getCanonicalType();
   if (auto P = dyn_cast<ProtocolType>(Ty)) {
     appendProtocolName(P->getDecl(), /*allowStandardSubstitution=*/false);
     appendOperator("P");
diff --git a/lib/SIL/Utils/DynamicCasts.cpp b/lib/SIL/Utils/DynamicCasts.cpp
@@ -468,8 +468,7 @@ swift::classifyDynamicCast(ModuleDecl *M,
                              : DynamicCastFeasibility::WillFail;
     }
 
-    if (targetMetatype.isAnyExistentialType() &&
-        (isa<ProtocolType>(target) || isa<ProtocolCompositionType>(target))) {
+    if (targetMetatype.isAnyExistentialType() && target->isExistentialType()) {
       auto Feasibility =
           classifyDynamicCastToProtocol(M, source, target, isWholeModuleOpts);
       // Cast from existential metatype to existential metatype may still
diff --git a/lib/SILGen/SILGenConvert.cpp b/lib/SILGen/SILGenConvert.cpp
@@ -913,8 +913,11 @@ ManagedValue SILGenFunction::emitExistentialMetatypeToObject(SILLocation loc,
 ManagedValue SILGenFunction::emitProtocolMetatypeToObject(SILLocation loc,
                                                           CanType inputTy,
                                                           SILType resultTy) {
-  ProtocolDecl *protocol = inputTy->castTo<MetatypeType>()
-    ->getInstanceType()->castTo<ProtocolType>()->getDecl();
+  auto protocolType = inputTy->castTo<MetatypeType>()->getInstanceType();
+  if (auto existential = protocolType->getAs<ExistentialType>())
+    protocolType = existential->getConstraintType();
+
+  ProtocolDecl *protocol = protocolType->castTo<ProtocolType>()->getDecl();
 
   SILValue value = B.createObjCProtocol(loc, protocol, resultTy);
   
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -831,7 +831,10 @@ static SILFunction *emitSelfConformanceWitness(SILGenModule &SGM,
                                           ProtocolConformanceRef(conformance));
 
   // Open the protocol type.
-  auto openedType = OpenedArchetypeType::get(protocolType);
+  Type existential = protocolType;
+  if (SGM.getASTContext().LangOpts.EnableExplicitExistentialTypes)
+    existential = ExistentialType::get(protocolType);
+  auto openedType = OpenedArchetypeType::get(existential);
 
   // Form the substitutions for calling the witness.
   auto witnessSubs = SubstitutionMap::getProtocolSubstitutions(protocol,
diff --git a/lib/Sema/TypeCheckAccess.cpp b/lib/Sema/TypeCheckAccess.cpp
@@ -783,7 +783,12 @@ class AccessControlChecker : public AccessControlCheckerBase,
                               Type());
     }
 
-    auto declKindForType = [](Type type) {
+    auto declKindForType = [](Type type) -> DescriptiveDeclKind {
+      // If this is an existential type, use the decl kind of
+      // its constraint type.
+      if (auto existential = type->getAs<ExistentialType>())
+        type = existential->getConstraintType();
+
       if (isa<TypeAliasType>(type.getPointer()))
         return DescriptiveDeclKind::TypeAlias;
       else if (auto nominal = type->getAnyNominal())
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -1899,6 +1899,13 @@ bool swift::isMemberOperator(FuncDecl *decl, Type type) {
     }
 
     if (isProtocol) {
+      // FIXME: Source compatibility hack for Swift 5. The compiler
+      // accepts member operators on protocols with existential
+      // type arguments. We should consider banning this in Swift 6.
+      if (auto existential = paramType->getAs<ExistentialType>()) {
+        return selfNominal == existential->getConstraintType()->getAnyNominal();
+      }
+
       // For a protocol, is it the 'Self' type parameter?
       if (auto genericParam = paramType->getAs<GenericTypeParamType>())
         if (genericParam->isEqual(DC->getSelfInterfaceType()))
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -5249,8 +5249,11 @@ void swift::diagnoseConformanceFailure(Type T,
       TypeChecker::containsProtocol(T, Proto, DC->getParentModule())) {
 
     if (!T->isObjCExistentialType()) {
+      Type constraintType = T;
+      if (auto existential = T->getAs<ExistentialType>())
+        constraintType = existential->getConstraintType();
       diags.diagnose(ComplainLoc, diag::type_cannot_conform, true,
-                     T, T->isEqual(Proto->getDeclaredInterfaceType()), 
+                     T, constraintType->isEqual(Proto->getDeclaredInterfaceType()),
                      Proto->getDeclaredInterfaceType());
       diags.diagnose(ComplainLoc,
                      diag::only_concrete_types_conform_to_protocols);
@@ -5382,7 +5385,10 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
   if (T->isExistentialType()) {
     // Handle the special case of the Error protocol, which self-conforms
     // *and* has a witness table.
-    if (T->isEqual(Proto->getDeclaredInterfaceType()) &&
+    auto constraint = T;
+    if (auto existential = T->getAs<ExistentialType>())
+      constraint = existential->getConstraintType();
+    if (constraint->isEqual(Proto->getDeclaredInterfaceType()) &&
         Proto->requiresSelfConformanceWitnessTable()) {
       auto &ctx = M->getASTContext();
       return ProtocolConformanceRef(ctx.getSelfConformance(Proto));

Original file line number	Diff line number	Diff line change
`@@ -660,7 +660,7 @@ class SelfProtocolConformance : public RootProtocolConformance {`
`660`	`660`	`public:`
`661`	`661`	`/// Get the protocol being conformed to.`
`662`	`662`	`ProtocolDecl *getProtocol() const {`
`663`		`- return getType()->castTo<ProtocolType>()->getDecl();`
	`663`	`+ return dyn_cast<ProtocolDecl>(getType()->getAnyNominal());`
`664`	`664`	`}`
`665`	`665`
`666`	`666`	`/// Get the declaration context in which this conformance was declared.`
Original file line number	Diff line number	Diff line change
`@@ -6301,6 +6301,8 @@ inline NominalTypeDecl *TypeBase::getNominalOrBoundGenericNominal() {`
`6301`	`6301`	`inline NominalTypeDecl *CanType::getNominalOrBoundGenericNominal() const {`
`6302`	`6302`	`if (auto Ty = dyn_cast<NominalOrBoundGenericNominalType>(*this))`
`6303`	`6303`	`return Ty->getDecl();`
	`6304`	`+ if (auto Ty = dyn_cast<ExistentialType>(*this))`
	`6305`	`+ return Ty->getConstraintType()->getNominalOrBoundGenericNominal();`
`6304`	`6306`	`return nullptr;`
`6305`	`6307`	`}`
`6306`	`6308`
`@@ -6309,6 +6311,9 @@ inline NominalTypeDecl *TypeBase::getAnyNominal() {`
`6309`	`6311`	`}`
`6310`	`6312`
`6311`	`6313`	`inline Type TypeBase::getNominalParent() {`
	`6314`	`+ if (auto existential = getAs<ExistentialType>())`
	`6315`	`+ return existential->getConstraintType()->getNominalParent();`
	`6316`	`+`
`6312`	`6317`	`return castTo<AnyGenericType>()->getParent();`
`6313`	`6318`	`}`
`6314`	`6319`
Original file line number	Diff line number	Diff line change
`@@ -158,6 +158,8 @@ TypeDecl *DebugTypeInfo::getDecl() const {`
`158`	`158`	`return UBG->getDecl();`
`159`	`159`	`if (auto *BG = dyn_cast<BoundGenericType>(Type))`
`160`	`160`	`return BG->getDecl();`
	`161`	`+ if (auto *E = dyn_cast<ExistentialType>(Type))`
	`162`	`+ return E->getConstraintType()->getAnyNominal();`
`161`	`163`	`return nullptr;`
`162`	`164`	`}`
`163`	`165`
Original file line number	Diff line number	Diff line change
`@@ -468,8 +468,7 @@ swift::classifyDynamicCast(ModuleDecl *M,`
`468`	`468`	`: DynamicCastFeasibility::WillFail;`
`469`	`469`	`}`
`470`	`470`
`471`		`- if (targetMetatype.isAnyExistentialType() &&`
`472`		`- (isa<ProtocolType>(target) \|\| isa<ProtocolCompositionType>(target))) {`
	`471`	`+ if (targetMetatype.isAnyExistentialType() && target->isExistentialType()) {`
`473`	`472`	`auto Feasibility =`
`474`	`473`	`classifyDynamicCastToProtocol(M, source, target, isWholeModuleOpts);`
`475`	`474`	`// Cast from existential metatype to existential metatype may still`