Merge branch 'release/6.2' into pick-task-names-update

Author: ktoso

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -53,7 +53,7 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
     }
   }
   for instruction in function.instructions {
-    if let markDep = instruction as? MarkDependenceInst, markDep.isUnresolved {
+    if let markDep = instruction as? MarkDependenceInstruction, markDep.isUnresolved {
       if let lifetimeDep = LifetimeDependence(markDep, context) {
         if analyze(dependence: lifetimeDep, context) {
           // Note: This promotes the mark_dependence flag but does not invalidate analyses; preserving analyses is good,
@@ -202,12 +202,29 @@ private struct DiagnoseDependence {
     // Check that the parameter dependence for this result is the same
     // as the current dependence scope.
     if let arg = dependence.scope.parentValue as? FunctionArgument,
-       function.argumentConventions[resultDependsOn: arg.index] != nil {
-      // The returned value depends on a lifetime that is inherited or
-      // borrowed in the caller. The lifetime of the argument value
-      // itself is irrelevant here.
-      log("  has dependent function result")
-      return .continueWalk
+       let argDep = function.argumentConventions[resultDependsOn: arg.index] {
+      switch argDep {
+      case .inherit:
+        if dependence.markDepInst != nil {
+          // A mark_dependence represents a "borrow" scope. A local borrow scope cannot inherit the caller's dependence
+          // because the borrow scope depends on the argument value itself, while the caller allows the result to depend
+          // on a value that the argument was copied from.
+          break
+        }
+        fallthrough
+      case .scope:
+        // The returned value depends on a lifetime that is inherited or
+        // borrowed in the caller. The lifetime of the argument value
+        // itself is irrelevant here.
+        log("  has dependent function result")
+        return .continueWalk
+      }
+      // Briefly (April 2025), RawSpan._extracting, Span._extracting, and UTF8Span.span returned a borrowed value that
+      // depended on a copied argument. Continue to support those interfaces. The implementations were correct but
+      // needed an explicit _overrideLifetime.
+      if let sourceFileKind = dependence.function.sourceFileKind, sourceFileKind == .interface {
+        return .continueWalk
+      }
     }
     return .abortWalk
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -119,7 +119,10 @@ let lifetimeDependenceScopeFixupPass = FunctionPass(
     // Recursively sink enclosing end_access, end_borrow, end_apply, and destroy_value. If the scope can be extended
     // into the caller, return the function arguments that are the dependency sources.
     var scopeExtension = ScopeExtension(localReachabilityCache, context)
-    let args = scopeExtension.extendScopes(dependence: newLifetimeDep)
+    guard scopeExtension.extendScopes(dependence: newLifetimeDep) else {
+      continue
+    }
+    let args = scopeExtension.findArgumentDependencies()
 
     // Redirect the dependence base to the function arguments. This may create additional mark_dependence instructions.
     markDep.redirectFunctionReturn(to: args, context)
@@ -246,28 +249,25 @@ private struct ScopeExtension {
 // `mark_dependence` to the outer access `%0`. This ensures that exclusivity diagnostics correctly reports the
 // violation, and that subsequent optimizations do not shrink the inner access `%a1`.
 extension ScopeExtension {
-  mutating func extendScopes(dependence: LifetimeDependence) -> SingleInlineArray<FunctionArgument> {
+  mutating func extendScopes(dependence: LifetimeDependence) -> Bool {
     log("Scope fixup for lifetime dependent instructions: \(dependence)")
 
     gatherExtensions(dependence: dependence)
 
-    let noCallerScope = SingleInlineArray<FunctionArgument>()
-
     // computeDependentUseRange initializes scopeExtension.dependsOnCaller.
     guard var useRange = computeDependentUseRange(of: dependence) else {
-      return noCallerScope
+      return false
     }
     // tryExtendScopes deinitializes 'useRange'
     var scopesToExtend = SingleInlineArray<ExtendableScope>()
     guard canExtendScopes(over: &useRange, scopesToExtend: &scopesToExtend) else {
       useRange.deinitialize()
-      return noCallerScope
+      return false
     }
     // extend(over:) must receive the original unmodified `useRange`, without intermediate scope ending instructions.
     // This deinitializes `useRange` before erasing instructions.
     extend(scopesToExtend: scopesToExtend, over: &useRange, context)
-
-    return dependsOnArgs
+    return true
   }
 }
 
@@ -448,10 +448,15 @@ extension ScopeExtension {
 }
 
 extension ScopeExtension {
-  /// Return all scope owners as long as they are all function arguments and all nested accesses are compatible with
-  /// their argument convention. Then, if all nested accesses were extended to the return statement, it is valid to
-  /// logically combine them into a single access for the purpose of diagnostic lifetime dependence.
-  var dependsOnArgs: SingleInlineArray<FunctionArgument> {
+  /// Check if the dependent value depends only on function arguments and can therefore be returned to caller. If so,
+  /// return the list of arguments that it depends on. If this returns an empty list, then the dependent value cannot be
+  /// returned.
+  ///
+  /// The conditions for returning a dependent value are:
+  /// - The dependent value is returned from this function.
+  /// - All nested scopes are access scopes that are redundant with the caller's exclusive access scope.
+  /// - All scope owners are function arguments.
+  func findArgumentDependencies() -> SingleInlineArray<FunctionArgument> {
     let noCallerScope = SingleInlineArray<FunctionArgument>()
     // Check that the dependent value is returned by this function.
     if !dependsOnCaller! {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -161,7 +161,7 @@ extension LifetimeDependence {
 
   // Construct a LifetimeDependence from a return value. This only
   // constructs a dependence for ~Escapable results that do not have a
-  // lifetime dependence (@_unsafeNonescapableResult).
+  // lifetime dependence (@lifetime(immortal), @_unsafeNonescapableResult).
   //
   // This is necessary because inserting a mark_dependence placeholder for such an unsafe dependence would illegally
   // have the same base and value operand.

lib/AST/LifetimeDependence.cpp

@@ -790,7 +790,8 @@ class LifetimeDependenceChecker {
         auto immortalParam =
           std::find_if(afd->getParameters()->begin(),
                        afd->getParameters()->end(), [](ParamDecl *param) {
-                         return strcmp(param->getName().get(), "immortal") == 0;
+                         return param->getName().nonempty()
+                           && strcmp(param->getName().get(), "immortal") == 0;
                        });
         if (immortalParam != afd->getParameters()->end()) {
           diagnose(*immortalParam,

stdlib/public/core/Span/RawSpan.swift

@@ -711,7 +711,8 @@ extension RawSpan {
   public func _extracting(first maxLength: Int) -> Self {
     _precondition(maxLength >= 0, "Can't have a prefix of negative length")
     let newCount = min(maxLength, byteCount)
-    return unsafe Self(_unchecked: _pointer, byteCount: newCount)
+    let newSpan = unsafe Self(_unchecked: _pointer, byteCount: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
   }
 
   /// Returns a span over all but the given number of trailing bytes.
@@ -734,7 +735,8 @@ extension RawSpan {
     _precondition(k >= 0, "Can't drop a negative number of bytes")
     let droppedCount = min(k, byteCount)
     let count = byteCount &- droppedCount
-    return unsafe Self(_unchecked: _pointer, byteCount: count)
+    let newSpan = unsafe Self(_unchecked: _pointer, byteCount: count)
+    return unsafe _overrideLifetime(newSpan, copying: self)
   }
 
   /// Returns a span containing the trailing bytes of the span,

stdlib/public/core/Span/Span.swift

@@ -764,7 +764,8 @@ extension Span where Element: ~Copyable {
   public func _extracting(first maxLength: Int) -> Self {
     _precondition(maxLength >= 0, "Can't have a prefix of negative length")
     let newCount = min(maxLength, count)
-    return unsafe Self(_unchecked: _pointer, count: newCount)
+    let newSpan = unsafe Self(_unchecked: _pointer, count: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
   }
 
   /// Returns a span over all but the given number of trailing elements.
@@ -786,7 +787,8 @@ extension Span where Element: ~Copyable {
   public func _extracting(droppingLast k: Int) -> Self {
     _precondition(k >= 0, "Can't drop a negative number of elements")
     let droppedCount = min(k, count)
-    return unsafe Self(_unchecked: _pointer, count: count &- droppedCount)
+    let newSpan = unsafe Self(_unchecked: _pointer, count: count &- droppedCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
   }
 
   /// Returns a span containing the final elements of the span,

stdlib/public/core/UTF8Span.swift

@@ -181,7 +181,8 @@ extension UTF8Span {
   public var span: Span<UInt8> {
     @lifetime(copy self)
     get {
-      unsafe Span(_unchecked: _unsafeBaseAddress, count: self.count)
+      let newSpan = unsafe Span<UInt8>(_unchecked: _unsafeBaseAddress, count: self.count)
+      return unsafe _overrideLifetime(newSpan, copying: self)
     }
   }
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -2907,25 +2907,6 @@ static NodePointer getParameterList(NodePointer funcType) {
   return parameterContainer;
 }
 
-static const Metadata *decodeType(TypeDecoder<DecodedMetadataBuilder> &decoder,
-                                  NodePointer type) {
-  assert(type->getKind() == Node::Kind::Type);
-
-  auto builtTypeOrError = decoder.decodeMangledType(type);
-
-  if (builtTypeOrError.isError()) {
-    auto err = builtTypeOrError.getError();
-    char *errStr = err->copyErrorString();
-    err->freeErrorString(errStr);
-    return nullptr;
-  }
-
-  if (!builtTypeOrError.getType().isMetadata())
-    return nullptr;
-
-  return builtTypeOrError.getType().getMetadata();
-}
-
 SWIFT_CC(swift)
 SWIFT_RUNTIME_STDLIB_SPI
 unsigned swift_func_getParameterCount(const char *typeNameStart,
@@ -3009,8 +2990,21 @@ swift_func_getParameterTypeInfo(
 
   SubstGenericParametersFromMetadata substFn(genericEnv, genericArguments);
 
-  DecodedMetadataBuilder builder(
-      demangler,
+  // for each parameter (TupleElement), store it into the provided buffer
+  for (unsigned index = 0; index != typesLength; ++index) {
+    auto nodePointer = parameterList->getChild(index);
+
+    if (nodePointer->getKind() == Node::Kind::TupleElement) {
+      assert(nodePointer->getNumChildren() == 1);
+      nodePointer = nodePointer->getFirstChild();
+    }
+    assert(nodePointer->getKind() == Node::Kind::Type);
+
+    auto request = MetadataRequest(MetadataState::Complete);
+
+    auto typeInfoOrErr = swift_getTypeByMangledNode(
+      request, demangler, nodePointer,
+      /*arguments=*/genericArguments,
       /*substGenericParam=*/
       [&substFn](unsigned depth, unsigned index) {
         return substFn.getMetadata(depth, index).Ptr;
@@ -3019,24 +3013,13 @@ swift_func_getParameterTypeInfo(
       [&substFn](const Metadata *type, unsigned index) {
         return substFn.getWitnessTable(type, index);
       });
-  TypeDecoder<DecodedMetadataBuilder> decoder(builder);
-
-  // for each parameter (TupleElement), store it into the provided buffer
-  for (unsigned index = 0; index != typesLength; ++index) {
-    auto *parameter = parameterList->getChild(index);
-
-    if (parameter->getKind() == Node::Kind::TupleElement) {
-      assert(parameter->getNumChildren() == 1);
-      parameter = parameter->getFirstChild();
-    }
-
-    assert(parameter->getKind() == Node::Kind::Type);
 
-    auto type = decodeType(decoder, parameter);
-    if (!type)
+    if (typeInfoOrErr.isError()) {
       return -3; // Failed to decode a type.
+    }
 
-    types[index] = type;
+    auto typeInfo = typeInfoOrErr.getType();
+    types[index] = typeInfo.getMetadata();
   } // end foreach parameter
 
   return typesLength;

test/Distributed/Runtime/distributed_actor_func_calls_without_touching_returnType_metadata_first.swift

@@ -1,8 +1,9 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -target %target-swift-5.7-abi-triple %S/../Inputs/FakeDistributedActorSystems.swift
 // RUN: %target-build-swift -module-name dist -target %target-swift-5.7-abi-triple -parse-as-library -j2 -parse-as-library -plugin-path %swift-plugin-dir -I %t %s %S/../Inputs/FakeDistributedActorSystems.swift -o %t/a.out
 // RUN: %target-codesign %t/a.out
-// RUN: %target-run %t/a.out
+
+// RUN: %target-run %t/a.out PARAMETER_TYPE
+// RUN: %target-run %t/a.out RETURN_TYPE
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
@@ -17,7 +18,6 @@
 
 import Darwin
 import Distributed
-import FakeDistributedActorSystems
 import Foundation
 
 typealias DefaultDistributedActorSystem = FakeRoundtripActorSystem
@@ -1052,20 +1052,39 @@ struct BigGeneric<T>: Codable {
 }
 
 distributed actor D {
+  public distributed func getBigGeneric(_ value: BigGeneric<TypeXXXX>) {}
   public distributed func getBigGeneric() -> BigGeneric<TypeXXXX> {
-    return BigGeneric()
-  }
+     return BigGeneric()
+   }
 }
 
-func attempt(n: Int) {
-  var fname = "$s4dist1DC13getBigGenericAA0cD0VyAA8Type\(n)VGyF"
+func attempt(_ mode: Mode, n: Int) {
+  var funcName_returnType = "$s4dist1DC13getBigGenericAA0cD0VyAA8Type\(n)VGyF"
+  var funcName_param = "$s4dist1DC13getBigGenericyyAA0cD0VyAA8Type\(n)VGF"
 
   func tryLookup() {
-    let t = fname.withUTF8 {
-      __getReturnTypeInfo($0.baseAddress!, UInt($0.count), nil, nil)
-    }
+    let t: (any Any.Type)? =
+      switch mode {
+      case .returnType:
+        funcName_returnType.withUTF8 {
+          __getReturnTypeInfo($0.baseAddress!, UInt($0.count), nil, nil)
+        }
+
+      case .paramType:
+        funcName_param.withUTF8 { nameBuf in
+          var type: Any.Type?
+          withUnsafeMutablePointer(to: &type) { typePtr in
+            let ret = __getParameterTypeInfo(nameBuf.baseAddress!, UInt(nameBuf.count), nil, nil, typePtr._rawValue, 1)
+            if ret != 1 {
+              fatalError("Decoded \(ret) parameters, expected 1")
+            }
+          }
+          return type
+        }
+      }
+
     guard let t else {
-      print("couldn't look up type for: \(fname)")
+      print("couldn't look up type for mode: \(mode)")
       exit(1)
     }
     func examineType<T>(_t: T.Type) {
@@ -1081,10 +1100,23 @@ func attempt(n: Int) {
   }
 }
 
+enum Mode: String {
+  case returnType = "RETURN_TYPE"
+  case paramType = "PARAMETER_TYPE"
+}
+
 @main struct Main {
   static func main() {
+    if CommandLine.arguments.count < 2 {
+      fatalError("Expected explicit mode in command line arguments, was: \(CommandLine.arguments)")
+    }
+
+    let mode = Mode.init(rawValue: CommandLine.arguments.dropFirst().first!)!
+    print("Checking in mode: \(mode)...")
+
     for i in 1000...1999 {
-      attempt(n: i)
+      attempt(mode, n: i)
     }
+    print("Passed in mode: \(mode)!")
   }
-}
+}

test/SIL/explicit_lifetime_dependence_specifiers.swift

@@ -105,7 +105,8 @@ func deriveThisOrThat1(_ this: borrowing BufferView, _ that: borrowing BufferVie
   if (Int.random(in: 1..<100) == 0) {
     return BufferView(independent: this.ptr)
   }
-  return BufferView(independent: that.ptr)
+  let newThat = BufferView(independent: that.ptr)
+  return _overrideLifetime(newThat, copying: that)
 }
 
 // CHECK-LABEL: sil hidden @$s39explicit_lifetime_dependence_specifiers17deriveThisOrThat2yAA10BufferViewVAD_ADntF : $@convention(thin) (@guaranteed BufferView, @owned BufferView) -> @lifetime(copy 1, borrow 0)  @owned BufferView {

test/SIL/implicit_lifetime_dependence.swift

@@ -85,12 +85,14 @@ func testBasic() {
 // CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence6deriveyAA10BufferViewVADF : $@convention(thin) (@guaranteed BufferView) -> @lifetime(copy 0)  @owned BufferView {
 @lifetime(copy x)
 func derive(_ x: borrowing BufferView) -> BufferView {
-  return BufferView(x.ptr, x.c)
+  let newBV = BufferView(x.ptr, x.c)
+  return _overrideLifetime(newBV, copying: x)
 }
 
 @lifetime(copy x)
 func derive(_ unused: Int, _ x: borrowing BufferView) -> BufferView {
-  return BufferView(independent: x.ptr, x.c)
+  let newBV = BufferView(independent: x.ptr, x.c)
+  return _overrideLifetime(newBV, copying: x)
 }
 
 // CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence16consumeAndCreateyAA10BufferViewVADnF : $@convention(thin) (@owned BufferView) -> @lifetime(copy 0)  @owned BufferView {
@@ -212,7 +214,9 @@ struct GenericBufferView<Element> : ~Escapable {
 // CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence23tupleLifetimeDependenceyAA10BufferViewV_ADtADF : $@convention(thin) (@guaranteed BufferView) -> @lifetime(copy 0)  (@owned BufferView, @owned BufferView) {
 @lifetime(copy x)
 func tupleLifetimeDependence(_ x: borrowing BufferView) -> (BufferView, BufferView) {
-  return (BufferView(x.ptr, x.c), BufferView(x.ptr, x.c))
+  let newX1 = BufferView(x.ptr, x.c)
+  let newX2 = BufferView(x.ptr, x.c)
+  return (_overrideLifetime(newX1, copying: x), _overrideLifetime(newX2, copying: x))
 }
 
 public struct OuterNE: ~Escapable {