Fix LifetimeDependenceScopeFixup for loops.

Handle situations in which the uses of the new scope are inside a loop so the
new range has no end instructions.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -149,8 +149,6 @@ private func extendAccessScope(beginAccess: BeginAccessInst, range: inout Instru
   if !requiresExtension {
     return nil
   }
-  assert(!range.ends.isEmpty)
-
   // Create new end_access at the end of extended uses
   var dependsOnCaller = false
   for end in range.ends {
@@ -167,6 +165,11 @@ private func extendAccessScope(beginAccess: BeginAccessInst, range: inout Instru
       range.insert(endAccess)
     }
   }
+  for exitInst in range.exits {
+    let location = exitInst.location.autoGenerated
+    let endAccess = Builder(before: exitInst, location: location, context).createEndAccess(beginAccess: beginAccess)
+    range.insert(endAccess)
+  }
   // Delete original end_access instructions
   for endAccess in endAcceses {
     context.erase(instruction: endAccess)

test/SILOptimizer/lifetime_dependence/lifetime_dependence_mutate.swift

@@ -8,38 +8,83 @@
 // REQUIRES: asserts
 // REQUIRES: swift_in_compiler
 
-struct MBV : ~Escapable, ~Copyable {
-  let p: UnsafeMutableRawPointer
-  let c: Int
+struct MutableSpan : ~Escapable, ~Copyable {
+  let base: UnsafeMutableRawPointer
+  let count: Int
 
   init(_ p: UnsafeMutableRawPointer, _ c: Int) -> dependsOn(p) Self {
-    self.p = p
-    self.c = c
+    self.base = p
+    self.count = c
   }
 
   subscript(position: Int) -> Int {
     get {
       let offset = position * MemoryLayout<Int>.stride
-      return p.loadUnaligned(fromByteOffset: offset, as: Int.self)
+      return base.loadUnaligned(fromByteOffset: offset, as: Int.self)
     }
     nonmutating set(newValue) {
       let offset = position * MemoryLayout<Int>.stride
-      p.storeBytes(of: newValue, toByteOffset: offset,
+      base.storeBytes(of: newValue, toByteOffset: offset,
                    as: Int.self)
     }
   }
+
+  struct Iter: ~Escapable {
+    var base: UnsafeMutableRawPointer
+    var count: Int
+
+    init(base: UnsafeMutableRawPointer, count: Int) -> dependsOn(base) Self {
+      self.base = base
+      self.count = count
+    }
+
+    mutating func next() -> Int? {
+      guard count > 0 else { return nil }
+      count -= 1
+      let n = base.load(as: Int.self)
+      base = base + MemoryLayout<Int>.stride
+      return n
+    }
+  }
+
+  var iterator: Iter { Iter(base: base, count: count) }
+}
+
+extension Array where Element == Int {
+  // TODO: comment out dependsOn(scoped)
+  mutating func mutspan() -> /* dependsOn(scoped self) */ MutableSpan {
+    /* not the real implementation */
+    let p = self.withUnsafeMutableBufferPointer { $0.baseAddress! }
+    return MutableSpan(p, count)
+  }
 }
 
 struct NC : ~Copyable {
   let p: UnsafeMutableRawPointer
   let c: Int
 
   // Requires a mutable borrow.
-  mutating func getMBV() -> dependsOn(self) MBV {
-    MBV(p, c)
+  mutating func getMutableSpan() -> dependsOn(self) MutableSpan {
+    MutableSpan(p, c)
   }
 }
 
 func mbv_set_element(nc: inout NC, e: Int) {
-  nc.getMBV()[3] = e
+  nc.getMutableSpan()[3] = e
+}
+
+func test_mutate_iterate() {
+  var array = [1,2,3]
+  // mutable 'array' access
+  let mutatingSpan = array.mutspan()
+  var iterator = mutatingSpan.iterator
+  var i = 0
+  while let n = iterator.next() {
+    _ = n
+    if i < mutatingSpan.count {
+      mutatingSpan[i+1] = mutatingSpan[i]
+      i += 1
+    }
+  }
+  // end mutable 'array' access
 }