Merge pull request #69954 from plotfi/plotfi-swift-virtual-functions

[cxx-interop] Enable virtual function calling from Swift to C++

Author: plotfi

include/swift/ClangImporter/ClangImporter.h

@@ -611,6 +611,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// Enable the symbolic import experimental feature for the given callback.
   void withSymbolicFeatureEnabled(llvm::function_ref<void(void)> callback);
 
+  /// Returns true when the symbolic import experimental feature is enabled.
+  bool isSymbolicImportEnabled() const;
+
   const clang::TypedefType *getTypeDefForCXXCFOptionsDefinition(
       const clang::Decl *candidateDecl) override;
 

lib/ClangImporter/ClangImporter.cpp

@@ -4785,26 +4785,37 @@ static clang::CXXMethodDecl *synthesizeCxxBaseMethod(
     ReferenceReturnTypeBehaviorForBaseMethodSynthesis
         referenceReturnTypeBehavior =
             ReferenceReturnTypeBehaviorForBaseMethodSynthesis::KeepReference,
-    bool forceConstQualifier = false) {
+    bool forceConstQualifier = false,
+    bool isVirtualCall = false) {
   auto &clangCtx = impl.getClangASTContext();
   auto &clangSema = impl.getClangSema();
+  // When emitting symbolic decls, the method might not have a concrete
+  // record type as this type.
+  if (impl.isSymbolicImportEnabled()
+      && !method->getThisType()->getPointeeCXXRecordDecl()) {
+    return nullptr;
+  }
 
   // Create a new method in the derived class that calls the base method.
   clang::DeclarationName name = method->getNameInfo().getName();
   if (name.isIdentifier()) {
     std::string newName;
     llvm::raw_string_ostream os(newName);
-    os << "__synthesizedBaseCall_" << name.getAsIdentifierInfo()->getName();
+    os << (isVirtualCall ? "__synthesizedVirtualCall_" :
+                           "__synthesizedBaseCall_")
+       << name.getAsIdentifierInfo()->getName();
     name = clang::DeclarationName(
         &impl.getClangPreprocessor().getIdentifierTable().get(os.str()));
   } else if (name.getCXXOverloadedOperator() == clang::OO_Subscript) {
     name = clang::DeclarationName(
         &impl.getClangPreprocessor().getIdentifierTable().get(
-            "__synthesizedBaseCall_operatorSubscript"));
+            (isVirtualCall ? "__synthesizedVirtualCall_operatorSubscript" :
+                             "__synthesizedBaseCall_operatorSubscript")));
   } else if (name.getCXXOverloadedOperator() == clang::OO_Star) {
     name = clang::DeclarationName(
         &impl.getClangPreprocessor().getIdentifierTable().get(
-            "__synthesizedBaseCall_operatorStar"));
+            (isVirtualCall ? "__synthesizedVirtualCall_operatorStar" :
+                             "__synthesizedBaseCall_operatorStar")));
   }
   auto methodType = method->getType();
   // Check if we need to drop the reference from the return type
@@ -4930,6 +4941,16 @@ static clang::CXXMethodDecl *synthesizeCxxBaseMethod(
   return newMethod;
 }
 
+// Synthesize a C++ virtual method
+clang::CXXMethodDecl *synthesizeCxxVirtualMethod(
+    swift::ClangImporter &Impl, const clang::CXXRecordDecl *derivedClass,
+    const clang::CXXRecordDecl *baseClass, const clang::CXXMethodDecl *method) {
+  return synthesizeCxxBaseMethod(
+      Impl, derivedClass, baseClass, method,
+      ReferenceReturnTypeBehaviorForBaseMethodSynthesis::KeepReference,
+      false /* forceConstQualifier */, true /* isVirtualCall */);
+}
+
 // Find the base C++ method called by the base function we want to synthesize
 // the derived thunk for.
 // The base C++ method is either the original C++ method that corresponds
