[cxx-interop] Re-implement namespaces using enums + extensions.

C++ namespaces are module-independent, but enums are owned by their module's in Swift. So, to prevent declaring two enums with the same name, this patch implements a new approach to namespaces: enums with extensions.

Here's an example:
```
// Module A
namespace N { void test1(); }
// Module B
namespace N { void test2(); }
// __ObjC module
enum N { }
// Swift module A
extension N { func test1() }
// Swift module B
extension N { func test1() }
```

Thanks to @gribozavr for the great idea.

Author: zoecarver

lib/ClangImporter/ImportDecl.cpp

@@ -2445,19 +2445,116 @@ namespace {
       auto importedName = importFullName(decl, correctSwiftName);
       if (!importedName) return nullptr;
 
-      auto dc =
+      auto extensionDC =
           Impl.importDeclContextOf(decl, importedName.getEffectiveContext());
-      if (!dc)
+      if (!extensionDC)
         return nullptr;
 
       SourceLoc loc = Impl.importSourceLoc(decl->getBeginLoc());
-
-      // FIXME: If Swift gets namespaces, import as a namespace.
-      auto enumDecl = Impl.createDeclWithClangNode<EnumDecl>(
+      DeclContext *dc = nullptr;
+      // If this is a top-level namespace, don't put it in the module we're
+      // importing, put it in the "__ObjC" module that is implicitly imported.
+      // This way, if we have multiple modules that all open the same namespace,
+      // we won't import multiple enums with the same name in swift.
+      if (extensionDC->getContextKind() == DeclContextKind::FileUnit)
+        dc = Impl.ImportedHeaderUnit;
+      else {
+        // This is a nested namespace, we need to find its extension decl
+        // context and then use that to find the parent enum. It's important
+        // that we add this to the parent enum (in the "__ObjC" module) and not
+        // to the extension.
+        auto parentNS = cast<clang::NamespaceDecl>(decl->getParent());
+        auto parent = Impl.importDecl(parentNS, getVersion());
+        // Sometimes when the parent namespace is imported, this namespace
+        // also gets imported. If that's the case, then the parent namespace
+        // will be an enum (because it was able to be fully imported) in which
+        // case we need to bail here.
+        auto cachedResult =
+            Impl.ImportedDecls.find({decl->getCanonicalDecl(), getVersion()});
+        if (cachedResult != Impl.ImportedDecls.end())
+          return cachedResult->second;
+        dc = cast<ExtensionDecl>(parent)
+                 ->getExtendedType()
+                 ->getEnumOrBoundGenericEnum();
+      }
+      auto *enumDecl = Impl.createDeclWithClangNode<EnumDecl>(
           decl, AccessLevel::Public, loc,
           importedName.getDeclName().getBaseIdentifier(),
           Impl.importSourceLoc(decl->getLocation()), None, nullptr, dc);
-      enumDecl->setMemberLoader(&Impl, 0);
+      if (isa<clang::NamespaceDecl>(decl->getParent()))
+        cast<EnumDecl>(dc)->addMember(enumDecl);
+
+      // We are creating an extension, so put it at the top level. This is done
+      // after creating the enum, though, because we may need the correctly
+      // nested decl context above when creating the enum.
+      while (extensionDC->getParent() &&
+             extensionDC->getContextKind() != DeclContextKind::FileUnit)
+        extensionDC = extensionDC->getParent();
+
+      auto *extension = ExtensionDecl::create(Impl.SwiftContext, loc, nullptr,
+                                              {}, extensionDC, nullptr, decl);
+      Impl.SwiftContext.evaluator.cacheOutput(ExtendedTypeRequest{extension},
+                                              enumDecl->getDeclaredType());
+      Impl.SwiftContext.evaluator.cacheOutput(ExtendedNominalRequest{extension},
+                                              std::move(enumDecl));
+      // Keep track of what members we've already added so we don't add the same
+      // member twice. Note: we can't use "ImportedDecls" for this because we
+      // might import a decl that we don't add (for example, if it was a
+      // parameter to another decl).
+      SmallPtrSet<Decl *, 16> addedMembers;
+      for (auto redecl : decl->redecls()) {
+        // This will be reset as the EnumDecl after we return from
+        // VisitNamespaceDecl.
+        Impl.ImportedDecls[{redecl->getCanonicalDecl(), getVersion()}] =
+            extension;
+
+        // Insert these backwards into "namespaceDecls" so we can pop them off
+        // the end without loosing order.
+        SmallVector<clang::Decl *, 16> namespaceDecls;
+        auto addDeclsReversed = [&](auto decls) {
+          auto begin = decls.begin();
+          auto end = decls.end();
+          int currentSize = namespaceDecls.size();
+          int declCount = currentSize + std::distance(begin, end);
+          namespaceDecls.resize(declCount);
+          for (int index = declCount - 1; index >= currentSize; --index)
+            namespaceDecls[index] = *(begin++);
+        };
+        addDeclsReversed(redecl->decls());
+        while (!namespaceDecls.empty()) {
+          auto nd = dyn_cast<clang::NamedDecl>(namespaceDecls.pop_back_val());
+          // Make sure we only import the defenition of a record.
+          if (auto tagDecl = dyn_cast_or_null<clang::TagDecl>(nd))
+            // Some decls, for example ClassTemplateSpecializationDecls, won't
+            // have a definition here. That's OK.
+            nd = tagDecl->getDefinition() ? tagDecl->getDefinition() : tagDecl;
+          if (!nd)
+            continue;
+
+          // Special case class templates: import all their specilizations here.
+          if (auto classTemplate = dyn_cast<clang::ClassTemplateDecl>(nd)) {
+            addDeclsReversed(classTemplate->specializations());
+            continue;
+          }
+
+          auto member = Impl.importDecl(nd, getVersion());
+          if (!member || addedMembers.count(member) ||
+              isa<clang::NamespaceDecl>(nd))
+            continue;
+          // This happens (for example) when a struct is declared inside another
+          // struct inside a namespace but defined out of line.
+          assert(member->getDeclContext()->getAsDecl());
+          if (dyn_cast<ExtensionDecl>(member->getDeclContext()->getAsDecl()) !=
+              extension)
+            continue;
+          extension->addMember(member);
+          addedMembers.insert(member);
+        }
+      }
+
+      if (!extension->getMembers().empty())
+        enumDecl->addExtension(extension);
+
       return enumDecl;
     }
 
@@ -8583,6 +8680,7 @@ DeclContext *ClangImporter::Implementation::importDeclContextImpl(
   auto decl = dyn_cast<clang::NamedDecl>(dc);
   if (!decl)
     return nullptr;
+
   // Category decls with same name can be merged and using canonical decl always
   // leads to the first category of the given name. We'd like to keep these
   // categories separated.

test/ClangImporter/cxx_interop_ir.swift

@@ -9,17 +9,17 @@ func indirectUsage() {
   useT(makeT())
 }
 
-// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s6cxx_ir14reflectionInfo3argypXpSo2nsV1TV_tF"
-// CHECK: %0 = call swiftcc %swift.metadata_response @"$sSo2nsV1TVMa"({{i64|i32}} 0)
+// CHECK-LABEL: define hidden swiftcc %swift.type* @"$s6cxx_ir14reflectionInfo3argypXpSo2nsV10CXXInteropE1TV_tF"
+// CHECK: %0 = call swiftcc %swift.metadata_response @"$sSo2nsV10CXXInteropE1TVMa"({{i64|i32}} 0)
 func reflectionInfo(arg: namespacedT) -> Any.Type {
   return type(of: arg)
 }
 
-// CHECK: define hidden swiftcc void @"$s6cxx_ir24namespaceManglesIntoName3argySo2nsV1TV_tF"
+// CHECK: define hidden swiftcc void @"$s6cxx_ir24namespaceManglesIntoName3argySo2nsV10CXXInteropE1TV_tF"
 func namespaceManglesIntoName(arg: namespacedT) {
 }
 
-// CHECK: define hidden swiftcc void @"$s6cxx_ir42namespaceManglesIntoNameForUsingShadowDecl3argySo2nsV14NamespacedTypeV_tF"
+// CHECK: define hidden swiftcc void @"$s6cxx_ir42namespaceManglesIntoNameForUsingShadowDecl3argySo2nsV10CXXInteropE14NamespacedTypeV_tF"
 func namespaceManglesIntoNameForUsingShadowDecl(arg: NamespacedType) {
 }
 

test/Interop/Cxx/class/linked-records-module-interface.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-ide-test -print-module -module-to-print=LinkedRecords -I %S/Inputs/ -source-filename=x -enable-cxx-interop | %FileCheck %s
 
-// CHECK: enum Space {
+// CHECK: extension Space {
 // CHECK:   struct C {
 // CHECK:     struct D {
 // CHECK:       var B: Space.A.B

test/Interop/Cxx/namespace/Inputs/classes-second-header.h

@@ -0,0 +1,12 @@
+#ifndef TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_SECOND_HEADER_H
+#define TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_SECOND_HEADER_H
+
+#include "classes.h"
+
+struct ClassesNS1::ClassesNS2::DefinedInDefs {
+  const char *basicMember() {
+    return "ClassesNS1::ClassesNS2::DefinedInDefs::basicMember";
+  }
+};
+
+#endif // TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_SECOND_HEADER_H

test/Interop/Cxx/namespace/Inputs/classes.h

@@ -0,0 +1,43 @@
+#ifndef TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_H
+#define TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_H
+
+namespace ClassesNS1 {
+struct BasicStruct {
+  const char *basicMember() { return "ClassesNS1::BasicStruct::basicMember"; }
+};
+struct ForwardDeclaredStruct;
+} // namespace ClassesNS1
+
+struct ClassesNS1::ForwardDeclaredStruct {
+  const char *basicMember() {
+    return "ClassesNS1::ForwardDeclaredStruct::basicMember";
+  }
+};
+
+namespace ClassesNS1 {
+namespace ClassesNS2 {
+struct BasicStruct {
+  const char *basicMember() {
+    return "ClassesNS1::ClassesNS2::BasicStruct::basicMember";
+  }
+};
+struct ForwardDeclaredStruct;
+struct DefinedInDefs;
+} // namespace ClassesNS2
+} // namespace ClassesNS1
+
+namespace ClassesNS1 {
+struct ClassesNS2::ForwardDeclaredStruct {
+  const char *basicMember() {
+    return "ClassesNS1::ClassesNS2::ForwardDeclaredStruct::basicMember";
+  }
+};
+} // namespace ClassesNS1
+
+namespace ClassesNS3 {
+struct BasicStruct {
+  const char *basicMember() { return "ClassesNS3::BasicStruct::basicMember"; }
+};
+} // namespace ClassesNS3
+
+#endif // TEST_INTEROP_CXX_NAMESPACE_INPUTS_CLASSES_H

test/Interop/Cxx/namespace/Inputs/free-functions-second-header.h

@@ -0,0 +1,10 @@
+#ifndef TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTIONS_SECOND_HEADER_H
+#define TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTIONS_SECOND_HEADER_H
+
+#include "free-functions.h"
+
+inline const char *FunctionsNS1::definedInDefs() {
+  return "FunctionsNS1::definedInDefs";
+}
+
+#endif // TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTIONS_SECOND_HEADER_H

test/Interop/Cxx/namespace/Inputs/free-functions.h

@@ -0,0 +1,60 @@
+#ifndef TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTION_H
+#define TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTION_H
+
+namespace FunctionsNS1 {
+inline const char *basicFunctionTopLevel() {
+  return "FunctionsNS1::basicFunctionTopLevel";
+}
+inline const char *forwardDeclared();
+inline const char *definedOutOfLine();
+} // namespace FunctionsNS1
+
+namespace FunctionsNS1 {
+inline const char *forwardDeclared() { return "FunctionsNS1::forwardDeclared"; }
+} // namespace FunctionsNS1
+
+inline const char *FunctionsNS1::definedOutOfLine() {
+  return "FunctionsNS1::definedOutOfLine";
+}
+
+namespace FunctionsNS1 {
+namespace FunctionsNS2 {
+inline const char *basicFunctionSecondLevel() {
+  return "FunctionsNS1::FunctionsNS2::basicFunctionSecondLevel";
+}
+} // namespace FunctionsNS2
+} // namespace FunctionsNS1
+
+namespace FunctionsNS1 {
+namespace FunctionsNS2 {
+namespace FunctionsNS3 {
+inline const char *basicFunctionLowestLevel() {
+  return "FunctionsNS1::FunctionsNS2::FunctionsNS3::basicFunctionLowestLevel";
+}
+} // namespace FunctionsNS3
+} // namespace FunctionsNS2
+} // namespace FunctionsNS1
+
+namespace FunctionsNS1 {
+inline const char *definedInDefs();
+}
+
+namespace FunctionsNS1 {
+inline const char *sameNameInChild() { return "FunctionsNS1::sameNameInChild"; }
+inline const char *sameNameInSibling() {
+  return "FunctionsNS1::sameNameInSibling";
+}
+namespace FunctionsNS2 {
+inline const char *sameNameInChild() {
+  return "FunctionsNS1::FunctionsNS2::sameNameInChild";
+}
+} // namespace FunctionsNS2
+} // namespace FunctionsNS1
+
+namespace FunctionsNS4 {
+inline const char *sameNameInSibling() {
+  return "FunctionsNS4::sameNameInSibling";
+}
+} // namespace FunctionsNS4
+
+#endif // TEST_INTEROP_CXX_NAMESPACE_INPUTS_FREE_FUNCTION_H

test/Interop/Cxx/namespace/Inputs/module.modulemap

@@ -0,0 +1,28 @@
+module Classes {
+  header "classes.h"
+}
+
+module ClassesSecondHeader {
+  // TODO: we shouldn't have to include both of these, and the decls defined in
+  // these headers should be added to the correct module: SR-14214.
+  header "classes.h"
+  header "classes-second-header.h"
+}
+
+module FreeFunctions {
+  header "free-functions.h"
+}
+
+module FreeFunctionsSecondHeader {
+  header "free-functions.h"
+  header "free-functions-second-header.h"
+}
+
+module Templates {
+  header "templates.h"
+}
+
+module TemplatesSecondHeader {
+  header "templates.h"
+  header "templates-second-header.h"
+}

test/Interop/Cxx/namespace/Inputs/templates-second-header.h

@@ -0,0 +1,18 @@
+#ifndef TEST_INTEROP_CXX_NAMESPACE_INPUTS_TEMPLATES_SECOND_HEADER_H
+#define TEST_INTEROP_CXX_NAMESPACE_INPUTS_TEMPLATES_SECOND_HEADER_H
+
+template <class T>
+const char *TemplatesNS1::basicFunctionTemplateDefinedInDefs(T) {
+  return "TemplatesNS1::basicFunctionTemplateDefinedInDefs";
+}
+
+template <class> struct TemplatesNS1::BasicClassTemplateDefinedInDefs {
+  const char *basicMember() {
+    return "TemplatesNS1::BasicClassTemplateDefinedInDefs::basicMember";
+  }
+};
+
+using BasicClassTemplateDefinedInDefsChar =
+    TemplatesNS1::BasicClassTemplateDefinedInDefs<char>;
+
+#endif // TEST_INTEROP_CXX_NAMESPACE_INPUTS_TEMPLATES_SECOND_HEADER_H