[Interop][SwiftToCxx] Support enum creation from Cxx

Author: WANGJIEKE

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -19,6 +19,8 @@
 using namespace swift;
 using namespace cxx_synthesis;
 
+StringRef cxx_synthesis::getCxxSwiftNamespaceName() { return "swift"; }
+
 StringRef cxx_synthesis::getCxxImplNamespaceName() { return "_impl"; }
 
 StringRef cxx_synthesis::getCxxOpaqueStorageClassName() {

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -25,6 +25,9 @@ class NominalTypeDecl;
 
 namespace cxx_synthesis {
 
+/// Return the name of the namespace for things exported from Swift stdlib
+StringRef getCxxSwiftNamespaceName();
+
 /// Return the name of the implementation namespace that is used to hide
 /// declarations from the namespace that corresponds to the imported Swift
 /// module in C++.

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -503,7 +503,11 @@ class ModuleWriter {
   bool writeEnum(const EnumDecl *ED) {
     if (addImport(ED))
       return true;
-    
+
+    if (outputLangMode == OutputLanguageMode::Cxx) {
+      forwardDeclareMemberTypes(ED->getMembers(), ED);
+    }
+
     if (seenTypes[ED].first == EmissionState::Defined)
       return true;
 

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -824,3 +824,44 @@ bool DeclAndTypeClangFunctionPrinter::hasKnownOptionalNullableCxxMapping(
   }
   return false;
 }
+
+void DeclAndTypeClangFunctionPrinter::printCustomCxxFunction(
+    const SmallVector<Type> &neededTypes, PrinterTy retTypeAndNamePrinter,
+    PrinterTy paramPrinter, bool isConstFunc, PrinterTy bodyPrinter,
+    ModuleDecl *emittedModule, raw_ostream &outOfLineOS) {
+  llvm::MapVector<Type, std::string> types;
+
+  for (auto &type : neededTypes) {
+    std::string typeStr;
+    llvm::raw_string_ostream typeOS(typeStr);
+    OptionalTypeKind optKind;
+    Type objectType;
+    std::tie(objectType, optKind) =
+        DeclAndTypePrinter::getObjectTypeAndOptionality(
+            type->getNominalOrBoundGenericNominal(), type);
+
+    // Use FunctionSignatureTypeUse::ReturnType to avoid printing extra const or
+    // references
+    CFunctionSignatureTypePrinter typePrinter(
+        typeOS, cPrologueOS, typeMapping, OutputLanguageMode::Cxx,
+        interopContext, CFunctionSignatureTypePrinterModifierDelegate(),
+        emittedModule, declPrinter, FunctionSignatureTypeUse::ReturnType);
+    typePrinter.visit(objectType, optKind, /* isInOutParam */ false);
+
+    types.insert({type, typeStr});
+  }
+
+  retTypeAndNamePrinter(types);
+  os << '(';
+  outOfLineOS << '(';
+  paramPrinter(types);
+  os << ')';
+  outOfLineOS << ')';
+  if (isConstFunc) {
+    os << " const;\n";
+    outOfLineOS << " const";
+  }
+  outOfLineOS << " {\n";
+  bodyPrinter(types);
+  outOfLineOS << "}\n";
+}

lib/PrintAsClang/PrintClangFunction.cpp

@@ -19,6 +19,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
@@ -140,6 +141,16 @@ class DeclAndTypeClangFunctionPrinter {
                                ModuleDecl *moduleContext,
                                OutputLanguageMode outputLang);
 
+  using PrinterTy =
+      llvm::function_ref<void(llvm::MapVector<Type, std::string> &)>;
+
+  /// Print generated C++ helper function
+  void printCustomCxxFunction(const SmallVector<Type> &neededTypes,
+                              PrinterTy retTypeAndNamePrinter,
+                              PrinterTy paramPrinter, bool isConstFunc,
+                              PrinterTy bodyPrinter, ModuleDecl *emittedModule,
+                              raw_ostream &outOfLineOS);
+
 private:
   void printCxxToCFunctionParameterUse(
       Type type, StringRef name, const ModuleDecl *moduleContext, bool isInOut,

lib/PrintAsClang/PrintClangFunction.h

@@ -270,11 +270,23 @@ void ClangValueTypePrinter::printValueTypeDecl(
           "metadata._0);\n";
     os << "    return _getOpaquePointer();\n";
     os << "  }\n";
+    os << "  inline void _destructiveInjectEnumTag(unsigned tag) {\n";
+    printEnumVWTableVariable();
+    os << "    enumVWTable->destructiveInjectEnumTag(_getOpaquePointer(), tag, "
+          "metadata._0);\n";
+    os << "  }\n";
     os << "  inline unsigned _getEnumTag() const {\n";
     printEnumVWTableVariable();
     os << "    return enumVWTable->getEnumTag(_getOpaquePointer(), "
           "metadata._0);\n";
     os << "  }\n";
+
+    for (const auto &pair : interopContext.getIrABIDetails().getEnumTagMapping(
+             cast<EnumDecl>(typeDecl))) {
+      os << "  using _impl_" << pair.first->getNameStr() << " = decltype(";
+      ClangSyntaxPrinter(os).printIdentifier(pair.first->getNameStr());
+      os << ");\n";
+    }
   }
   // Print out the storage for the value type.
   os << "  ";

lib/PrintAsClang/PrintClangValueType.cpp

@@ -32,6 +32,30 @@ public func printFoo(_ x: Foo) {
     print(x)
 }
 
+public enum Empty {
+
+}
+
+// CHECK:         // Tags for resilient enum Empty
+// CHECK-NEXT:    extern "C" {
+// CHECK-NEXT:    }
+// CHECK-EMPTY:
+// CHECK-NEXT:    } // namespace _impl
+// CHECK-EMPTY:
+// CHECK-NEXT:    class Empty final {
+// CHECK:         enum class cases {
+// CHECK-NEXT:      unknownDefault
+// CHECK-NEXT:    };
+// CHECK-EMPTY:
+// CHECK-NEXT:    static struct {  // impl struct for case unknownDefault
+// CHECK-NEXT:      inline constexpr operator cases() const {
+// CHECK-NEXT:        return cases::unknownDefault;
+// CHECK-NEXT:      }
+// CHECK-NEXT:    } unknownDefault;
+// CHECK-NEXT:    inline bool isUnknownDefault() const;
+// CHECK:         inline operator cases() const {
+// CHECK-NEXT:      return cases::unknownDefault;
+// CHECK-NEXT:    }
 // CHECK:         // Tags for resilient enum Foo
 // CHECK-NEXT:    extern "C" {
 // CHECK-NEXT:    extern unsigned $s5Enums3FooO1ayACSdcACmFWC;
@@ -48,14 +72,14 @@ public func printFoo(_ x: Foo) {
 // CHECK-NEXT:      unknownDefault
 // CHECK-NEXT:    }
 // CHECK:         static struct {  // impl struct for case unknownDefault
-// CHECK-NEXT:      constexpr operator cases() const {
+// CHECK-NEXT:      inline constexpr operator cases() const {
 // CHECK-NEXT:        return cases::unknownDefault;
 // CHECK-NEXT:      }
 // CHECK-NEXT:    } unknownDefault;
-// CHECK-NEXT:    inline bool isUnknownDefault() const {
-// CHECK-NEXT:      return *this == Foo::unknownDefault;
-// CHECK-NEXT:    }
-// CHECK:         inline operator cases() const {
+// CHECK-NEXT:    inline bool isUnknownDefault() const;
+// CHECK-EMPTY:
+// CHECK-EMPTY:
+// CHECK-NEXT:    inline operator cases() const {
 // CHECK-NEXT:      auto tag = _getEnumTag();
 // CHECK-NEXT:      if (tag == _impl::$s5Enums3FooO1ayACSdcACmFWC) return cases::a;
 // NEW_CASE-NEXT:   if (tag == _impl::$s5Enums3FooO1byACSicACmFWC) return cases::b;