[cxx-interop] Overhaul virtual method support

This adds a new implementation of virtual method dispatch that handles reference types correctly.

Previously, for all C++ types an invocation of a virtual method would actually get dispatched statically. For value types this is expected and matches what C++ does because of slicing. For reference types, however, this is incorrect, we should do dynamic dispatch.

rdar://123852577

Author: egorzhdan

lib/ClangImporter/ImportDecl.cpp

@@ -3753,10 +3753,43 @@ namespace {
         }
       }
 
-      if (decl->isVirtual() && isa_and_nonnull<ValueDecl>(method)) {
-        Impl.markUnavailable(
-            cast<ValueDecl>(method),
-            "virtual functions are not yet available in Swift");
+      if (decl->isVirtual()) {
+        if (auto funcDecl = dyn_cast_or_null<FuncDecl>(method)) {
+          if (Impl.isCxxInteropCompatVersionAtLeast(6)) {
+            if (auto structDecl =
+                    dyn_cast_or_null<StructDecl>(method->getDeclContext())) {
+              // If this is a method of a Swift struct, any possible override of
+              // this method would get sliced away, and an invocation would get
+              // dispatched statically. This is fine because it matches the C++
+              // behavior.
+              if (decl->isPure()) {
+                // If this is a pure virtual method, we won't have any
+                // implementation of it to invoke.
+                Impl.markUnavailable(
+                    funcDecl, "virtual function is not available in Swift "
+                              "because it is pure");
+              }
+            } else if (auto classDecl = dyn_cast_or_null<ClassDecl>(
+                           funcDecl->getDeclContext())) {
+              // This is a foreign reference type. Since `class T` on the Swift
+              // side is mapped from `T*` on the C++ side, an invocation of a
+              // virtual method `t->method()` should get dispatched dynamically.
+              // Create a thunk that will perform dynamic dispatch.
+              // TODO: we don't have to import the actual `method` in this case,
+              // we can just synthesize a thunk and import that instead.
+              auto result = synthesizer.makeVirtualMethod(decl);
+              if (result) {
+                return result;
+              } else {
+                Impl.markUnavailable(
+                    funcDecl, "virtual function is not available in Swift");
+              }
+            }
+          } else {
+            Impl.markUnavailable(
+                funcDecl, "virtual functions are not yet available in Swift");
+          }
+        }
       }
 
       if (Impl.SwiftContext.LangOpts.CxxInteropGettersSettersAsProperties ||

lib/ClangImporter/ImportName.cpp

@@ -2258,6 +2258,14 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
         baseName = newName;
       }
     }
+    if (method->isImplicit() &&
+        baseName.starts_with("__synthesizedVirtualCall_")) {
+      // If this is a thunk for a virtual method of a C++ reference type, we
+      // strip away the underscored prefix. This method should be visible and
+      // callable from Swift.
+      newName = baseName.substr(StringRef("__synthesizedVirtualCall_").size());
+      baseName = newName;
+    }
   }
 
   // swift_newtype-ed declarations may have common words with the type name

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2235,6 +2235,26 @@ SwiftDeclSynthesizer::makeOperator(FuncDecl *operatorMethod,
   return topLevelStaticFuncDecl;
 }
 
