[Clang importer] Delay resolution of import-as-member declarations when needed.

It's possible for swift_name to make a global declaration into a
member of another entity that has not been seen yet. In such cases,
delay resolution until the end of the translation unit (module). Fixes
the rest of rdar://problem/25502497.

Author: DougGregor

include/swift/AST/DiagnosticsClangImporter.def

@@ -72,6 +72,10 @@ WARNING(inconsistent_swift_name,none,
         (bool, StringRef, StringRef, DeclName, StringRef, DeclName,
          StringRef))
 
+WARNING(unresolvable_clang_decl,none,
+        "imported declaration '%0' could not be mapped to '%1'",
+        (StringRef, StringRef))
+
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

lib/ClangImporter/ClangImporter.cpp

@@ -844,6 +844,25 @@ void ClangImporter::Implementation::addMacrosToLookupTable(
   }
 }
 
+void ClangImporter::Implementation::finalizeLookupTable(
+       clang::ASTContext &clangCtx,
+       clang::Preprocessor &pp,
+       SwiftLookupTable &table) {
+  // Resolve any unresolved entries.
+  SmallVector<SwiftLookupTable::SingleEntry, 4> unresolved;
+  if (table.resolveUnresolvedEntries(unresolved)) {
+    // Complain about unresolved entries that remain.
+    for (auto entry : unresolved) {
+      auto decl = entry.get<clang::NamedDecl *>();
+      auto swiftName = decl->getAttr<clang::SwiftNameAttr>();
+
+      SwiftContext.Diags.diagnose(SourceLoc(), diag::unresolvable_clang_decl,
+                                  decl->getNameAsString(),
+                                  swiftName->getName());
+    }
+  }
+}
+
 bool ClangImporter::Implementation::importHeader(
     Module *adapter, StringRef headerName, SourceLoc diagLoc,
     bool trackParsedSymbols,
@@ -920,6 +939,10 @@ bool ClangImporter::Implementation::importHeader(
     }
   }
 
