[Clang importer] Use Clang swift_bridge attribute for bridging.

When an Objective-C class type is annotated with the swift_bridge
value type, bridge it to the named type. Use API notes on Foundation
rather than special cases.

For Objective-C classes where bridging was baked into the Clang
importer (NSString, NSArray, NSDictionary, NSSet), add API notes to
put the appropriate swift_bridge attribute on these Objective-C
classes.

Note: requires Clang update.

Author: DougGregor

apinotes/Foundation.apinotes

@@ -1,6 +1,14 @@
 ---
 Name: Foundation
 Classes:
+- Name: NSArray
+  SwiftBridge: 'Swift.Array'
+- Name: NSDictionary
+  SwiftBridge: 'Swift.Dictionary'
+- Name: NSSet
+  SwiftBridge: 'Swift.Set'
+- Name: NSString
+  SwiftBridge: 'Swift.String'
 - Name: NSDistributedNotificationCenter
   Methods:
   - Selector: 'notificationCenterForType:'

apinotes/ObjectiveC.apinotes

@@ -1,6 +1,14 @@
 ---
 Name: ObjectiveC
 Classes:
+- Name: NSArray
+  SwiftBridge: 'Swift.Array'
+- Name: NSDictionary
+  SwiftBridge: 'Swift.Dictionary'
+- Name: NSSet
+  SwiftBridge: 'Swift.Set'
+- Name: NSString
+  SwiftBridge: 'Swift.String'
 - Name: List
   Methods:
   - Selector: init

lib/ClangImporter/ImportType.cpp

@@ -646,6 +646,31 @@ namespace {
       return nullptr;
     }
 
