[ClangImporter] Decide whether to import Objective-C pointer types as

protocol types or existential types based on context.

When an id<P> type is the underlying type of a typedef or a generic
constraint, it should be imported as a protocol or composition. Otherwise,
it should be imported as an existential type. This is similar to how type
resolution resolves existential types using TypeResolverContext.

Author: hborla

lib/ClangImporter/ImportDecl.cpp

@@ -2796,16 +2796,6 @@ namespace {
                                       SourceLoc(), Name,
                                       Loc,
                                       /*genericparams*/nullptr, DC);
-
-      // Unwrap an explicit ExistentialType around the underlying type so that
-      // the typealias can be used in a generic constraint context.
-      //
-      // FIXME: We might want to push this down further into importType(), and
-      // once ExistentialType becomes mandatory in the future we want to wrap
-      // references to imported typealiases in Sema's resolveType() as well.
-      if (auto *existentialType = SwiftType->getAs<ExistentialType>())
-        SwiftType = existentialType->getConstraintType();
-
       Result->setUnderlyingType(SwiftType);
 
       // Make Objective-C's 'id' unavailable.

lib/ClangImporter/ImportType.cpp

@@ -1050,6 +1050,7 @@ namespace {
               if (memberTypes.empty())
                 hasExplicitAnyObject = true;
 
+              // Generic arguments are always imported as existential types.
               Type importedTypeArg = ExistentialType::get(
                   ProtocolCompositionType::get(
                       Impl.SwiftContext, memberTypes,
@@ -1182,9 +1183,6 @@ namespace {
             }
           }
 
-          if (bridgedType->isConstraintType())
-            bridgedType = ExistentialType::get(bridgedType);
-
           return { importedType,
                    ImportHint(ImportHint::ObjCBridged, bridgedType) };
         }
@@ -1205,9 +1203,9 @@ namespace {
           members.push_back(proto->getDeclaredInterfaceType());
         }
 
-        importedType = ExistentialType::get(
+        importedType =
             ProtocolCompositionType::get(Impl.SwiftContext, members,
-                                         /*HasExplicitAnyObject=*/false));
+                                         /*HasExplicitAnyObject=*/false);
       }
 
       // Class or Class<P> maps to an existential metatype.
@@ -1285,6 +1283,32 @@ 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) {
@@ -1550,6 +1574,11 @@ 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,8 +1835,7 @@ class DeclAndTypePrinter::Implementation
 
   void visitExistentialType(ExistentialType *ET,
                             Optional<OptionalTypeKind> optionalKind) {
-    visitExistentialType(ET, optionalKind,
-        /*isMetatype=*/ET->getConstraintType()->is<AnyMetatypeType>());
+    visitPart(ET->getConstraintType(), optionalKind);
   }
 
   void visitExistentialMetatypeType(ExistentialMetatypeType *MT,