[Swiftify] Update availability for CxxSpan<->Span, ignore lifetimebound

on parameters with reference type

Because swift-ide-test doesn't care about typechecking,
std-span-interface.swift passed despite containing 2 separate errors.
This updates the test file to properly exercise the entire compilation
pipeline for the macro expansions, by running swift-frontend
-emit-module and calling each macro expansion.

The first issue was that CxxSpan initializers taking [Mutable]Span still
had their availability set to Swift 6.2+, even after back-deploying
caused [Mutable]Span to have availability back to Swift 5.0. Since
_SwiftifyImport expansions copy the availbility of Span, this resulted
in the macro expansions calling unavailable initializers.
Interestingly enough, this manifested itself in the form of a tripped
assert in SIL verification, because although we do now typecheck the
expansions from _SwiftifyImport, the compilation can still keep going
after `shouldEmitFunctionBody` returns false: the macro expansion
declaration is still there, but is now missing its definition, despite
not being external.

The second issue was when parameters with C++ reference types were
annotated with `[[clang::lifetimebound]]`. C++ reference parameters are
imported as `inout`, but lifetimebound results in the macro expansion
having a lifetime dependence on the parameter. For parameters with a
type that is `Escapable`, this is done using `@lifetime(borrow foo)`.
However, you can't borrow an inout paramter. For parameters with a type
that is `~Escapable` it's done using `@lifetime(copy foo)`, which works
with inout. When the parameter is `inout Escapable` however, neither
annotation works. Because of this we now ignore lifetimebound on
parameters with an `Escapable` type when they are imported as inout.

rdar://151493400
rdar://151678415

Author: hnrklssn

lib/ClangImporter/ImportDecl.cpp

@@ -9268,11 +9268,16 @@ void ClangImporter::Implementation::swiftify(FuncDecl *MappedDecl) {
         paramHasLifetimeInfo = true;
       }
       if (clangParam->hasAttr<clang::LifetimeBoundAttr>()) {
-        printer.printLifetimeboundReturn(
-            index, !paramHasBoundsInfo &&
-                       swiftParamTy->isEscapable());
-        paramHasLifetimeInfo = true;
-        returnHasLifetimeInfo = true;
+        // If this parameter has bounds info we will tranform it into a Span,
+        // so then it will no longer be Escapable.
+        bool willBeEscapable = swiftParamTy->isEscapable() && !paramHasBoundsInfo;
+        // We can't borrow the lifetime of an inout parameter,
+        // but we can't copy the lifetime of an Escapable type. Simply ignore.
+        if (!willBeEscapable || !swiftParam->isInOut()) {
+          printer.printLifetimeboundReturn(index, willBeEscapable);
+          paramHasLifetimeInfo = true;
+          returnHasLifetimeInfo = true;
+        }
       }
       if (paramIsStdSpan && paramHasLifetimeInfo)
         attachMacro = true;

stdlib/public/Cxx/CxxSpan.swift

@@ -88,7 +88,7 @@ extension CxxSpan {
     unsafe self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
   }
 
-  @available(SwiftStdlib 6.2, *)
+  @available(SwiftCompatibilitySpan 5.0, *)
   @inlinable
   @unsafe
   public init(_ span: Span<Element>) {
@@ -99,7 +99,7 @@ extension CxxSpan {
   }
 }
 
-@available(SwiftStdlib 6.2, *)
+@available(SwiftCompatibilitySpan 5.0, *)
 extension Span {
   @_alwaysEmitIntoClient
   @unsafe
@@ -115,7 +115,7 @@ extension Span {
   }
 }
 
