Merge pull request swiftlang#41147 from hborla/import-id-as-any

[ClangImporter] Import `id<P>` as either `any P` or `P` based on context.

Author: hborla

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,

test/ClangImporter/Inputs/explicit_existential.h

@@ -0,0 +1,13 @@
+@import Foundation;
+
+@protocol P
+@end
+
+@protocol Q
+@end
+
+typedef id<P, Q> PAndQ;
+
+@interface PAndQProcessor : NSObject
+- (void) takesPAndQExistential: (PAndQ)arg;
+@end

test/ClangImporter/explicit_existential.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift %clang-importer-sdk -enable-objc-interop -import-objc-header %S/Inputs/explicit_existential.h
+
+// Make sure that 'typedef id<P, Q> PAndQ' imports as a typealias without
+// the ExistentialType wrapping the underlying type.
+
+protocol InheritsFromQAndQ : PAndQ {}
+
+func genericOverPAndQ<T : PAndQ>(_: T) {}
+
+func takesSequenceOfPAndQ<T : Sequence>(_: T) where T.Element : PAndQ {}
+
+func takesPAndQExistential(_ x: PAndQ) {
+  let b = PAndQProcessor()
+  b.takesPAndQExistential(x)
+}