Merge pull request #41965 from hyp/i/cfuncprim

[interop] generate C interfaces for Swift top-level functions that use primitive types

Author: hyp

lib/PrintAsClang/CMakeLists.txt

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

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

@@ -1,4 +1,4 @@
-//===--- CxxSynthesis.cpp - Rules for synthesizing C++ code -----*- C++ -*-===//
+//===--- ClangSyntaxPrinter.cpp - Printer for C and C++ code ----*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,15 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "CxxSynthesis.h"
+#include "ClangSyntaxPrinter.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 CxxPrinter::printNamespace(
+void ClangSyntaxPrinter::printNamespace(
     llvm::function_ref<void(raw_ostream &OS)> namePrinter,
     llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const {
   os << "namespace ";
@@ -30,8 +30,49 @@ void CxxPrinter::printNamespace(
   os << "\n\n";
 }
 
-void CxxPrinter::printNamespace(
+void ClangSyntaxPrinter::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/CxxSynthesis.h renamed to lib/PrintAsClang/ClangSyntaxPrinter.h

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

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -11,8 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "DeclAndTypePrinter.h"
-#include "CxxSynthesis.h"
+#include "ClangSyntaxPrinter.h"
 #include "PrimitiveTypeMapping.h"
+#include "PrintClangFunction.h"
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -79,6 +80,29 @@ 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 {
@@ -98,17 +122,14 @@ static bool looksLikeInitMethod(ObjCSelector selector) {
 }
 
 class DeclAndTypePrinter::Implementation
-  : private DeclVisitor<DeclAndTypePrinter::Implementation>,
-    private TypeVisitor<DeclAndTypePrinter::Implementation, void,
-                        Optional<OptionalTypeKind>>
-{
+    : private DeclVisitor<DeclAndTypePrinter::Implementation>,
+      private TypeVisitor<DeclAndTypePrinter::Implementation, void,
+                          Optional<OptionalTypeKind>>,
+      private ClangSyntaxPrinter {
   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;
 
@@ -126,7 +147,7 @@ class DeclAndTypePrinter::Implementation
 public:
   explicit Implementation(raw_ostream &out, DeclAndTypePrinter &owner,
                           OutputLanguageMode outputLang)
-      : os(out), owningPrinter(owner), outputLang(outputLang) {}
+      : ClangSyntaxPrinter(out), owningPrinter(owner), outputLang(outputLang) {}
 
   void print(const Decl *D) {
     PrettyStackTraceDecl trace("printing", D);
@@ -285,17 +306,7 @@ class DeclAndTypePrinter::Implementation
   // isImplicitlyUnwrappedOptional().
   static std::pair<Type, OptionalTypeKind>
   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};
+    return DeclAndTypePrinter::getObjectTypeAndOptionality(D, ty);
   }
 
   // Ignore other declarations.
@@ -845,7 +856,10 @@ class DeclAndTypePrinter::Implementation
     FuncionSwiftABIInformation funcABI(FD, mangler);
 
     os << "SWIFT_EXTERN ";
-    printFunctionDeclAsCFunctionDecl(FD, funcABI.getSymbolName(), resultTy);
+
+    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.typeMapping);
+    funcPrinter.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.
@@ -1372,55 +1386,6 @@ 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,6 +26,7 @@ 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.
@@ -88,6 +89,12 @@ 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 "CxxSynthesis.h"
+#include "ClangSyntaxPrinter.h"
 #include "DeclAndTypePrinter.h"
 #include "OutputLanguageMode.h"
 #include "PrimitiveTypeMapping.h"
@@ -642,26 +642,34 @@ swift::printModuleContentsAsObjC(raw_ostream &os,
 void swift::printModuleContentsAsCxx(
     raw_ostream &os, llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
     ModuleDecl &M) {
-  using cxx_synthesis::CxxPrinter;
+  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";
+  }
+
   // Construct a C++ namespace for the module.
-  CxxPrinter(os).printNamespace(
+  ClangSyntaxPrinter(os).printNamespace(
       [&](raw_ostream &os) { M.ValueDecl::getName().print(os); },
-      [&](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();
-      });
+      [&](raw_ostream &os) { os << moduleOS.str(); });
 }