Merge pull request #74339 from apple/gaborh/print-function-sig-transactional

[cxx-interop] Make function signature printing transactional

Author: Xazax-hun

lib/PrintAsClang/PrintClangFunction.cpp

@@ -531,10 +531,10 @@ class CFunctionSignatureTypePrinter
 
 ClangRepresentation
 DeclAndTypeClangFunctionPrinter::printClangFunctionReturnType(
-    Type ty, OptionalTypeKind optKind, ModuleDecl *moduleContext,
-    OutputLanguageMode outputLang) {
+    raw_ostream &stream, Type ty, OptionalTypeKind optKind,
+    ModuleDecl *moduleContext, OutputLanguageMode outputLang) {
   CFunctionSignatureTypePrinter typePrinter(
-      os, cPrologueOS, typeMapping, outputLang, interopContext,
+      stream, cPrologueOS, typeMapping, outputLang, interopContext,
       CFunctionSignatureTypePrinterModifierDelegate(), moduleContext,
       declPrinter, FunctionSignatureTypeUse::ReturnType);
   // Param for indirect return cannot be marked as inout
@@ -703,12 +703,14 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
     const AbstractFunctionDecl *FD, const LoweredFunctionSignature &signature,
     StringRef name, Type resultTy, FunctionSignatureKind kind,
     FunctionSignatureModifiers modifiers) {
+  std::string functionSignature;
+  llvm::raw_string_ostream functionSignatureOS(functionSignature);
   // Print any template and requires clauses for the
   // C++ class context to which this C++ member will belong to.
   if (const auto *typeDecl = modifiers.qualifierContext) {
     assert(kind == FunctionSignatureKind::CxxInlineThunk);
-    ClangSyntaxPrinter(os).printNominalTypeOutsideMemberDeclTemplateSpecifiers(
-        typeDecl);
+    ClangSyntaxPrinter(functionSignatureOS)
+        .printNominalTypeOutsideMemberDeclTemplateSpecifiers(typeDecl);
   }
   if (FD->isGeneric()) {
     auto Signature = FD->getGenericSignature().getCanonicalSignature();
@@ -717,7 +719,7 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
 
     // Print the template and requires clauses for this function.
     if (kind == FunctionSignatureKind::CxxInlineThunk)
-      ClangSyntaxPrinter(os).printGenericSignature(Signature);
+      ClangSyntaxPrinter(functionSignatureOS).printGenericSignature(Signature);
   }
   if (const auto *enumDecl = FD->getDeclContext()->getSelfEnumDecl()) {
     // We cannot emit functions with the same name as an enum case yet, the resulting header
@@ -743,31 +745,31 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
     // FIXME: add support for noescape and PrintMultiPartType,
     // see DeclAndTypePrinter::print.
     CFunctionSignatureTypePrinter typePrinter(
-        os, cPrologueOS, typeMapping, outputLang, interopContext, delegate,
-        emittedModule, declPrinter);
+        functionSignatureOS, cPrologueOS, typeMapping, outputLang,
+        interopContext, delegate, emittedModule, declPrinter);
     auto result = typePrinter.visit(ty, optionalKind, isInOutParam);
 
     if (!name.empty()) {
-      os << ' ';
-      ClangSyntaxPrinter(os).printIdentifier(name);
+      functionSignatureOS << ' ';
+      ClangSyntaxPrinter(functionSignatureOS).printIdentifier(name);
     }
     return result;
   };
 
   // Print any modifiers before the signature.
   if (modifiers.isStatic) {
     assert(!modifiers.isConst);
-    os << "static ";
+    functionSignatureOS << "static ";
   }
   if (modifiers.isInline)
-    ClangSyntaxPrinter(os).printInlineForThunk();
+    ClangSyntaxPrinter(functionSignatureOS).printInlineForThunk();
 
   ClangRepresentation resultingRepresentation =
       ClangRepresentation::representable;
 
   // Print out the return type.
   if (FD->hasThrows() && outputLang == OutputLanguageMode::Cxx)