+// MARK: C++ virtual methods
+
+FuncDecl *SwiftDeclSynthesizer::makeVirtualMethod(
+    const clang::CXXMethodDecl *clangMethodDecl) {
+  auto clangDC = clangMethodDecl->getParent();
+  auto &ctx = ImporterImpl.SwiftContext;
+
+  assert(!clangMethodDecl->isStatic() &&
+         "C++ virtual functions cannot be static");
+
+  auto newMethod = synthesizeCXXForwardingMethod(
+      clangDC, clangDC, clangMethodDecl, ForwardingMethodKind::Virtual,
+      ReferenceReturnTypeBehaviorForBaseMethodSynthesis::KeepReference,
+      /*forceConstQualifier*/ false);
+
+  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

@@ -315,6 +315,10 @@ class SwiftDeclSynthesizer {
               ReferenceReturnTypeBehaviorForBaseMethodSynthesis::KeepReference,
       bool forceConstQualifier = false);
 
+  /// Given an overload of a C++ virtual method on a reference type, create a
+  /// method that dispatches the call dynamically.
+  FuncDecl *makeVirtualMethod(const clang::CXXMethodDecl *clangMethodDecl);
+
   VarDecl *makeComputedPropertyFromCXXMethods(FuncDecl *getter,
                                               FuncDecl *setter);
 

test/Interop/Cxx/class/Inputs/protocol-conformance.h

@@ -68,4 +68,8 @@ struct HasOperatorPlusEqual {
 
 using HasOperatorPlusEqualInt = HasOperatorPlusEqual<int>;
 
+struct HasVirtualMethod {
+  virtual int return42() { return 42; } 
+};
+
 #endif // TEST_INTEROP_CXX_CLASS_INPUTS_PROTOCOL_CONFORMANCE_H

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

@@ -1,4 +1,4 @@
-extern "C" void puts(const char *);
+extern "C" void puts(const char *_Null_unspecified);
 
 inline void testFunctionCollected() {
   puts("test\n");
@@ -38,3 +38,50 @@ using UnusedInt = Unused<int>;
 struct VirtualNonAbstractBase {
   virtual void nonAbstractMethod() const;
 };
+
+struct CallsPureMethod {
+  virtual int getPureInt() const = 0;
+  int getInt() const { return getPureInt() + 1; }
+};
+
+struct DerivedFromCallsPureMethod : CallsPureMethod {
+  int getPureInt() const override { return 789; }
+};
+
+struct DerivedFromDerivedFromCallsPureMethod : DerivedFromCallsPureMethod {};
+
+// MARK: Reference Types:
+
+#define IMMORTAL_FRT                                                           \
+  __attribute__((swift_attr("import_reference")))                              \
+  __attribute__((swift_attr("retain:immortal")))                               \
+  __attribute__((swift_attr("release:immortal")))
+
+struct IMMORTAL_FRT ImmortalBase {
+  int value = 0;
+
+  virtual int get42() const { return 42; }
+  virtual int getOverridden42() const { return 123; }
+  virtual int getIntValue() const { return value; }
+};
+
+struct IMMORTAL_FRT Immortal : public ImmortalBase {
+  static Immortal *_Nonnull create() { return new Immortal(); }
+
+  virtual int getOverridden42() const override { return 42; }
+  virtual void setIntValue(int newValue) { this->value = newValue; }
+};
+
+struct IMMORTAL_FRT DerivedFromImmortal : public Immortal {
+  static DerivedFromImmortal *_Nonnull create() { return new DerivedFromImmortal(); }
+};
+
+inline const ImmortalBase *_Nonnull castToImmortalBase(
+    const Immortal *_Nonnull immortal) {
+  return static_cast<const ImmortalBase *>(immortal);
+}
+
+inline const Immortal *_Nonnull castToImmortal(
+    const DerivedFromImmortal *_Nonnull immortal) {
+  return static_cast<const Immortal *>(immortal);
+}

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

@@ -24,3 +24,12 @@
 // CHECK: struct VirtualNonAbstractBase {
 // CHECK-NEXT:  init()
 // CHECK-NEXT:  func nonAbstractMethod()
+
+// CHECK: class ImmortalBase {
+// CHECK:  func get42() -> Int32
+// CHECK:  func getOverridden42() -> Int32
+// CHECK: }
+// CHECK: class Immortal {
+// CHECK:  func getOverridden42() -> Int32
+// CHECK:  func get42() -> Int32
+// CHECK: }

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

@@ -13,3 +13,26 @@ let _ = Derived4()
 let _ = DerivedFromDerived2()
 
 VirtualNonAbstractBase().nonAbstractMethod()
+
+@available(macOS 13.3, *)
+func takesImmortalBase(_ i: ImmortalBase) {
+  let _ = i.get42()
+  let _ = i.getOverridden42()
+  let _ = i.getIntValue()
+}
+
+@available(macOS 13.3, *)
+func takesImmortal(_ i: Immortal) {
+  let _ = i.get42()
+  let _ = i.getOverridden42()
+  let _ = i.getIntValue()
+  i.setIntValue(1)
+}
+
+@available(macOS 13.3, *)
+func takesDerivedFromImmortal(_ i: DerivedFromImmortal) {
+  let _ = i.get42()
+  let _ = i.getOverridden42()
+  let _ = i.getIntValue()
+  i.setIntValue(1)
+}

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

@@ -0,0 +1,55 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -cxx-interoperability-mode=swift-6)
+// RUN: %target-run-simple-swift(-I %S/Inputs -cxx-interoperability-mode=upcoming-swift)
+
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import VirtualMethods
+
+var VirtualMethodsTestSuite = TestSuite("Virtual Methods")
+
+VirtualMethodsTestSuite.test("value type") {
+  var d2 = Derived2()
+  expectEqual(42, d2.f())
+
+  var d3 = Derived3()
+  expectEqual(42, d3.f())
+
+  var d4 = Derived4()
+  expectEqual(24, d4.f())
+
+  let d5 = DerivedFromCallsPureMethod()
+  expectEqual(790, d5.getInt())
+  expectEqual(789, d5.getPureInt())
+
+  let d6 = DerivedFromDerivedFromCallsPureMethod()
+  expectEqual(790, d6.getInt())
+  expectEqual(789, d6.getPureInt())
+}
+
+if #available(macOS 13.3, *) {
+  VirtualMethodsTestSuite.test("immortal reference type") {
+    let i = Immortal.create()
+    expectEqual(42, i.get42())
+    expectEqual(0, i.getIntValue())
+
+    let base = castToImmortalBase(i)
+    expectEqual(42, base.get42())
+    expectEqual(42, base.getOverridden42())
+    expectEqual(0, base.getIntValue())
+
+    i.setIntValue(566)
+    expectEqual(566, i.getIntValue())
+    expectEqual(566, base.getIntValue())
+
+    let d = DerivedFromImmortal.create()
+    expectEqual(42, d.get42())
+    expectEqual(42, d.getOverridden42())
+    d.setIntValue(321)
+    expectEqual(321, d.getIntValue())
+    let base2 = castToImmortalBase(castToImmortal(d))
+    expectEqual(321, base2.getIntValue())
+  }
+}
+
+runAllTests()

test/Interop/Cxx/class/protocol-conformance-typechecker.swift

@@ -1,6 +1,8 @@
 // Tests that a C++ class can conform to a Swift protocol.
 
 // RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -D VIRTUAL_METHODS -cxx-interoperability-mode=swift-6
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -D VIRTUAL_METHODS -cxx-interoperability-mode=upcoming-swift
 
 import ProtocolConformance
 
@@ -10,6 +12,10 @@ protocol HasReturn42 {
 
 extension ConformsToProtocol : HasReturn42 {}
 
+#if VIRTUAL_METHODS
+extension HasVirtualMethod : HasReturn42 {}
+#endif
+
 extension DoesNotConformToProtocol : HasReturn42 {} // expected-error {{'DoesNotConformToProtocol' does not conform to protocol}}