OwnershipUtils review feedback: code formatting.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/BorrowUtils.swift

@@ -289,8 +289,12 @@ enum BeginBorrowValue {
       let inst = operand.instruction as! SingleValueInstruction
       self = BeginBorrowValue(inst)!
     case is BranchInst:
-      guard let phi = Phi(using: operand) else { return nil }
-      guard phi.isReborrow else { return nil }
+      guard let phi = Phi(using: operand) else {
+        return nil
+      }
+      guard phi.isReborrow else {
+        return nil
+      }
       self = .reborrow(phi)
     default:
       return nil
@@ -404,16 +408,16 @@ private struct BorrowIntroducers {
   }
 
   private mutating func push(_ introducer: Value,
-    introducers: inout Stack<Value>) {
+    in introducers: inout Stack<Value>) {
     if visitedIntroducers.insert(introducer.hashable).inserted {
       introducers.push(introducer)
     }
   }
 
   private mutating func push<S: Sequence>(contentsOf other: S,
-    introducers: inout Stack<Value>) where S.Element == Value {
+    in introducers: inout Stack<Value>) where S.Element == Value {
     for elem in other {
-      push(elem, introducers: &introducers)
+      push(elem, in: &introducers)
     }
   }
 
@@ -430,7 +434,7 @@ private struct BorrowIntroducers {
     // 'introducers' to avoid duplicates and avoid exponential
     // recursion on aggregates.
     if let cachedIntroducers = cache.valueIntroducers[value.hashable] {
-      cachedIntroducers.forEach { push($0, introducers: &introducers) }
+      push(contentsOf: cachedIntroducers, in: &introducers)
       return
     }
     introducers.withMarker(
@@ -452,7 +456,7 @@ private struct BorrowIntroducers {
       return
 
     case .owned:
-      push(value, introducers: &introducers);
+      push(value, in: &introducers);
       return
 
     case .guaranteed:
@@ -461,7 +465,7 @@ private struct BorrowIntroducers {
     // BeginBorrowedValue handles the initial scope introducers: begin_borrow,
     // load_borrow, & reborrow.
     if BeginBorrowValue(value) != nil {
-      push(value, introducers: &introducers)
+      push(value, in: &introducers)
       return
     }
     // Handle guaranteed forwarding phis
@@ -531,7 +535,7 @@ private struct BorrowIntroducers {
       // Map the incoming introducers to an outer-adjacent phi if one exists.
       push(contentsOf: mapToPhi(predecessor: pred,
                                 incomingValues: incomingIntroducers),
-           introducers: &introducers)
+           in: &introducers)
     }
     // Remove this phi from the pending set. This phi may be visited
     // again at a different level of phi recursion. In that case, we
@@ -724,8 +728,9 @@ private struct EnclosingValues {
                                in enclosingValues: inout Stack<Value>,
                                _ cache: inout BorrowIntroducers.Cache) {
 
-    guard visitedReborrows.insert(reborrow.value) else { return }
-
+    guard visitedReborrows.insert(reborrow.value) else {
+      return
+    }
     // avoid duplicates in the enclosingValues set.
     var pushedEnclosingValues = ValueSet(context)
     defer { pushedEnclosingValues.deinitialize() }

SwiftCompilerSources/Sources/Optimizer/Utilities/ForwardingUtils.swift

@@ -145,14 +145,15 @@ func gatherLifetimeIntroducers(for value: Value, _ context: Context) -> [Value]
     introducers.append($0)
     return .continueWalk
   }
-  defer { walker.visitedValues.deinitialize() }
+  defer { walker.deinitialize() }
   _ = walker.walkUp(value: value)
   return introducers
 }
 
 // TODO: visitor can be nonescaping when we have borrowed properties.
 func visitLifetimeIntroducers(for value: Value, _ context: Context,
-  visitor: @escaping (Value) -> WalkResult) -> WalkResult {
+                              visitor: @escaping (Value) -> WalkResult)
+  -> WalkResult {
   var walker = VisitLifetimeIntroducers(context, visitor: visitor)
   defer { walker.visitedValues.deinitialize() }
   return walker.walkUp(value: value)
@@ -167,6 +168,8 @@ private struct VisitLifetimeIntroducers : ForwardingUseDefWalker {
     self.visitedValues = ValueSet(context)
   }
 
+  mutating func deinitialize() { visitedValues.deinitialize() }
+
   mutating func needWalk(for value: Value) -> Bool {
     visitedValues.insert(value)
   }

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -95,7 +95,7 @@ func computeInteriorLiveness(for definingValue: Value,
 
   var range = InstructionRange(for: definingValue, context)
 
-  var visitor = InteriorUseVisitor(definingValue: definingValue, context) {
+  var visitor = InteriorUseWalker(definingValue: definingValue, context) {
     range.insert($0.instruction)
     return .continueWalk
   }
@@ -159,18 +159,19 @@ func computeInteriorLiveness(for definingValue: Value,
 ///
 /// TODO: Change the operandOwnership of MarkDependenceInst base operand.
 /// It should be a borrowing operand, not a pointer escape.
-struct InteriorUseVisitor: OwnershipUseVisitor, AddressUseVisitor {
+struct InteriorUseWalker: OwnershipUseVisitor, AddressUseVisitor {
   let context: FunctionPassContext
   var _context: Context { context }
 
-  let function: Function
   let definingValue: Value
   let useVisitor: (Operand) -> WalkResult
 
   var innerScopeHandler: InnerScopeHandler? = nil
 
   var unenclosedPhis: [Phi] = []
 
+  var function: Function { definingValue.parentFunction }
+
   /// If any interior pointer may escape, then record the first instance
   /// here. This immediately aborts the walk, so further instances are
   /// unavailable.
@@ -197,7 +198,6 @@ struct InteriorUseVisitor: OwnershipUseVisitor, AddressUseVisitor {
     visitor: @escaping (Operand) -> WalkResult) {
     assert(!definingValue.type.isAddress, "address values have no ownership")
     self.context = context
-    self.function = definingValue.parentFunction
     self.definingValue = definingValue
     self.useVisitor = visitor
     self.visited = ValueSet(context)
@@ -312,18 +312,22 @@ struct InteriorUseVisitor: OwnershipUseVisitor, AddressUseVisitor {
   }
 
   func handleInner(borrow: BeginBorrowValue) -> WalkResult  {
-    guard let innerScopeHandler else { return .continueWalk }
+    guard let innerScopeHandler else {
+      return .continueWalk
+    }
     return innerScopeHandler(borrow.value)
   }
 
   func handleAccess(address: BeginAccessInst) -> WalkResult {
-    guard let innerScopeHandler else { return .continueWalk }
+    guard let innerScopeHandler else {
+      return .continueWalk
+    }
     return innerScopeHandler(address)
   }
 }
 
 // Helpers to walk down forwarding operations.
-extension InteriorUseVisitor {
+extension InteriorUseWalker {
   // Walk down forwarding operands
   private mutating func walkDown(operand: Operand) -> WalkResult {
     // Record all uses
@@ -345,10 +349,12 @@ extension InteriorUseVisitor {
   }
 
   private mutating func walkDownUses(of value: Value) -> WalkResult {
-    guard value.ownership.hasLifetime else { return .continueWalk }
-
-    guard visited.insert(value) else { return .continueWalk }
-
+    guard value.ownership.hasLifetime else {
+      return .continueWalk
+    }
+    guard visited.insert(value) else {
+      return .continueWalk
+    }
     switch value.ownership {
     case .owned:
       return visitUsesOfInner(value: value)
@@ -985,7 +991,7 @@ let interiorLivenessTest = FunctionTest("interior_liveness_swift") {
   var range = InstructionRange(for: value, context)
   defer { range.deinitialize() }
 
-  var visitor = InteriorUseVisitor(definingValue: value, context) {
+  var visitor = InteriorUseWalker(definingValue: value, context) {
     range.insert($0.instruction)
     return .continueWalk
   }
@@ -1047,5 +1053,5 @@ let addressUseTest = FunctionTest("address_use_test") {
   print(function)
   print("Uses of address: \(address)")
   var printer = AddressUsePrinter(_context: context)
-  printer.walkDownUses(ofAddress: address)
+  _ = printer.walkDownUses(ofAddress: address)
 }