-    os << "swift::ThrowingResult<";
+    functionSignatureOS << "swift::ThrowingResult<";
   if (kind == FunctionSignatureKind::CFunctionProto) {
     // First, verify that the C++ return type is representable.
     {
@@ -794,19 +796,20 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
       return ClangRepresentation::unsupported;
 
     if (!directResultType) {
-      os << "void";
+      functionSignatureOS << "void";
     } else {
       if (!printDirectReturnOrParamCType(
-              *directResultType, resultTy, emittedModule, os, cPrologueOS,
-              typeMapping, interopContext, [&]() {
+              *directResultType, resultTy, emittedModule, functionSignatureOS,
+              cPrologueOS, typeMapping, interopContext, [&]() {
                 OptionalTypeKind retKind;
                 Type objTy;
                 std::tie(objTy, retKind) =
                     DeclAndTypePrinter::getObjectTypeAndOptionality(FD,
                                                                     resultTy);
 
                 auto s = printClangFunctionReturnType(
-                    objTy, retKind, emittedModule, outputLang);
+                    functionSignatureOS, objTy, retKind, emittedModule,
+                    outputLang);
                 assert(!s.isUnsupported());
               }))
         return ClangRepresentation::unsupported;
@@ -817,19 +820,19 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
     std::tie(objTy, retKind) =
         DeclAndTypePrinter::getObjectTypeAndOptionality(FD, resultTy);
     if (resultingRepresentation
-            .merge(printClangFunctionReturnType(objTy, retKind, emittedModule,
-                                                outputLang))
+            .merge(printClangFunctionReturnType(
+                functionSignatureOS, objTy, retKind, emittedModule, outputLang))
             .isUnsupported())
       return resultingRepresentation;
   }
   if (FD->hasThrows() && outputLang == OutputLanguageMode::Cxx)
-    os << ">";
-  os << ' ';
+    functionSignatureOS << ">";
+  functionSignatureOS << ' ';
   if (const auto *typeDecl = modifiers.qualifierContext)
-    ClangSyntaxPrinter(os).printNominalTypeQualifier(
-        typeDecl, typeDecl->getModuleContext());
-  ClangSyntaxPrinter(os).printIdentifier(name);
-  os << '(';
+    ClangSyntaxPrinter(functionSignatureOS)
+        .printNominalTypeQualifier(typeDecl, typeDecl->getModuleContext());
+  ClangSyntaxPrinter(functionSignatureOS).printIdentifier(name);
+  functionSignatureOS << '(';
 
   bool HasParams = false;
 
@@ -855,7 +858,7 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
     bool needsComma = false;
     auto emitNewParam = [&]() {
       if (needsComma)
-        os << ", ";
+        functionSignatureOS << ", ";
       needsComma = true;
     };
     auto printParamName = [&](const ParamDecl &param) {
@@ -864,8 +867,8 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
       if (param.isSelfParameter())
         paramName = "_self";
       if (!paramName.empty()) {
-        os << ' ';
-        ClangSyntaxPrinter(os).printIdentifier(paramName);
+        functionSignatureOS << ' ';
+        ClangSyntaxPrinter(functionSignatureOS).printIdentifier(paramName);
       }
     };
     auto printParamCType = [&](const ParamDecl &param) {
@@ -875,9 +878,9 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
           DeclAndTypePrinter::getObjectTypeAndOptionality(
               &param, param.getInterfaceType());
       CFunctionSignatureTypePrinter typePrinter(
-          os, cPrologueOS, typeMapping, outputLang, interopContext,
-          CFunctionSignatureTypePrinterModifierDelegate(), emittedModule,
-          declPrinter);
+          functionSignatureOS, cPrologueOS, typeMapping, outputLang,
+          interopContext, CFunctionSignatureTypePrinterModifierDelegate(),
+          emittedModule, declPrinter);
       auto s = typePrinter.visit(ty, optionalKind, param.isInOut());
       assert(!s.isUnsupported());
     };
@@ -886,22 +889,22 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
                 &indirectResult) {
           emitNewParam();
           if (indirectResult.hasSRet())
-            os << "SWIFT_INDIRECT_RESULT ";
+            functionSignatureOS << "SWIFT_INDIRECT_RESULT ";
           // FIXME: it would be nice to print out the C struct type here.
-          os << "void * _Nonnull";
+          functionSignatureOS << "void * _Nonnull";
         },
         [&](const LoweredFunctionSignature::DirectParameter &param) {
           emitNewParam();
           printDirectReturnOrParamCType(
-              param, param.getParamDecl().getInterfaceType(), emittedModule, os,
-              cPrologueOS, typeMapping, interopContext,
+              param, param.getParamDecl().getInterfaceType(), emittedModule,
+              functionSignatureOS, cPrologueOS, typeMapping, interopContext,
               [&]() { printParamCType(param.getParamDecl()); });
           printParamName(param.getParamDecl());
         },
         [&](const LoweredFunctionSignature::IndirectParameter &param) {
           emitNewParam();
           if (param.getParamDecl().isSelfParameter())
-            os << "SWIFT_CONTEXT ";
+            functionSignatureOS << "SWIFT_CONTEXT ";
           bool isConst =
               !param.getParamDecl().isInOut() &&
               !(param.getParamDecl().isSelfParameter() &&
@@ -910,7 +913,7 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
                     .getInterfaceType()
                     ->isAnyClassReferenceType());
           if (isConst)
-            os << "const ";
+            functionSignatureOS << "const ";
           if (isKnownCType(param.getParamDecl().getInterfaceType(),
                            typeMapping) ||
               (!param.getParamDecl().getInterfaceType()->hasTypeParameter() &&
@@ -919,76 +922,86 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
                    ->isAnyClassReferenceType()))
             printParamCType(param.getParamDecl());
           else
-            os << "void * _Nonnull";
+            functionSignatureOS << "void * _Nonnull";
           printParamName(param.getParamDecl());
         },
         [&](const LoweredFunctionSignature::GenericRequirementParameter
                 &genericRequirementParam) {
           emitNewParam();
-          os << "void * _Nonnull ";
+          functionSignatureOS << "void * _Nonnull ";
           auto reqt = genericRequirementParam.getRequirement();
           if (reqt.isAnyWitnessTable())
-            ClangSyntaxPrinter(os).printBaseName(reqt.getProtocol());
+            ClangSyntaxPrinter(functionSignatureOS)
+                .printBaseName(reqt.getProtocol());
           else
             assert(reqt.isAnyMetadata());
         },
         [&](const LoweredFunctionSignature::MetadataSourceParameter
                 &metadataSrcParam) {
           emitNewParam();
-          os << "void * _Nonnull ";
+          functionSignatureOS << "void * _Nonnull ";
         },
         [&](const LoweredFunctionSignature::ContextParameter &) {
           emitNewParam();
-          os << "SWIFT_CONTEXT void * _Nonnull _ctx";
+          functionSignatureOS << "SWIFT_CONTEXT void * _Nonnull _ctx";
         },
         [&](const LoweredFunctionSignature::ErrorResultValue &) {
           emitNewParam();
-          os << "SWIFT_ERROR_RESULT void * _Nullable * _Nullable _error";
+          functionSignatureOS
+              << "SWIFT_ERROR_RESULT void * _Nullable * _Nullable _error";
         });
     if (needsComma == false)
       // Emit 'void' in an empty parameter list for C function declarations.
