[cxx-interop] Emit C++ inline function thunks that with correct primitive types

hyp · hyp · commit f7902a60957e · 2022-03-29T13:37:01.000-07:00
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -716,8 +716,7 @@ class DeclAndTypePrinter::Implementation
   /// Print the core function declaration for a given function with the given
   /// name.
   void printFunctionDeclAsCFunctionDecl(FuncDecl *FD, StringRef name,
-                                        Type resultTy,
-                                        bool printEmptyParamNames = false) {
+                                        Type resultTy) {
     // The result type may be a partial function type we need to close
     // up later.
     PrintMultiPartType multiPart(*this);
@@ -737,12 +736,8 @@ class DeclAndTypePrinter::Implementation
         Type objTy;
         std::tie(objTy, kind) =
             getObjectTypeAndOptionality(param, param->getInterfaceType());
-        std::string paramName =
-            param->getName().empty() ? "" : param->getName().str().str();
-        if (printEmptyParamNames && paramName.empty()) {
-          llvm::raw_string_ostream os(paramName);
-          os << "_" << index;
-        }
+        StringRef paramName =
+            param->getName().empty() ? "" : param->getName().str();
         print(objTy, kind, paramName, IsFunctionParam);
         ++index;
       });
@@ -868,9 +863,9 @@ class DeclAndTypePrinter::Implementation
         getForeignResultType(FD, funcTy, asyncConvention, errorConvention);
 
     os << "inline ";
-    printFunctionDeclAsCFunctionDecl(FD,
-                                     FD->getName().getBaseIdentifier().get(),
-                                     resultTy, /*printEmptyParamNames=*/true);
+    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
+    funcPrinter.printFunctionDeclAsCxxFunctionDecl(
+        FD, FD->getName().getBaseIdentifier().get(), resultTy);
     // FIXME: Support throwing exceptions for Swift errors.
     os << " noexcept";
     printFunctionClangAttributes(FD, funcTy);
