[interop] NFC, refactor clang function printer to share code between C and C++ signature printer

hyp · hyp · commit d76c45d10431 · 2022-03-29T15:09:12.000-07:00
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -826,8 +826,9 @@ class DeclAndTypePrinter::Implementation
     os << "SWIFT_EXTERN ";
 
     DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
-    funcPrinter.printFunctionDeclAsCFunctionDecl(FD, funcABI.getSymbolName(),
-                                                 resultTy);
+    funcPrinter.printFunctionSignature(
+        FD, funcABI.getSymbolName(), resultTy,
+        DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CFunctionProto);
     // Swift functions can't throw exceptions, we can only
     // throw them from C++ when emitting C++ inline thunks for the Swift
     // functions.
@@ -864,8 +865,9 @@ class DeclAndTypePrinter::Implementation
 
     os << "inline ";
     DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
-    funcPrinter.printFunctionDeclAsCxxFunctionDecl(
-        FD, FD->getName().getBaseIdentifier().get(), resultTy);
+    funcPrinter.printFunctionSignature(
+        FD, FD->getName().getBaseIdentifier().get(), resultTy,
+        DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk);
     // FIXME: Support throwing exceptions for Swift errors.
     os << " noexcept";
     printFunctionClangAttributes(FD, funcTy);
diff --git a/lib/PrintAsClang/PrintClangFunction.cpp b/lib/PrintAsClang/PrintClangFunction.cpp
@@ -26,20 +26,6 @@ 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
@@ -55,16 +41,9 @@ class CFunctionSignatureTypePrinter
 
   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);
+    auto knownTypeInfo = languageMode == OutputLanguageMode::Cxx
+                             ? typeMapping.getKnownCxxTypeInfo(typeDecl)
+                             : typeMapping.getKnownCTypeInfo(typeDecl);
     if (!knownTypeInfo)
       return false;
     os << knownTypeInfo->name;
@@ -116,15 +95,17 @@ class CFunctionSignatureTypePrinter
 
 } // end namespace
 
-void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCFunctionDecl(
-    FuncDecl *FD, StringRef name, Type resultTy) {
+void DeclAndTypeClangFunctionPrinter::printFunctionSignature(
+    FuncDecl *FD, StringRef name, Type resultTy, FunctionSignatureKind kind) {
+  OutputLanguageMode outputLang = kind == FunctionSignatureKind::CFunctionProto
+                                      ? OutputLanguageMode::ObjC
+                                      : OutputLanguageMode::Cxx;
   // FIXME: Might need a PrintMultiPartType here.
-  auto print = [this](Type ty, Optional<OptionalTypeKind> optionalKind,
-                      StringRef name) {
+  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::ObjC);
+    CFunctionSignatureTypePrinter typePrinter(os, typeMapping, outputLang);
     typePrinter.visit(ty, optionalKind);
 
     if (!name.empty()) {
@@ -134,59 +115,12 @@ void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCFunctionDecl(
   };
 
   // Print out the return type.
-  OptionalTypeKind kind;
+  OptionalTypeKind retKind;
   Type objTy;
-  std::tie(objTy, kind) =
+  std::tie(objTy, retKind) =
       DeclAndTypePrinter::getObjectTypeAndOptionality(FD, resultTy);
-  CFunctionSignatureTypePrinter typePrinter(os, typeMapping,
-                                            OutputLanguageMode::ObjC);
-  typePrinter.visit(objTy, kind);
-
-  os << ' ' << name << '(';
-
-  // Print out the parameter types.
-  auto params = FD->getParameters();
-  if (params->size()) {
-    llvm::interleaveComma(*params, os, [&](const ParamDecl *param) {
-      OptionalTypeKind kind;
-      Type objTy;
-      std::tie(objTy, kind) = DeclAndTypePrinter::getObjectTypeAndOptionality(
-          param, param->getInterfaceType());
-      StringRef paramName =
-          param->getName().empty() ? "" : param->getName().str();
-      print(objTy, kind, paramName);
-    });
-  } else {
-    os << "void";
-  }
-  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);
+  CFunctionSignatureTypePrinter typePrinter(os, typeMapping, outputLang);
+  typePrinter.visit(objTy, retKind);
 
   os << ' ' << name << '(';
 
@@ -195,19 +129,25 @@ void DeclAndTypeClangFunctionPrinter::printFunctionDeclAsCxxFunctionDecl(
   if (params->size()) {
     size_t paramIndex = 1;
     llvm::interleaveComma(*params, os, [&](const ParamDecl *param) {
-      OptionalTypeKind kind;
+      OptionalTypeKind argKind;
       Type objTy;
-      std::tie(objTy, kind) = DeclAndTypePrinter::getObjectTypeAndOptionality(
-          param, param->getInterfaceType());
+      std::tie(objTy, argKind) =
+          DeclAndTypePrinter::getObjectTypeAndOptionality(
+              param, param->getInterfaceType());
       std::string paramName =
           param->getName().empty() ? "" : param->getName().str().str();
-      if (paramName.empty()) {
+      // Always emit a named parameter for the C++ inline thunk to ensure it can
+      // be referenced in the body.
+      if (kind == FunctionSignatureKind::CxxInlineThunk && paramName.empty()) {
         llvm::raw_string_ostream os(paramName);
         os << "_" << paramIndex;
       }
-      print(objTy, kind, paramName);
+      print(objTy, argKind, paramName);
       ++paramIndex;
     });
+  } else if (kind == FunctionSignatureKind::CFunctionProto) {
+    // Emit 'void' in an empty parameter list for C function declarations.
+    os << "void";
   }
   os << ')';
 }
diff --git a/lib/PrintAsClang/PrintClangFunction.h b/lib/PrintAsClang/PrintClangFunction.h
@@ -31,15 +31,19 @@ class DeclAndTypeClangFunctionPrinter {
                                   PrimitiveTypeMapping &typeMapping)
       : os(os), typeMapping(typeMapping) {}
 
-  /// Print the C function declaration that corresponds to the given function
-  /// declaration.
-  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);
+  /// What kind of function signature should be emitted for the given Swift
+  /// function.
+  enum class FunctionSignatureKind {
+    /// Emit a signature for the C function prototype.
+    CFunctionProto,
+    /// Emit a signature for the inline C++ function thunk.
+    CxxInlineThunk
+  };
+
+  /// Print the C function declaration or the C++ function thunk that
+  /// corresponds to the given function declaration.
+  void printFunctionSignature(FuncDecl *FD, StringRef name, Type resultTy,
+                              FunctionSignatureKind kind);
 
 private:
   raw_ostream &os;