+  // Finalize the lookup table, which may fail.
+  finalizeLookupTable(getClangASTContext(), getClangPreprocessor(),
+                      BridgingHeaderLookupTable);
+
   // FIXME: What do we do if there was already an error?
   if (!hadError && clangDiags.hasErrorOccurred()) {
     SwiftContext.Diags.diagnose(diagLoc, diag::bridging_header_error,
@@ -4043,6 +4066,9 @@ ClangImporter::Implementation::SwiftNameLookupExtension::createExtensionWriter(
 
     // Add macros to the lookup table.
     Impl.addMacrosToLookupTable(sema.Context, sema.getPreprocessor(), table);
+
+    // Finalize the lookup table, which may fail.
+    Impl.finalizeLookupTable(sema.Context, sema.getPreprocessor(), table);
   };
 
   return std::unique_ptr<clang::ModuleFileExtensionWriter>(

lib/ClangImporter/ImporterImpl.h

@@ -696,6 +696,11 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void addMacrosToLookupTable(clang::ASTContext &clangCtx,
                               clang::Preprocessor &pp, SwiftLookupTable &table);
 
+  /// Finalize a lookup table, handling any as-yet-unresolved entries
+  /// and emitting diagnostics if necessary.
+  void finalizeLookupTable(clang::ASTContext &clangCtx,
+                           clang::Preprocessor &pp, SwiftLookupTable &table);
+
 public:
   void registerExternalDecl(Decl *D) {
     RegisteredExternalDecls.push_back(D);

lib/ClangImporter/SwiftLookupTable.cpp

@@ -84,7 +84,7 @@ translateDeclToContext(clang::NamedDecl *decl) {
     // If this typedef is merely a restatement of a tag declaration's type,
     // return the result for that tag.
     if (auto tag = typedefName->getUnderlyingType()->getAsTagDecl())
-      return translateDeclToContext(tag);
+      return translateDeclToContext(const_cast<clang::TagDecl *>(tag));
 
     // Otherwise, this must be a typedef mapped to a strong type.
     return std::make_pair(SwiftLookupTable::ContextKind::Typedef,
@@ -105,13 +105,8 @@ SwiftLookupTable::translateContext(EffectiveClangContext context) {
       return std::make_pair(ContextKind::TranslationUnit, StringRef());
 
     // Tag declaration context.
-    if (auto tag = dyn_cast<clang::TagDecl>(dc)) {
-      if (tag->getIdentifier())
-        return std::make_pair(ContextKind::Tag, tag->getName());
-      if (auto typedefDecl = tag->getTypedefNameForAnonDecl())
-        return std::make_pair(ContextKind::Tag, typedefDecl->getName());
-      return None;
-    }
+    if (auto tag = dyn_cast<clang::TagDecl>(dc))
+      return translateDeclToContext(const_cast<clang::TagDecl *>(tag));
 
     // Objective-C class context.
     if (auto objcClass = dyn_cast<clang::ObjCInterfaceDecl>(dc))
@@ -130,10 +125,8 @@ SwiftLookupTable::translateContext(EffectiveClangContext context) {
 
   case EffectiveClangContext::UnresolvedContext:
     // Resolve the context.
-    if (auto decl = resolveContext(context.getUnresolvedName())) {
-      if (auto context = translateDeclToContext(decl))
-        return context;
-    }
+    if (auto decl = resolveContext(context.getUnresolvedName()))
+      return translateDeclToContext(decl);
 
     return None;
   }
@@ -167,6 +160,66 @@ void SwiftLookupTable::addCategory(clang::ObjCCategoryDecl *category) {
   Categories.push_back(category);
 }
 
+bool SwiftLookupTable::resolveUnresolvedEntries(
+    SmallVectorImpl<SingleEntry> &unresolved) {
+  // Common case: nothing left to resolve.
+  unresolved.clear();
+  if (UnresolvedEntries.empty()) return false;
+
+  // Reprocess each of the unresolved entries to see if it can be
+  // resolved now that we're done. This occurs when a swift_name'd
+  // entity becomes a member of an entity that follows it in the
+  // translation unit, e.g., given:
+  //
+  // \code
+  //   typedef enum FooSomeEnumeration __attribute__((Foo.SomeEnum)) {
+  //     ...
+  //   } FooSomeEnumeration;
+  //
+  //   typedef struct Foo {
+  //     
+  //   } Foo;
+  // \endcode
+  //
+  // FooSomeEnumeration belongs inside "Foo", but we haven't actually
+  // seen "Foo" yet. Therefore, we will reprocess FooSomeEnumeration
+  // at the end, once "Foo" is available. There are several reasons
+  // this loop can execute:
+  //
+  // * Import-as-member places an entity inside of an another entity
+  // that comes later in the translation unit. The number of
+  // iterations that can be caused by this is bounded by the nesting
+  // depth. (At present, that depth is limited to 2).
+  //
+  // * An erroneous import-as-member will cause an extra iteration at
+  // the end, so that the loop can detect that nothing changed and
+  // return a failure.
+  while (true) {
+    // Take the list of unresolved entries to process.
+    auto prevNumUnresolvedEntries = UnresolvedEntries.size();
+    auto currentUnresolved = std::move(UnresolvedEntries);
+    UnresolvedEntries.clear();
+
+    // Process each of the currently-unresolved entries.
+    for (const auto &entry : currentUnresolved)
+      addEntry(std::get<0>(entry), std::get<1>(entry), std::get<2>(entry));
+
+    // Are we done?
+    if (UnresolvedEntries.empty()) return false;
+
+    // If nothing changed, fail: something is unresolvable, and the
+    // caller should complain.
+    if (UnresolvedEntries.size() == prevNumUnresolvedEntries) {
+      for (const auto &entry : UnresolvedEntries)
+        unresolved.push_back(std::get<1>(entry));
+      return true;
+    }
+
+    // Something got resolved, so loop again.
+    assert(UnresolvedEntries.size() < prevNumUnresolvedEntries);
+  }
+}
+
 /// Determine whether the entry is a global declaration that is being
 /// mapped as a member of a particular type or extension thereof.
 ///
@@ -237,7 +290,19 @@ void SwiftLookupTable::addEntry(DeclName name, SingleEntry newEntry,
 
   // Translate the context.
   auto contextOpt = translateContext(effectiveContext);
-  if (!contextOpt) return;
+  if (!contextOpt) {
+    // If is is a declaration with a swift_name attribute, we might be
+    // able to resolve this later.
+    if (auto decl = newEntry.dyn_cast<clang::NamedDecl *>()) {
+      if (decl->hasAttr<clang::SwiftNameAttr>()) {
+        UnresolvedEntries.push_back(
+          std::make_tuple(name, newEntry, effectiveContext));
+      }
+    }
+
+    return;
+  }
+
   auto context = *contextOpt;
 
   // If this is a global imported as a member, record is as such.

lib/ClangImporter/SwiftLookupTable.h

@@ -281,6 +281,11 @@ class SwiftLookupTable {
   /// The reader responsible for lazily loading the contents of this table.
   SwiftLookupTableReader *Reader;
 
+  /// Entries whose effective contexts could not be resolved, and
+  /// therefore will need to be added later.
+  SmallVector<std::tuple<DeclName, SingleEntry, EffectiveClangContext>, 4>
+    UnresolvedEntries;
+
   friend class SwiftLookupTableReader;
   friend class SwiftLookupTableWriter;
 
@@ -320,6 +325,15 @@ class SwiftLookupTable {
   /// Add an Objective-C category or extension to the table.
   void addCategory(clang::ObjCCategoryDecl *category);
 
+  /// Resolve any unresolved entries.
+  ///
+  /// \param unresolved Will be populated with the list of entries
+  /// that could not be resolved.
+  ///
+  /// \returns true if any remaining entries could not be resolved,
+  /// and false otherwise.
+  bool resolveUnresolvedEntries(SmallVectorImpl<SingleEntry> &unresolved);
+
 private:
   /// Lookup the set of entities with the given base name.
   ///

test/IDE/Inputs/custom-modules/ImportAsMemberClass.h

@@ -3,15 +3,15 @@
 
 @import Foundation;
 
-__attribute__((swift_name("SomeClass")))
-@interface IAMSomeClass : NSObject
-@end
-
 typedef NS_OPTIONS(NSInteger, IAMSomeClassOptions) {
   IAMSomeClassFuzzyDice = 0x01,
   IAMSomeClassSpoiler = 0x02
 } __attribute__((swift_name("SomeClass.Options")));
 
+__attribute__((swift_name("SomeClass")))
+@interface IAMSomeClass : NSObject
+@end
+
 __attribute__((swift_name("SomeClass.init(value:)")))
 IAMSomeClass * _Nonnull MakeIAMSomeClass(double x);
 

test/IDE/import_as_member_objc.swift

@@ -23,14 +23,14 @@
 // PRINT-CLASS-NEXT:   init()
 // PRINT-CLASS-NEXT: }
 // PRINT-CLASS-NEXT: extension SomeClass {
+// PRINT-CLASS-NEXT:   /*not inherited*/ init(value x: Double)
+// PRINT-CLASS-NEXT:   func applyOptions(_ options: SomeClass.Options)
 // PRINT-CLASS-NEXT:   struct Options : OptionSet {
 // PRINT-CLASS-NEXT:     init(rawValue rawValue: Int)
 // PRINT-CLASS-NEXT:     let rawValue: Int
 // PRINT-CLASS-NEXT:     static var fuzzyDice: SomeClass.Options { get }
 // PRINT-CLASS-NEXT:     static var spoiler: SomeClass.Options { get }
 // PRINT-CLASS-NEXT:   }
-// PRINT-CLASS-NEXT:   /*not inherited*/ init(value x: Double)
-// PRINT-CLASS-NEXT:   func applyOptions(_ options: SomeClass.Options)
 // PRINT-CLASS-NEXT: }
 
 // RUN: %target-parse-verify-swift -I %S/Inputs/custom-modules