Merge pull request #41207 from hborla/import-as-any

[Type Resolution] Allow imported existential typealiases to be used as constraints.

Author: hborla

lib/ClangImporter/ImportType.cpp

@@ -1050,7 +1050,6 @@ namespace {
               if (memberTypes.empty())
                 hasExplicitAnyObject = true;
 
-              // Generic arguments are always imported as existential types.
               Type importedTypeArg = ExistentialType::get(
                   ProtocolCompositionType::get(
                       Impl.SwiftContext, memberTypes,
@@ -1183,6 +1182,9 @@ namespace {
             }
           }
 
+          if (bridgedType->isConstraintType())
+            bridgedType = ExistentialType::get(bridgedType);
+
           return { importedType,
                    ImportHint(ImportHint::ObjCBridged, bridgedType) };
         }
@@ -1203,9 +1205,9 @@ namespace {
           members.push_back(proto->getDeclaredInterfaceType());
         }
 
-        importedType =
+        importedType = ExistentialType::get(
             ProtocolCompositionType::get(Impl.SwiftContext, members,
-                                         /*HasExplicitAnyObject=*/false);
+                                         /*HasExplicitAnyObject=*/false));
       }
 
       // Class or Class<P> maps to an existential metatype.
@@ -1283,32 +1285,6 @@ static bool isCFAudited(ImportTypeKind importKind) {
   llvm_unreachable("Invalid ImportTypeKind.");
 }
 
-/// True if the type can be an existential type in this context.
-static bool isExistentialContext(ImportTypeKind importKind) {
-  switch (importKind) {
-  case ImportTypeKind::Abstract:
-  case ImportTypeKind::Typedef:
-    return false;
-  case ImportTypeKind::Value:
-  case ImportTypeKind::ObjCCollectionElement:
-  case ImportTypeKind::Variable:
-  case ImportTypeKind::Result:
-  case ImportTypeKind::Enum:
-  case ImportTypeKind::RecordField:
-  case ImportTypeKind::AuditedVariable:
-  case ImportTypeKind::AuditedResult:
-  case ImportTypeKind::Parameter:
-  case ImportTypeKind::CompletionHandlerResultParameter:
-  case ImportTypeKind::CFRetainedOutParameter:
-  case ImportTypeKind::CFUnretainedOutParameter:
-  case ImportTypeKind::Property:
-  case ImportTypeKind::PropertyWithReferenceSemantics:
-    return true;
-  }
-
-  llvm_unreachable("Invalid ImportTypeKind.");
-}
-
 /// Turn T into Unmanaged<T>.
 static Type getUnmanagedType(ClangImporter::Implementation &impl,
                              Type payloadType) {
@@ -1574,11 +1550,6 @@ static ImportedType adjustTypeForConcreteImport(
 
   assert(importedType);
 
-  if (importedType->isConstraintType() &&
-      isExistentialContext(importKind)) {
-    importedType = ExistentialType::get(importedType);
-  }
-
   if (importKind == ImportTypeKind::RecordField &&
       importedType->isAnyClassReferenceType() &&
       !importedType->isForeignReferenceType()) {

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -1835,7 +1835,8 @@ class DeclAndTypePrinter::Implementation
 
   void visitExistentialType(ExistentialType *ET,
                             Optional<OptionalTypeKind> optionalKind) {
-    visitPart(ET->getConstraintType(), optionalKind);
+    visitExistentialType(ET, optionalKind,
+        /*isMetatype=*/ET->getConstraintType()->is<AnyMetatypeType>());
   }
 
   void visitExistentialMetatypeType(ExistentialMetatypeType *MT,

lib/Sema/TypeCheckType.cpp

@@ -3499,6 +3499,17 @@ TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
     return ExistentialType::get(result);
   }
 
+  if (!options.isConstraintImplicitExistential()) {
+    // Imported existential typealiases, e.g. id<P>, can be
+    // used as constraints by extracting the underlying protocol
+    // types.
+    auto *typeAlias = dyn_cast<TypeAliasType>(result.getPointer());
+    if (typeAlias && typeAlias->is<ExistentialType>() &&
+        typeAlias->getDecl()->hasClangNode()) {
+      return typeAlias->getAs<ExistentialType>()->getConstraintType();
+    }
+  }
+
   // Hack to apply context-specific @escaping to a typealias with an underlying
   // function type.
   if (result->is<FunctionType>())