Clang importer: recursively add members to the Swift lookup tables.

This is needed for member lookup via the Swift lookup tables, although
the lookup part is not yet implemented. Note also that the results are
currently wrong for C enumerations mapped into Swift enums or option
sets. That will come shortly.

Author: DougGregor

lib/ClangImporter/ClangImporter.cpp

@@ -702,6 +702,30 @@ bool ClangImporter::addSearchPath(StringRef newSearchPath, bool isFramework) {
   return false;
 }
 
+void ClangImporter::Implementation::addEntryToLookupTable(
+       SwiftLookupTable &table, clang::NamedDecl *named)
+{
+  // If we have a name to import as, add this entry to the table.
+  if (DeclName name = importFullName(named)) {
+    clang::DeclContext *effectiveContext
+      = named->getDeclContext()->getRedeclContext() ->getPrimaryContext();
+
+    table.addEntry(name, named, effectiveContext);
+  }
+
+  // Walk the members of any context that can have nested members.
+  if (isa<clang::TagDecl>(named) ||
+      isa<clang::ObjCInterfaceDecl>(named) ||
+      isa<clang::ObjCProtocolDecl>(named) ||
+      isa<clang::ObjCCategoryDecl>(named)) {
+    clang::DeclContext *dc = cast<clang::DeclContext>(named);
+    for (auto member : dc->decls()) {
+      if (auto namedMember = dyn_cast<clang::NamedDecl>(member))
+        addEntryToLookupTable(table, namedMember);
+    }
+  }
+}
+
 bool ClangImporter::Implementation::importHeader(
     Module *adapter, StringRef headerName, SourceLoc diagLoc,
     bool trackParsedSymbols,
@@ -743,8 +767,7 @@ bool ClangImporter::Implementation::importHeader(
 
         if (UseSwiftLookupTables) {
           if (auto named = dyn_cast<clang::NamedDecl>(D)) {
-            if (DeclName name = importFullName(named))
-              BridgingHeaderLookupTable.addEntry(name, named);
+            addEntryToLookupTable(BridgingHeaderLookupTable, named);
           }
         }
       }

lib/ClangImporter/ImporterImpl.h

@@ -625,6 +625,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void addBridgeHeaderTopLevelDecls(clang::Decl *D);
   bool shouldIgnoreBridgeHeaderTopLevelDecl(clang::Decl *D);
 
+  /// Add the given named declaration as an entry to the given Swift name
+  /// lookup table, including any of its child entries.
+  void addEntryToLookupTable(SwiftLookupTable &table, clang::NamedDecl *named);
+
 public:
   void registerExternalDecl(Decl *D) {
     RegisteredExternalDecls.push_back(D);

lib/ClangImporter/SwiftLookupTable.cpp

@@ -51,7 +51,8 @@ static bool matchesExistingDecl(clang::Decl *decl, clang::Decl *existingDecl) {
   return false;
 }
 
-void SwiftLookupTable::addEntry(DeclName name, clang::NamedDecl *decl) {
+void SwiftLookupTable::addEntry(DeclName name, clang::NamedDecl *decl,
+                                clang::DeclContext *effectiveContext) {
   clang::DeclContext *context
     = decl->getDeclContext()->getRedeclContext()->getPrimaryContext();
 
@@ -91,6 +92,22 @@ void SwiftLookupTable::addEntry(DeclName name, clang::NamedDecl *decl) {
   fullEntries.push_back(newEntry);
 }
 
+static void printName(clang::NamedDecl *named, llvm::raw_ostream &out) {
+  // If there is a name, print it.
+  if (!named->getDeclName().isEmpty()) {
+    named->printName(out);
+    return;
+  }
+
+  // If this is an anonymous tag declaration with a typedef name, use that.
+  if (auto tag = dyn_cast<clang::TagDecl>(named)) {
+    if (auto typedefName = tag->getTypedefNameForAnonDecl()) {
+      printName(typedefName, out);
+      return;
+    }
+  }
+}
+
 void SwiftLookupTable::dump() const {
   // Dump the base name -> full name mappings.
   SmallVector<Identifier, 4> baseNames;
@@ -134,8 +151,7 @@ void SwiftLookupTable::dump() const {
       if (fullEntry.Context->isTranslationUnit()) {
         llvm::errs() << "TU";
       } else if (auto named = dyn_cast<clang::NamedDecl>(fullEntry.Context)) {
-        named->printName(llvm::errs());
-        llvm::errs();
+        printName(named, llvm::errs());
       } else {
         llvm::errs() << "<unknown>";
       }

lib/ClangImporter/SwiftLookupTable.h

@@ -71,7 +71,9 @@ class SwiftLookupTable {
   ///
   /// \param name The Swift name of the entry.
   /// \param decl The Clang declaration to add.
-  void addEntry(DeclName name, clang::NamedDecl *decl);
+  /// \param effectiveContext The effective context in which name lookup occurs.
+  void addEntry(DeclName name, clang::NamedDecl *decl,
+                clang::DeclContext *effectiveContext);
 
   /// Lookup the set of declarations with the given base name.
   ///

test/IDE/Inputs/swift_name.h

@@ -28,7 +28,7 @@ typedef int SNIntegerType SWIFT_NAME(MyInt);
 
 // Renaming enumerations.
 SWIFT_ENUM(unsigned char, SNColorChoice) {
-  SNColorRed,
+  SNColorRed SWIFT_NAME(Rouge),
   SNColorGreen,
   SNColorBlue
 };

test/IDE/dump_swift_lookup_tables.swift

@@ -5,10 +5,16 @@
 // CHECK-NEXT:   Bar --> Bar
 // CHECK-NEXT:   MyInt --> MyInt
 // CHECK-NEXT:   Point --> Point
+// CHECK-NEXT:   Rouge --> Rouge
+// CHECK-NEXT:   SNColorBlue --> SNColorBlue
 // CHECK-NEXT:   SNColorChoice --> SNColorChoice
+// CHECK-NEXT:   SNColorGreen --> SNColorGreen
 // CHECK-NEXT:   SomeStruct --> SomeStruct
 // CHECK-NEXT:   __SNTransposeInPlace --> __SNTransposeInPlace
 // CHECK-NEXT:   makeSomeStruct --> makeSomeStruct(x:y:), makeSomeStruct(x:)
+// CHECK-NEXT:   x --> x
+// CHECK-NEXT:   y --> y
+// CHECK-NEXT:   z --> z
 
 // CHECK:      Full name -> entry mappings:
 // CHECK-NEXT:   Bar:
@@ -17,8 +23,14 @@
 // CHECK-NEXT:     TU: SNIntegerType
 // CHECK-NEXT:   Point:
 // CHECK-NEXT:     TU: SNPoint
+// CHECK-NEXT:   Rouge:
+// CHECK-NEXT:     TU: SNColorRed
+// CHECK-NEXT:   SNColorBlue:
+// CHECK-NEXT:     TU: SNColorBlue
 // CHECK-NEXT:   SNColorChoice:
-// CHECK-NEXT:     TU: SNColorChoice, SNColorChoice{{$}}
+// CHECK-NEXT:     TU: SNColorChoice, SNColorChoice
+// CHECK-NEXT:   SNColorGreen:
+// CHECK-NEXT:     TU: SNColorGreen
 // CHECK-NEXT:   SomeStruct:
 // CHECK-NEXT:     TU: SNSomeStruct
 // CHECK-NEXT:   __SNTransposeInPlace:
@@ -27,3 +39,10 @@
 // CHECK-NEXT:     TU: SNMakeSomeStructForX
 // CHECK-NEXT:   makeSomeStruct(x:y:):
 // CHECK-NEXT:     TU: SNMakeSomeStruct
+// CHECK-NEXT:   x:
+// CHECK-NEXT:     SNSomeStruct: X
+// CHECK-NEXT:     SNPoint: x
+// CHECK-NEXT:   y:
+// CHECK-NEXT:     SNPoint: y
+// CHECK-NEXT:   z:
+// CHECK-NEXT:     SNPoint: z