Merge pull request #85232 from atrick/rdar159793739-lifedep-cast

LifetimeDependenceDiagnostics: handle dynamic casting of Span<T>

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -128,27 +128,36 @@ private func analyze(dependence: LifetimeDependence, _ context: FunctionPassCont
   var range = dependence.computeRange(context)
   defer { range?.deinitialize() }
 
-  var error = false
-  let diagnostics =
-    DiagnoseDependence(dependence: dependence, range: range,
-                       onError: { error = true }, context: context)
+  let diagnostics = DiagnoseDependence(dependence: dependence, range: range, context: context)
 
   // Check each lifetime-dependent use via a def-use visitor
   var walker = DiagnoseDependenceWalker(diagnostics, context)
   defer { walker.deinitialize() }
   let result = walker.walkDown(dependence: dependence)
-  // The walk may abort without a diagnostic error.
-  assert(!error || result == .abortWalk)
+  assert(result == .continueWalk || diagnostics.errorStatus != nil,
+         "Lifetime diagnostics failed without raising an error")
   return result == .continueWalk
 }
 
 /// Analyze and diagnose a single LifetimeDependence.
-private struct DiagnoseDependence {
+private class DiagnoseDependence {
+  enum ErrorStatus {
+    case diagnostic
+    case unresolvedDependence
+  }
+
   let dependence: LifetimeDependence
   let range: InstructionRange?
-  let onError: ()->()
   let context: FunctionPassContext
 
+  init(dependence: LifetimeDependence, range: InstructionRange?, context: FunctionPassContext) {
+    self.dependence = dependence
+    self.range = range
+    self.context = context
+  }
+
+  var errorStatus: ErrorStatus? = nil
+
   var function: Function { dependence.function }
 
   func diagnose(_ position: SourceLoc?, _ id: DiagID,
@@ -266,9 +275,10 @@ private struct DiagnoseDependence {
   func reportError(escapingValue: Value, user: Instruction, diagID: DiagID) {
     // If the dependent value is Escapable, then mark_dependence resolution fails, but this is not a diagnostic error.
     if dependence.dependentValue.isEscapable {
+      errorStatus = .unresolvedDependence
       return
     }
-    onError()
+    errorStatus = .diagnostic
 
     // Identify the escaping variable.
     let escapingVar = LifetimeVariable(definedBy: escapingValue, user: user, context)
@@ -598,10 +608,10 @@ extension DiagnoseDependenceWalker : LifetimeDependenceDefUseWalker {
     return .continueWalk
   }
 
-  // Override AddressUseVisitor here because LifetimeDependenceDefUseWalker
-  // returns .abortWalk, and we want a more useful crash report.
+  // Override AddressUseVisitor here because LifetimeDependenceDefUseWalker returns .abortWalk and
+  // DiagnoseDependenceWalker requires a diagnostic error for all aborts.
   mutating func unknownAddressUse(of operand: Operand) -> WalkResult {
     diagnostics.reportUnknown(operand: operand)
-    return .continueWalk
+    return .abortWalk
   }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -622,6 +622,9 @@ extension LifetimeDependence.Scope {
 ///   walkDown(dependence: LifetimeDependence)
 ///
 /// Note: this may visit values that are not dominated by `dependence` because of dependent phi operands.
+///
+/// WARNING: Do not return .abortWalk at this level or below. .abortWalk may only be returned by an overridden callback
+/// or the default implementation of unknownAddressUse().
 protocol LifetimeDependenceDefUseWalker : ForwardingDefUseWalker,
                                           OwnershipUseVisitor,
                                           AddressUseVisitor {
@@ -1069,12 +1072,14 @@ extension LifetimeDependenceDefUseWalker {
         return loadedAddressUse(of: localAccess.operand!, intoValue: load)
       case let copyAddr as SourceDestAddrInstruction:
         return loadedAddressUse(of: localAccess.operand!, intoAddress: copyAddr.destinationOperand)
+      case let castAddr as CheckedCastAddrBranchInst:
+        return loadedAddressUse(of: localAccess.operand!, intoAddress: castAddr.destinationOperand)
       case is SwitchEnumAddrInst:
         // switch_enum_addr does not produce any values. Subsequent uses of the address (unchecked_enum_data_addr)
         // directly use the original address.
         return .continueWalk
       default:
-        return .abortWalk
+        return unknownAddressUse(of: localAccess.operand!)
       }
     case .dependenceSource:
       switch localAccess.instruction! {
@@ -1086,7 +1091,7 @@ extension LifetimeDependenceDefUseWalker {
       case let md as MarkDependenceAddrInst:
         return loadedAddressUse(of: localAccess.operand!, intoAddress: md.addressOperand)
       default:
-        return .abortWalk
+        return unknownAddressUse(of: localAccess.operand!)
       }
     case .dependenceDest:
       // Simply a marker that indicates the start of an in-memory dependent value. If this was a mark_dependence, uses

SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift

@@ -525,6 +525,13 @@ extension LocalVariableAccessWalker: AddressUseVisitor {
       // switch_enum_addr is truly a leaf address use. It does not produce a new value. But in every other respect it is
       // like a load.
       visit(LocalVariableAccess(.load, operand))
+    case let castBr as CheckedCastAddrBranchInst:
+      if operand == castBr.sourceOperand {
+        visit(LocalVariableAccess(.load, operand))
+      } else {
+        assert(operand == castBr.destinationOperand)
+        visit(LocalVariableAccess(.store, operand))
+      }
     case is DeallocStackInst:
       break
     default:

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -2049,8 +2049,11 @@ final public class CheckedCastBranchInst : TermInst, UnaryInstruction {
 }
 
 final public class CheckedCastAddrBranchInst : TermInst {
-  public var source: Value { operands[0].value }
-  public var destination: Value { operands[1].value }
+  public var sourceOperand: Operand { return operands[0] }
+  public var destinationOperand: Operand { return operands[1] }
+
+  public var source: Value { sourceOperand.value }
+  public var destination: Value { destinationOperand.value }
 
   public var sourceFormalType: CanonicalType {
     CanonicalType(bridged: bridged.CheckedCastAddrBranch_getSourceFormalType())

test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift

@@ -429,3 +429,22 @@ extension MutableSpan {
     return false
   }
 }
+
+// =============================================================================
+// Local variable analysis - address uses
+// =============================================================================
+
+func dynamicCastGood<T>(_ span: Span<T>) {
+  if let intSpan = span as? Span<Int> {
+    _ = intSpan
+  }
+}
+
+@_lifetime(immortal)
+func dynamicCastBad<T>(_ span: Span<T>) -> Span<Int> {
+  if let intSpan = span as? Span<Int> { // expected-error{{lifetime-dependent variable 'intSpan' escapes its scope}}
+    // expected-note @-2{{it depends on the lifetime of argument 'span'}}
+    return intSpan // expected-note{{this use causes the lifetime-dependent value to escape}}
+  }
+  return Span<Int>()
+}