@@ -1998,7 +1993,7 @@ class DeclAndTypePrinter::Implementation
   /// visitPart().
 public:
   void print(Type ty, Optional<OptionalTypeKind> optionalKind,
-             std::string name = "",
+             StringRef name = "",
              IsFunctionParam_t isFuncParam = IsNotFunctionParam) {
     PrettyStackTraceType trace(getASTContext(), "printing", ty);
 
diff --git a/lib/PrintAsClang/PrimitiveTypeMapping.cpp b/lib/PrintAsClang/PrimitiveTypeMapping.cpp
@@ -24,11 +24,20 @@ void PrimitiveTypeMapping::initialize(ASTContext &ctx) {
   mappedTypeNames[{ctx.StdlibModuleName, ctx.getIdentifier(#SWIFT_NAME)}] = {  \
     CLANG_REPR,                                                                \
     Optional<StringRef>(CLANG_REPR),                                           \
+    Optional<StringRef>(CLANG_REPR),                                           \
     NEEDS_NULLABILITY                                                          \
   }
 #define MAP_C(SWIFT_NAME, OBJC_REPR, C_REPR, NEEDS_NULLABILITY)                \
   mappedTypeNames[{ctx.StdlibModuleName, ctx.getIdentifier(#SWIFT_NAME)}] = {  \
-      OBJC_REPR, Optional<StringRef>(C_REPR), NEEDS_NULLABILITY}
+    OBJC_REPR,                                                                 \
+    Optional<StringRef>(C_REPR),                                               \
+    Optional<StringRef>(C_REPR),                                               \
+    NEEDS_NULLABILITY                                                          \
+  }
+#define MAP_CXX(SWIFT_NAME, OBJC_REPR, C_REPR, CXX_REPR, NEEDS_NULLABILITY)    \
+  mappedTypeNames[{ctx.StdlibModuleName, ctx.getIdentifier(#SWIFT_NAME)}] = {  \
+      OBJC_REPR, Optional<StringRef>(C_REPR), Optional<StringRef>(CXX_REPR),   \
+      NEEDS_NULLABILITY}
 
   MAP(CBool, "bool", false);
 
@@ -66,8 +75,8 @@ void PrimitiveTypeMapping::initialize(ASTContext &ctx) {
   MAP(Float32, "float", false);
   MAP(Float64, "double", false);
 
-  MAP_C(Int, "NSInteger", "ptrdiff_t", false);
-  MAP_C(UInt, "NSUInteger", "size_t", false);
+  MAP_CXX(Int, "NSInteger", "ptrdiff_t", "swift::Int", false);
+  MAP_CXX(UInt, "NSUInteger", "size_t", "swift::UInt", false);
   MAP_C(Bool, "BOOL", "bool", false);
 
   MAP(OpaquePointer, "void *", true);
@@ -76,33 +85,33 @@ void PrimitiveTypeMapping::initialize(ASTContext &ctx) {
 
   Identifier ID_ObjectiveC = ctx.Id_ObjectiveC;
   mappedTypeNames[{ID_ObjectiveC, ctx.getIdentifier("ObjCBool")}] = {
-      "BOOL", None, false};
+      "BOOL", None, None, false};
   mappedTypeNames[{ID_ObjectiveC, ctx.getIdentifier("Selector")}] = {
-      "SEL", None, true};
+      "SEL", None, None, true};
   mappedTypeNames[{ID_ObjectiveC, ctx.getIdentifier(ctx.getSwiftName(
                                       KnownFoundationEntity::NSZone))}] = {
-      "struct _NSZone *", None, true};
+      "struct _NSZone *", None, None, true};
 
   mappedTypeNames[{ctx.Id_Darwin, ctx.getIdentifier("DarwinBoolean")}] = {
-      "Boolean", None, false};
+      "Boolean", None, None, false};
 
   mappedTypeNames[{ctx.Id_CoreGraphics, ctx.Id_CGFloat}] = {"CGFloat", None,
-                                                            false};
+                                                            None, false};
 
   mappedTypeNames[{ctx.Id_CoreFoundation, ctx.Id_CGFloat}] = {"CGFloat", None,
-                                                              false};
+                                                              None, false};
 
   // Use typedefs we set up for SIMD vector types.
 #define MAP_SIMD_TYPE(BASENAME, _, __)                                         \
+  StringRef simd2##BASENAME = "swift_" #BASENAME "2";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "2")}] = {         \
-      "swift_" #BASENAME "2", Optional<StringRef>("swift_" #BASENAME "2"),     \
-      false};                                                                  \
+      simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false};               \
+  StringRef simd3##BASENAME = "swift_" #BASENAME "3";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "3")}] = {         \
-      "swift_" #BASENAME "3", Optional<StringRef>("swift_" #BASENAME "3"),     \
-      false};                                                                  \
+      simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false};               \
+  StringRef simd4##BASENAME = "swift_" #BASENAME "4";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "4")}] = {         \
-      "swift_" #BASENAME "4", Optional<StringRef>("swift_" #BASENAME "4"),     \
-      false};
+      simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false};
 #include "swift/ClangImporter/SIMDMappedTypes.def"
   static_assert(SWIFT_MAX_IMPORTED_SIMD_ELEMENTS == 4,
                 "must add or remove special name mappings if max number of "
@@ -137,3 +146,12 @@ PrimitiveTypeMapping::getKnownCTypeInfo(const TypeDecl *typeDecl) {
   }
   return None;
 }
