SIL: add some use-list APIs

* `users`: maps from a sequence of operands to a sequence of instructions
* `users(ofType:)` : as `users`, but filters users of a certain instruction type
* `Value.users`: = `Value.uses.users`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -454,7 +454,7 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
 
 private extension InstructionWorklist {
   mutating func pushIfNotVisited(usersOf value: Value) {
-    pushIfNotVisited(contentsOf: value.uses.lazy.map { $0.instruction })
+    pushIfNotVisited(contentsOf: value.users)
   }
 }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -236,7 +236,7 @@ extension Value {
   -> Bool {
     var users = InstructionSet(context)
     defer { users.deinitialize() }
-    uses.lazy.map({ $0.instruction }).forEach { users.insert($0) }
+    users.insert(contentsOf: self.users)
 
     var worklist = InstructionWorklist(context)
     defer { worklist.deinitialize() }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1248,6 +1248,10 @@ final public class AllocStackInst : SingleValueInstruction, Allocation, DebugVar
   public var debugVariable: DebugVariable {
     return bridged.AllocStack_getVarInfo()
   }
+
+  public var deallocations: LazyMapSequence<LazyFilterSequence<UseList>, Instruction> {
+    uses.users(ofType: DeallocStackInst.self)
+  }
 }
 
 final public class AllocVectorInst : SingleValueInstruction, Allocation, UnaryInstruction {
@@ -1317,7 +1321,7 @@ extension Instruction {
   /// Return the sequence of use points of any instruction.
   public var endInstructions: EndInstructions {
     if let scopedInst = self as? ScopedInstruction {
-      return .scoped(scopedInst.endOperands.map({ $0.instruction }))
+      return .scoped(scopedInst.endOperands.users)
     }
     return .single(self)
   }
@@ -1366,6 +1370,10 @@ final public class StoreBorrowInst : SingleValueInstruction, StoringInstruction,
     }
     return dest as! AllocStackInst
   }
+
+  public var endBorrows: LazyMapSequence<LazyFilterSequence<UseList>, Instruction> {
+    uses.users(ofType: EndBorrowInst.self)
+  }
 }
 
 final public class BeginAccessInst : SingleValueInstruction, UnaryInstruction {

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -169,6 +169,20 @@ extension Sequence where Element == Operand {
   public var endingLifetime: LazyFilterSequence<Self> {
     return self.lazy.filter { $0.endsLifetime }
   }
+
+  public var users: LazyMapSequence<Self, Instruction> {
+    return self.lazy.map { $0.instruction }
+  }
+
+  // This intentinally returns a Sequence of `Instruction` and not a Sequence of `I` to be able to use
+  // it as argument to `InstructionSet.insert(contentsOf:)`.
+  public func users<I: Instruction>(ofType: I.Type) -> LazyMapSequence<LazyFilterSequence<Self>, Instruction> {
+    self.lazy.filter{ $0.instruction is I }.users
+  }
+}
+
+extension Value {
+  public var users: LazyMapSequence<UseList, Instruction> { uses.users }
 }
 
 extension Operand {