-      os << "void";
-    os << ')';
+      functionSignatureOS << "void";
+    functionSignatureOS << ')';
+    if (!resultingRepresentation.isUnsupported())
+      os << functionSignatureOS.str();
     return resultingRepresentation;
   }
 
   // Print out the C++ parameter types.
   auto params = FD->getParameters();
   if (params->size()) {
     if (HasParams)
-      os << ", ";
+      functionSignatureOS << ", ";
     HasParams = true;
     size_t paramIndex = 1;
-    llvm::interleaveComma(*params, os, [&](const ParamDecl *param) {
-      OptionalTypeKind argKind;
-      Type objTy;
-      std::tie(objTy, argKind) =
-          DeclAndTypePrinter::getObjectTypeAndOptionality(
-              param, param->getInterfaceType());
-      std::string paramName =
-          param->getName().empty() ? "" : param->getName().str().str();
-      renameCxxParameterIfNeeded(FD, paramName);
-      // 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;
-      }
-      resultingRepresentation.merge(
-          print(objTy, argKind, paramName, param->isInOut()));
-      ++paramIndex;
-    });
-    if (resultingRepresentation.isUnsupported())
+    llvm::interleaveComma(
+        *params, functionSignatureOS, [&](const ParamDecl *param) {
+          OptionalTypeKind argKind;
+          Type objTy;
+          std::tie(objTy, argKind) =
+              DeclAndTypePrinter::getObjectTypeAndOptionality(
+                  param, param->getInterfaceType());
+          std::string paramName =
+              param->getName().empty() ? "" : param->getName().str().str();
+          renameCxxParameterIfNeeded(FD, paramName);
+          // 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;
+          }
+          resultingRepresentation.merge(
+              print(objTy, argKind, paramName, param->isInOut()));
+          ++paramIndex;
+        });
+    if (resultingRepresentation.isUnsupported()) {
       return resultingRepresentation;
+    }
   }
