[Interop][SwiftToCxx] add support for resilient enum

WANGJIEKE · WANGJIEKE · commit 979bbf5b4e57 · 2022-08-06T17:06:04.000-07:00
diff --git a/include/swift/IRGen/IRABIDetailsProvider.h b/include/swift/IRGen/IRABIDetailsProvider.h
@@ -105,9 +105,15 @@ class IRABIDetailsProvider {
   /// access function.
   FunctionABISignature getTypeMetadataAccessFunctionSignature();
 
+  struct EnumElementInfo {
+    unsigned tag;
+    StringRef globalVariableName;
+  };
+
   /// Returns EnumElementDecls (enum cases) in their declaration order with
   /// their tag indices from the given EnumDecl
-  llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED);
+  llvm::MapVector<EnumElementDecl *, EnumElementInfo>
+  getEnumTagMapping(const EnumDecl *ED);
 
   /// Returns the additional params if they exist after lowering the function.
   SmallVector<ABIAdditionalParam, 1>
diff --git a/lib/IRGen/IRABIDetailsProvider.cpp b/lib/IRGen/IRABIDetailsProvider.cpp
@@ -126,14 +126,18 @@ class IRABIDetailsProviderImpl {
     return {returnTy, {paramTy}};
   }
 
-  llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED) {
-    llvm::MapVector<EnumElementDecl *, unsigned> elements;
+  llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
+  getEnumTagMapping(const EnumDecl *ED) {
+    llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
+        elements;
     auto &enumImplStrat =
         getEnumImplStrategy(IGM, ED->getDeclaredType()->getCanonicalType());
 
     for (auto *element : ED->getAllElements()) {
       auto tagIdx = enumImplStrat.getTagIndex(element);
-      elements.insert({element, tagIdx});
+      auto *global = cast<llvm::GlobalVariable>(
+          IGM.getAddrOfEnumCase(element, NotForDefinition).getAddress());
+      elements.insert({element, {tagIdx, global->getName()}});
     }
 
     return elements;
@@ -217,7 +221,7 @@ IRABIDetailsProvider::getTypeMetadataAccessFunctionSignature() {
   return impl->getTypeMetadataAccessFunctionSignature();
 }
 
-llvm::MapVector<EnumElementDecl *, unsigned>
-IRABIDetailsProvider::getEnumTagMapping(EnumDecl *ED) {
+llvm::MapVector<EnumElementDecl *, IRABIDetailsProvider::EnumElementInfo>
+IRABIDetailsProvider::getEnumTagMapping(const EnumDecl *ED) {
   return impl->getEnumTagMapping(ED);
 }
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -411,7 +411,7 @@ class DeclAndTypePrinter::Implementation
           owningPrinter.interopContext.getIrABIDetails().getEnumTagMapping(ED);
       // Sort cases based on their assigned tag indices
       llvm::stable_sort(elementTagMapping, [](const auto &p1, const auto &p2) {
-        return p1.second < p2.second;
+        return p1.second.tag < p2.second.tag;
       });
 
       if (elementTagMapping.empty()) {
@@ -429,18 +429,43 @@ class DeclAndTypePrinter::Implementation
 
       // Printing operator cases()
       os << "  inline operator cases() const {\n";
-      os << "    switch (_getEnumTag()) {\n";
-      for (const auto &pair : elementTagMapping) {
-        // TODO: have to use global variable for resilient enum
-        os << "      case " << pair.second << ": return cases::";
-        syntaxPrinter.printIdentifier(pair.first->getNameStr());
-        os << ";\n";
+      if (ED->isResilient()) {
+        os << "    auto tag = _getEnumTag();\n";
+        for (const auto &pair : elementTagMapping) {
+          os << "    if (tag == " << cxx_synthesis::getCxxImplNamespaceName();
+          os << "::" << pair.second.globalVariableName << ") return cases::";
+          syntaxPrinter.printIdentifier(pair.first->getNameStr());
+          os << ";\n";
+        }
+        os << "    abort();\n";
+      } else { // non-resilient enum
+        os << "    switch (_getEnumTag()) {\n";
+        for (const auto &pair : elementTagMapping) {
+          os << "      case " << pair.second.tag << ": return cases::";
+          syntaxPrinter.printIdentifier(pair.first->getNameStr());
+          os << ";\n";
+        }
+        // TODO: change to Swift's fatalError when it's available in C++
+        os << "      default: abort();\n";
+        os << "    }\n"; // switch's closing bracket
       }
-      // TODO: change to Swift's fatalError when it's available in C++
-      os << "      default: abort();\n";
-      os << "    }\n"; // switch's closing bracket
       os << "  }\n";   // operator cases()'s closing bracket
 
+      if (ED->isResilient()) {
+        os << "  inline bool inResilientUnknownCase() const {\n";
+        os << "    auto tag = _getEnumTag();\n";
+        os << "    return";
+        llvm::interleave(
+            elementTagMapping, os,
+            [&](const auto &pair) {
+              os << "\n      tag !=" << cxx_synthesis::getCxxImplNamespaceName()
+                 << "::" << pair.second.globalVariableName;
+            },
+            " &&");
+        os << ";\n";
+        os << "  }\n";
+      }
+
       // Printing case-related functions
       DeclAndTypeClangFunctionPrinter clangFuncPrinter(
           os, owningPrinter.prologueOS, owningPrinter.typeMapping,
diff --git a/lib/PrintAsClang/PrintClangValueType.cpp b/lib/PrintAsClang/PrintClangValueType.cpp
@@ -126,6 +126,22 @@ void ClangValueTypePrinter::printValueTypeDecl(
                            // access type metadata.
                            printCTypeMetadataTypeFunction(os, typeDecl,
                                                           typeMetadataFuncName);
+                           // Print out global variables for resilient enum
+                           // cases
+                           if (isa<EnumDecl>(typeDecl) && isOpaqueLayout) {
+                             auto elementTagMapping =
+                                 interopContext.getIrABIDetails()
+                                     .getEnumTagMapping(
+                                         cast<EnumDecl>(typeDecl));
+                             os << "// Tags for resilient enum ";
+                             os << typeDecl->getName().str() << '\n';
+                             os << "extern \"C\" {\n";
+                             for (const auto &pair : elementTagMapping) {
+                               os << "extern int "
+                                  << pair.second.globalVariableName << ";\n";
+                             }
+                             os << "}\n";
+                           }
                          });
 
   auto printEnumVWTableVariable = [&](StringRef metadataName = "metadata",
@@ -278,17 +294,13 @@ void ClangValueTypePrinter::printValueTypeDecl(
         os << "    return result;\n";
         os << "  }\n";
         // Print out helper function for initializeWithTake
-        // TODO: (tongjie) support opaque layout
-        if (!isOpaqueLayout) {
-          os << "  static inline void initializeWithTake(char * _Nonnull "
-                "destStorage, char * _Nonnull srcStorage) {\n";
-          ClangValueTypePrinter::printValueWitnessTableAccessAsVariable(
-              os, typeMetadataFuncName);
-          os << "    vwTable->initializeWithTake(destStorage, srcStorage, "
-                "metadata._0);\n";
-          os << "  }\n";
-        }
-
+        os << "  static inline void initializeWithTake(char * _Nonnull "
+              "destStorage, char * _Nonnull srcStorage) {\n";
+        ClangValueTypePrinter::printValueWitnessTableAccessAsVariable(
+            os, typeMetadataFuncName);
+        os << "    vwTable->initializeWithTake(destStorage, srcStorage, "
+              "metadata._0);\n";
+        os << "  }\n";
         os << "};\n";
       });
 
diff --git a/test/Interop/SwiftToCxx/enums/resilient-enum-in-cxx-execution.cpp b/test/Interop/SwiftToCxx/enums/resilient-enum-in-cxx-execution.cpp
@@ -0,0 +1,39 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/resilient-enum-in-cxx.swift -enable-library-evolution -typecheck -module-name Enums -clang-header-expose-public-decls -emit-clang-header-path %t/enums.h
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-enums-execution.o
+// RUN: %target-interop-build-swift %S/resilient-enum-in-cxx.swift -enable-library-evolution -o %t/swift-enums-execution -Xlinker %t/swift-enums-execution.o -module-name Enums -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+
+// RUN: %target-codesign %t/swift-enums-execution
+// RUN: %target-run %t/swift-enums-execution
+
+// REQUIRES: executable_test
+
+#include <cassert>
+#include "enums.h"
+
+int main() {
+  using namespace Enums;
+
+  {
+    auto f = makeFoo(0);
+    assert(f == Foo::cases::a);
+  }
+  {
+    auto f = makeFoo(1);
+    assert(f == Foo::cases::b);
+    assert(f.getB() == 123);
+  }
+  {
+    auto f = makeFoo(2);
+    assert(f == Foo::cases::c);
+  }
+  {
+    auto f = makeFoo(3);
+    assert(f == Foo::cases::d);
+    assert(f.getD() == 2.34);
+  }
+
+  return 0;
+}
diff --git a/test/Interop/SwiftToCxx/enums/resilient-enum-in-cxx.swift b/test/Interop/SwiftToCxx/enums/resilient-enum-in-cxx.swift
@@ -0,0 +1,52 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -enable-library-evolution -typecheck -module-name Enums -clang-header-expose-public-decls -emit-clang-header-path %t/enums.h
+// RUN: %FileCheck %s < %t/enums.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/enums.h -Wno-unused-private-field -Wno-unused-function)
+
+public enum Foo {
+    case a, b(Int), c
+    case d(Double)
+}
+
+public func makeFoo(_ x: Int) -> Foo {
+    switch x {
+    case 0:
+        return .a
+    case 1:
+        return .b(123)
+    case 2:
+        return .c
+    default:
+        return .d(2.34)
+    }
+}
+
+// CHECK:      // Tags for resilient enum Foo
+// CHECK-NEXT: extern "C" {
+// CHECK-NEXT: extern int $s5Enums3FooO1ayA2CmFWC;
+// CHECK-NEXT: extern int $s5Enums3FooO1byACSicACmFWC;
+// CHECK-NEXT: extern int $s5Enums3FooO1cyA2CmFWC;
+// CHECK-NEXT: extern int $s5Enums3FooO1dyACSdcACmFWC;
+// CHECK-NEXT: }
+// CHECK-EMPTY:
+// CHECK-NEXT: } // namespace _impl
+// CHECK-EMPTY:
+// CHECK-NEXT: class Foo final {
+// CHECK-NEXT:   public:
+// CHECK:      inline operator cases() const {
+// CHECK-NEXT:   auto tag = _getEnumTag();
+// CHECK-NEXT:   if (tag == _impl::$s5Enums3FooO1byACSicACmFWC) return cases::b;
+// CHECK-NEXT:   if (tag == _impl::$s5Enums3FooO1dyACSdcACmFWC) return cases::d;
+// CHECK-NEXT:   if (tag == _impl::$s5Enums3FooO1ayA2CmFWC) return cases::a;
+// CHECK-NEXT:   if (tag == _impl::$s5Enums3FooO1cyA2CmFWC) return cases::c;
+// CHECK-NEXT:   abort();
+// CHECK-NEXT: }
+// CHECK-NEXT: inline bool inResilientUnknownCase() const {
+// CHECK-NEXT:   auto tag = _getEnumTag();
+// CHECK-NEXT:   return
+// CHECK-NEXT:     tag !=_impl::$s5Enums3FooO1byACSicACmFWC &&
+// CHECK-NEXT:     tag !=_impl::$s5Enums3FooO1dyACSdcACmFWC &&
+// CHECK-NEXT:     tag !=_impl::$s5Enums3FooO1ayA2CmFWC &&
+// CHECK-NEXT:     tag !=_impl::$s5Enums3FooO1cyA2CmFWC;
+// CHECK-NEXT: }
