[cxx-interop] import static operator call from C++23 as member callAsFunction functions in Swift to preserve source compatibility

Author: hyp

lib/ClangImporter/ImportDecl.cpp

@@ -3734,6 +3734,17 @@ namespace {
     }
 
     Decl *VisitCXXMethodDecl(const clang::CXXMethodDecl *decl) {
+      // The static `operator ()` introduced in C++ 23 is still callable as an
+      // instance operator in C++, and we want to preserve the ability to call it as
+      // an instance method in Swift as well for source compatibility. Therefore, we synthesize a C++
+      // instance member that invokes the operator and import it instead.
+      if (decl->getDeclName().getNameKind() == clang::DeclarationName::CXXOperatorName &&
+          decl->getDeclName().getCXXOverloadedOperator() == clang::OverloadedOperatorKind::OO_Call 
+         && decl->isStatic()) {
+        auto result = synthesizer.makeInstanceToStaticOperatorCallMethod(decl);
+        if (result)
+          return result;
+      }
       auto method = VisitFunctionDecl(decl);
 
       // Do not expose constructors of abstract C++ classes.

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2021,9 +2021,10 @@ clang::CXXMethodDecl *SwiftDeclSynthesizer::synthesizeCXXForwardingMethod(
 
   auto &clangCtx = ImporterImpl.getClangASTContext();
   auto &clangSema = ImporterImpl.getClangSema();
+  assert(!method->isStatic() || method->getNameInfo().getName().getCXXOverloadedOperator() == clang::OO_Call);
   // When emitting symbolic decls, the method might not have a concrete
   // record type as this type.
-  if (ImporterImpl.importSymbolicCXXDecls &&
+  if (ImporterImpl.importSymbolicCXXDecls && !method->isStatic() &&
       !method->getThisType()->getPointeeCXXRecordDecl())
     return nullptr;
 
@@ -2051,6 +2052,11 @@ clang::CXXMethodDecl *SwiftDeclSynthesizer::synthesizeCXXForwardingMethod(
             (forwardingMethodKind == ForwardingMethodKind::Virtual
                  ? "__synthesizedVirtualCall_operatorStar"
                  : "__synthesizedBaseCall_operatorStar")));
+  } else if (name.getCXXOverloadedOperator() == clang::OO_Call) {
+    assert(forwardingMethodKind != ForwardingMethodKind::Virtual);
+    name = clang::DeclarationName(
+        &ImporterImpl.getClangPreprocessor().getIdentifierTable().get(
+            "__synthesizedBaseCall_operatorCall"));
   }
   auto methodType = method->getType();
   // Check if we need to drop the reference from the return type
@@ -2093,7 +2099,7 @@ clang::CXXMethodDecl *SwiftDeclSynthesizer::synthesizeCXXForwardingMethod(
       clangCtx, const_cast<clang::CXXRecordDecl *>(derivedClass),
       method->getSourceRange().getBegin(),
       clang::DeclarationNameInfo(name, clang::SourceLocation()), methodType,
-      method->getTypeSourceInfo(), method->getStorageClass(),
+      method->getTypeSourceInfo(), method->isStatic() ? clang::SC_None : method->getStorageClass(),
       method->UsesFPIntrin(), /*isInline=*/true, method->getConstexprKind(),
       method->getSourceRange().getEnd());
   newMethod->setImplicit();
@@ -2264,6 +2270,28 @@ FuncDecl *SwiftDeclSynthesizer::makeVirtualMethod(
   return result;
 }
 
+// MARK: C++ operators
+
+FuncDecl *SwiftDeclSynthesizer::makeInstanceToStaticOperatorCallMethod(
+    const clang::CXXMethodDecl *clangMethodDecl) {
+  auto clangDC = clangMethodDecl->getParent();
+  auto &ctx = ImporterImpl.SwiftContext;
+
+  assert(clangMethodDecl->isStatic() &&
+         "Expected a static operator");
+
+  auto newMethod = synthesizeCXXForwardingMethod(
+      clangDC, clangDC, clangMethodDecl, ForwardingMethodKind::Base,
+      ReferenceReturnTypeBehaviorForBaseMethodSynthesis::KeepReference,
+      /*forceConstQualifier*/ true);
+  newMethod->addAttr(clang::SwiftNameAttr::CreateImplicit(clangMethodDecl->getASTContext(), "callAsFunction"));
+
+  auto result = dyn_cast_or_null<FuncDecl>(
+      ctx.getClangModuleLoader()->importDeclDirectly(newMethod));
+  return result;
+}
+
+
 // MARK: C++ properties
 
 static std::pair<BraceStmt *, bool>

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -319,6 +319,8 @@ class SwiftDeclSynthesizer {
   /// method that dispatches the call dynamically.
   FuncDecl *makeVirtualMethod(const clang::CXXMethodDecl *clangMethodDecl);
 
+  FuncDecl *makeInstanceToStaticOperatorCallMethod(const clang::CXXMethodDecl *clangMethodDecl);
+
   VarDecl *makeComputedPropertyFromCXXMethods(FuncDecl *getter,
                                               FuncDecl *setter);
 

test/Interop/Cxx/operators/Inputs/member-inline.h

@@ -477,4 +477,14 @@ struct HasOperatorCallWithDefaultArg {
   int operator()(int x = 0) const { return value + x; }
 };
 
+class HasStaticOperatorCallBase {
+public:
+    static int operator()(int x) {
+        return x + 42;
+    }
+};
+
+class HasStaticOperatorCallDerived: public HasStaticOperatorCallBase {
+};
+
 #endif

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

@@ -294,3 +294,11 @@
 // CHECK: struct HasOperatorCallWithDefaultArg {
 // CHECK:   func callAsFunction(_ x: Int32 = cxxDefaultArg) -> Int32
 // CHECK: }
+
+// CHECK: struct HasStaticOperatorCallBase {
+// CHECK:   func callAsFunction(_ x: Int32) -> Int32
+// CHECK: }
+
+// CHECK: struct HasStaticOperatorCallDerived {
+// CHECK:   func callAsFunction(_ x: Int32) -> Int32
+// CHECK: }

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

@@ -437,4 +437,16 @@ OperatorsTestSuite.test("HasOperatorCallWithDefaultArg.call") {
   expectEqual(444, res)
 }
 
+OperatorsTestSuite.test("HasStaticOperatorCallBase.call") {
+  let h = HasStaticOperatorCallBase()
+  let res = h(1)
+  expectEqual(43, res)
+}
+
+OperatorsTestSuite.test("HasStaticOperatorCallDerived.call") {
+  let h = HasStaticOperatorCallDerived()
+  let res = h(0)
+  expectEqual(42, res)
+}
+
 runAllTests()