[cxx-interop] Support nested structs

It is really involved to change how methods and classes are emitted into
the header so this patch introduces the impression of nested structs
through using statements and still emits the structs themselves as top
level structs. It emits them in their own namespace to avoid name
collisions. This patch also had to change some names to be fully
qualified to avoid some name lookup errors in case of nested structs.
Moreover, nesting level of 3 and above requires C++17 because it relies
on nested namespaces. Only nested structs are supported, not nested
classes.

Since this patch is already started to grow quite big, I decided to put
it out for reviews and plan to address some of the shortcomings in a
follow-up PR.

rdar://118793469

Author: Gabor Horvath

lib/AST/SwiftNameTranslation.cpp

@@ -244,8 +244,8 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
         return {Unsupported, UnrepresentableGeneric};
       genericSignature = typeDecl->getGenericSignature();
     }
-    // Nested types are not yet supported.
-    if (!typeDecl->hasClangNode() &&
+    // Nested classes are not yet supported.
+    if (isa<ClassDecl>(VD) && !typeDecl->hasClangNode() &&
         isa_and_nonnull<NominalTypeDecl>(
             typeDecl->getDeclContext()->getAsDecl()))
       return {Unsupported, UnrepresentableNested};

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -20,8 +20,10 @@
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Assertions.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/NestedNameSpecifier.h"
+#include "llvm/Support/Casting.h"
 
 using namespace swift;
 using namespace cxx_synthesis;
@@ -79,7 +81,6 @@ void ClangSyntaxPrinter::printModuleNamespaceQualifiersIfNeeded(
 
 bool ClangSyntaxPrinter::printNominalTypeOutsideMemberDeclTemplateSpecifiers(
     const NominalTypeDecl *typeDecl) {
-  // FIXME: Full qualifiers for nested types?
   if (!typeDecl->isGeneric())
     return true;
   printGenericSignature(
@@ -126,6 +127,26 @@ void ClangSyntaxPrinter::printClangTypeReference(const clang::Decl *typeDecl) {
   }
 }
 
+bool ClangSyntaxPrinter::printNestedTypeNamespaceQualifiers(
+    const ValueDecl *D) const {
+  bool first = true;
+  while (auto parent = dyn_cast_or_null<NominalTypeDecl>(
+             D->getDeclContext()->getAsDecl())) {
+    // C++ namespaces are imported as enums.
+    if (parent->hasClangNode() &&
+        isa<clang::NamespaceDecl>(parent->getClangNode().getAsDecl()))
+      break;
+    if (!first)
+      os << "::";
+    first = false;
+    os << "__";
+    printBaseName(parent);
+    os << "Nested";
+    D = parent;
+  }
+  return first;
+}
+
 void ClangSyntaxPrinter::printNominalTypeReference(
     const NominalTypeDecl *typeDecl, const ModuleDecl *moduleContext) {
   if (typeDecl->hasClangNode()) {
@@ -134,7 +155,8 @@ void ClangSyntaxPrinter::printNominalTypeReference(
   }
   printModuleNamespaceQualifiersIfNeeded(typeDecl->getModuleContext(),
                                          moduleContext);
-  // FIXME: Full qualifiers for nested types?
+  if (!printNestedTypeNamespaceQualifiers(typeDecl))
+    os << "::";
   ClangSyntaxPrinter(os).printBaseName(typeDecl);
   if (typeDecl->isGeneric())
     printGenericSignatureParams(
@@ -180,6 +202,18 @@ void ClangSyntaxPrinter::printNamespace(
   printNamespace([&](raw_ostream &os) { os << name; }, bodyPrinter, trivia);
 }
 
+void ClangSyntaxPrinter::printParentNamespaceForNestedTypes(
+    const ValueDecl *D, llvm::function_ref<void(raw_ostream &OS)> bodyPrinter,
+    NamespaceTrivia trivia) const {
+  if (!isa_and_nonnull<NominalTypeDecl>(D->getDeclContext()->getAsDecl())) {
+    bodyPrinter(os);
+    return;
+  }
+  printNamespace(
+      [=](raw_ostream &os) { printNestedTypeNamespaceQualifiers(D); },
+      bodyPrinter, trivia);
+}
+
 void ClangSyntaxPrinter::printExternC(
     llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const {
   os << "#ifdef __cplusplus\n";
@@ -383,7 +417,8 @@ void ClangSyntaxPrinter::printPrimaryCxxTypeName(
     const NominalTypeDecl *type, const ModuleDecl *moduleContext) {
   printModuleNamespaceQualifiersIfNeeded(type->getModuleContext(),
                                          moduleContext);
-  // FIXME: Print class qualifiers for nested class references.
+  if (!printNestedTypeNamespaceQualifiers(type))
+    os << "::";
   printBaseName(type);
 }
 

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -94,6 +94,9 @@ class ClangSyntaxPrinter {
   bool printNominalTypeOutsideMemberDeclInnerStaticAssert(
       const NominalTypeDecl *typeDecl);
 
+  // Returns true when no qualifiers were printed.
+  bool printNestedTypeNamespaceQualifiers(const ValueDecl *D) const;
+
   /// Print out the C++ class access qualifier for the given Swift  type
   /// declaration.
   ///
@@ -135,6 +138,13 @@ class ClangSyntaxPrinter {
                       llvm::function_ref<void(raw_ostream &OS)> bodyPrinter,
                       NamespaceTrivia trivia = NamespaceTrivia::None) const;
 
+  /// Prints the C++ namespaces of the outer types for a nested type.
+  /// E.g., for struct Foo { struct Bar {...} } it will print
+  /// namespace __FooNested { ..body.. } // namespace __FooNested
+  void printParentNamespaceForNestedTypes(
+      const ValueDecl *D, llvm::function_ref<void(raw_ostream &OS)> bodyPrinter,
+      NamespaceTrivia trivia = NamespaceTrivia::None) const;
+
   /// Print an extern C block with given body.
   void
   printExternC(llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const;

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -12,6 +12,7 @@
 
 #include "DeclAndTypePrinter.h"
 #include "ClangSyntaxPrinter.h"
+#include "OutputLanguageMode.h"
 #include "PrimitiveTypeMapping.h"
 #include "PrintClangClassType.h"
 #include "PrintClangFunction.h"
@@ -46,6 +47,7 @@
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
@@ -234,14 +236,33 @@ class DeclAndTypePrinter::Implementation
     os << ">";
   }
 
+  void printUsingForNestedType(const NominalTypeDecl *TD,
+                               const ModuleDecl *moduleContext) {
+    if (TD->isImplicit() || TD->isSynthesized())
+      return;
+    os << "  using ";
+    ClangSyntaxPrinter(os).printBaseName(TD);
+    os << "=";
+    ClangSyntaxPrinter(os).printNominalTypeReference(TD, moduleContext);
+    os << ";\n";
+  }
+
   /// Prints the members of a class, extension, or protocol.
   template <bool AllowDelayed = false, typename R>
   void printMembers(R &&members) {
     CxxEmissionScopeRAII cxxScopeRAII(owningPrinter);
-    // FIXME: Actually track emitted members in nested
-    // lexical scopes.
-    // FIXME: Emit unavailable C++ decls for not emitted
-    // nested members.
+    // Using statements for nested types.
+    if (outputLang == OutputLanguageMode::Cxx) {
+      for (const Decl *member : members) {
+        if (member->getModuleContext()->isStdlibModule())
+          break;
+        // TODO: support nested classes.
+        if (isa<ClassDecl>(member))
+          continue;
+        if (const auto *TD = dyn_cast<NominalTypeDecl>(member))
+          printUsingForNestedType(TD, TD->getModuleContext());
+      }
+    }
     bool protocolMembersOptional = false;
     for (const Decl *member : members) {
       auto VD = dyn_cast<ValueDecl>(member);
@@ -2796,14 +2817,16 @@ static bool isAsyncAlternativeOfOtherDecl(const ValueDecl *VD) {
   return false;
 }
 
-static bool isStringNestedType(const ValueDecl *VD, StringRef Typename) {
+namespace swift {
+bool isStringNestedType(const ValueDecl *VD, StringRef Typename) {
   auto ctx = VD->getDeclContext();
   return VD->hasName() && VD->getName().isSimpleName() &&
          VD->getBaseIdentifier().str() == Typename &&
          isa<ExtensionDecl>(ctx->getAsDecl()) &&
          cast<ExtensionDecl>(ctx->getAsDecl())->getExtendedNominal() ==
              VD->getASTContext().getStringDecl();
 }
+} // namespace swift
 
 static bool hasExposeAttr(const ValueDecl *VD) {
   if (isa<NominalTypeDecl>(VD) && VD->getModuleContext()->isStdlibModule()) {

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -148,6 +148,8 @@ class DeclAndTypePrinter {
   getObjectTypeAndOptionality(const ValueDecl *D, Type ty);
 };
 
+bool isStringNestedType(const ValueDecl *VD, StringRef Typename);
+
 } // end namespace swift
 
 #endif

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -31,6 +31,7 @@
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/Strings.h"
 
 #include "clang/AST/Decl.h"
@@ -218,7 +219,10 @@ class ModuleWriter {
     return state.first == EmissionState::Defined;
   }
 
-  bool require(const TypeDecl *D) {
+  bool require(const TypeDecl *D) { return requireTypes(D, declsToWrite); }
+
+  template <typename T>
+  bool requireTypes(const TypeDecl *D, T &types) {
     if (addImport(D)) {
       seenTypes[D] = { EmissionState::Defined, true };
       return true;
@@ -229,7 +233,7 @@ class ModuleWriter {
     case EmissionState::NotYetDefined:
     case EmissionState::DefinitionRequested:
       state.first = EmissionState::DefinitionRequested;
-      declsToWrite.push_back(D);
+      types.push_back(D);
       return false;
     case EmissionState::Defined:
       return true;
@@ -364,23 +368,31 @@ class ModuleWriter {
     }
 
     bool hadAnyDelayedMembers = false;
-    SmallVector<ValueDecl *, 4> nestedTypes;
+    SmallVector<const ValueDecl *, 4> nestedTypes;
     for (auto member : members) {
       PrettyStackTraceDecl loopEntry("printing for member", member);
       auto VD = dyn_cast<ValueDecl>(member);
       if (!VD || !printer.shouldInclude(VD))
         continue;
 
       // Catch nested types and emit their definitions /after/ this class.
-      if (isa<TypeDecl>(VD)) {
-        // Don't emit nested types that are just implicitly @objc.
-        // You should have to opt into this, since they are even less
-        // namespaced than usual.
-        if (std::any_of(VD->getAttrs().begin(), VD->getAttrs().end(),
-                        [](const DeclAttribute *attr) {
-                          return isa<ObjCAttr>(attr) && !attr->isImplicit();
-                        })) {
-          nestedTypes.push_back(VD);
+      if (const auto *TD = dyn_cast<TypeDecl>(VD)) {
+        if (outputLangMode == OutputLanguageMode::Cxx) {
+          if (!isa<TypeAliasDecl>(TD) && !isStringNestedType(VD, "UTF8View") &&
+              !isStringNestedType(VD, "Index")) {
+            forwardDeclareType(TD);
+            requireTypes(TD, nestedTypes);
+          }
+        } else {
+          // Don't emit nested types that are just implicitly @objc.
+          // You should have to opt into this, since they are even less
+          // namespaced than usual.
+          if (std::any_of(VD->getAttrs().begin(), VD->getAttrs().end(),
+                          [](const DeclAttribute *attr) {
+                            return isa<ObjCAttr>(attr) && !attr->isImplicit();
+                          })) {
+            nestedTypes.push_back(VD);
+          }
         }
         continue;
       }
@@ -1060,11 +1072,14 @@ EmittedClangHeaderDependencyInfo swift::printModuleContentsAsCxx(
     os << "}\n";
   }
 
+  os << "#pragma clang diagnostic push\n";
+  os << "#pragma clang diagnostic ignored \"-Wreserved-identifier\"\n";
   // Construct a C++ namespace for the module.
   ClangSyntaxPrinter(os).printNamespace(
       [&](raw_ostream &os) { ClangSyntaxPrinter(os).printBaseName(&M); },
       [&](raw_ostream &os) { os << moduleOS.str(); },
       ClangSyntaxPrinter::NamespaceTrivia::AttributeSwiftPrivate, &M);
+  os << "#pragma clang diagnostic pop\n";
 
   if (M.isStdlibModule()) {
     os << "#pragma clang diagnostic pop\n";