-  os << ')';
+  functionSignatureOS << ')';
   if (modifiers.isConst)
-    os << " const";
+    functionSignatureOS << " const";
   if (modifiers.isNoexcept)
-    os << " noexcept";
+    functionSignatureOS << " noexcept";
   if (modifiers.hasSymbolUSR)
-    ClangSyntaxPrinter(os).printSymbolUSRAttribute(
-        modifiers.symbolUSROverride ? modifiers.symbolUSROverride : FD);
+    ClangSyntaxPrinter(functionSignatureOS)
+        .printSymbolUSRAttribute(
+            modifiers.symbolUSROverride ? modifiers.symbolUSROverride : FD);
+  if (!resultingRepresentation.isUnsupported())
+    os << functionSignatureOS.str();
   return resultingRepresentation;
 }
 
@@ -1474,8 +1487,9 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
             std::tie(objTy, retKind) =
                 DeclAndTypePrinter::getObjectTypeAndOptionality(FD, resultTy);
 
-            auto s = printClangFunctionReturnType(objTy, retKind, const_cast<ModuleDecl *>(moduleContext),
-                                                  OutputLanguageMode::Cxx);
+            auto s = printClangFunctionReturnType(
+                os, objTy, retKind, const_cast<ModuleDecl *>(moduleContext),
+                OutputLanguageMode::Cxx);
             os << ">(swift::Error(opaqueError));\n";
             os << "#endif\n";
 
@@ -1484,7 +1498,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
               os << "\n";
               os << "  return SWIFT_RETURN_THUNK(";
               printClangFunctionReturnType(
-                  objTy, retKind, const_cast<ModuleDecl *>(moduleContext),
+                  os, objTy, retKind, const_cast<ModuleDecl *>(moduleContext),
                   OutputLanguageMode::Cxx);
               os << ", returnValue);\n";
             }

lib/PrintAsClang/PrintClangFunction.h

@@ -143,10 +143,9 @@ class DeclAndTypeClangFunctionPrinter {
       std::optional<IRABIDetailsProvider::MethodDispatchInfo> dispatchInfo);
 
   /// Print Swift type as C/C++ type, as the return type of a C/C++ function.
-  ClangRepresentation
-  printClangFunctionReturnType(Type ty, OptionalTypeKind optKind,
-                               ModuleDecl *moduleContext,
-                               OutputLanguageMode outputLang);
+  ClangRepresentation printClangFunctionReturnType(
+      raw_ostream &stream, Type ty, OptionalTypeKind optKind,
+      ModuleDecl *moduleContext, OutputLanguageMode outputLang);
 
   static void printGenericReturnSequence(
       raw_ostream &os, const GenericTypeParamType *gtpt,