[interop][SwiftToCxx] make it possible to convert Swift String to a std::string in C++

hyp · hyp · commit 28af8bef5579 · 2022-12-14T16:22:41.000-08:00
This is done by exposing nested Index and UTF8View type in String. Nested types aren't
supported yet, so we need to employ a number of hacks to emit them.
diff --git a/lib/AST/SwiftNameTranslation.cpp b/lib/AST/SwiftNameTranslation.cpp
@@ -162,6 +162,12 @@ swift::cxx_translation::getNameForCxx(const ValueDecl *VD,
   if (customNamesOnly)
     return StringRef();
 
+  // FIXME: String.Index should be exposed as String::Index, not _String_Index.
+  if (VD->getModuleContext()->isStdlibModule() &&
+      VD->getBaseIdentifier().str() == "Index") {
+    return "String_Index";
+  }
+
   return VD->getBaseIdentifier().str();
 }
 
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -2608,6 +2608,15 @@ static bool isAsyncAlternativeOfOtherDecl(const ValueDecl *VD) {
   return false;
 }
 
+static bool isStringNestedType(const ValueDecl *VD, StringRef Typename) {
+  auto ctx = VD->getDeclContext();
+  return VD->hasName() && VD->getName().isSimpleName() &&
+         VD->getBaseIdentifier().str() == Typename &&
+         isa<ExtensionDecl>(ctx->getAsDecl()) &&
+         cast<ExtensionDecl>(ctx->getAsDecl())->getExtendedNominal() ==
+             VD->getASTContext().getStringDecl();
+}
+
 static bool hasExposeAttr(const ValueDecl *VD, bool isExtension = false) {
   if (isa<NominalTypeDecl>(VD) && VD->getModuleContext()->isStdlibModule()) {
     if (VD == VD->getASTContext().getStringDecl() && !isExtension)
@@ -2616,6 +2625,8 @@ static bool hasExposeAttr(const ValueDecl *VD, bool isExtension = false) {
       return true;
     if (VD == VD->getASTContext().getOptionalDecl() && !isExtension)
       return true;
+    if (isStringNestedType(VD, "UTF8View") || isStringNestedType(VD, "Index"))
+      return true;
     return false;
   }
   // Clang decls don't need to be explicitly exposed.
@@ -2643,6 +2654,33 @@ static bool hasExposeAttr(const ValueDecl *VD, bool isExtension = false) {
               .contains_insensitive("index"))
         return false;
     }
+    if (ED->getExtendedNominal() == VD->getASTContext().getStringDecl()) {
+      if (isa<ValueDecl>(VD) &&
+          !cast<ValueDecl>(VD)->getName().getBaseName().isSpecial() &&
+          cast<ValueDecl>(VD)
+              ->getName()
+              .getBaseName()
+              .getIdentifier()
+              .str()
+              .contains_insensitive("utf8"))
+        return true;
+    }
+    if (isStringNestedType(ED->getExtendedNominal(), "UTF8View")) {
+      // Do not expose ambiguous 'index(after:' / 'index(before:' overloads.
+      if (isa<AbstractFunctionDecl>(VD) &&
+          cast<AbstractFunctionDecl>(VD)->getParameters()->size() == 1 &&
+          !cast<AbstractFunctionDecl>(VD)
+               ->getName()
+               .getBaseName()
+               .isSpecial() &&
+          cast<AbstractFunctionDecl>(VD)
+              ->getName()
+              .getBaseName()
+              .getIdentifier()
+              .str()
+              .contains_insensitive("index"))
+        return false;
+    }
     return hasExposeAttr(ED->getExtendedNominal(), /*isExtension=*/true);
   }
   return false;
diff --git a/lib/PrintAsClang/ModuleContentsWriter.cpp b/lib/PrintAsClang/ModuleContentsWriter.cpp
@@ -612,6 +612,25 @@ class ModuleWriter {
     });
     decls.erase(newEnd, decls.end());
 