+
+Optional<PrimitiveTypeMapping::CxxClangTypeInfo>
+PrimitiveTypeMapping::getKnownCxxTypeInfo(const TypeDecl *typeDecl) {
+  if (auto *typeInfo = getMappedTypeInfoOrNull(typeDecl)) {
+    if (typeInfo->cxxName)
+      return CxxClangTypeInfo{*typeInfo->cxxName, typeInfo->canBeNullable};
+  }
+  return None;
+}
diff --git a/lib/PrintAsClang/PrimitiveTypeMapping.h b/lib/PrintAsClang/PrimitiveTypeMapping.h
@@ -48,6 +48,15 @@ class PrimitiveTypeMapping {
   /// primitive type declaration, or \c None if no such type name exists.
   Optional<CClangTypeInfo> getKnownCTypeInfo(const TypeDecl *typeDecl);
 
+  struct CxxClangTypeInfo {
+    StringRef name;
+    bool canBeNullable;
+  };
+
+  /// Returns the C++ type name and nullability for the given Swift
+  /// primitive type declaration, or \c None if no such type name exists.
+  Optional<CxxClangTypeInfo> getKnownCxxTypeInfo(const TypeDecl *typeDecl);
+
 private:
   void initialize(ASTContext &ctx);
 
@@ -56,6 +65,8 @@ class PrimitiveTypeMapping {
     StringRef objcName;
     // The C name of the Swift type.
     Optional<StringRef> cName;
+    // The C++ name of the Swift type.
+    Optional<StringRef> cxxName;
     bool canBeNullable;
   };
 
diff --git a/lib/PrintAsClang/PrintAsClang.cpp b/lib/PrintAsClang/PrintAsClang.cpp
@@ -304,6 +304,15 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
   emitCxxConditional(
       out, [&] { emitMacro("SWIFT_NOEXCEPT", "noexcept"); },
       [&] { emitMacro("SWIFT_NOEXCEPT"); });
+  emitCxxConditional(out, [&] {
+    out << "#if !defined(SWIFT_CXX_INT_DEFINED)\n";
+    out << "#define SWIFT_CXX_INT_DEFINED\n";
+    out << "namespace swift {\n";
+    out << "using Int = ptrdiff_t;\n";
+    out << "using UInt = size_t;\n";
+    out << "}\n";
+    out << "#endif\n";
+  });
   static_assert(SWIFT_MAX_IMPORTED_SIMD_ELEMENTS == 4,
               "need to add SIMD typedefs here if max elements is increased");
 }
diff --git a/lib/PrintAsClang/PrintClangFunction.cpp b/lib/PrintAsClang/PrintClangFunction.cpp
@@ -13,6 +13,7 @@
 #include "PrintClangFunction.h"
 #include "ClangSyntaxPrinter.h"
 #include "DeclAndTypePrinter.h"
+#include "OutputLanguageMode.h"
 #include "PrimitiveTypeMapping.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/ParameterList.h"
@@ -23,6 +24,22 @@
 
 using namespace swift;
 
