SwiftCompilerSources: improve APIs for UseList

Make filter APIs for UseList chainable by adding them to Sequence where Element == Operand

For example, it allows to write:
```
let singleUse = value.uses.ignoreDebugUses.ignoreUsers(ofType: EndAccessInst.self).singleUse
```

Also, add `UseList.getSingleUser(notOfType:)`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/NamedReturnValueOptimization.swift

@@ -61,7 +61,7 @@ let namedReturnValueOptimization = FunctionPass(name: "named-return-value-optimi
 /// Returns a copy_addr which copies from an alloc_stack to the `outArg` at the end of the function.
 ///
 private func findCopyForNRVO(for outArg: FunctionArgument) -> CopyAddrInst? {
-  guard let singleArgUse = outArg.uses.singleNonDebugUse,
+  guard let singleArgUse = outArg.uses.ignoreDebugUses.singleUse,
         let copyToArg = singleArgUse.instruction as? CopyAddrInst else {
     return nil
   }
@@ -106,7 +106,7 @@ private func findCopyForNRVO(for outArg: FunctionArgument) -> CopyAddrInst? {
 }
 
 private func performNRVO(with copy: CopyAddrInst, _ context: FunctionPassContext) {
-  copy.source.uses.replaceAllExceptDealloc(with: copy.destination, context)
+  copy.source.replaceAllUsesExceptDealloc(with: copy.destination, context)
   assert(copy.source == copy.destination)
   context.erase(instruction: copy)
 }
@@ -122,10 +122,8 @@ private func isAnyInstructionWritingToMemory(after: Instruction) -> Bool {
   return false
 }
 
-private extension UseList {
-  func replaceAllExceptDealloc(with replacement: Value, _ context: some MutatingContext) {
-    for use in self where !(use.instruction is Deallocation)  {
-      use.set(to: replacement, context)
-    }
+private extension Value {
+  func replaceAllUsesExceptDealloc(with replacement: Value, _ context: some MutatingContext) {
+    uses.lazy.filter{!($0.instruction is Deallocation)}.replaceAll(with: replacement, context)
   }
 }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginCOWMutation.swift

@@ -59,7 +59,7 @@ private extension BeginCOWMutationInst {
     if !isEmptyCOWSingleton(instance) {
       return
     }
-    if uniquenessResult.nonDebugUses.isEmpty {
+    if uniquenessResult.uses.ignoreDebugUses.isEmpty {
       /// Don't create an integer_literal which would be dead. This would result
       /// in an infinite loop in SILCombine.
       return
@@ -70,15 +70,15 @@ private extension BeginCOWMutationInst {
   }
 
   func optimizeEmptyBeginEndPair(_ context: SimplifyContext) -> Bool {
-    if !uniquenessResult.nonDebugUses.isEmpty {
+    if !uniquenessResult.uses.ignoreDebugUses.isEmpty {
       return false
     }
     let buffer = instanceResult
-    if buffer.nonDebugUses.contains(where: { !($0.instruction is EndCOWMutationInst) }) {
+    if buffer.uses.ignoreDebugUses.contains(where: { !($0.instruction is EndCOWMutationInst) }) {
       return false
     }
 
-    for use in buffer.nonDebugUses {
+    for use in buffer.uses.ignoreDebugUses {
       let endCOW = use.instruction as! EndCOWMutationInst
       endCOW.uses.replaceAll(with: instance, context)
       context.erase(instruction: endCOW)
@@ -88,13 +88,13 @@ private extension BeginCOWMutationInst {
   }
 
   func optimizeEmptyEndBeginPair(_ context: SimplifyContext) -> Bool {
-    if !uniquenessResult.nonDebugUses.isEmpty {
+    if !uniquenessResult.uses.ignoreDebugUses.isEmpty {
       return false
     }
     guard let endCOW = instance as? EndCOWMutationInst else {
       return false
     }
-    if endCOW.nonDebugUses.contains(where: { $0.instruction != self }) {
+    if endCOW.uses.ignoreDebugUses.contains(where: { $0.instruction != self }) {
       return false
     }
 

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyDestructure.swift

@@ -87,7 +87,7 @@ extension DestructureStructInst : OnoneSimplifyable {
 private func tryReplaceConstructDestructPair(construct: SingleValueInstruction,
                                              destruct: MultipleValueInstruction,
                                              _ context: SimplifyContext) {
-  let singleUse = context.preserveDebugInfo ? construct.uses.singleUse : construct.uses.singleNonDebugUse
+  let singleUse = context.preserveDebugInfo ? construct.uses.singleUse : construct.uses.ignoreDebugUses.singleUse
   let canEraseFirst = singleUse?.instruction == destruct
 
   if !canEraseFirst && construct.parentFunction.hasOwnership && construct.ownership == .owned {

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -197,7 +197,7 @@ extension LoadInst : OnoneSimplifyable, SILCombineSimplifyable {
     if context.preserveDebugInfo {
       return !uses.contains { !($0.instruction is DestroyValueInst) }
     } else {
-      return !nonDebugUses.contains { !($0.instruction is DestroyValueInst) }
+      return !uses.ignoreDebugUses.contains { !($0.instruction is DestroyValueInst) }
     }
   }
 }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyRefCasts.swift

@@ -65,7 +65,7 @@ private extension UnaryInstruction {
   }
 
   func tryReplaceSource(withOperandOf inst: SingleValueInstruction, _ context: SimplifyContext) -> Bool {
-    let singleUse = context.preserveDebugInfo ? inst.uses.singleUse : inst.uses.singleNonDebugUse
+    let singleUse = context.preserveDebugInfo ? inst.uses.singleUse : inst.uses.ignoreDebugUses.singleUse
     let canEraseInst = singleUse?.instruction == self
     let replacement = inst.operands[0].value
 

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -265,7 +265,14 @@ private extension Value {
     var singleUseValue: any Value = self
     var path = SmallProjectionPath()
     while true {
-      guard let use = singleUseValue.uses.singleRelevantUse else {
+      // The initializer value of a global can contain access instructions if it references another
+      // global variable by address, e.g.
+      //   var p = Point(x: 10, y: 20)
+      //   let o = UnsafePointer(&p)
+      // Therefore ignore the `end_access` use of a `begin_access`.
+      let relevantUses = singleUseValue.uses.ignoreDebugUses.ignoreUsers(ofType: EndAccessInst.self)
+
+      guard let use = relevantUses.singleUse else {
         return nil
       }
 
@@ -383,27 +390,3 @@ fileprivate struct FunctionWorklist {
     }
   }
 }
-
-private extension UseList {
-  var singleRelevantUse: Operand? {
-    var singleUse: Operand?
-    for use in self {
-      switch use.instruction {
-      case is DebugValueInst,
-           // The initializer value of a global can contain access instructions if it references another
-           // global variable by address, e.g.
-           //   var p = Point(x: 10, y: 20)
-           //   let o = UnsafePointer(&p)
-           // Therefore ignore the `end_access` use of a `begin_access`.
-           is EndAccessInst:
-        continue
-      default:
-        if singleUse != nil {
-          return nil
-        }
-        singleUse = use
-      }
-    }
-    return singleUse
-  }
-}

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -365,9 +365,7 @@ private struct StackProtectionOptimization {
     let builder = Builder(after: beginAccess, location: beginAccess.location.autoGenerated, context)
     let temporary = builder.createAllocStack(beginAccess.type)
 
-    for use in beginAccess.uses where !(use.instruction is EndAccessInst) {
-      use.instruction.setOperand(at: use.index, to: temporary, context)
-    }
+    beginAccess.uses.ignoreUsers(ofType: EndAccessInst.self).replaceAll(with: temporary, context)
 
     for endAccess in beginAccess.endInstructions {
       let endBuilder = Builder(before: endAccess, location: endAccess.location.autoGenerated, context)

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -448,7 +448,7 @@ extension AllocRefInstBase {
   }
 }
 
-extension UseList {
+extension Sequence where Element == Operand {
   func replaceAll(with replacement: Value, _ context: some MutatingContext) {
     for use in self {
       use.set(to: replacement, context)

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -14,10 +14,6 @@ import SIL
 import OptimizerBridging
 
 extension Value {
-  var nonDebugUses: LazyFilterSequence<UseList> {
-    uses.lazy.filter { !($0.instruction is DebugValueInst) }
-  }
-
   var lookThroughBorrow: Value {
     if let beginBorrow = self as? BeginBorrowInst {
       return beginBorrow.borrowedValue.lookThroughBorrow
@@ -206,7 +202,7 @@ extension Instruction {
   }
 
   var isTriviallyDeadIgnoringDebugUses: Bool {
-    if results.contains(where: { !$0.uses.isEmptyIgnoringDebugUses }) {
+    if results.contains(where: { !$0.uses.ignoreDebugUses.isEmpty }) {
       return false
     }
     return self.canBeRemovedIfNotUsed
@@ -320,32 +316,6 @@ extension LoadInst {
   }
 }
 
-
-extension UseList {
-  var singleNonDebugUse: Operand? {
-    var singleUse: Operand?
-    for use in self {
-      if use.instruction is DebugValueInst {
-        continue
-      }
-      if singleUse != nil {
-        return nil
-      }
-      singleUse = use
-    }
-    return singleUse
-  }
-
-  var isEmptyIgnoringDebugUses: Bool {
-    for use in self {
-      if !(use.instruction is DebugValueInst) {
-        return false
-      }
-    }
-    return true
-  }
-}
-
 extension SmallProjectionPath {
   /// Returns true if the path only contains projections which can be materialized as
   /// SIL struct or tuple projection instructions - for values or addresses.
@@ -421,7 +391,7 @@ extension SimplifyContext {
   /// The operation is not done if it would require to insert a copy due to keep ownership correct.
   func tryReplaceRedundantInstructionPair(first: SingleValueInstruction, second: SingleValueInstruction,
                                           with replacement: Value) {
-    let singleUse = preserveDebugInfo ? first.uses.singleUse : first.uses.singleNonDebugUse
+    let singleUse = preserveDebugInfo ? first.uses.singleUse : first.uses.ignoreDebugUses.singleUse
     let canEraseFirst = singleUse?.instruction == second
 
     if !canEraseFirst && first.parentFunction.hasOwnership && replacement.ownership == .owned {

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -115,33 +115,43 @@ public struct UseList : CollectionLikeSequence {
     self.firstOpPtr = firstOpPtr
   }
 
-  public var singleUse: Operand? {
-    if let op = firstOpPtr.operand {
-      if op.getNextUse().operand != nil {
-        return nil
-      }
-      return Operand(bridged: op)
-    }
-    return nil
+  public func makeIterator() -> Iterator {
+    return Iterator(currentOpPtr: firstOpPtr)
   }
+}
 
-  public func getSingleUser<I: Instruction>(ofType: I.Type) -> I? {
-    var result: I? = nil
-    for use in self {
-      if let user = use.instruction as? I {
-        if result != nil {
-          return nil
-        }
-        result = user
+extension Sequence where Element == Operand {
+  public var singleUse: Operand? {
+    var result: Operand? = nil
+    for op in self {
+      if result != nil {
+        return nil
       }
+      result = op
     }
     return result
   }
 
   public var isSingleUse: Bool { singleUse != nil }
 
-  public func makeIterator() -> Iterator {
-    return Iterator(currentOpPtr: firstOpPtr)
+  public var ignoreDebugUses: LazyFilterSequence<Self> {
+    self.lazy.filter { !($0.instruction is DebugValueInst) }
+  }
+
+  public func filterUsers<I: Instruction>(ofType: I.Type) -> LazyFilterSequence<Self> {
+    self.lazy.filter { $0.instruction is I }
+  }
+
+  public func ignoreUsers<I: Instruction>(ofType: I.Type) -> LazyFilterSequence<Self> {
+    self.lazy.filter { !($0.instruction is I) }
+  }
+
+  public func getSingleUser<I: Instruction>(ofType: I.Type) -> I? {
+    filterUsers(ofType: I.self).singleUse?.instruction as? I
+  }
+
+  public func getSingleUser<I: Instruction>(notOfType: I.Type) -> Instruction? {
+    ignoreUsers(ofType: I.self).singleUse?.instruction
   }
 }