Merge pull request #61205 from apple/egorzhdan/cxx-successor-no-immortal

[cxx-interop] Do not synthesize `successor()` for immortal types

Author: egorzhdan

lib/ClangImporter/ImportDecl.cpp

@@ -2221,7 +2221,21 @@ namespace {
               MD->overwriteAccess(AccessLevel::Private);
             } else if (cxxOperatorKind ==
                        clang::OverloadedOperatorKind::OO_PlusPlus) {
-              if (cxxMethod->param_empty()) {
+              // Make sure the type is not an immortal foreign reference type.
+              // We cannot handle `operator++` for those types, since the
+              // current implementation creates a new instance of the type.
+              bool isImmortal = false;
+              if (auto classDecl = dyn_cast<ClassDecl>(result)) {
+                auto retainOperation = evaluateOrDefault(
+                    Impl.SwiftContext.evaluator,
+                    CustomRefCountingOperation(
+                        {classDecl, CustomRefCountingOperationKind::retain}),
+                    {});
+                isImmortal = retainOperation.kind ==
+                             CustomRefCountingOperationResult::immortal;
+              }
+
+              if (cxxMethod->param_empty() && !isImmortal) {
                 // This is a pre-increment operator. We synthesize a
                 // non-mutating function called `successor() -> Self`.
                 FuncDecl *successorFunc = synthesizer.makeSuccessorFunc(MD);

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

@@ -85,6 +85,18 @@ struct HasPreIncrementOperatorWithVoidReturnType {
   void operator++() { ++value; }
 };
 
+struct __attribute__((swift_attr("import_reference"),
+                      swift_attr("retain:immortal"),
+                      swift_attr("release:immortal"))) ImmortalCounter {
+  int value = 0;
+
+  ImmortalCounter &operator++() {
+    value++;
+    return *this;
+  }
+};
+static ImmortalCounter myCounter;
+
 struct HasDeletedOperator {
   void operator!=(HasDeletedOperator) const = delete;
 };

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

@@ -49,3 +49,5 @@ let anotherReturnTypeResult: HasPreIncrementOperatorWithAnotherReturnType = anot
 
 let voidReturnType = HasPreIncrementOperatorWithVoidReturnType()
 let voidReturnTypeResult: HasPreIncrementOperatorWithVoidReturnType = voidReturnType.successor()
+
+let immortalIncrement = myCounter.successor() // expected-error {{value of type 'ImmortalCounter' has no member 'successor'}}