[cxx-interop] Remove SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT annotation (#81329)

This patch removes the `SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT`
annotation while maintaining the support for
`SWIFT_RETURNED_AS_UNRETAINED_BY_DEFAULT`. These type-level annotations
were initially introduced in
[PR-81093](#81093) to reduce the
annotation burden in large C++ codebases where many C++ APIs returning
`SWIFT_SHARED_REFERENCE` types are exposed to Swift.

### Motivation
The original goal was to make C++ interop more ergonomic by allowing
type-level defaults for ownership conventions
for`SWIFT_SHARED_REFERENCE` types . However, defaulting to retained
return values (+1) seems to be problematic and poses memory safety
risks.

### Why we’re removing `SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT`

- **Memory safety risks:** Defaulting to retained can potentially lead
to use-after-free bugs when the API implementation actually returns
`unowned` (`+0`). These errors are subtle and can be hard to debug or
discover, particularly in the absence of explicit API-level
`SWIFT_RETURNS_(UN)RETAINED` annotations.
- **Risky transitive behavior:** If a `SWIFT_SHARED_REFERENCE` type is
annotated with `SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT`, any new C++ API
returning this type will inherit the retained behavior by default—even
if the API's actual return behavior is unretained. Unless explicitly
overridden with `SWIFT_RETURNS_UNRETAINED`, this can introduce a silent
mismatch in ownership expectations and lead to use-after-free bugs. This
is especially risky in large or evolving codebases where such defaults
may be overlooked.
- **Simpler multiple inheritance semantics:** With only one type-level
default (`SWIFT_RETURNED_AS_UNRETAINED_BY_DEFAULT`), we avoid
complications that can arise when multiple base classes specify
conflicting ownership defaults. This simplifies reasoning about behavior
in class hierarchies and avoids ambiguity when Swift determines the
ownership convention for inherited APIs.

### Why we’re keeping `SWIFT_RETURNED_AS_UNRETAINED_BY_DEFAULT`
- It still enables projects to suppress warnings for unannotated C++
APIs returning `SWIFT_SHARED_REFERENCE` types, helping to reduce noise
while maintaining clarity.
- It encourages explicitness for retained behavior. Developers must
annotate retained return values with `SWIFT_RETURNS_RETAINED`, making
ownership intent clearer and safer.
- The worst-case outcome of assuming unretained when the return is
actually retained is a memory leak, which is more tolerable and easier
to debug than a use-after-free.
- Having a single default mechanism improves clarity for documentation,
diagnostics, and long-term maintenance of Swift/C++ interop code.

Author: fahadnayyar

lib/ClangImporter/ClangImporter.cpp

@@ -8809,8 +8809,7 @@ swift::importer::getCxxRefConventionWithAttrs(const clang::Decl *decl) {
     if (const clang::RecordDecl *record =
             ptrType->getPointeeType()->getAsRecordDecl()) {
       return matchSwiftAttrConsideringInheritance<RC>(
-          record, {{"returned_as_unretained_by_default", RC::Unowned},
-                   {"returned_as_retained_by_default", RC::Owned}});
+          record, {{"returned_as_unretained_by_default", RC::Unowned}});
     }
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -3656,8 +3656,7 @@ namespace {
           }
 
           if (importer::matchSwiftAttrOnRecordPtr<bool>(
-                  retType, {{"returned_as_retained_by_default", true},
-                            {"returned_as_unretained_by_default", true}})) {
+                  retType, {{"returned_as_unretained_by_default", true}})) {
             unannotatedAPIWarningNeeded = false;
           }
 

lib/ClangImporter/SwiftBridging/swift/bridging

@@ -191,23 +191,6 @@
 #define SWIFT_RETURNS_UNRETAINED                                               \
   __attribute__((swift_attr("returns_unretained")))
 
-/// Applied to a C++ foreign reference type annotated with
-/// SWIFT_SHARED_REFERENCE. Indicates that C++ APIs returning this type are
-/// assumed to return an owned (+1) value by default, unless explicitly annotated with
-/// SWIFT_RETURNS_UNRETAINED.
-///
-/// For example:
-/// ```c++
-/// struct SWIFT_SHARED_REFERENCE(retainFoo, releaseFoo)
-/// SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT
-/// Foo { ... };
-/// ```
-///
-/// In Swift, C++ APIs returning `Foo*` will be assumed to return an owned
-/// value.
-#define SWIFT_RETURNED_AS_RETAINED_BY_DEFAULT                                      \
-  __attribute__((swift_attr("returned_as_retained_by_default")))
-
 /// Applied to a C++ foreign reference type annotated with
 /// SWIFT_SHARED_REFERENCE. Indicates that C++ APIs returning this type are
 /// assumed to return an unowned (+0) value by default, unless explicitly annotated

test/Interop/Cxx/foreign-reference/Inputs/cxx-functions-and-methods-returning-frt.h

@@ -331,13 +331,6 @@ struct Derived : Base {
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 namespace DefaultOwnershipConventionOnCXXForeignRefType {
-struct __attribute__((swift_attr("import_reference")))
-__attribute__((swift_attr("retain:defRetain1")))
-__attribute__((swift_attr("release:defRelease1"))) 
-__attribute__((swift_attr("returned_as_retained_by_default"))) RefTyDefRetained {};
-
-RefTyDefRetained *returnRefTyDefRetained() { return new RefTyDefRetained(); }
-
 struct __attribute__((swift_attr("import_reference")))
 __attribute__((swift_attr("retain:defRetain2")))
 __attribute__((swift_attr("release:defRelease2"))) 
@@ -348,11 +341,6 @@ RefTyDefUnretained *returnRefTyDefUnretained() {
 }
 } // namespace DefaultOwnershipConventionOnCXXForeignRefType
 
-void defRetain1(
-    DefaultOwnershipConventionOnCXXForeignRefType::RefTyDefRetained *v) {};
-void defRelease1(
-    DefaultOwnershipConventionOnCXXForeignRefType::RefTyDefRetained *v) {};
-
 void defRetain2(
     DefaultOwnershipConventionOnCXXForeignRefType::RefTyDefUnretained *v) {};
 void defRelease2(
@@ -372,25 +360,11 @@ RefTyDefUnretained *returnRefTyDefUnretainedAnnotatedRetained()
   return new RefTyDefUnretained();
 }
 
-struct __attribute__((swift_attr("import_reference")))
-__attribute__((swift_attr("retain:defaultRetain2")))
-__attribute__((swift_attr("release:defaultRelease2"))) 
-__attribute__((swift_attr("returned_as_retained_by_default"))) RefTyDefRetained {};
-
-RefTyDefRetained *returnRefTyDefRetained() { return new RefTyDefRetained(); }
-RefTyDefRetained *returnRefTyDefRetainedAnnotatedUnRetained()
-__attribute__((swift_attr("returns_unretained"))) {
-  return new RefTyDefRetained();
-}
-
 } // namespace FunctionAnnotationHasPrecedence
 
 void defaultRetain1(FunctionAnnotationHasPrecedence::RefTyDefUnretained *v) {};
 void defaultRelease1(FunctionAnnotationHasPrecedence::RefTyDefUnretained *v) {};
 
-void defaultRetain2(FunctionAnnotationHasPrecedence::RefTyDefRetained *v) {};
-void defaultRelease2(FunctionAnnotationHasPrecedence::RefTyDefRetained *v) {};
-
 namespace DefaultOwnershipSuppressUnannotatedAPIWarning {
 
 struct __attribute__((swift_attr("import_reference")))
@@ -402,26 +376,26 @@ RefType *returnRefType() { return new RefType(); } // expected-warning {{'return
 struct __attribute__((swift_attr("import_reference")))
 __attribute__((swift_attr("retain:dretain")))
 __attribute__((swift_attr("release:drelease"))) 
-__attribute__((swift_attr("returned_as_retained_by_default"))) RefTyDefRetained {};
+__attribute__((swift_attr("returned_as_unretained_by_default"))) RefTyDefUnretained {};
 
-RefTyDefRetained *returnRefTyDefRetained() { return new RefTyDefRetained(); }
+RefTyDefUnretained *returnRefTyDefUnretainedd() { return new RefTyDefUnretained(); }
 
 } // namespace DefaultOwnershipSuppressUnannotatedAPIWarning
 
 void rretain(DefaultOwnershipSuppressUnannotatedAPIWarning::RefType *v) {};
 void rrelease(DefaultOwnershipSuppressUnannotatedAPIWarning::RefType *v) {};
 
 void dretain(
-    DefaultOwnershipSuppressUnannotatedAPIWarning::RefTyDefRetained *v) {};
+    DefaultOwnershipSuppressUnannotatedAPIWarning::RefTyDefUnretained *v) {};
 void drelease(
-    DefaultOwnershipSuppressUnannotatedAPIWarning::RefTyDefRetained *v) {};
+    DefaultOwnershipSuppressUnannotatedAPIWarning::RefTyDefUnretained *v) {};
 
 namespace DefaultOwnershipInheritance {
 
 struct __attribute__((swift_attr("import_reference")))
 __attribute__((swift_attr("retain:baseRetain")))
 __attribute__((swift_attr("release:baseRelease")))
-__attribute__((swift_attr("returned_as_retained_by_default"))) BaseType {};
+__attribute__((swift_attr("returned_as_unretained_by_default"))) BaseType {};
 
 struct __attribute__((swift_attr("import_reference")))
 __attribute__((swift_attr("retain:derivedRetain")))
@@ -433,16 +407,9 @@ __attribute__((swift_attr("retain:derivedRetain2")))
 __attribute__((swift_attr("release:derivedRelease2"))) DerivedType2
     : public DerivedType {};
 
-struct __attribute__((swift_attr("import_reference")))
-__attribute__((swift_attr("retain:derivedRetain3")))
-__attribute__((swift_attr("release:derivedRelease3"))) 
-__attribute__((swift_attr("returned_as_unretained_by_default"))) DerivedOverride
-    : public DerivedType {};
-
-BaseType *returnBaseType() { return new BaseType(); }
-DerivedType *returnDerivedType() { return new DerivedType(); }
-DerivedType2 *returnDerivedType2() { return new DerivedType2(); }
-DerivedOverride *returnDerivedOverride() { return new DerivedOverride(); }
+BaseType *createBaseType() { return new BaseType(); }
+DerivedType *createDerivedType() { return new DerivedType(); }
+DerivedType2 *createDerivedType2() { return new DerivedType2(); }
 
 struct __attribute__((swift_attr("import_reference")))
 __attribute__((swift_attr("retain:bRetain")))
@@ -453,10 +420,15 @@ __attribute__((swift_attr("retain:dRetain")))
 __attribute__((swift_attr("release:dRelease"))) DerivedTypeNonDefault
     : public BaseTypeNonDefault {};
 
-BaseTypeNonDefault *returnBaseTypeNonDefault() { // expected-warning {{'returnBaseTypeNonDefault' should be annotated with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED as it is returning a SWIFT_SHARED_REFERENCE}}
+BaseTypeNonDefault *createBaseTypeNonDefault() { // expected-warning {{'createBaseTypeNonDefault' should be annotated with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED as it is returning a SWIFT_SHARED_REFERENCE}}
   return new BaseTypeNonDefault();
 }
-DerivedTypeNonDefault *returnDerivedTypeNonDefault() { // expected-warning {{'returnDerivedTypeNonDefault' should be annotated with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED as it is returning a SWIFT_SHARED_REFERENCE}}
+DerivedTypeNonDefault *createDerivedTypeNonDefault() { // expected-warning {{'createDerivedTypeNonDefault' should be annotated with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED as it is returning a SWIFT_SHARED_REFERENCE}}
+  return new DerivedTypeNonDefault();
+}
+
+DerivedTypeNonDefault *createDerivedTypeNonDefaultUnretained()
+    __attribute__((swift_attr("returns_unretained"))) {
   return new DerivedTypeNonDefault();
 }
 
@@ -471,9 +443,6 @@ void derivedRelease(DefaultOwnershipInheritance::DerivedType *v) {};
 void derivedRetain2(DefaultOwnershipInheritance::DerivedType2 *v) {};
 void derivedRelease2(DefaultOwnershipInheritance::DerivedType2 *v) {};
 
-void derivedRetain3(DefaultOwnershipInheritance::DerivedOverride *v) {};
-void derivedRelease3(DefaultOwnershipInheritance::DerivedOverride *v) {};
-
 void bRetain(DefaultOwnershipInheritance::BaseTypeNonDefault *v) {};
 void bRelease(DefaultOwnershipInheritance::BaseTypeNonDefault *v) {};
 

test/Interop/Cxx/foreign-reference/frt-retained-unretained-attributes-error.swift

@@ -32,10 +32,14 @@ let f = FunctionVoidToFRTStruct()
 let frt = f()
 let nonFrt = NonFRTStruct()
 let nonFrtLocalVar1 = global_function_returning_templated_retrun_frt_owned(nonFrt)
+let _ = DefaultOwnershipConventionOnCXXForeignRefType.returnRefTyDefUnretained()
+let _ = FunctionAnnotationHasPrecedence.returnRefTyDefUnretained()
+let _ = FunctionAnnotationHasPrecedence.returnRefTyDefUnretainedAnnotatedRetained()
 let _ = DefaultOwnershipSuppressUnannotatedAPIWarning.returnRefType()
-let _ = DefaultOwnershipSuppressUnannotatedAPIWarning.returnRefTyDefRetained()
-let _ = DefaultOwnershipInheritance.returnBaseType()
-let _ = DefaultOwnershipInheritance.returnDerivedType()
-let _ = DefaultOwnershipInheritance.returnDerivedType2()
-let _ = DefaultOwnershipInheritance.returnBaseTypeNonDefault()
-let _ = DefaultOwnershipInheritance.returnDerivedTypeNonDefault()
+let _ = DefaultOwnershipSuppressUnannotatedAPIWarning.returnRefTyDefUnretainedd()
+let _ = DefaultOwnershipInheritance.createBaseType()
+let _ = DefaultOwnershipInheritance.createDerivedType()
+let _ = DefaultOwnershipInheritance.createDerivedType2()
+let _ = DefaultOwnershipInheritance.createBaseTypeNonDefault()
+let _ = DefaultOwnershipInheritance.createDerivedTypeNonDefault()
+let _ = DefaultOwnershipInheritance.createDerivedTypeNonDefaultUnretained()

test/Interop/Cxx/foreign-reference/frt-retained-unretained-attributes.swift

@@ -249,9 +249,6 @@ func testVirtualMethods(base: Base, derived: Derived) {
 }
 
 func testDefaultOwnershipAnnotation() {
-  let _ = DefaultOwnershipConventionOnCXXForeignRefType.returnRefTyDefRetained()
-  // CHECK: function_ref {{.*}}returnRefTyDefRetained{{.*}} : $@convention(c) () -> @owned DefaultOwnershipConventionOnCXXForeignRefType.RefTyDefRetained
-
   let _ = DefaultOwnershipConventionOnCXXForeignRefType.returnRefTyDefUnretained()
   // CHECK: function_ref {{.*}}returnRefTyDefUnretained{{.*}} : $@convention(c) () -> DefaultOwnershipConventionOnCXXForeignRefType.RefTyDefUnretained
 
@@ -261,27 +258,21 @@ func testDefaultOwnershipAnnotation() {
   let _ = FunctionAnnotationHasPrecedence.returnRefTyDefUnretainedAnnotatedRetained()
   // CHECK: function_ref {{.*}}returnRefTyDefUnretainedAnnotatedRetained{{.*}} : $@convention(c) () -> @owned FunctionAnnotationHasPrecedence.RefTyDefUnretained
 
-  let _ = FunctionAnnotationHasPrecedence.returnRefTyDefRetained()
-  // CHECK: function_ref {{.*}}returnRefTyDefRetained{{.*}} : $@convention(c) () -> @owned FunctionAnnotationHasPrecedence.RefTyDefRetained
-
-  let _ = FunctionAnnotationHasPrecedence.returnRefTyDefRetainedAnnotatedUnRetained()
-  // CHECK: function_ref {{.*}}returnRefTyDefRetainedAnnotatedUnRetained{{.*}} : $@convention(c) () -> FunctionAnnotationHasPrecedence.RefTyDefRetained
-
-  let _ = DefaultOwnershipInheritance.returnBaseType()
-  // CHECK: function_ref {{.*}}returnBaseType{{.*}} : $@convention(c) () -> @owned DefaultOwnershipInheritance.BaseType
+  let _ = DefaultOwnershipInheritance.createBaseType()
+  // CHECK: function_ref {{.*}}createBaseType{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.BaseType
 
-  let _ = DefaultOwnershipInheritance.returnDerivedType()
-  // CHECK: function_ref {{.*}}returnDerivedType{{.*}} : $@convention(c) () -> @owned DefaultOwnershipInheritance.DerivedType
+  let _ = DefaultOwnershipInheritance.createDerivedType()
+  // CHECK: function_ref {{.*}}createDerivedType{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.DerivedType
 
-  let _ = DefaultOwnershipInheritance.returnDerivedType2()
-  // CHECK: function_ref {{.*}}returnDerivedType2{{.*}} : $@convention(c) () -> @owned DefaultOwnershipInheritance.DerivedType2
+  let _ = DefaultOwnershipInheritance.createDerivedType2()
+  // CHECK: function_ref {{.*}}createDerivedType2{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.DerivedType2
 
-  let _ = DefaultOwnershipInheritance.returnDerivedOverride()
-  // CHECK: function_ref {{.*}}returnDerivedOverride{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.DerivedOverride
+  let _ = DefaultOwnershipInheritance.createBaseTypeNonDefault()
+  // CHECK: function_ref {{.*}}createBaseTypeNonDefault{{.*}} : $@convention(c) () -> @owned DefaultOwnershipInheritance.BaseTypeNonDefault
 
-  let _ = DefaultOwnershipInheritance.returnBaseTypeNonDefault()
-  // CHECK: function_ref {{.*}}returnBaseTypeNonDefault{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.BaseTypeNonDefault
+  let _ = DefaultOwnershipInheritance.createDerivedTypeNonDefault()
+  // CHECK: function_ref {{.*}}createDerivedTypeNonDefault{{.*}} : $@convention(c) () -> @owned DefaultOwnershipInheritance.DerivedTypeNonDefault
 
-  let _ = DefaultOwnershipInheritance.returnDerivedTypeNonDefault()
-  // CHECK: function_ref {{.*}}returnDerivedTypeNonDefault{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.DerivedTypeNonDefault
+  let _ = DefaultOwnershipInheritance.createDerivedTypeNonDefaultUnretained()
+  // CHECK: function_ref {{.*}}createDerivedTypeNonDefaultUnretained{{.*}} : $@convention(c) () -> DefaultOwnershipInheritance.DerivedTypeNonDefault
 }