[Interop][SwiftToCxx] Implement enum case switching

Author: WANGJIEKE

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -384,30 +384,73 @@ class DeclAndTypePrinter::Implementation
     os << "@end\n";
   }
 
+  void visitEnumDeclCxx(EnumDecl *ED) {
+    // FIXME: Print enum's availability
+    ClangValueTypePrinter printer(os, owningPrinter.prologueOS,
+                                  owningPrinter.typeMapping,
+                                  owningPrinter.interopContext);
+    printer.printValueTypeDecl(ED, /*bodyPrinter=*/[&]() {
+      ClangSyntaxPrinter syntaxPrinter(os);
+      llvm::SmallVector<const EnumElementDecl *> elements;
+
+      os << "  enum class cases {\n";
+      for (const auto *caseDecl : ED->getAllCases()) {
+        for (const auto *element : caseDecl->getElements()) {
+          os << "    ";
+          syntaxPrinter.printIdentifier(element->getNameStr());
+          elements.push_back(element);
+          os << ",\n";
+        }
+      }
+      os << "  };\n"; // enum class cases' closing bracket
+
+      if (elements.size() == 0) {
+        os << "\n";
+        return;
+      }
+
+      // Rearrange cases so that they match their tag values
+      llvm::stable_sort(elements, [&](const auto *e1, const auto *e2) {
+        return e1->hasAssociatedValues() && !e2->hasAssociatedValues();
+      });
+
+      // Printing operator cases()
+      os << "  inline operator cases() const {\n";
+      os << "    switch (_getEnumTag()) {\n";
+      for (unsigned i = 0; i < elements.size(); ++i) {
+        if (i != elements.size() - 1) {
+          os << "      case " << i << ": return cases::";
+        } else {
+          os << "      case " << i << ": default: return cases::";
+        }
+        syntaxPrinter.printIdentifier(elements[i]->getNameStr());
+        os << ";\n";
+      }
+      os << "    }\n"; // switch's closing bracket
+      os << "  }\n";   // operator cases()'s closing bracket
+
+      // Printing predicates
+      for (const auto *element : elements) {
+        os << "  inline bool is";
+        auto name = element->getNameStr().str();
+        // TODO: (tongjie) maybe find a reliable way for upper case conversion
+        name[0] = std::toupper(name[0]);
+        os << name << "() const {\n";
+        os << "    return *this == cases::";
+        syntaxPrinter.printIdentifier(element->getNameStr());
+        os << ";\n  }\n";
+      }
+      os << "\n";
+    });
+    os << outOfLineDefinitions;
+    outOfLineDefinitions.clear();
+  }
+
   void visitEnumDecl(EnumDecl *ED) {
     printDocumentationComment(ED);
 
     if (outputLang == OutputLanguageMode::Cxx) {
-      // FIXME: Print enum's availability
-      ClangValueTypePrinter printer(os, owningPrinter.prologueOS,
-                                    owningPrinter.typeMapping,
-                                    owningPrinter.interopContext);
-      printer.printValueTypeDecl(ED, /*bodyPrinter=*/[&]() {
-        ClangSyntaxPrinter syntaxPrinter(os);
-        os << "  enum class cases {";
-        llvm::interleaveComma(
-            ED->getAllCases(), os, [&](const EnumCaseDecl *caseDecl) {
-              llvm::interleaveComma(caseDecl->getElements(), os,
-                                    [&](const EnumElementDecl *elementDecl) {
-                                      os << "\n    ";
-                                      syntaxPrinter.printIdentifier(
-                                          elementDecl->getNameStr());
-                                    });
-            });
-        os << "\n  };\n";
-      });
-      os << outOfLineDefinitions;
-      outOfLineDefinitions.clear();
+      visitEnumDeclCxx(ED);
       return;
     }
 

lib/PrintAsClang/PrintClangValueType.cpp

@@ -202,7 +202,25 @@ void ClangValueTypePrinter::printValueTypeDecl(
     os << ".getOpaquePointer()";
   os << "; }\n";
   os << "\n";
-
+  // Print out helper function for getting enum tag for enum type
+  if (isa<EnumDecl>(typeDecl)) {
+    // FIXME: (tongjie) return type should be unsigned
+    os << "  inline int _getEnumTag() const {\n";
+    os << "    auto metadata = " << cxx_synthesis::getCxxImplNamespaceName()
+       << "::";
+    printer.printSwiftTypeMetadataAccessFunctionCall(typeMetadataFuncName);
+    os << ";\n";
+    os << "    auto *vwTable = ";
+    printer.printValueWitnessTableAccessFromTypeMetadata("metadata");
+    os << ";\n";
+    os << "    const auto *enumVWTable = reinterpret_cast<";
+    ClangSyntaxPrinter(os).printSwiftImplQualifier();
+    os << "EnumValueWitnessTable";
+    os << " *>(vwTable);\n";
+    os << "    return enumVWTable->getEnumTag(_getOpaquePointer(), "
+          "metadata._0);\n";
+    os << "  }\n";
+  }
   // Print out the storage for the value type.
   os << "  ";
   if (isOpaqueLayout) {

lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp

@@ -62,11 +62,12 @@ static void printKnownType(
   printKnownStruct(typeMapping, os, name, typeRecord);
 }
 
-static void printValueWitnessTableFunctionType(raw_ostream &os, StringRef name,
-                                               StringRef returnType,
-                                               std::string paramTypes,
-                                               uint16_t ptrauthDisc) {
-  os << "using ValueWitness" << name << "Ty = " << returnType
+static void
+printValueWitnessTableFunctionType(raw_ostream &os, StringRef prefix,
+                                   StringRef name, StringRef returnType,
+                                   std::string paramTypes,
+                                   uint16_t ptrauthDisc) {
+  os << "using " << prefix << name << "Ty = " << returnType
      << "(* __ptrauth_swift_value_witness_function_pointer(" << ptrauthDisc
      << "))(" << paramTypes << ");\n";
 }
@@ -87,7 +88,7 @@ static void printValueWitnessTable(raw_ostream &os) {
   membersOS << "  " << type << " " << #lowerId << ";\n";
 #define FUNCTION_VALUE_WITNESS(lowerId, upperId, returnType, paramTypes)       \
   printValueWitnessTableFunctionType(                                          \
-      os, #upperId, returnType, makeParams paramTypes,                         \
+      os, "ValueWitness", #upperId, returnType, makeParams paramTypes,         \
       SpecialPointerAuthDiscriminators::upperId);                              \
   membersOS << "  ValueWitness" << #upperId << "Ty _Nonnull " << #lowerId      \
             << ";\n";
@@ -102,7 +103,32 @@ static void printValueWitnessTable(raw_ostream &os) {
 #define VOID_TYPE "void"
 #include "swift/ABI/ValueWitness.def"
 
-  os << "\nstruct ValueWitnessTable {\n" << membersOS.str() << "};\n";
+  os << "\nstruct ValueWitnessTable {\n" << membersOS.str() << "};\n\n";
+  membersOS.str().clear();
+
+#define WANT_ONLY_ENUM_VALUE_WITNESSES
+#define DATA_VALUE_WITNESS(lowerId, upperId, type)                             \
+  membersOS << "  " << type << " " << #lowerId << ";\n";
+#define FUNCTION_VALUE_WITNESS(lowerId, upperId, returnType, paramTypes)       \
+  printValueWitnessTableFunctionType(                                          \
+      os, "EnumValueWitness", #upperId, returnType, makeParams paramTypes,     \
+      SpecialPointerAuthDiscriminators::upperId);                              \
+  membersOS << "  EnumValueWitness" << #upperId << "Ty _Nonnull " << #lowerId  \
+            << ";\n";
+#define MUTABLE_VALUE_TYPE "void * _Nonnull"
+#define IMMUTABLE_VALUE_TYPE "const void * _Nonnull"
+#define MUTABLE_BUFFER_TYPE "void * _Nonnull"
+#define IMMUTABLE_BUFFER_TYPE "const void * _Nonnull"
+#define TYPE_TYPE "void * _Nonnull"
+#define SIZE_TYPE "size_t"
+#define INT_TYPE "int"
+#define UINT_TYPE "unsigned"
+#define VOID_TYPE "void"
+#include "swift/ABI/ValueWitness.def"
+
+  os << "\nstruct EnumValueWitnessTable {\n"
+     << "  ValueWitnessTable vwTable;\n"
+     << membersOS.str() << "};\n\n";
 }
 
 static void printTypeMetadataResponseType(SwiftToClangInteropContext &ctx,

test/Interop/SwiftToCxx/core/swift-impl-defs-in-cxx.swift

@@ -47,6 +47,18 @@
 // CHECK-NEXT:  unsigned extraInhabitantCount;
 // CHECK-NEXT: };
 // CHECK-EMPTY:
+// CHECK-NEXT: using EnumValueWitnessGetEnumTagTy = int(* __ptrauth_swift_value_witness_function_pointer(41909))(const void * _Nonnull, void * _Nonnull);
+// CHECK-NEXT: using EnumValueWitnessDestructiveProjectEnumDataTy = void(* __ptrauth_swift_value_witness_function_pointer(1053))(void * _Nonnull, void * _Nonnull);
+// CHECK-NEXT: using EnumValueWitnessDestructiveInjectEnumTagTy = void(* __ptrauth_swift_value_witness_function_pointer(45796))(void * _Nonnull, unsigned, void * _Nonnull);
+// CHECK-EMPTY:
+// CHECK-NEXT: struct EnumValueWitnessTable {
+// CHECK-NEXT:   ValueWitnessTable vwTable;
+// CHECK-NEXT:   EnumValueWitnessGetEnumTagTy _Nonnull getEnumTag;
+// CHECK-NEXT:   EnumValueWitnessDestructiveProjectEnumDataTy _Nonnull destructiveProjectEnumData;
+// CHECK-NEXT:   EnumValueWitnessDestructiveInjectEnumTagTy _Nonnull destructiveInjectEnumTag;
+// CHECK-NEXT: };
+// CHECK-EMPTY:
+// CHECK-EMPTY:
 // CHECK-NEXT: #ifdef __cplusplus
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif

test/Interop/SwiftToCxx/enums/enum-cxx-clike-enum-case-functions-execution.cpp

@@ -0,0 +1,181 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/enum-cxx-clike-enum-case-functions.swift -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/enum-cxx-clike-enum-case-functions.swift -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"
+
+using namespace Enums;
+
+void cxxCheckEnum(const DataCase &e) {
+    assert(e.isOne());
+}
+
+void cxxCheckEnum(const CLikeEnum &e) {
+    switch (e) {
+        case CLikeEnum::cases::one:
+            assert(checkCLikeEnum(e, 1));
+            assert(e.isOne());
+            break;
+        case CLikeEnum::cases::two:
+            assert(checkCLikeEnum(e, 2));
+            assert(e.isTwo());
+            break;
+        case CLikeEnum::cases::three:
+            assert(checkCLikeEnum(e, 3));
+            assert(e.isThree());
+            break;
+    }
+}
+
+void cxxCheckEnum(const CharOrSectionMarker &e) {
+    switch (e) {
+        case CharOrSectionMarker::cases::Paragraph:
+            assert(checkCharOrSectionMarker(e, 1));
+            assert(e.isParagraph());
+            break;
+        case CharOrSectionMarker::cases::Char:
+            assert(checkCharOrSectionMarker(e, 2));
+            assert(e.isChar());
+            break;
+        case CharOrSectionMarker::cases::Chapter:
+            assert(checkCharOrSectionMarker(e, 3));
+            assert(e.isChapter());
+            break;
+    }
+}
+
+void cxxCheckEnum(const IntOrInfinity &e) {
+    switch (e) {
+        case IntOrInfinity::cases::NegInfinity:
+            assert(checkIntOrInfinity(e, 1));
+            assert(e.isNegInfinity());
+            break;
+        case IntOrInfinity::cases::Int:
+            assert(checkIntOrInfinity(e, 2));
+            assert(e.isInt());
+            break;
+        case IntOrInfinity::cases::PosInfinity:
+            assert(checkIntOrInfinity(e, 3));
+            assert(e.isPosInfinity());
+            break;
+    }
+}
+
+void cxxCheckEnum(const TerminalChar &e) {
+    switch (e) {
+        case TerminalChar::cases::Plain:
+            assert(checkTerminalChar(e, 1));
+            assert(e.isPlain());
+            break;
+        case TerminalChar::cases::Bold:
+            assert(checkTerminalChar(e, 2));
+            assert(e.isBold());
+            break;
+        case TerminalChar::cases::Underline:
+            assert(checkTerminalChar(e, 3));
+            assert(e.isUnderline());
+            break;
+        case TerminalChar::cases::Blink:
+            assert(checkTerminalChar(e, 4));
+            assert(e.isBlink());
+            break;
+        case TerminalChar::cases::Empty:
+            assert(checkTerminalChar(e, 5));
+            assert(e.isEmpty());
+            break;
+        case TerminalChar::cases::Cursor:
+            assert(checkTerminalChar(e, 6));
+            assert(e.isCursor());
+            break;
+    }
+}
+
+void cxxCheckEnum(const IntDoubleOrBignum &e) {
+    switch (e) {
+        case IntDoubleOrBignum::cases::Int:
+            assert(checkIntDoubleOrBignum(e, 1));
+            assert(e.isInt());
+            break;
+        case IntDoubleOrBignum::cases::Double:
+            assert(checkIntDoubleOrBignum(e, 2));
+            assert(e.isDouble());
+            break;
+        case IntDoubleOrBignum::cases::Bignum:
+            assert(checkIntDoubleOrBignum(e, 3));
+            assert(e.isBignum());
+            break;
+    }
+}
+
+int main() {
+    {
+        auto e1 = makeDataCase();
+        cxxCheckEnum(e1);
+    }
+
+    {
+        auto e1 = makeCLikeEnum(1);
+        auto e2 = makeCLikeEnum(2);
+        auto e3 = makeCLikeEnum(3);
+
+        cxxCheckEnum(e1);
+        cxxCheckEnum(e2);
+        cxxCheckEnum(e3);
+    }
+
+    {
+        auto e1 = makeCharOrSectionMarker(1);
+        auto e2 = makeCharOrSectionMarker(2);
+        auto e3 = makeCharOrSectionMarker(3);
+
+        cxxCheckEnum(e1);
+        cxxCheckEnum(e2);
+        cxxCheckEnum(e3);
+    }
+
+    {
+        auto e1 = makeIntOrInfinity(1);
+        auto e2 = makeIntOrInfinity(2);
+        auto e3 = makeIntOrInfinity(3);
+
+        cxxCheckEnum(e1);
+        cxxCheckEnum(e2);
+        cxxCheckEnum(e3);
+    }
+
+    {
+        auto e1 = makeTerminalChar(1);
+        auto e2 = makeTerminalChar(2);
+        auto e3 = makeTerminalChar(3);
+        auto e4 = makeTerminalChar(4);
+        auto e5 = makeTerminalChar(5);
+        auto e6 = makeTerminalChar(6);
+
+        cxxCheckEnum(e1);
+        cxxCheckEnum(e2);
+        cxxCheckEnum(e3);
+        cxxCheckEnum(e4);
+        cxxCheckEnum(e5);
+        cxxCheckEnum(e6);
+    }
+
+    {
+        auto e1 = makeIntDoubleOrBignum(1);
+        auto e2 = makeIntDoubleOrBignum(2);
+        auto e3 = makeIntDoubleOrBignum(3);
+
+        cxxCheckEnum(e1);
+        cxxCheckEnum(e2);
+        cxxCheckEnum(e3);
+    }
+    return  0;
+}