Revert "Merge pull request swiftlang#41965 from hyp/i/cfuncprim"

This reverts commit fbbfb70, reversing
changes made to cee0b4c.

Author: hyp

lib/PrintAsClang/CMakeLists.txt

@@ -1,11 +1,10 @@
 
 add_swift_host_library(swiftPrintAsClang STATIC
-  ClangSyntaxPrinter.cpp
+  CxxSynthesis.cpp
   DeclAndTypePrinter.cpp
   ModuleContentsWriter.cpp
   PrimitiveTypeMapping.cpp
-  PrintAsClang.cpp
-  PrintClangFunction.cpp)
+  PrintAsClang.cpp)
 target_link_libraries(swiftPrintAsClang PRIVATE
   swiftAST
   swiftClangImporter

lib/PrintAsClang/ClangSyntaxPrinter.cpp renamed to lib/PrintAsClang/CxxSynthesis.cpp

@@ -1,4 +1,4 @@
-//===--- ClangSyntaxPrinter.cpp - Printer for C and C++ code ----*- C++ -*-===//
+//===--- CxxSynthesis.cpp - Rules for synthesizing C++ code -----*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,15 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "ClangSyntaxPrinter.h"
+#include "CxxSynthesis.h"
 
 using namespace swift;
 using namespace cxx_synthesis;
 
 StringRef cxx_synthesis::getCxxImplNamespaceName() { return "_impl"; }
 
 /// Print a C++ namespace declaration with the give name and body.
-void ClangSyntaxPrinter::printNamespace(
+void CxxPrinter::printNamespace(
     llvm::function_ref<void(raw_ostream &OS)> namePrinter,
     llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const {
   os << "namespace ";
@@ -30,49 +30,8 @@ void ClangSyntaxPrinter::printNamespace(
   os << "\n\n";
 }
 
-void ClangSyntaxPrinter::printNamespace(
+void CxxPrinter::printNamespace(
     StringRef name,
     llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const {
   printNamespace([&](raw_ostream &os) { os << name; }, bodyPrinter);
 }
-
-void ClangSyntaxPrinter::printNullability(
-    Optional<OptionalTypeKind> kind, NullabilityPrintKind printKind) const {
-  if (!kind)
-    return;
-
-  switch (printKind) {
-  case NullabilityPrintKind::ContextSensitive:
-    switch (*kind) {
-    case OTK_None:
-      os << "nonnull";
-      break;
-    case OTK_Optional:
-      os << "nullable";
-      break;
-    case OTK_ImplicitlyUnwrappedOptional:
-      os << "null_unspecified";
-      break;
-    }
-    break;
-  case NullabilityPrintKind::After:
-    os << ' ';
-    LLVM_FALLTHROUGH;
-  case NullabilityPrintKind::Before:
-    switch (*kind) {
-    case OTK_None:
-      os << "_Nonnull";
-      break;
-    case OTK_Optional:
-      os << "_Nullable";
-      break;
-    case OTK_ImplicitlyUnwrappedOptional:
-      os << "_Null_unspecified";
-      break;
-    }
-    break;
-  }
-
-  if (printKind != NullabilityPrintKind::After)
-    os << ' ';
-}

lib/PrintAsClang/ClangSyntaxPrinter.h renamed to lib/PrintAsClang/CxxSynthesis.h

@@ -1,4 +1,4 @@
-//===--- ClangSyntaxPrinter.h - Printer for C and C++ code ------*- C++ -*-===//
+//===--- CxxSynthesis.h - Rules for synthesizing C++ code -------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,11 +10,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
-#define SWIFT_PRINTASCLANG_CLANGSYNTAXPRINTER_H
+#ifndef SWIFT_PRINTASCLANG_CXXSYNTHESIS_H
+#define SWIFT_PRINTASCLANG_CXXSYNTHESIS_H
 
 #include "swift/Basic/LLVM.h"
-#include "swift/ClangImporter/ClangImporter.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -27,11 +26,9 @@ namespace cxx_synthesis {
 /// module in C++.
 StringRef getCxxImplNamespaceName();
 
-} // end namespace cxx_synthesis
-
-class ClangSyntaxPrinter {
+class CxxPrinter {
 public:
-  ClangSyntaxPrinter(raw_ostream &os) : os(os) {}
+  CxxPrinter(raw_ostream &os) : os(os) {}
 
   /// Print a C++ namespace declaration with the give name and body.
   void
@@ -42,21 +39,11 @@ class ClangSyntaxPrinter {
   printNamespace(StringRef name,
                  llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const;
 
-  /// Where nullability information should be printed.
-  enum class NullabilityPrintKind {
-    Before,
-    After,
-    ContextSensitive,
-  };
-
-  void printNullability(
-      Optional<OptionalTypeKind> kind,
-      NullabilityPrintKind printKind = NullabilityPrintKind::After) const;
-
-protected:
+private:
   raw_ostream &os;
 };
 
+} // end namespace cxx_synthesis
 } // end namespace swift
 
 #endif

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -11,9 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "DeclAndTypePrinter.h"
-#include "ClangSyntaxPrinter.h"
+#include "CxxSynthesis.h"
 #include "PrimitiveTypeMapping.h"
-#include "PrintClangFunction.h"
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -80,29 +79,6 @@ static bool isClangKeyword(Identifier name) {
   return isClangKeyword(name.str());
 }
 
-bool DeclAndTypePrinter::isStrClangKeyword(StringRef name) {
-  return ::isClangKeyword(name);
-}
-
-// For a given Decl and Type, if the type is not an optional return
-// the type and OTK_None as the optionality. If the type is
-// optional, return the underlying object type, and an optionality
-// that is based on the type but overridden by the return value of
-// isImplicitlyUnwrappedOptional().
-std::pair<Type, OptionalTypeKind>
-DeclAndTypePrinter::getObjectTypeAndOptionality(const ValueDecl *D, Type ty) {
-  OptionalTypeKind kind;
-  if (auto objTy = ty->getReferenceStorageReferent()->getOptionalObjectType()) {
-    kind = OTK_Optional;
-    if (D->isImplicitlyUnwrappedOptional())
-      kind = OTK_ImplicitlyUnwrappedOptional;
-
-    return {objTy, kind};
-  }
-
-  return {ty, OTK_None};
-}
-
 namespace {
   /// Whether the type being printed is in function param position.
   enum IsFunctionParam_t : bool {
@@ -122,14 +98,17 @@ static bool looksLikeInitMethod(ObjCSelector selector) {
 }
 
 class DeclAndTypePrinter::Implementation
-    : private DeclVisitor<DeclAndTypePrinter::Implementation>,
-      private TypeVisitor<DeclAndTypePrinter::Implementation, void,
-                          Optional<OptionalTypeKind>>,
-      private ClangSyntaxPrinter {
+  : private DeclVisitor<DeclAndTypePrinter::Implementation>,
+    private TypeVisitor<DeclAndTypePrinter::Implementation, void,
+                        Optional<OptionalTypeKind>>
+{
   using PrinterImpl = Implementation;
   friend ASTVisitor;
   friend TypeVisitor;
 
+  // The output stream is accessible through 'owningPrinter',
+  // but it makes the code simpler to have it here too.
+  raw_ostream &os;
   DeclAndTypePrinter &owningPrinter;
   OutputLanguageMode outputLang;
 
@@ -147,7 +126,7 @@ class DeclAndTypePrinter::Implementation
 public:
   explicit Implementation(raw_ostream &out, DeclAndTypePrinter &owner,
                           OutputLanguageMode outputLang)
-      : ClangSyntaxPrinter(out), owningPrinter(owner), outputLang(outputLang) {}
+      : os(out), owningPrinter(owner), outputLang(outputLang) {}
 
   void print(const Decl *D) {
     PrettyStackTraceDecl trace("printing", D);
@@ -306,7 +285,17 @@ class DeclAndTypePrinter::Implementation
   // isImplicitlyUnwrappedOptional().
   static std::pair<Type, OptionalTypeKind>
   getObjectTypeAndOptionality(const ValueDecl *D, Type ty) {
-    return DeclAndTypePrinter::getObjectTypeAndOptionality(D, ty);
+    OptionalTypeKind kind;
+    if (auto objTy =
+            ty->getReferenceStorageReferent()->getOptionalObjectType()) {
+      kind = OTK_Optional;
+      if (D->isImplicitlyUnwrappedOptional())
+        kind = OTK_ImplicitlyUnwrappedOptional;
+
+      return {objTy, kind};
+    }
+
+    return {ty, OTK_None};
   }
 
   // Ignore other declarations.
@@ -856,10 +845,7 @@ class DeclAndTypePrinter::Implementation
     FuncionSwiftABIInformation funcABI(FD, mangler);
 
     os << "SWIFT_EXTERN ";
-
-    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
-    funcPrinter.printFunctionDeclAsCFunctionDecl(FD, funcABI.getSymbolName(),
-                                                 resultTy);
+    printFunctionDeclAsCFunctionDecl(FD, funcABI.getSymbolName(), resultTy);
     // Swift functions can't throw exceptions, we can only
     // throw them from C++ when emitting C++ inline thunks for the Swift
     // functions.
@@ -1386,6 +1372,55 @@ class DeclAndTypePrinter::Implementation
     TypeVisitor::visit(ty, optionalKind);
   }
 
+  /// Where nullability information should be printed.
+  enum class NullabilityPrintKind {
+    Before,
+    After,
+    ContextSensitive,
+  };
+
+  void printNullability(Optional<OptionalTypeKind> kind,
+                        NullabilityPrintKind printKind
+                          = NullabilityPrintKind::After) {
+    if (!kind)
+      return;
+
+    switch (printKind) {
+    case NullabilityPrintKind::ContextSensitive:
+      switch (*kind) {
+      case OTK_None:
+        os << "nonnull";
+        break;
+      case OTK_Optional:
+        os << "nullable";
+        break;
+      case OTK_ImplicitlyUnwrappedOptional:
+        os << "null_unspecified";
+        break;
+      }
+      break;
+    case NullabilityPrintKind::After:
+      os << ' ';
+      LLVM_FALLTHROUGH;
+    case NullabilityPrintKind::Before:
+      switch (*kind) {
+      case OTK_None:
+        os << "_Nonnull";
+        break;
+      case OTK_Optional:
+        os << "_Nullable";
+        break;
+      case OTK_ImplicitlyUnwrappedOptional:
+        os << "_Null_unspecified";
+        break;
+      }
+      break;
+    }
+
+    if (printKind != NullabilityPrintKind::After)
+      os << ' ';
+  }
+
   /// Determine whether this generic Swift nominal type maps to a
   /// generic Objective-C class.
   static bool hasGenericObjCType(const NominalTypeDecl *nominal) {

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -26,7 +26,6 @@ namespace clang {
 namespace swift {
 
 class PrimitiveTypeMapping;
-class ValueDecl;
 
 /// Responsible for printing a Swift Decl or Type in Objective-C, to be
 /// included in a Swift module's ObjC compatibility header.
@@ -89,12 +88,6 @@ class DeclAndTypePrinter {
   /// Returns the name of an <os/object.h> type minus the leading "OS_",
   /// or an empty string if \p decl is not an <os/object.h> type.
   static StringRef maybeGetOSObjectBaseName(const clang::NamedDecl *decl);
-
-  static std::pair<Type, OptionalTypeKind>
-  getObjectTypeAndOptionality(const ValueDecl *D, Type ty);
-
-  /// Returns true if \p name matches a keyword in any Clang language mode.
-  static bool isStrClangKeyword(StringRef name);
 };
 
 } // end namespace swift

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -12,7 +12,7 @@
 
 #include "ModuleContentsWriter.h"
 
-#include "ClangSyntaxPrinter.h"
+#include "CxxSynthesis.h"
 #include "DeclAndTypePrinter.h"
 #include "OutputLanguageMode.h"
 #include "PrimitiveTypeMapping.h"
@@ -642,34 +642,26 @@ swift::printModuleContentsAsObjC(raw_ostream &os,
 void swift::printModuleContentsAsCxx(
     raw_ostream &os, llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
     ModuleDecl &M) {
-  std::string moduleContentsBuf;
-  llvm::raw_string_ostream moduleOS{moduleContentsBuf};
-  std::string modulePrologueBuf;
-  llvm::raw_string_ostream prologueOS{modulePrologueBuf};
-
-  ModuleWriter(moduleOS, prologueOS, imports, M, getRequiredAccess(M),
-               OutputLanguageMode::Cxx)
-      .write();
-
-  // FIXME: refactor.
-  if (!prologueOS.str().empty()) {
-    os << "#endif\n";
-    os << "#ifdef __cplusplus\n";
-    os << "namespace ";
-    M.ValueDecl::getName().print(os);
-    os << " {\n";
-    os << "namespace " << cxx_synthesis::getCxxImplNamespaceName() << " {\n";
-    os << "#endif\n\n";
-
-    os << prologueOS.str();
-
-    os << "\n#ifdef __cplusplus\n";
-    os << "}\n";
-    os << "}\n";
-  }
-
+  using cxx_synthesis::CxxPrinter;
   // Construct a C++ namespace for the module.
-  ClangSyntaxPrinter(os).printNamespace(
+  CxxPrinter(os).printNamespace(
       [&](raw_ostream &os) { M.ValueDecl::getName().print(os); },
-      [&](raw_ostream &os) { os << moduleOS.str(); });
+      [&](raw_ostream &os) {
+        std::string moduleContentsBuf;
+        llvm::raw_string_ostream moduleOS{moduleContentsBuf};
+        std::string modulePrologueBuf;
+        llvm::raw_string_ostream prologueOS{modulePrologueBuf};
+
+        ModuleWriter(moduleOS, prologueOS, imports, M, getRequiredAccess(M),
+                     OutputLanguageMode::Cxx)
+            .write();
+
+        // The module's prologue contains implementation details,
+        // like extern "C" symbols for the referenced Swift functions.
+        CxxPrinter(os).printNamespace(
+            cxx_synthesis::getCxxImplNamespaceName(),
+            [&](raw_ostream &os) { os << prologueOS.str(); });
+
+        os << moduleOS.str();
+      });
 }