+namespace {
+
+class ClangFunctionSignatureTypePrinter : private ClangSyntaxPrinter {
+public:
+  ClangFunctionSignatureTypePrinter(raw_ostream &os) : ClangSyntaxPrinter(os) {}
+
+  void printIfSimpleType(StringRef name, bool canBeNullable,
+                         Optional<OptionalTypeKind> optionalKind) {
+    os << name;
+    if (canBeNullable)
+      printNullability(optionalKind);
+  }
+
+  void printVoidType() { os << "void"; }
+};
+
 // Prints types in the C function signature that corresponds to the
 // native Swift function/method.
 class CFunctionSignatureTypePrinter
@@ -31,11 +48,22 @@ class CFunctionSignatureTypePrinter
       private ClangSyntaxPrinter {
 public:
   CFunctionSignatureTypePrinter(raw_ostream &os,
-                                PrimitiveTypeMapping &typeMapping)
-      : ClangSyntaxPrinter(os), typeMapping(typeMapping) {}
+                                PrimitiveTypeMapping &typeMapping,
+                                OutputLanguageMode languageMode)
+      : ClangSyntaxPrinter(os), typeMapping(typeMapping),
+        languageMode(languageMode) {}
 
   bool printIfKnownSimpleType(const TypeDecl *typeDecl,
                               Optional<OptionalTypeKind> optionalKind) {
+    if (languageMode == OutputLanguageMode::Cxx) {
+      auto knownTypeInfo = typeMapping.getKnownCxxTypeInfo(typeDecl);
+      if (!knownTypeInfo)
+        return false;
+      os << knownTypeInfo->name;
+      if (knownTypeInfo->canBeNullable)
+        printNullability(optionalKind);
+      return true;
+    }
     auto knownTypeInfo = typeMapping.getKnownCTypeInfo(typeDecl);
     if (!knownTypeInfo)
       return false;
@@ -83,16 +111,20 @@ class CFunctionSignatureTypePrinter
 
 private:
   PrimitiveTypeMapping &typeMapping;
+  OutputLanguageMode languageMode;
 };
 
+} // end namespace
+
 void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCFunctionDecl(
     FuncDecl *FD, StringRef name, Type resultTy) {
   // FIXME: Might need a PrintMultiPartType here.
   auto print = [this](Type ty, Optional<OptionalTypeKind> optionalKind,
                       StringRef name) {
     // FIXME: add support for noescape and PrintMultiPartType,
     // see DeclAndTypePrinter::print.
-    CFunctionSignatureTypePrinter typePrinter(os, typeMapping);
+    CFunctionSignatureTypePrinter typePrinter(os, typeMapping,
+                                              OutputLanguageMode::ObjC);
     typePrinter.visit(ty, optionalKind);
 
     if (!name.empty()) {
@@ -106,7 +138,8 @@ void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCFunctionDecl(
   Type objTy;
   std::tie(objTy, kind) =
       DeclAndTypePrinter::getObjectTypeAndOptionality(FD, resultTy);
-  CFunctionSignatureTypePrinter typePrinter(os, typeMapping);
+  CFunctionSignatureTypePrinter typePrinter(os, typeMapping,
+                                            OutputLanguageMode::ObjC);
   typePrinter.visit(objTy, kind);
 
   os << ' ' << name << '(';
@@ -128,3 +161,53 @@ void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCFunctionDecl(
   }
   os << ')';
 }
+
+void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCxxFunctionDecl(
+    FuncDecl *FD, StringRef name, Type resultTy) {
+  // FIXME: Might need a PrintMultiPartType here.
+  auto print = [this](Type ty, Optional<OptionalTypeKind> optionalKind,
+                      StringRef name) {
+    // FIXME: add support for noescape and PrintMultiPartType,
+    // see DeclAndTypePrinter::print.
+    CFunctionSignatureTypePrinter typePrinter(os, typeMapping,
+                                              OutputLanguageMode::Cxx);
+    typePrinter.visit(ty, optionalKind);
+
+    if (!name.empty()) {
+      os << ' ';
+      ClangSyntaxPrinter(os).printIdentifier(name);
+    }
+  };
+
+  // Print out the return type.
+  OptionalTypeKind kind;
+  Type objTy;
+  std::tie(objTy, kind) =
+      DeclAndTypePrinter::getObjectTypeAndOptionality(FD, resultTy);
+  CFunctionSignatureTypePrinter typePrinter(os, typeMapping,
+                                            OutputLanguageMode::Cxx);
+  typePrinter.visit(objTy, kind);
+
+  os << ' ' << name << '(';
+
+  // Print out the parameter types.
+  auto params = FD->getParameters();
+  if (params->size()) {
+    size_t paramIndex = 1;
+    llvm::interleaveComma(*params, os, [&](const ParamDecl *param) {
+      OptionalTypeKind kind;
+      Type objTy;
+      std::tie(objTy, kind) = DeclAndTypePrinter::getObjectTypeAndOptionality(
+          param, param->getInterfaceType());
+      std::string paramName =
+          param->getName().empty() ? "" : param->getName().str().str();
+      if (paramName.empty()) {
+        llvm::raw_string_ostream os(paramName);
+        os << "_" << paramIndex;
+      }
+      print(objTy, kind, paramName);
+      ++paramIndex;
+    });
+  }
+  os << ')';
+}
diff --git a/lib/PrintAsClang/PrintClangFunction.h b/lib/PrintAsClang/PrintClangFunction.h
@@ -36,6 +36,11 @@ class DeclAndTypeClangFunctionPrinter {
   void printFunctionDeclAsCFunctionDecl(FuncDecl *FD, StringRef name,
                                         Type resultTy);
 
+  /// Print the inline C++ function thunk declaration that corresponds to the
+  /// given Swift function declaration.
+  void printFunctionDeclAsCxxFunctionDecl(FuncDecl *FD, StringRef name,
+                                          Type resultTy);
+
 private:
   raw_ostream &os;
   PrimitiveTypeMapping &typeMapping;
diff --git a/test/Interop/SwiftToCxx/functions/function-availability.swift b/test/Interop/SwiftToCxx/functions/function-availability.swift
@@ -16,22 +16,22 @@
 
 // CHECK: }
 
-// CHECK: inline void alwaysDeprecated(void) noexcept SWIFT_DEPRECATED {
+// CHECK: inline void alwaysDeprecated() noexcept SWIFT_DEPRECATED {
 @available(*, deprecated)
 public func alwaysDeprecated() {}
 
-// CHECK: inline void alwaysDeprecatedTwo(void) noexcept SWIFT_DEPRECATED_MSG("it should not be used")
+// CHECK: inline void alwaysDeprecatedTwo() noexcept SWIFT_DEPRECATED_MSG("it should not be used")
 @available(*, deprecated, message: "it should not be used")
 public func alwaysDeprecatedTwo() {}
 
-// CHECK: inline void alwaysUnavailable(void) noexcept SWIFT_UNAVAILABLE
+// CHECK: inline void alwaysUnavailable() noexcept SWIFT_UNAVAILABLE
 @available(*, unavailable)
 public func alwaysUnavailable() {}
 
-// CHECK: inline void alwaysUnavailableMessage(void) noexcept SWIFT_UNAVAILABLE_MSG("stuff happened")
+// CHECK: inline void alwaysUnavailableMessage() noexcept SWIFT_UNAVAILABLE_MSG("stuff happened")
 @available(*, unavailable, message: "stuff happened")
 public func alwaysUnavailableMessage() {}
 
-// CHECK: inline void singlePlatAvailability(void) noexcept SWIFT_AVAILABILITY(macos,introduced=11)
+// CHECK: inline void singlePlatAvailability() noexcept SWIFT_AVAILABILITY(macos,introduced=11)
 @available(macOS 11, *)
 public func singlePlatAvailability() {}
diff --git a/test/Interop/SwiftToCxx/functions/swift-functions.swift b/test/Interop/SwiftToCxx/functions/swift-functions.swift
@@ -45,6 +45,6 @@ public func passTwoIntReturnIntNoArgLabelParamName(_ x2: CInt, _ y2: CInt) -> CI
 
 public func passVoidReturnVoid() { print("passVoidReturnVoid") }
 
-// CHECK: inline void passVoidReturnVoid(void) noexcept {
+// CHECK: inline void passVoidReturnVoid() noexcept {
 // CHECK: return _impl::$s9Functions014passVoidReturnC0yyF();
 // CHECK: }
diff --git a/test/Interop/SwiftToCxx/functions/swift-primitive-functions-cxx-bridging.swift b/test/Interop/SwiftToCxx/functions/swift-primitive-functions-cxx-bridging.swift
diff --git a/test/Interop/SwiftToCxx/functions/swift-primitive-functions-execution.cpp b/test/Interop/SwiftToCxx/functions/swift-primitive-functions-execution.cpp
diff --git a/test/lit.cfg b/test/lit.cfg