@@ -6555,7 +6576,7 @@ static ValueDecl *addThunkForDependentTypes(FuncDecl *oldDecl,
 // are not used in the function signature. We supply the type params as explicit
 // metatype arguments to aid in typechecking, but they shouldn't be forwarded to
 // the corresponding C++ function.
-static std::pair<BraceStmt *, bool>
+std::pair<BraceStmt *, bool>
 synthesizeForwardingThunkBody(AbstractFunctionDecl *afd, void *context) {
   ASTContext &ctx = afd->getASTContext();
 
@@ -7439,6 +7460,10 @@ void ClangImporter::withSymbolicFeatureEnabled(
       oldImportSymbolicCXXDecls.get());
 }
 
+bool ClangImporter::isSymbolicImportEnabled() const {
+  return Impl.importSymbolicCXXDecls;
+}
+
 const clang::TypedefType *ClangImporter::getTypeDefForCXXCFOptionsDefinition(
     const clang::Decl *candidateDecl) {
 

lib/ClangImporter/ImportDecl.cpp

@@ -3711,9 +3711,33 @@ namespace {
     Decl *VisitCXXMethodDecl(const clang::CXXMethodDecl *decl) {
       auto method = VisitFunctionDecl(decl);
       if (decl->isVirtual() && isa_and_nonnull<ValueDecl>(method)) {
+
+        if (auto dc = method->getDeclContext();
+            !decl->isPure() &&
+            isa_and_nonnull<NominalTypeDecl>(dc->getAsDecl())) {
+
+          // generates the __synthesizedVirtualCall_ C++ thunk
+          clang::CXXMethodDecl *cxxThunk = synthesizeCxxVirtualMethod(
+              *static_cast<ClangImporter *>(
+                  dc->getASTContext().getClangModuleLoader()),
+              decl->getParent(), decl->getParent(), decl);
+
+          // call the __synthesizedVirtualCall_ C++ thunk from a Swift thunk
+          if (Decl *swiftThunk =
+                  cxxThunk ? VisitCXXMethodDecl(cxxThunk) : nullptr;
+              isa_and_nonnull<FuncDecl>(swiftThunk)) {
+            // synthesize the body of the Swift method to call the swiftThunk
+            synthesizeForwardingThunkBody(cast<FuncDecl>(method),
+                                          cast<FuncDecl>(swiftThunk));
+            return method;
+          }
+        }
+
         Impl.markUnavailable(
             cast<ValueDecl>(method),
-            "virtual functions are not yet available in Swift");
+            decl->isPure() ?
+            "virtual function is not available in Swift because it is pure" :
+            "virtual function is not available in Swift");
       }
 
       if (Impl.SwiftContext.LangOpts.CxxInteropGettersSettersAsProperties ||

lib/ClangImporter/ImporterImpl.h

@@ -1988,4 +1988,14 @@ inline std::string getPrivateOperatorName(const std::string &OperatorToken) {
 }
 }
 
+// Forwards to synthesizeCxxBasicMethod(), producing a thunk that calls a
+// virtual function.
+clang::CXXMethodDecl *synthesizeCxxVirtualMethod(
+    swift::ClangImporter &Impl, const clang::CXXRecordDecl *derivedClass,
+    const clang::CXXRecordDecl *baseClass, const clang::CXXMethodDecl *method);
+
+// Exposed to produce a Swift method body for calling a Swift thunk.
+std::pair<swift::BraceStmt *, bool>
+synthesizeForwardingThunkBody(swift::AbstractFunctionDecl *afd, void *context);
+
 #endif

test/Interop/Cxx/class/inheritance/Inputs/virtual-methods.h

@@ -8,6 +8,12 @@ struct Base {
   virtual void foo() = 0;
 };
 
+struct Base2 { virtual int f() = 0; };
+struct Base3 { virtual int f() { return 24; } };
+struct Derived2 : public Base2 { virtual int f() {  return 42; } };
+struct Derived3 : public Base3 { virtual int f() {  return 42; } };
+struct Derived4 : public Base3 { };
+
 template <class T>
 struct Derived : Base {
   inline void foo() override {

test/Interop/Cxx/class/inheritance/virtual-methods-irgen.swift

@@ -8,6 +8,24 @@ import VirtualMethods
 var x = DerivedInt()
 x.callMe()
 
+var b3 = Base3()
+var d2 = Derived2()
+var d3 = Derived3()
+var d4 = Derived4()
+
+b3.f()
+d2.f()
+d3.f()
+d4.f()
+
+// CHECK: invoke {{.*}} @_ZN5Base31fEv
+// CHECK: invoke {{.*}} @_ZN8Derived21fEv
+// CHECK: invoke {{.*}} @_ZN8Derived31fEv
+// CHECK: call swiftcc {{.*}} @"$sSo8Derived4V1fs5Int32VyF"
+
+// CHECK: define {{.*}} @"$sSo8Derived4V1fs5Int32VyF"(ptr swiftself dereferenceable
+// CHECK: invoke {{.*}}  @_ZN8Derived423__synthesizedBaseCall_fEv
+
 // CHECK: define {{.*}}void @{{_ZN7DerivedIiE3fooEv|"\?foo@\?$Derived@H@@UEAAXXZ"}}
 // CHECK:   call void @{{_Z21testFunctionCollectedv|"\?testFunctionCollected@@YAXXZ"}}
 

test/Interop/Cxx/class/inheritance/virtual-methods-module-interface.swift

@@ -2,14 +2,14 @@
 
 // CHECK: struct Base {
 // CHECK-NEXT:  init()
-// CHECK-NEXT:   @available(*, unavailable, message: "virtual functions are not yet available in Swift")
+// CHECK-NEXT:   @available(*, unavailable, message: "virtual function is not available in Swift because it is pure")
 // CHECK-NEXT:   mutating func foo()
 
 // CHECK: struct Derived<CInt> {
-// CHECK: @available(*, unavailable, message: "virtual functions are not yet available in Swift")
-// CHECK:  mutating func foo()
+// CHECK-NEXT:  init()
+// CHECK-NEXT:  mutating func foo()
 // CHECK: }
 
 // CHECK: struct VirtualNonAbstractBase {
-// CHECK:  @available(*, unavailable, message: "virtual functions are not yet available in Swift")
-// CHECK:  func nonAbstractMethod()
+// CHECK-NEXT:  init()
+// CHECK-NEXT:  func nonAbstractMethod()

test/Interop/Cxx/class/inheritance/virtual-methods-typechecker.swift

@@ -2,4 +2,4 @@
 
 import VirtualMethods
 
-VirtualNonAbstractBase().nonAbstractMethod() // expected-error {{'nonAbstractMethod()' is unavailable: virtual functions are not yet available in Swift}}
+VirtualNonAbstractBase().nonAbstractMethod()