-@available(SwiftStdlib 6.2, *)
+@available(SwiftCompatibilitySpan 5.0, *)
 extension MutableSpan {
   @_alwaysEmitIntoClient
   @unsafe
@@ -151,7 +151,7 @@ extension CxxMutableSpan {
     unsafe self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
   }
 
-  @available(SwiftStdlib 6.2, *)
+  @available(SwiftCompatibilitySpan 5.0, *)
   @inlinable
   @unsafe
   public init(_ span: consuming MutableSpan<Element>) {

test/Interop/Cxx/stdlib/std-span-interface.swift

@@ -2,7 +2,11 @@
 // RUN: %target-swift-ide-test -plugin-path %swift-plugin-dir -I %S/Inputs -enable-experimental-feature SafeInteropWrappers -print-module -module-to-print=StdSpan -source-filename=x -enable-experimental-cxx-interop -Xcc -std=c++20 -module-cache-path %t > %t/interface.swift
 // RUN: %FileCheck %s < %t/interface.swift
 
+// Make sure we trigger typechecking and SIL diagnostics
+// RUN: %target-swift-frontend -emit-module -plugin-path %swift-plugin-dir -I %S/Inputs -enable-experimental-feature SafeInteropWrappers -enable-experimental-feature LifetimeDependence -cxx-interoperability-mode=default -strict-memory-safety -warnings-as-errors -Xcc -std=c++20 %s
+
 // REQUIRES: swift_feature_SafeInteropWrappers
+// REQUIRES: swift_feature_LifetimeDependence
 
 // FIXME swift-ci linux tests do not support std::span
 // UNSUPPORTED: OS=linux-gnu, OS=linux-android, OS=linux-androideabi
@@ -46,15 +50,10 @@ import CxxStdlib
 // CHECK-NEXT: @lifetime(s: copy s)
 // CHECK-NEXT: @_alwaysEmitIntoClient public func FuncWithMutableSafeWrapper2(_ s: inout MutableSpan<CInt>) -> MutableSpan<CInt>
 // CHECK-NEXT: @available(visionOS 1.1, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *)
-// CHECK-NEXT: @lifetime(borrow v)
-// CHECK-NEXT: @_alwaysEmitIntoClient @_disfavoredOverload public func FuncWithMutableSafeWrapper3(_ v: inout VecOfInt) -> MutableSpan<CInt>
-// CHECK-NEXT: @available(visionOS 1.1, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *)
 // CHECK-NEXT: @lifetime(copy p)
 // CHECK-NEXT: @lifetime(p: copy p)
 // CHECK-NEXT: @_alwaysEmitIntoClient public func MixedFuncWithMutableSafeWrapper1(_ p: inout MutableSpan<Int32>) -> MutableSpan<CInt>
-// CHECK-NEXT: @available(visionOS 1.1, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *)
-// CHECK-NEXT: @lifetime(borrow v)
-// CHECK-NEXT: @_alwaysEmitIntoClient @_disfavoredOverload public func MixedFuncWithMutableSafeWrapper2(_ v: inout VecOfInt, _ len: Int32) -> MutableSpan<Int32>
+// CHECK-NEXT: @_alwaysEmitIntoClient @_disfavoredOverload public func MixedFuncWithMutableSafeWrapper2(_ v: inout VecOfInt, _ len: Int32) -> UnsafeMutableBufferPointer<Int32>
 // CHECK-NEXT: @available(visionOS 1.1, tvOS 12.2, watchOS 5.2, iOS 12.2, macOS 10.14.4, *)
 // CHECK-NEXT: @lifetime(s: copy s)
 // CHECK-NEXT: @_alwaysEmitIntoClient public func MixedFuncWithMutableSafeWrapper3(_ s: inout MutableSpan<CInt>, _ p: UnsafeMutableBufferPointer<Int32>)
@@ -90,3 +89,96 @@ import CxxStdlib
 // CHECK-NEXT: @_alwaysEmitIntoClient public func mixedFuncWithSafeWrapper5(_ s: ConstSpanOfInt, _ p: Span<Int32>)
 // CHECK-NEXT: @_alwaysEmitIntoClient public func mixedFuncWithSafeWrapper6(_ s: ConstSpanOfInt, _ p: UnsafeMutableBufferPointer<Int32>)
 // CHECK-NEXT: @_alwaysEmitIntoClient public func mixedFuncWithSafeWrapper7(_ p: UnsafeBufferPointer<Int32>) -> ConstSpanOfInt
+
+func callMethodWithSafeWrapper(_ x: inout X, s: Span<CInt>) {
+    x.methodWithSafeWrapper(s)
+}
+
+func callFooBar(_ x: inout SpanWithoutTypeAlias, _ s: ConstSpanOfInt) {
+    let _: Span<CInt> = x.bar()
+    unsafe x.foo(s)
+}
+
+@lifetime(span: copy span)
+func callFuncWithMutableSafeWrapper(_ span: inout MutableSpan<CInt>, ) {
+    FuncWithMutableSafeWrapper(&span)
+}
+
+@lifetime(span: copy span)
+func callFuncWithMutableSafeWrapper2(_ span: inout MutableSpan<CInt>, ) {
+    let _: MutableSpan<CInt> = FuncWithMutableSafeWrapper2(&span)
+}
+
+@lifetime(span: copy span)
+func callMixedFuncWithMutableSafeWrapper1(_ span: inout MutableSpan<CInt>, ) {
+    let _: MutableSpan<CInt> = MixedFuncWithMutableSafeWrapper1(&span)
+}
+
+func MixedFuncWithMutableSafeWrapper2(_ v: VecOfInt) {
+    var v2 = v
+    let _ = MixedFuncWithMutableSafeWrapper2(&v2, 37)
+}
+
+@lifetime(span: copy span)
+func callMixedFuncWithMutableSafeWrapper3(_ span: inout MutableSpan<CInt>, _ p: UnsafeMutableBufferPointer<CInt>) {
+    unsafe MixedFuncWithMutableSafeWrapper3(&span, p)
+}
+
+@lifetime(span1: copy span2)
+@lifetime(span2: copy span2)
+func callMixedFuncWithMutableSafeWrapper4(_ span1: inout MutableSpan<CInt>, _ span2: inout MutableSpan<CInt>) {
+    MixedFuncWithMutableSafeWrapper4(&span1, &span2)
+}
+
+@lifetime(span: copy span)
+func callMixedFuncWithMutableSafeWrapper5(_ span: inout MutableSpan<CInt>, _ s: SpanOfInt) {
+    unsafe MixedFuncWithMutableSafeWrapper5(s, &span)
+}
+
+func callMixedFuncWithMutableSafeWrapper6(_ s: SpanOfInt, _ p: UnsafeMutableBufferPointer<CInt>) {
+    unsafe MixedFuncWithMutableSafeWrapper6(s, p)
+}
+
+func callMixedFuncWithMutableSafeWrapper7(_ p: UnsafeMutableBufferPointer<CInt>) {
+    let _ = unsafe MixedFuncWithMutableSafeWrapper7(p)
+}
+
+func callFuncWithSafeWrapper(_ s: Span<CInt>) {
+    funcWithSafeWrapper(s)
+}
+
+func callFuncWithSafeWrapper2(_ s: Span<CInt>) {
+    let _ = funcWithSafeWrapper2(s)
+}
+
+func callFuncWithSafeWrapper3(_ v: borrowing VecOfInt) {
+    let _: Span<CInt> = funcWithSafeWrapper3(v)
+}
+
+func callMixedFuncWithSafeWrapper1(_ s: Span<CInt>) {
+    let _: Span<CInt> = mixedFuncWithSafeWrapper1(s)
+}
+
+func callMixedFuncWithSafeWrapper2(_ v: borrowing VecOfInt) {
+    let _: Span<CInt> = mixedFuncWithSafeWrapper2(v, 73)
+}
+
+func callMixedFuncWithSafeWrapper3(_ s: Span<CInt>, _ p: UnsafeMutableBufferPointer<CInt>) {
+    unsafe mixedFuncWithSafeWrapper3(s, p)
+}
+
+func callMixedFuncWithSafeWrapper4(_ s: Span<CInt>, _ s2: Span<CInt>) {
+    mixedFuncWithSafeWrapper4(s, s2)
+}
+
+func callMixedFuncWithSafeWrapper5(_ s: ConstSpanOfInt, _ s2: Span<CInt>) {
+    unsafe mixedFuncWithSafeWrapper5(s, s2)
+}
+
+func callMixedFuncWithSafeWrapper6(_ s: ConstSpanOfInt, _ p: UnsafeMutableBufferPointer<CInt>) {
+    unsafe mixedFuncWithSafeWrapper6(s, p)
+}
+
+func callMixedFuncWithSafeWrapper7(_ p: UnsafeBufferPointer<CInt>) {
+    let _: ConstSpanOfInt = unsafe mixedFuncWithSafeWrapper7(p)
+}