+    if (M.isStdlibModule()) {
+      llvm::SmallVector<Decl *, 2> nestedAdds;
+      for (const auto *d : decls) {
+        auto *ext = dyn_cast<ExtensionDecl>(d);
+        if (!ext ||
+            ext->getExtendedNominal() != M.getASTContext().getStringDecl())
+          continue;
+        for (auto *m : ext->getMembers()) {
+          if (auto *sd = dyn_cast<StructDecl>(m)) {
+            if (sd->getBaseIdentifier().str() == "UTF8View" ||
+                sd->getBaseIdentifier().str() == "Index") {
+              nestedAdds.push_back(sd);
+            }
+          }
+        }
+      }
+      decls.append(nestedAdds);
+    }
+
     // REVERSE sort the decls, since we are going to copy them onto a stack.
     llvm::array_pod_sort(decls.begin(), decls.end(),
                          [](Decl * const *lhs, Decl * const *rhs) -> int {
@@ -783,6 +802,9 @@ EmittedClangHeaderDependencyInfo swift::printModuleContentsAsCxx(
     // Embed an overlay for the standard library.
     ClangSyntaxPrinter(moduleOS).printIncludeForShimHeader(
         "_SwiftStdlibCxxOverlay.h");
+    // Ignore typos in Swift stdlib doc comments.
+    os << "#pragma clang diagnostic push\n";
+    os << "#pragma clang diagnostic ignored \"-Wdocumentation\"\n";
   }
 
   os << "#ifndef SWIFT_PRINTED_CORE\n";
@@ -820,5 +842,9 @@ EmittedClangHeaderDependencyInfo swift::printModuleContentsAsCxx(
       [&](raw_ostream &os) { M.ValueDecl::getName().print(os); },
       [&](raw_ostream &os) { os << moduleOS.str(); },
       ClangSyntaxPrinter::NamespaceTrivia::AttributeSwiftPrivate);
+
+  if (M.isStdlibModule()) {
+    os << "#pragma clang diagnostic pop\n";
+  }
   return info;
 }
diff --git a/lib/PrintAsClang/PrintClangValueType.cpp b/lib/PrintAsClang/PrintClangValueType.cpp
@@ -167,6 +167,9 @@ static void addCppExtensionsToStdlibType(const NominalTypeDecl *typeDecl,
     os << "    memcpy(_getOpaquePointer(), &res, sizeof(res));\n";
     os << "}\n";
     os << "#endif\n";
+    // Add additional methods for the `String` declaration.
+    printer.printDefine("SWIFT_CXX_INTEROP_STRING_MIXIN");
+    printer.printIncludeForShimHeader("_SwiftStdlibCxxOverlay.h");
   } else if (typeDecl == typeDecl->getASTContext().getOptionalDecl()) {
     // Add additional methods for the `Optional` declaration.
     printer.printDefine("SWIFT_CXX_INTEROP_OPTIONAL_MIXIN");
diff --git a/lib/PrintAsClang/_SwiftStdlibCxxOverlay.h b/lib/PrintAsClang/_SwiftStdlibCxxOverlay.h
@@ -31,12 +31,40 @@ SWIFT_INLINE_THUNK T_0_0 get() const
 
 #undef SWIFT_CXX_INTEROP_OPTIONAL_MIXIN
 
+#elifdef SWIFT_CXX_INTEROP_STRING_MIXIN
+
+#ifndef SWIFT_CXX_INTEROP_HIDE_STL_OVERLAY
+
+/// Casts the Swift String value to a C++ std::string.
+SWIFT_INLINE_THUNK operator std::string() const;
+
+#endif // SWIFT_CXX_INTEROP_HIDE_STL_OVERLAY
+
+#undef SWIFT_CXX_INTEROP_STRING_MIXIN
+
 #else
 // out-of-class overlay for Swift standard library.
 
 static_assert(sizeof(_impl::_impl_String) >= 0,
               "included outside of stdlib bindings");
 
+#ifndef SWIFT_CXX_INTEROP_HIDE_STL_OVERLAY
+
+SWIFT_INLINE_THUNK String::operator std::string() const {
+  auto u = getUtf8();
+  std::string result;
+  result.reserve(u.getCount() + 1);
+  using IndexType = decltype(u.getStartIndex());
+  for (auto s = u.getStartIndex().getEncodedOffset(),
+            e = u.getEndIndex().getEncodedOffset();
+       s != e; s = u.index(IndexType::init(s), 1).getEncodedOffset()) {
+    result.push_back(u[IndexType::init(s)]);
+  }
+  return result;
+}
+
+#endif // SWIFT_CXX_INTEROP_HIDE_STL_OVERLAY
+
 namespace cxxOverlay {
 
 class IterationEndSentinel;
diff --git a/test/Interop/SwiftToCxx/stdlib/string/string-conversions.cpp b/test/Interop/SwiftToCxx/stdlib/string/string-conversions.cpp
@@ -17,6 +17,11 @@ public func printString(_ s: String) {
     print("'''\(s)'''")
 }
 
+@_expose(Cxx)
+public func makeString(_ s: String, _ y: String) -> String {
+    return "\(s)++\(y)"
+}
+
 //--- string-conversions.cpp
 
 #include <cassert>
@@ -37,5 +42,13 @@ int main() {
     printString(str);
   }
 // CHECK-NEXT: '''test std::string'''
+  {
+    auto s = makeString(String("start"), String("end"));
+    std::string str = s;
+    assert(str == "start++end");
+    str += "++cxx";
+    printString(String(str));
+  }
+// CHECK-NEXT: '''start++end++cxx'''
   return 0;
 }
diff --git a/test/Interop/SwiftToCxx/stdlib/swift-stdlib-in-cxx.swift b/test/Interop/SwiftToCxx/stdlib/swift-stdlib-in-cxx.swift
@@ -75,6 +75,9 @@
 // CHECK:  }
 // CHECK-NEXT:  inline String(String &&) { abort(); }
 // CHECK-NEXT:  static inline String init();
+// CHECK-NEXT:  inline UTF8View getUtf8() const;
+// CHECK-NEXT:  inline void setUtf8(const UTF8View& newValue);
+// CHECK-NEXT:  inline bool isContiguousUTF8() const;
 // CHECK-NEXT:  #if defined(__OBJC__)
 // CHECK-NEXT:  inline __attribute__((always_inline)) operator NSString * _Nonnull () const noexcept {
 // CHECK-NEXT:    return (__bridge_transfer NSString *)(_impl::$sSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF(_impl::swift_interop_passDirect_Swift_String(_getOpaquePointer())));
@@ -93,6 +96,18 @@
 // CHECK-NEXT:      memcpy(_getOpaquePointer(), &res, sizeof(res));
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
+// CHECK-NEXT: #define SWIFT_CXX_INTEROP_STRING_MIXIN
+// CHECK-NEXT: // Look for the C++ interop support header relative to clang's resource dir:
+// CHECK-NEXT: //  '<toolchain>/usr/lib/clang/<version>/include/../../../swift/swiftToCxx'.
+// CHECK-NEXT: #if __has_include(<../../../swift/swiftToCxx/_SwiftStdlibCxxOverlay.h>)
+// CHECK-NEXT: #include <../../../swift/swiftToCxx/_SwiftStdlibCxxOverlay.h>
+// CHECK-NEXT: #elif __has_include(<../../../../../lib/swift/swiftToCxx/_SwiftStdlibCxxOverlay.h>)
+// CHECK-NEXT: //  '<toolchain>/usr/local/lib/clang/<version>/include/../../../../../lib/swift/swiftToCxx'.
+// CHECK-NEXT: #include <../../../../../lib/swift/swiftToCxx/_SwiftStdlibCxxOverlay.h>
+// CHECK-NEXT: // Alternatively, allow user to find the header using additional include path into '<toolchain>/lib/swift'.
+// CHECK-NEXT: #elif __has_include(<swiftToCxx/_SwiftStdlibCxxOverlay.h>)
+// CHECK-NEXT: #include <swiftToCxx/_SwiftStdlibCxxOverlay.h>
+// CHECK-NEXT: #endif
 // CHECK-NEXT: private:
 
 // CHECK: #if __has_include(<../../../swift/swiftToCxx/_SwiftStdlibCxxOverlay.h>)