+    /// Map the Clang swift_bridge attribute to a specific type.
+    Type mapSwiftBridgeAttr(const clang::NamedDecl *clangDecl) {
+      // Check whether there is a swift_bridge attribute.
+      auto bridgeAttr = clangDecl->getAttr<clang::SwiftBridgeAttr>();
+      if (!bridgeAttr) return Type();
+
+      // Determine the module and Swift declaration names.
+      StringRef moduleName;
+      StringRef name = bridgeAttr->getSwiftType();
+      auto dotPos = name.find('.');
+      if (dotPos == StringRef::npos) {
+        // Determine the module name from the Clang declaration.
+        if (auto module = clangDecl->getImportedOwningModule())
+          moduleName = module->getTopLevelModuleName();
+        else
+          moduleName = clangDecl->getASTContext().getLangOpts().CurrentModule;
+      } else {
+        // The string is ModuleName.TypeName.
+        moduleName = name.substr(0, dotPos);
+        name = name.substr(dotPos + 1);
+      }
+
+      return Impl.getNamedSwiftType(moduleName, name);
+    }
+
     ImportResult
     VisitObjCObjectPointerType(const clang::ObjCObjectPointerType *type) {
       // If this object pointer refers to an Objective-C class (possibly
@@ -684,20 +709,11 @@ namespace {
 
         // Determine whether this Objective-C class type is bridged to
         // a Swift type.
-        NominalTypeDecl *bridgedTypeDecl = nullptr;
-        StringRef objcClassName = objcClass->getName();
-        if (objcClassName == "NSString")
-          bridgedTypeDecl = Impl.SwiftContext.getStringDecl();
-        else if (objcClassName == "NSArray")
-          bridgedTypeDecl = Impl.SwiftContext.getArrayDecl();
-        else if (objcClassName == "NSDictionary")
-          bridgedTypeDecl = Impl.SwiftContext.getDictionaryDecl();
-        else if (objcClassName == "NSSet")
-          bridgedTypeDecl = Impl.SwiftContext.getSetDecl();
-
         Type bridgedType;
-        if (bridgedTypeDecl)
-          bridgedType = bridgedTypeDecl->getDeclaredType();
+        if (auto objcClassDef = objcClass->getDefinition())
+          bridgedType = mapSwiftBridgeAttr(objcClassDef);
+        else
+          bridgedType = mapSwiftBridgeAttr(objcClass);
 
         if (bridgedType) {
           // Gather the type arguments.
@@ -2214,29 +2230,36 @@ Module *ClangImporter::Implementation::getNamedModule(StringRef name) {
 }
 
 static Module *tryLoadModule(ASTContext &C,
-                             Identifier name,
+                             Identifier moduleName,
                              bool importForwardDeclarations,
-                             Optional<Module *> &cache) {
-  if (!cache.hasValue()) {
-    // If we're synthesizing forward declarations, we don't want to pull in
-    // the module too eagerly.
-    if (importForwardDeclarations)
-      cache = C.getLoadedModule(name);
-    else
-      cache = C.getModule({ {name, SourceLoc()} });
-  }
+                             llvm::DenseMap<Identifier, Module *>
+                               &checkedModules) {
+  // If we've already done this check, return the cached result.
+  auto known = checkedModules.find(moduleName);
+  if (known != checkedModules.end())
+    return known->second;
+
+  Module *module;
+
+  // If we're synthesizing forward declarations, we don't want to pull in
+  // the module too eagerly.
+  if (importForwardDeclarations)
+    module = C.getLoadedModule(moduleName);
+  else
+    module = C.getModule({ {moduleName, SourceLoc()} });
 
-  return cache.getValue();
+  checkedModules[moduleName] = module;
+  return module;
 }
 
 Module *ClangImporter::Implementation::tryLoadFoundationModule() {
   return tryLoadModule(SwiftContext, SwiftContext.Id_Foundation,
-                       ImportForwardDeclarations, checkedFoundationModule);
+                       ImportForwardDeclarations, checkedModules);
 }
 
 Module *ClangImporter::Implementation::tryLoadSIMDModule() {
   return tryLoadModule(SwiftContext, SwiftContext.Id_simd,
-                       ImportForwardDeclarations, checkedSIMDModule);
+                       ImportForwardDeclarations, checkedModules);
 }
 
 Type ClangImporter::Implementation::getNamedSwiftType(Module *module,
@@ -2277,6 +2300,17 @@ Type ClangImporter::Implementation::getNamedSwiftType(Module *module,
   return type->getDeclaredType();
 }
 
+Type ClangImporter::Implementation::getNamedSwiftType(StringRef moduleName,
+                                                      StringRef name) {
+  // Try to load the module.
+  auto module = tryLoadModule(SwiftContext,
+                              SwiftContext.getIdentifier(moduleName),
+                              ImportForwardDeclarations, checkedModules);
+  if (!module) return Type();
+
+  return getNamedSwiftType(module, name);
+}
+
 Type
 ClangImporter::Implementation::
 getNamedSwiftTypeSpecialization(Module *module, StringRef name,

lib/ClangImporter/ImporterImpl.h

@@ -605,7 +605,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   clang::Selector setObjectForKeyedSubscript;
 
 private:
-  Optional<Module *> checkedFoundationModule, checkedSIMDModule;
+  /// Records those modules that we have looked up.
+  llvm::DenseMap<Identifier, Module *> checkedModules;
 
   /// External Decls that we have imported but not passed to the ASTContext yet.
   SmallVector<Decl *, 4> RegisteredExternalDecls;
@@ -1098,7 +1099,16 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 
   /// \brief Retrieve the named Swift type, e.g., Int32.
   ///
-  /// \param module The name of the module in which the type should occur.
+  /// \param moduleName The name of the module in which the type should occur.
+  ///
+  /// \param name The name of the type to find.
+  ///
+  /// \returns The named type, or null if the type could not be found.
+  Type getNamedSwiftType(StringRef moduleName, StringRef name);
+
+  /// \brief Retrieve the named Swift type, e.g., Int32.
+  ///
+  /// \param module The module in which the type should occur.
   ///
   /// \param name The name of the type to find.
   ///

lib/ClangImporter/SwiftLookupTable.h

@@ -128,7 +128,7 @@ const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MAJOR = 1;
 /// Lookup table minor version number.
 ///
 /// When the format changes IN ANY WAY, this number should be incremented.
-const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 9; // typedef context kind
+const uint16_t SWIFT_LOOKUP_TABLE_VERSION_MINOR = 10; // swift bridge
 
 /// A lookup table that maps Swift names to the set of Clang
 /// declarations with that particular name.