[AST] Teach ExistentialType::get to only produce ExistentialType when

explicit existential types are enabled.

Author: hborla

include/swift/AST/ASTContext.h

@@ -526,7 +526,6 @@ class ASTContext final {
 
   /// Retrieve the declaration of Swift.Error.
   ProtocolDecl *getErrorDecl() const;
-  CanType getExceptionType() const;
   CanType getErrorExistentialType() const;
 
 #define KNOWN_STDLIB_TYPE_DECL(NAME, DECL_CLASS, NUM_GENERIC_PARAMS) \

include/swift/AST/Decl.h

@@ -4297,6 +4297,11 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// not exist.
   AssociatedTypeDecl *getAssociatedType(Identifier name) const;
 
+  /// Returns the existential type for this protocol.
+  Type getExistentialType() const {
+    return ExistentialType::get(getDeclaredInterfaceType());
+  }
+
   /// Walk this protocol and all of the protocols inherited by this protocol,
   /// transitively, invoking the callback function for each protocol.
   ///

include/swift/AST/Types.h

@@ -5218,7 +5218,7 @@ class ExistentialType final : public TypeBase {
         ConstraintType(constraintType) {}
 
 public:
-  static ExistentialType *get(Type constraint);
+  static Type get(Type constraint);
 
   Type getConstraintType() const { return ConstraintType; }
 

lib/AST/ASTContext.cpp

@@ -856,9 +856,9 @@ Type ASTContext::get##NAME##Type() const { \
 }
 #include "swift/AST/KnownStdlibTypes.def"
 
-CanType ASTContext::getExceptionType() const {
+CanType ASTContext::getErrorExistentialType() const {
   if (auto exn = getErrorDecl()) {
-    return exn->getDeclaredInterfaceType()->getCanonicalType();
+    return exn->getExistentialType()->getCanonicalType();
   } else {
     // Use Builtin.NativeObject just as a stand-in.
     return TheNativeObjectType;
@@ -869,16 +869,6 @@ ProtocolDecl *ASTContext::getErrorDecl() const {
   return getProtocol(KnownProtocolKind::Error);
 }
 
-CanType ASTContext::getErrorExistentialType() const {
-  Type errorType = getExceptionType();
-  if (LangOpts.EnableExplicitExistentialTypes &&
-      errorType->isConstraintType()) {
-    errorType = ExistentialType::get(errorType);
-  }
-
-  return errorType->getCanonicalType();
-}
-
 EnumElementDecl *ASTContext::getOptionalSomeDecl() const {
   if (!getImpl().OptionalSomeDecl)
     getImpl().OptionalSomeDecl = getOptionalDecl()->getUniqueElement(/*hasVal*/true);
@@ -2336,7 +2326,7 @@ ASTContext::getSelfConformance(ProtocolDecl *protocol) {
   auto &entry = selfConformances[protocol];
   if (!entry) {
     entry = new (*this, AllocationArena::Permanent)
-      SelfProtocolConformance(protocol->getDeclaredInterfaceType());
+      SelfProtocolConformance(protocol->getExistentialType());
   }
   return entry;
 }
@@ -3364,15 +3354,7 @@ ExistentialMetatypeType::ExistentialMetatypeType(Type T,
 }
 
 Type ExistentialMetatypeType::getExistentialInstanceType() {
-  auto instanceType = getInstanceType();
-  // Note that Any and AnyObject don't yet use ExistentialType.
-  if (getASTContext().LangOpts.EnableExplicitExistentialTypes &&
-      !instanceType->is<ExistentialMetatypeType>() &&
-      !(instanceType->isAny() || instanceType->isAnyObject())) {
-    instanceType = ExistentialType::get(instanceType);
-  }
-
-  return instanceType;
+  return ExistentialType::get(getInstanceType());
 }
 
 ModuleType *ModuleType::get(ModuleDecl *M) {
@@ -4121,11 +4103,22 @@ ProtocolType::ProtocolType(ProtocolDecl *TheDecl, Type Parent,
                            RecursiveTypeProperties properties)
   : NominalType(TypeKind::Protocol, &Ctx, TheDecl, Parent, properties) { }
 
-ExistentialType *ExistentialType::get(Type constraint) {
+Type ExistentialType::get(Type constraint) {
+  auto &C = constraint->getASTContext();
+  if (!C.LangOpts.EnableExplicitExistentialTypes)
+    return constraint;
+
+  // FIXME: Any and AnyObject don't yet use ExistentialType.
+  if (constraint->isAny() || constraint->isAnyObject())
+    return constraint;
+
+  // ExistentialMetatypeType is already an existential type.
+  if (constraint->is<ExistentialMetatypeType>())
+    return constraint;
+
   auto properties = constraint->getRecursiveProperties();
   auto arena = getArena(properties);
 
-  auto &C = constraint->getASTContext();
   auto &entry = C.getImpl().getArena(arena).ExistentialTypes[constraint];
   if (entry)
     return entry;

lib/AST/Type.cpp

@@ -1462,7 +1462,7 @@ CanType TypeBase::computeCanonicalType() {
   case TypeKind::Existential: {
     auto *existential = cast<ExistentialType>(this);
     auto constraint = existential->getConstraintType()->getCanonicalType();
-    Result = ExistentialType::get(constraint);
+    Result = ExistentialType::get(constraint).getPointer();
     break;
   }
   case TypeKind::ExistentialMetatype: {
@@ -3208,10 +3208,7 @@ Type ArchetypeType::getExistentialType() const {
   auto constraint = ProtocolCompositionType::get(
      ctx, constraintTypes, requiresClass());
 
-  if (ctx.LangOpts.EnableExplicitExistentialTypes)
-    return ExistentialType::get(constraint);
-
-  return constraint;
+  return ExistentialType::get(constraint);
 }
 
 PrimaryArchetypeType::PrimaryArchetypeType(const ASTContext &Ctx,

lib/AST/TypeJoinMeet.cpp

@@ -287,11 +287,6 @@ CanType TypeJoin::visitExistentialType(CanType second) {
   if (!joinInstance)
     return CanType();
 
-  if (joinInstance->is<ExistentialMetatypeType>() ||
-      joinInstance->isAny() ||
-      joinInstance->isAnyObject())
-    return joinInstance;
-
   return ExistentialType::get(joinInstance)->getCanonicalType();
 }
 

lib/ClangImporter/ImportType.cpp

@@ -1019,12 +1019,10 @@ namespace {
               if (memberTypes.empty())
                 hasExplicitAnyObject = true;
 
-              Type importedTypeArg = ProtocolCompositionType::get(
-                  Impl.SwiftContext, memberTypes,
-                  hasExplicitAnyObject);
-              if (Impl.SwiftContext.LangOpts.EnableExplicitExistentialTypes) {
-                importedTypeArg = ExistentialType::get(importedTypeArg);
-              }
+              Type importedTypeArg = ExistentialType::get(
+                  ProtocolCompositionType::get(
+                      Impl.SwiftContext, memberTypes,
+                      hasExplicitAnyObject));
               importedTypeArgs.push_back(importedTypeArg);
             }
           }
@@ -1153,8 +1151,7 @@ namespace {
             }
           }
 
-          if (bridgedType->isConstraintType() &&
-              Impl.SwiftContext.LangOpts.EnableExplicitExistentialTypes)
+          if (bridgedType->isConstraintType())
             bridgedType = ExistentialType::get(bridgedType);
 
           return { importedType,
@@ -1177,13 +1174,9 @@ namespace {
           members.push_back(proto->getDeclaredInterfaceType());
         }
 
-        importedType = ProtocolCompositionType::get(Impl.SwiftContext,
-                                                    members,
-                                                    /*HasExplicitAnyObject=*/false);
-
-        if (Impl.SwiftContext.LangOpts.EnableExplicitExistentialTypes) {
-          importedType = ExistentialType::get(importedType);
-        }
+        importedType = ExistentialType::get(
+            ProtocolCompositionType::get(Impl.SwiftContext, members,
+                                         /*HasExplicitAnyObject=*/false));
       }
 
       // Class or Class<P> maps to an existential metatype.
@@ -2460,9 +2453,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     bool paramIsIUO;
     if (kind == SpecialMethodKind::NSDictionarySubscriptGetter &&
         paramTy->isObjCIdType()) {
-      swiftParamTy = SwiftContext.getNSCopyingType();
-      if (SwiftContext.LangOpts.EnableExplicitExistentialTypes)
-        swiftParamTy = ExistentialType::get(swiftParamTy);
+      swiftParamTy = ExistentialType::get(SwiftContext.getNSCopyingType());
       if (!swiftParamTy)
         return {Type(), false};
       if (optionalityOfParam != OTK_None)

lib/SILGen/SILGenType.cpp

@@ -831,10 +831,7 @@ static SILFunction *emitSelfConformanceWitness(SILGenModule &SGM,
                                           ProtocolConformanceRef(conformance));
 
   // Open the protocol type.
-  Type existential = protocolType;
-  if (SGM.getASTContext().LangOpts.EnableExplicitExistentialTypes)
-    existential = ExistentialType::get(protocolType);
-  auto openedType = OpenedArchetypeType::get(existential);
+  auto openedType = OpenedArchetypeType::get(protocol->getExistentialType());
 
   // Form the substitutions for calling the witness.
   auto witnessSubs = SubstitutionMap::getProtocolSubstitutions(protocol,

lib/Sema/CSSimplify.cpp

@@ -6849,12 +6849,7 @@ static bool isCastToExpressibleByNilLiteral(ConstraintSystem &cs, Type fromType,
   if (!nilLiteral)
     return false;
 
-  auto nilLiteralType = nilLiteral->getDeclaredType();
-  if (ctx.LangOpts.EnableExplicitExistentialTypes) {
-    nilLiteralType = ExistentialType::get(nilLiteralType);
-  }
-
-  return toType->isEqual(nilLiteralType) &&
+  return toType->isEqual(nilLiteral->getExistentialType()) &&
          fromType->getOptionalObjectType();
 }
 

lib/Sema/DerivedConformanceCodable.cpp

@@ -1211,10 +1211,7 @@ static FuncDecl *deriveEncodable_encode(DerivedConformance &derived) {
   //                         output: ()
   // Create from the inside out:
 
-  auto encoderType = C.getEncoderType();
-  if (C.LangOpts.EnableExplicitExistentialTypes)
-    encoderType = ExistentialType::get(encoderType);
-
+  auto encoderType = ExistentialType::get(C.getEncoderType());
   auto returnType = TupleType::getEmpty(C);
 
   // Params: (Encoder)
@@ -1805,10 +1802,7 @@ static ValueDecl *deriveDecodable_init(DerivedConformance &derived) {
   // Compute from the inside out:
 
   // Params: (Decoder)
-  auto decoderType = C.getDecoderType();
-  if (C.LangOpts.EnableExplicitExistentialTypes)
-    decoderType = ExistentialType::get(decoderType);
-
+  auto decoderType = ExistentialType::get(C.getDecoderType());
   auto *decoderParamDecl = new (C) ParamDecl(
       SourceLoc(), SourceLoc(), C.Id_from,
       SourceLoc(), C.Id_decoder, conformanceDC);

lib/Sema/TypeCheckProtocol.cpp

@@ -4771,11 +4771,7 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
     // With SE-0335, using a type alias as both a type witness and a generic
     // constraint will be disallowed in Swift 6, because existential types
     // must be explicit, and a generic constraint isn't a valid type witness.
-    //
-    // Note that Any and AnyObject aren't yet resolved using ExistentialType.
-    if (getASTContext().LangOpts.EnableExplicitExistentialTypes &&
-        memberType->isConstraintType() &&
-        !(memberType->isAny() || memberType->isAnyObject())) {
+    if (memberType->isConstraintType()) {
       memberType = ExistentialType::get(memberType);
     }
 

lib/Sema/TypeCheckType.cpp

@@ -3389,9 +3389,7 @@ TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
     return ErrorType::get(getASTContext());
   }
 
-  // FIXME: Don't use ExistentialType for AnyObject for now.
-  if (result->isConstraintType() && !result->isAnyObject() &&
-      getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+  if (result->isConstraintType() &&
       options.isConstraintImplicitExistential()) {
     return ExistentialType::get(result);
   }
@@ -3761,10 +3759,8 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
   auto composition =
       ProtocolCompositionType::get(getASTContext(), Members,
                                    /*HasExplicitAnyObject=*/false);
-  if (getASTContext().LangOpts.EnableExplicitExistentialTypes &&
-      options.isConstraintImplicitExistential() &&
-      !composition->isAny()) {
-    composition = ExistentialType::get(composition);
+  if (options.isConstraintImplicitExistential()) {
+    return ExistentialType::get(composition);
   }
   return composition;
 }
@@ -3792,7 +3788,6 @@ TypeResolver::resolveExistentialType(ExistentialTypeRepr *repr,
     diagnose(repr->getLoc(), diag::unnecessary_any,
              constraintType)
       .fixItRemove({anyStart, anyEnd});
-    return constraintType;
   }
 
   return ExistentialType::get(constraintType);