[interop][SwiftToCxx] emit unavailable type stubs for top level types that could not be emitted in the C++ section of the generated header

Author: hyp

include/swift/AST/DiagnosticsSema.def

@@ -1694,6 +1694,10 @@ ERROR(expose_enum_case_type_to_cxx,none,
       "enum %0 can not be represented in C++ as one of its cases has an associated value with type that can't be represented in C++", (ValueDecl *))
 ERROR(expose_enum_case_tuple_to_cxx,none,
       "enum %0 can not yet be represented in C++ as one of its cases has multiple associated values", (ValueDecl *))
+ERROR(unexposed_other_decl_in_cxx,none,
+      "%0 %1 is not yet exposed to C++", (DescriptiveDeclKind, ValueDecl *))
+ERROR(unsupported_other_decl_in_cxx,none,
+      "Swift %0 %1 cannot be represented in C++", (DescriptiveDeclKind, ValueDecl *))
 
 ERROR(attr_methods_only,none,
       "only methods can be declared %0", (DeclAttribute))

include/swift/AST/SwiftNameTranslation.h

@@ -13,8 +13,9 @@
 #ifndef SWIFT_NAME_TRANSLATION_H
 #define SWIFT_NAME_TRANSLATION_H
 
-#include "swift/AST/Identifier.h"
 #include "swift/AST/AttrKind.h"
+#include "swift/AST/DiagnosticEngine.h"
+#include "swift/AST/Identifier.h"
 
 namespace swift {
   class ValueDecl;
@@ -78,6 +79,9 @@ enum RepresentationError {
   UnrepresentableEnumCaseTuple,
 };
 
+/// Constructs a diagnostic that describes the given C++ representation error.
+Diagnostic diagnoseRepresenationError(RepresentationError error, ValueDecl *vd);
+
 struct DeclRepresentation {
   RepresentationKind kind;
   llvm::Optional<RepresentationError> error;

lib/AST/SwiftNameTranslation.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/SwiftNameTranslation.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
@@ -283,3 +284,37 @@ bool swift::cxx_translation::isVisibleToCxx(const ValueDecl *VD,
   }
   return false;
 }
+
+Diagnostic
+swift::cxx_translation::diagnoseRepresenationError(RepresentationError error,
+                                                   ValueDecl *vd) {
+  switch (error) {
+  case UnrepresentableObjC:
+    return Diagnostic(diag::expose_unsupported_objc_decl_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableAsync:
+    return Diagnostic(diag::expose_unsupported_async_decl_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableIsolatedInActor:
+    return Diagnostic(diag::expose_unsupported_actor_isolated_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableRequiresClientEmission:
+    return Diagnostic(diag::expose_unsupported_client_emission_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableGeneric:
+    return Diagnostic(diag::expose_generic_decl_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableGenericRequirements:
+    return Diagnostic(diag::expose_generic_requirement_to_cxx,
+                      vd->getDescriptiveKind(), vd);
+  case UnrepresentableThrows:
+    return Diagnostic(diag::expose_throwing_to_cxx, vd->getDescriptiveKind(),
+                      vd);
+  case UnrepresentableIndirectEnum:
+    return Diagnostic(diag::expose_indirect_enum_cxx, vd);
+  case UnrepresentableEnumCaseType:
+    return Diagnostic(diag::expose_enum_case_type_to_cxx, vd);
+  case UnrepresentableEnumCaseTuple:
+    return Diagnostic(diag::expose_enum_case_tuple_to_cxx, vd);
+  }
+}

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -100,6 +100,20 @@ static bool looksLikeInitMethod(ObjCSelector selector) {
   return !(firstPiece.size() > 4 && clang::isLowercase(firstPiece[4]));
 }
 
+// Enters and leaves a new lexical scope when emitting
+// members of a Swift type.
+struct CxxEmissionScopeRAII {
+  DeclAndTypePrinter &printer;
+  CxxDeclEmissionScope &prevScope;
+  CxxDeclEmissionScope scope;
+
+  CxxEmissionScopeRAII(DeclAndTypePrinter &printer)
+      : printer(printer), prevScope(printer.getCxxDeclEmissionScope()) {
+    printer.setCxxDeclEmissionScope(scope);
+  }
+  ~CxxEmissionScopeRAII() { printer.setCxxDeclEmissionScope(prevScope); }
+};
+
 class DeclAndTypePrinter::Implementation
     : private DeclVisitor<DeclAndTypePrinter::Implementation>,
       private TypeVisitor<DeclAndTypePrinter::Implementation, void,
@@ -188,6 +202,12 @@ class DeclAndTypePrinter::Implementation
   }
 
 private:
+  void recordEmittedDeclInCurrentCxxLexicalScope(const ValueDecl *vd) {
+    assert(outputLang == OutputLanguageMode::Cxx);
+    owningPrinter.getCxxDeclEmissionScope().emittedDeclarationNames.insert(
+        cxx_translation::getNameForCxx(vd));
+  }
+
   /// Prints a protocol adoption list: <code>&lt;NSCoding, NSCopying&gt;</code>
   ///
   /// This method filters out non-ObjC protocols.
@@ -215,6 +235,11 @@ class DeclAndTypePrinter::Implementation
   /// 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.
     bool protocolMembersOptional = false;
     for (const Decl *member : members) {
       auto VD = dyn_cast<ValueDecl>(member);
@@ -301,6 +326,7 @@ class DeclAndTypePrinter::Implementation
       ClangValueTypePrinter::forwardDeclType(os, CD, owningPrinter);
       ClangClassTypePrinter(os).printClassTypeDecl(
           CD, [&]() { printMembers(CD->getMembers()); }, owningPrinter);
+      recordEmittedDeclInCurrentCxxLexicalScope(CD);
       return;
     }
 
@@ -363,6 +389,7 @@ class DeclAndTypePrinter::Implementation
           }
         },
         owningPrinter);
+    recordEmittedDeclInCurrentCxxLexicalScope(SD);
   }
 
   void visitExtensionDecl(ExtensionDecl *ED) {
@@ -843,6 +870,7 @@ class DeclAndTypePrinter::Implementation
           printMembers(ED->getMembers());
         },
         owningPrinter);
