[interop][SwiftToCxx] remap bool is/has property getters directly as is/has methods in C++

Author: hyp

docs/CppInteroperability/CppInteroperabilityStatus.md

@@ -165,6 +165,6 @@ This status table describes which of the following Swift language features have
 
 | **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
 |--------------------------------|----------------------------------------------------------|
-| Getter accessors               | Yes, via `get<name>`. For structs only                   |
+| Getter accessors               | Yes, via `get<name>`. Boolean properties that start with `is` or `has` are remapped directly to a getter method using their original name. For structs only                   |
 | Setter accessors               | Yes, via `set<name>`. For structs only                   |
 | Mutation accessors             | No                                                       |

lib/PrintAsClang/PrintClangFunction.cpp

@@ -504,13 +504,28 @@ void DeclAndTypeClangFunctionPrinter::printCxxMethod(
   os << "  }\n";
 }
 
-static std::string remapPropertyName(const AccessorDecl *accessor) {
-  StringRef propertyName;
+/// Returns true if the given property name like `isEmpty` can be remapped
+/// directly to a C++ method.
+static bool canRemapBoolPropertyNameDirectly(StringRef name) {
+  auto startsWithAndLonger = [&](StringRef prefix) -> bool {
+    return name.startswith(prefix) && name.size() > prefix.size();
+  };
+  return startsWithAndLonger("is") || startsWithAndLonger("has");
+}
+
+static std::string remapPropertyName(const AccessorDecl *accessor,
+                                     Type resultTy) {
   // For a getter or setter, go through the variable or subscript decl.
-  propertyName = accessor->getStorage()->getBaseIdentifier().str();
+  StringRef propertyName = accessor->getStorage()->getBaseIdentifier().str();
+
+  // Boolean property getters can be remapped directly in certain cases.
+  if (accessor->isGetter() && resultTy->isBool() &&
+      canRemapBoolPropertyNameDirectly(propertyName)) {
+    return propertyName.str();
+  }
+
   std::string name;
   llvm::raw_string_ostream nameOS(name);
-  // FIXME: some names are remapped differently. (e.g. isX).
   nameOS << (accessor->isSetter() ? "set" : "get")
          << char(std::toupper(propertyName[0])) << propertyName.drop_front();
   nameOS.flush();
@@ -528,8 +543,9 @@ void DeclAndTypeClangFunctionPrinter::printCxxPropertyAccessorMethod(
     modifiers.qualifierContext = typeDeclContext;
   modifiers.isInline = true;
   modifiers.isConst = accessor->isGetter();
-  printFunctionSignature(accessor, remapPropertyName(accessor), resultTy,
-                         FunctionSignatureKind::CxxInlineThunk, {}, modifiers);
+  printFunctionSignature(accessor, remapPropertyName(accessor, resultTy),
+                         resultTy, FunctionSignatureKind::CxxInlineThunk, {},
+                         modifiers);
   if (!isDefinition) {
     os << ";\n";
     return;

test/Interop/SwiftToCxx/properties/bool-is-has-in-cxx.swift

@@ -0,0 +1,58 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -typecheck -module-name Properties -clang-header-expose-public-decls -emit-clang-header-path %t/properties.h
+// RUN: %FileCheck %s < %t/properties.h
+
+// RUN: %check-interop-cxx-header-in-clang(%t/properties.h)
+
+public struct IsHasProperties {
+    public var isEmpty: Bool { return true }
+
+    public let hasFlavor: Bool = false
+
+    public var isSolid: Bool = true
+
+    public var flag: Bool = false
+
+    public let has: Bool = true
+
+    public let isOption: Int = 0
+
+    // make it a large struct for easier ABI matching.
+    let x1, x2, x3, x4, x5, x6: Int
+}
+
+// CHECK: class IsHasProperties
+
+// CHECK: inline bool isEmpty() const;
+// CHECK-NEXT: inline bool hasFlavor() const;
+// CHECK-NEXT: inline bool isSolid() const;
+// CHECK-NEXT: inline void setIsSolid(bool value);
+// CHECK-NEXT: inline bool getFlag() const;
+// CHECK-NEXT: inline void setFlag(bool value);
+// CHECK-NEXT: inline bool getHas() const;
+// CHECK-NEXT: inline swift::Int getIsOption() const;
+
+// CHECK: inline bool IsHasProperties::isEmpty() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V7isEmptySbvg(_getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline bool IsHasProperties::hasFlavor() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V9hasFlavorSbvg(_getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline bool IsHasProperties::isSolid() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V7isSolidSbvg(_getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline void IsHasProperties::setIsSolid(bool value) {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V7isSolidSbvs(value, _getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline bool IsHasProperties::getFlag() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V4flagSbvg(_getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline void IsHasProperties::setFlag(bool value) {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V4flagSbvs(value, _getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline bool IsHasProperties::getHas() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V3hasSbvg(_getOpaquePointer());
+// CHECK-NEXT: }
+// CHECK-NEXT: inline swift::Int IsHasProperties::getIsOption() const {
+// CHECK-NEXT: return _impl::$s10Properties05IsHasA0V8isOptionSivg(_getOpaquePointer());
+// CHECK-NEXT: }