Merge pull request swiftlang#68578 from apple/egorzhdan/cxx-convertible-to-bool

[cxx-interop] Add conversion to Bool for types that define `operator bool()`

Author: egorzhdan

include/swift/AST/KnownProtocols.def

@@ -107,6 +107,7 @@ PROTOCOL(DistributedTargetInvocationDecoder)
 PROTOCOL(DistributedTargetInvocationResultHandler)
 
 // C++ Standard Library Overlay:
+PROTOCOL(CxxConvertibleToBool)
 PROTOCOL(CxxConvertibleToCollection)
 PROTOCOL(CxxDictionary)
 PROTOCOL(CxxOptional)

lib/AST/ASTContext.cpp

@@ -1135,6 +1135,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
     M = getLoadedModule(Id_Distributed);
     break;
+  case KnownProtocolKind::CxxConvertibleToBool:
   case KnownProtocolKind::CxxConvertibleToCollection:
   case KnownProtocolKind::CxxDictionary:
   case KnownProtocolKind::CxxPair:

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -571,6 +571,39 @@ void swift::conformToCxxIteratorIfNeeded(
         decl, {KnownProtocolKind::UnsafeCxxRandomAccessIterator});
 }
 
+void swift::conformToCxxConvertibleToBoolIfNeeded(
+    ClangImporter::Implementation &impl, swift::NominalTypeDecl *decl,
+    const clang::CXXRecordDecl *clangDecl) {
+  PrettyStackTraceDecl trace("conforming to CxxConvertibleToBool", decl);
+
+  assert(decl);
+  assert(clangDecl);
+  ASTContext &ctx = decl->getASTContext();
+
+  auto conversionId = ctx.getIdentifier("__convertToBool");
+  auto conversions = lookupDirectWithoutExtensions(decl, conversionId);
+
+  // Find a non-mutating overload of `__convertToBool`.
+  FuncDecl *conversion = nullptr;
+  for (auto c : conversions) {
+    auto candidate = dyn_cast<FuncDecl>(c);
+    if (!candidate || candidate->isMutating())
+      continue;
+    if (conversion)
+      // Overload ambiguity?
+      return;
+    conversion = candidate;
+  }
+  if (!conversion)
+    return;
+  auto conversionTy = conversion->getResultInterfaceType();
+  if (!conversionTy->isBool())
+    return;
+
+  impl.addSynthesizedProtocolAttrs(decl,
+                                   {KnownProtocolKind::CxxConvertibleToBool});
+}
+
 void swift::conformToCxxOptionalIfNeeded(
     ClangImporter::Implementation &impl, NominalTypeDecl *decl,
     const clang::CXXRecordDecl *clangDecl) {

lib/ClangImporter/ClangDerivedConformances.h

@@ -28,6 +28,12 @@ void conformToCxxIteratorIfNeeded(ClangImporter::Implementation &impl,
                                   NominalTypeDecl *decl,
                                   const clang::CXXRecordDecl *clangDecl);
 
+/// If the decl defines `operator bool()`, synthesize a conformance to the
+/// CxxConvertibleToBool protocol, which is defined in the Cxx module.
+void conformToCxxConvertibleToBoolIfNeeded(
+    ClangImporter::Implementation &impl, NominalTypeDecl *decl,
+    const clang::CXXRecordDecl *clangDecl);
+
 /// If the decl is an instantiation of C++ `std::optional`, synthesize a
 /// conformance to CxxOptional protocol, which is defined in the Cxx module.
 void conformToCxxOptionalIfNeeded(ClangImporter::Implementation &impl,

lib/ClangImporter/ImportDecl.cpp

@@ -2820,6 +2820,7 @@ namespace {
         auto nominalDecl = cast<NominalTypeDecl>(result);
         conformToCxxIteratorIfNeeded(Impl, nominalDecl, decl);
         conformToCxxSequenceIfNeeded(Impl, nominalDecl, decl);
+        conformToCxxConvertibleToBoolIfNeeded(Impl, nominalDecl, decl);
         conformToCxxSetIfNeeded(Impl, nominalDecl, decl);
         conformToCxxDictionaryIfNeeded(Impl, nominalDecl, decl);
         conformToCxxPairIfNeeded(Impl, nominalDecl, decl);

lib/IRGen/GenMeta.cpp

@@ -6527,6 +6527,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::DistributedTargetInvocationEncoder:
   case KnownProtocolKind::DistributedTargetInvocationDecoder:
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
+  case KnownProtocolKind::CxxConvertibleToBool:
   case KnownProtocolKind::CxxConvertibleToCollection:
   case KnownProtocolKind::CxxDictionary:
   case KnownProtocolKind::CxxPair:

stdlib/public/Cxx/CMakeLists.txt

@@ -7,6 +7,7 @@ if(SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT)
 endif()
 
 add_swift_target_library(swiftCxx STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_ONLY IS_FRAGILE
+    CxxConvertibleToBool.swift
     CxxConvertibleToCollection.swift
     CxxDictionary.swift
     CxxPair.swift

stdlib/public/Cxx/CxxConvertibleToBool.swift

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A C++ type that can be converted to a Boolean value.
+///
+/// Any C++ type that defines `operator bool()` conforms to this protocol.
+public protocol CxxConvertibleToBool {
+  /// Do not implement this function manually in Swift.
+  func __convertToBool() -> Bool
+}
+
+extension Bool {
+  @inlinable
+  public init<B: CxxConvertibleToBool>(fromCxx convertible: __shared B) {
+    self = convertible.__convertToBool()
+  }
+}

test/Interop/Cxx/operators/member-inline-module-interface.swift

@@ -9,7 +9,7 @@
 // CHECK:   mutating func callAsFunction(_ x: Int32, _ y: Int32) -> Int32
 // CHECK: }
 
-// CHECK: struct LoadableBoolWrapper {
+// CHECK: struct LoadableBoolWrapper
 // CHECK:   prefix static func ! (lhs: inout LoadableBoolWrapper) -> LoadableBoolWrapper
 // CHECK:   func __convertToBool() -> Bool
 // CHECK: }

test/Interop/Cxx/stdlib/overlay/Inputs/convertible-to-bool.h

@@ -0,0 +1,18 @@
+struct BoolBox {
+  bool value;
+
+  operator bool() const { return value; }
+};
+
+struct NonConstBoolBox {
+  bool value;
+
+  operator bool() { return value; }
+};
+
+struct DualOverloadBoolBox {
+  bool value;
+
+  operator bool() const { return value; }
+  operator bool() { return value; }
+};