+    recordEmittedDeclInCurrentCxxLexicalScope(ED);
   }
 
   void visitEnumDecl(EnumDecl *ED) {
@@ -1746,10 +1774,14 @@ class DeclAndTypePrinter::Implementation
       llvm::raw_string_ostream cFuncPrologueOS(cFuncDecl);
       auto funcABI = Implementation(cFuncPrologueOS, owningPrinter, outputLang)
                          .printSwiftABIFunctionSignatureAsCxxFunction(FD);
-      if (!funcABI)
+      if (!funcABI) {
+        owningPrinter.getCxxDeclEmissionScope()
+            .additionalUnrepresentableDeclarations.push_back(FD);
         return;
+      }
       owningPrinter.prologueOS << cFuncPrologueOS.str();
       printAbstractFunctionAsCxxFunctionThunk(FD, *funcABI);
+      recordEmittedDeclInCurrentCxxLexicalScope(FD);
       return;
     }
     if (FD->getDeclContext()->isTypeContext())

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -30,6 +30,15 @@ class PrimitiveTypeMapping;
 class ValueDecl;
 class SwiftToClangInteropContext;
 
+/// Tracks which C++ declarations have been emitted in a lexical
+/// C++ scope.
+struct CxxDeclEmissionScope {
+  /// Additional Swift declarations that are unrepresentable in C++.
+  std::vector<const ValueDecl *> additionalUnrepresentableDeclarations;
+  /// Records the C++ declaration names already emitted in this lexical scope.
+  llvm::StringSet<> emittedDeclarationNames;
+};
+
 /// Responsible for printing a Swift Decl or Type in Objective-C, to be
 /// included in a Swift module's ObjC compatibility header.
 class DeclAndTypePrinter {
@@ -45,6 +54,7 @@ class DeclAndTypePrinter {
   raw_ostream &prologueOS;
   raw_ostream &outOfLineDefinitionsOS;
   const DelayedMemberSet &delayedMembers;
+  CxxDeclEmissionScope *cxxDeclEmissionScope;
   PrimitiveTypeMapping &typeMapping;
   SwiftToClangInteropContext &interopContext;
   AccessLevel minRequiredAccess;
@@ -63,22 +73,31 @@ class DeclAndTypePrinter {
   DeclAndTypePrinter(ModuleDecl &mod, raw_ostream &out, raw_ostream &prologueOS,
                      raw_ostream &outOfLineDefinitionsOS,
                      DelayedMemberSet &delayed,
+                     CxxDeclEmissionScope &topLevelEmissionScope,
                      PrimitiveTypeMapping &typeMapping,
                      SwiftToClangInteropContext &interopContext,
                      AccessLevel access, bool requiresExposedAttribute,
                      llvm::StringSet<> &exposedModules,
                      OutputLanguageMode outputLang)
       : M(mod), os(out), prologueOS(prologueOS),
         outOfLineDefinitionsOS(outOfLineDefinitionsOS), delayedMembers(delayed),
-        typeMapping(typeMapping), interopContext(interopContext),
-        minRequiredAccess(access),
+        cxxDeclEmissionScope(&topLevelEmissionScope), typeMapping(typeMapping),
+        interopContext(interopContext), minRequiredAccess(access),
         requiresExposedAttribute(requiresExposedAttribute),
         exposedModules(exposedModules), outputLang(outputLang) {}
 
   PrimitiveTypeMapping &getTypeMapping() { return typeMapping; }
 
   SwiftToClangInteropContext &getInteropContext() { return interopContext; }
 
+  CxxDeclEmissionScope &getCxxDeclEmissionScope() {
+    return *cxxDeclEmissionScope;
+  }
+
+  void setCxxDeclEmissionScope(CxxDeclEmissionScope &scope) {
+    cxxDeclEmissionScope = &scope;
+  }
+
   /// Returns true if \p VD should be included in a compatibility header for
   /// the options the printer was constructed with.
   bool shouldInclude(const ValueDecl *VD);