Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/ClangImporter/ClangImporter.h

@@ -832,17 +832,24 @@ std::optional<T> matchSwiftAttrConsideringInheritance(
 /// Matches a `swift_attr("...")` on the record type pointed to by the given
 /// Clang type, searching base classes if it's a C++ class.
 ///
-/// \param type A Clang pointer type.
+/// \param type A Clang pointer or reference type.
 /// \param patterns List of attribute name-value pairs to match.
 /// \returns Matched value or std::nullopt.
 template <typename T>
 std::optional<T> matchSwiftAttrOnRecordPtr(
     const clang::QualType &type,
     llvm::ArrayRef<std::pair<llvm::StringRef, T>> patterns) {
+  clang::QualType pointeeType;
   if (const auto *ptrType = type->getAs<clang::PointerType>()) {
-    if (const auto *recordDecl = ptrType->getPointeeType()->getAsRecordDecl()) {
-      return matchSwiftAttrConsideringInheritance<T>(recordDecl, patterns);
-    }
+    pointeeType = ptrType->getPointeeType();
+  } else if (const auto *refType = type->getAs<clang::ReferenceType>()) {
+    pointeeType = refType->getPointeeType();
+  } else {
+    return std::nullopt;
+  }
+
+  if (const auto *recordDecl = pointeeType->getAsRecordDecl()) {
+    return matchSwiftAttrConsideringInheritance<T>(recordDecl, patterns);
   }
   return std::nullopt;
 }

lib/IRGen/GenReflection.cpp

@@ -315,9 +315,8 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
 // where completing the metadata during demangling might cause cyclic
 // dependencies.
 static std::pair<llvm::Constant *, unsigned>
-getTypeRefByFunction(IRGenModule &IGM,
-                     CanGenericSignature sig,
-                     CanType t) {
+getTypeRefByFunction(IRGenModule &IGM, CanGenericSignature sig, CanType t,
+                     MangledTypeRefRole role) {
   IRGenMangler mangler(IGM.Context);
   std::string symbolName =
     mangler.mangleSymbolNameForMangledMetadataAccessorString(
@@ -433,7 +432,11 @@ getTypeRefByFunction(IRGenModule &IGM,
       // Form the mangled name with its relative reference.
       auto S = B.beginStruct();
       S.setPacked(true);
-      S.add(llvm::ConstantInt::get(IGM.Int8Ty, 255));
+      if (role == MangledTypeRefRole::DefaultAssociatedTypeWitness) {
+        S.add(llvm::ConstantInt::get(
+            IGM.Int8Ty,
+            ProtocolRequirementFlags::AssociatedTypeInProtocolContextByte));
+      }
       S.add(llvm::ConstantInt::get(IGM.Int8Ty, 9));
       S.addCompactFunctionReference(accessor);
 
@@ -513,7 +516,7 @@ getTypeRefImpl(IRGenModule &IGM,
     // the field will be artificially hidden to reflectors.
     if (isAlwaysNoncopyable) {
       IGM.IRGen.noteUseOfTypeMetadata(type);
-      return getTypeRefByFunction(IGM, sig, type);
+      return getTypeRefByFunction(IGM, sig, type, role);
     }
   }
   LLVM_FALLTHROUGH;
@@ -524,12 +527,12 @@ getTypeRefImpl(IRGenModule &IGM,
     // ensuring that we can always reconstruct type metadata from a mangled name
     // in-process.
     IGM.IRGen.noteUseOfTypeMetadata(type);
-    
+
     // If the minimum deployment target's runtime demangler wouldn't understand
     // this mangled name, then fall back to generating a "mangled name" with a
     // symbolic reference with a callback function.
     if (mangledNameIsUnknownToDeployTarget(IGM, type)) {
-      return getTypeRefByFunction(IGM, sig, type);
+      return getTypeRefByFunction(IGM, sig, type, role);
     }
 
     break;

test/IRGen/Inputs/associated_type_by_mangled_name.swift

@@ -0,0 +1,21 @@
+public protocol Proto {
+    associatedtype T: Proto
+
+    var value: T {get}
+}
+
+public func makeThing<P: Proto>(_ t: P) -> some Proto {
+    return ProtoImpl(t.value)
+}
+
+public struct ProtoImpl<V>: Proto {
+    public let genValue: V
+
+    public init(_ genValue: V) {
+        self.genValue = genValue
+    }
+
+    public var value: some Proto {
+        return self
+    }
+}

test/IRGen/nonisolated_nonsending_closure.swift

@@ -0,0 +1,55 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-build-swift-dylib(%t/%target-library-name(associated_type_by_mangled_name)) -target %target-cpu-apple-macosx15.0 -enable-library-evolution %S/Inputs/associated_type_by_mangled_name.swift -emit-module -emit-module-path %t/associated_type_by_mangled_name.swiftmodule -module-name associated_type_by_mangled_name
+// RUN: %target-codesign %t/%target-library-name(associated_type_by_mangled_name)
+
+// RUN: %target-swift-frontend -target %target-cpu-apple-macosx15.0 -I %t %s -emit-ir -o - | %FileCheck %s
+// RUN: %target-swift-frontend -target %target-cpu-apple-macosx26.0 -I %t %s -emit-ir -o - | %FileCheck %s -check-prefix CHECK-SUPPORTED
+
+// RUN: %target-build-swift -target %target-cpu-apple-macosx15.0 %s -lassociated_type_by_mangled_name -I %t -L %t -o %t/main15 %target-rpath(%t)
+// RUN: %target-codesign %t/main15
+
+// RUN: %target-run %t/main15 %t/%target-library-name(associated_type_by_mangled_name)
+
+// RUN: %target-build-swift -target %target-cpu-apple-macosx26.0 %s -lassociated_type_by_mangled_name -I %t -L %t -o %t/main26 %target-rpath(%t)
+// RUN: %target-codesign %t/main26
+
+// RUN: %target-run %t/main26 %t/%target-library-name(associated_type_by_mangled_name)
+
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx
+// UNSUPPORTED: back_deployment_runtime || use_os_stdlib
+
+import associated_type_by_mangled_name
+
+protocol P: Sendable {
+    associatedtype T: Proto
+    func foo() -> T
+}
+
+struct PImpl: P {
+  func foo() -> some Proto {
+    return ProtoImpl(2)
+  }
+}
+
+// CHECK: @"get_type_metadata 30nonisolated_nonsending_closure1PRzl31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcG.3" = linkonce_odr hidden constant <{ i8, i32, i8 }> <{ i8 9, i32 trunc (i64 sub (i64 ptrtoint (ptr @"get_type_metadata 30nonisolated_nonsending_closure1PRzl31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcG" to i64), i64 ptrtoint (ptr getelementptr inbounds (<{ i8, i32, i8 }>, ptr @"get_type_metadata 30nonisolated_nonsending_closure1PRzl31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcG.3", i32 0, i32 1) to i64)) to i32), i8 0 }>
+// CHECK: define linkonce_odr hidden ptr @"$s31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcGACyxGAA0F0AAWl"() #1 {
+// CHECK:   call swiftcc %swift.metadata_response @"$s31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcGMa"(i64 255)
+// CHECK: }
+
+// CHECK-SUPPORTED-NOT: @"get_type_metadata 30nonisolated_nonsending_closure1PRzl31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcG.3"
+// CHECK-SUPPORTED: define linkonce_odr hidden ptr @"$s31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcGACyxGAA0F0AAWl"() #1 {
+// CHECK-SUPPORTED:   call ptr @__swift_instantiateConcreteTypeFromMangledNameAbstract(ptr @"$s31associated_type_by_mangled_name9ProtoImplVyySiYaKYCcGMD")
+// CHECK-SUPPORTED: }
+struct MyStruct<T: P>: Proto {
+  typealias Closure = nonisolated(nonsending) (Int) async throws -> Void
+
+  let x: T
+
+  public var value: some Proto {
+    return ProtoImpl<Closure> { _ in }
+  }
+}
+
+print(makeThing(MyStruct(x: PImpl())))

test/Interop/Cxx/foreign-reference/Inputs/frt-reference-returns.h

@@ -0,0 +1,71 @@
+#pragma once
+
+namespace NoAnnotations {
+
+struct RefCountedType {
+  int value;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retainRefCounted")))
+__attribute__((swift_attr("release:releaseRefCounted")));
+
+RefCountedType& getRefCountedByRef(); // expected-note {{'getRefCountedByRef()' is defined here}}
+RefCountedType& createRefCountedByRef(); // expected-note {{'createRefCountedByRef()' is defined here}}
+RefCountedType& copyRefCountedByRef(); // expected-note {{'copyRefCountedByRef()' is defined here}}   
+
+} // namespace NoAnnotations
+
+void retainRefCounted(NoAnnotations::RefCountedType* obj);
+void releaseRefCounted(NoAnnotations::RefCountedType* obj);
+
+namespace APIAnnotations {
+
+struct RefCountedType {
+  int value;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retainAPIRefCounted")))
+__attribute__((swift_attr("release:releaseAPIRefCounted")));
+
+RefCountedType& createByRef() __attribute__((swift_attr("returns_retained")));
+RefCountedType& getByRef() __attribute__((swift_attr("returns_unretained")));
+
+
+} // namespace APIAnnotations
+
+void retainAPIRefCounted(APIAnnotations::RefCountedType* obj);
+void releaseAPIRefCounted(APIAnnotations::RefCountedType* obj);
+
+namespace TypeAnnotation {
+
+struct RefCountedType {
+  int value;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retainTypeRefCounted")))
+__attribute__((swift_attr("release:releaseTypeRefCounted")))
+__attribute__((swift_attr("returned_as_unretained_by_default")));
+
+RefCountedType& getByRef();
+RefCountedType& createByRef();
+RefCountedType& copyByRef();
+
+} // namespace TypeAnnotation
+
+void retainTypeRefCounted(TypeAnnotation::RefCountedType* obj);
+void releaseTypeRefCounted(TypeAnnotation::RefCountedType* obj);
+
+namespace BothAnnotations {
+
+struct RefCountedType {
+  int value;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retainBothRefCounted")))
+__attribute__((swift_attr("release:releaseBothRefCounted")))
+__attribute__((swift_attr("returned_as_unretained_by_default")));
+
+// Note: Type default at type level is unretained, but API annotation overrides
+RefCountedType& createByRef() __attribute__((swift_attr("returns_retained")));
+RefCountedType& getByRef();
+
+} // namespace BothAnnotations
+
+void retainBothRefCounted(BothAnnotations::RefCountedType* obj);
+void releaseBothRefCounted(BothAnnotations::RefCountedType* obj);

test/Interop/Cxx/foreign-reference/Inputs/module.modulemap

@@ -87,3 +87,8 @@ module LoggingFrts {
     header "logging-frts.h"
     requires cplusplus
 }
+
+module FRTReferenceReturns {
+  header "frt-reference-returns.h"
+  requires cplusplus
+}

test/Interop/Cxx/foreign-reference/frt-reference-returns-diagnostics.swift

@@ -0,0 +1,31 @@
+// RUN: rm -rf %t
+// RUN: %target-typecheck-verify-swift -I %S%{fs-sep}Inputs -cxx-interoperability-mode=default -enable-experimental-feature WarnUnannotatedReturnOfCxxFrt -verify-additional-file %S%{fs-sep}Inputs%{fs-sep}frt-reference-returns.h
+
+// REQUIRES: swift_feature_WarnUnannotatedReturnOfCxxFrt
+
+import FRTReferenceReturns
+
+func testNoAnnotations() {
+  let _ = NoAnnotations.getRefCountedByRef()
+  // expected-warning@-1 {{cannot infer the ownership of the returned value, annotate 'getRefCountedByRef()' with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED}}
+  let _ = NoAnnotations.createRefCountedByRef()
+  // expected-warning@-1 {{cannot infer the ownership of the returned value, annotate 'createRefCountedByRef()' with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED}}
+  let _ = NoAnnotations.copyRefCountedByRef()
+  // expected-warning@-1 {{cannot infer the ownership of the returned value, annotate 'copyRefCountedByRef()' with either SWIFT_RETURNS_RETAINED or SWIFT_RETURNS_UNRETAINED}}
+}
+
+func testAPIAnnotations() {
+  let _ = APIAnnotations.createByRef()
+  let _ = APIAnnotations.getByRef()
+}
+
+func testTypeAnnotation() {
+  let _ = TypeAnnotation.getByRef()
+  let _ = TypeAnnotation.createByRef()
+  let _ = TypeAnnotation.copyByRef()
+}
+
+func testBothAnnotations() {
+  let _ = BothAnnotations.createByRef() 
+  let _ = BothAnnotations.getByRef()
+}

test/Interop/Cxx/foreign-reference/frt-reference-returns-sil.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-emit-sil -I %S/Inputs -cxx-interoperability-mode=default -disable-availability-checking -diagnostic-style llvm %s -validate-tbd-against-ir=none -Xcc -fignore-exceptions | %FileCheck %s
+
+import FRTReferenceReturns
+
+// Test that the ownership annotations work correctly for reference returns
+
+func useAll() {
+  let _ = NoAnnotations.getRefCountedByRef()
+  // CHECK: sil [clang NoAnnotations.getRefCountedByRef] @{{.*}} : $@convention(c) () -> NoAnnotations.RefCountedType
+  // Note: create/copy rule (default without ownership annotations) does not apply if return type is & to frt
+  let _ = NoAnnotations.createRefCountedByRef()
+  // CHECK: sil [clang NoAnnotations.createRefCountedByRef] @{{.*}} : $@convention(c) () -> NoAnnotations.RefCountedType
+  let _ = NoAnnotations.copyRefCountedByRef()
+  // CHECK: sil [clang NoAnnotations.copyRefCountedByRef] @{{.*}} : $@convention(c) () -> NoAnnotations.RefCountedType
+
+  // APIAnnotations - explicit ownership
+  let _ = APIAnnotations.createByRef()
+  // CHECK: sil [clang APIAnnotations.createByRef] @{{.*}} : $@convention(c) () -> @owned APIAnnotations.RefCountedType
+  let _ = APIAnnotations.getByRef()
+  // CHECK: sil [clang APIAnnotations.getByRef] @{{.*}} : $@convention(c) () -> APIAnnotations.RefCountedType
+
+  // TypeAnnotation - all unretained due to type default
+  let _ = TypeAnnotation.getByRef()
+  // CHECK: sil [clang TypeAnnotation.getByRef] @{{.*}} : $@convention(c) () -> TypeAnnotation.RefCountedType
+  let _ = TypeAnnotation.createByRef()
+  // CHECK: sil [clang TypeAnnotation.createByRef] @{{.*}} : $@convention(c) () -> TypeAnnotation.RefCountedType
+  let _ = TypeAnnotation.copyByRef()
+  // CHECK: sil [clang TypeAnnotation.copyByRef] @{{.*}} : $@convention(c) () -> TypeAnnotation.RefCountedType
+
+  // BothAnnotations - API overrides type
+  let _ = BothAnnotations.createByRef()
+  // CHECK: sil [clang BothAnnotations.createByRef] @{{.*}} : $@convention(c) () -> @owned BothAnnotations.RefCountedType
+  let _ = BothAnnotations.getByRef()
+  // CHECK: sil [clang BothAnnotations.getByRef] @{{.*}} : $@convention(c) () -> BothAnnotations.RefCountedType
+}