EscapeUtils: replace ...byWalkingDown APIs with an initialWalkingDirection parameter

It simplifies the EscapeUtils API
NFC

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -47,8 +47,10 @@ let computeEscapeEffects = FunctionPass(name: "compute-escape-effects") {
     }
 
     // First check: is the argument (or a projected value of it) escaping at all?
-    if !arg.at(.anything).isEscapingWhenWalkingDown(using: IgnoreRecursiveCallVisitor(),
-                                                    context) {
+    if !arg.at(.anything).isEscaping(using: IgnoreRecursiveCallVisitor(),
+                                     initialWalkingDirection: .down,
+                                     context)
+    {
       let effect = EscapeEffects.ArgumentEffect(.notEscaping, argumentIndex: arg.index,
                                                 pathPattern: SmallProjectionPath(.anything))
       newEffects.append(effect)
@@ -84,7 +86,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   // containing one or more references.
   let argPath = arg.type.isClass ? ap : ap.push(.anyValueFields)
 
-  guard let result = arg.at(argPath).visitByWalkingDown(using: ArgEffectsVisitor(), context) else {
+  guard let result = arg.at(argPath).visit(using: ArgEffectsVisitor(), initialWalkingDirection: .down, context) else {
     return false
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -544,6 +544,6 @@ private extension PartialApplyInst {
       var followTrivialTypes: Bool { true }
     }
 
-    return self.isEscapingWhenWalkingDown(using: EscapesToApply(), context)
+    return self.isEscaping(using: EscapesToApply(), initialWalkingDirection: .down, context)
   }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -74,23 +74,19 @@ extension ProjectedValue {
   /// The provided `visitor` can be used to override the handling a certain defs and uses during
   /// the walk. See `EscapeVisitor` for details.
   ///
-  func isEscaping(using visitor: some EscapeVisitor = DefaultVisitor(),
-                  complexityBudget: Int = Int.max,
-                  _ context: some Context) -> Bool {
+  func isEscaping(
+    using visitor: some EscapeVisitor = DefaultVisitor(),
+    initialWalkingDirection: EscapeUtilityTypes.WalkingDirection = .up,
+    complexityBudget: Int = Int.max,
+    _ context: some Context
+  ) -> Bool {
     var walker = EscapeWalker(visitor: visitor, complexityBudget: complexityBudget, context)
-    return walker.walkUp(addressOrValue: value, path: path.escapePath) == .abortWalk
-  }
-
-  /// Returns true if the function argument escapes, but ignoring any potential escapes in the caller.
-  ///
-  /// This function is similar to `ProjectedValue.isEscaping()`, but it ignores any potential
-  /// escapes which might have happened before the argument's function is called.
-  /// Technically, this means that the walk starts downwards instead of upwards.
-  ///
-  func isEscapingWhenWalkingDown(using visitor: some EscapeVisitor = DefaultVisitor(),
-                                 _ context: some Context) -> Bool {
-    var walker = EscapeWalker(visitor: visitor, context)
-    return walker.walkDown(addressOrValue: value, path: path.escapePath) == .abortWalk
+    let result: WalkResult
+    switch initialWalkingDirection {
+      case .up:   result = walker.walkUp(addressOrValue: value, path: path.escapePath)
+      case .down: result = walker.walkDown(addressOrValue: value, path: path.escapePath)
+    }
+    return result == .abortWalk
   }
 
   /// Returns the result of the visitor if the projected value does not escape.
@@ -99,27 +95,19 @@ extension ProjectedValue {
   /// it returns the `result` of the `visitor`, if the projected value does not escape.
   /// Returns nil, if the projected value escapes.
   ///
-  func visit<V: EscapeVisitorWithResult>(using visitor: V,
-                                         complexityBudget: Int = Int.max,
-                                         _ context: some Context) -> V.Result? {
+  func visit<V: EscapeVisitorWithResult>(
+    using visitor: V,
+    initialWalkingDirection: EscapeUtilityTypes.WalkingDirection = .up,
+    complexityBudget: Int = Int.max,
+    _ context: some Context
+  ) -> V.Result? {
     var walker = EscapeWalker(visitor: visitor, complexityBudget: complexityBudget, context)
-    if walker.walkUp(addressOrValue: value, path: path.escapePath) == .abortWalk {
-      walker.visitor.cleanupOnAbort()
-      return nil
+    let result: WalkResult
+    switch initialWalkingDirection {
+      case .up:   result = walker.walkUp(addressOrValue: value, path: path.escapePath)
+      case .down: result = walker.walkDown(addressOrValue: value, path: path.escapePath)
     }
-    return walker.visitor.result
-  }
-
-  /// Returns the result of the visitor if the projected value does not escape - ignoring
-  /// any potential escapes in the caller.
-  ///
-  /// This function is similar to `isEscapingIgnoringCallerEscapes() -> Bool`, but instead
-  /// of returning a Bool, it returns the `result` of the `visitor`.
-  ///
-  func visitByWalkingDown<V: EscapeVisitorWithResult>(using visitor: V,
-                                                      _ context: some Context) -> V.Result? {
-    var walker = EscapeWalker(visitor: visitor, context)
-    if walker.walkDown(addressOrValue: value, path: path.escapePath) == .abortWalk {
+    if result == .abortWalk {
       walker.visitor.cleanupOnAbort()
       return nil
     }
@@ -129,19 +117,25 @@ extension ProjectedValue {
 
 extension Value {
   /// The un-projected version of `ProjectedValue.isEscaping()`.
-  func isEscaping(using visitor: some EscapeVisitor = DefaultVisitor(),
-                  _ context: some Context) -> Bool {
-    return self.at(SmallProjectionPath()).isEscaping(using: visitor, context)
-  }
-
-  func isEscapingWhenWalkingDown(using visitor: some EscapeVisitor = DefaultVisitor(),
-                                 _ context: some Context) -> Bool {
-    return self.at(SmallProjectionPath()).isEscapingWhenWalkingDown(using: visitor, context)
+  func isEscaping(
+    using visitor: some EscapeVisitor = DefaultVisitor(),
+    initialWalkingDirection: EscapeUtilityTypes.WalkingDirection = .up,
+    _ context: some Context
+  ) -> Bool {
+    return self.at(SmallProjectionPath()).isEscaping(using: visitor,
+                                                     initialWalkingDirection: initialWalkingDirection,
+                                                     context)
   }
 
   /// The un-projected version of `ProjectedValue.visit()`.
-  func visit<V: EscapeVisitorWithResult>(using visitor: V, _ context: some Context) -> V.Result? {
-    return self.at(SmallProjectionPath()).visit(using: visitor, context)
+  func visit<V: EscapeVisitorWithResult>(
+    using visitor: V,
+    initialWalkingDirection: EscapeUtilityTypes.WalkingDirection = .up,
+    _ context: some Context
+  ) -> V.Result? {
+    return self.at(SmallProjectionPath()).visit(using: visitor,
+                                                initialWalkingDirection: initialWalkingDirection,
+                                                context)
   }
 }
 
@@ -198,6 +192,11 @@ struct DefaultVisitor : EscapeVisitor {}
 
 struct EscapeUtilityTypes {
 
+  enum WalkingDirection {
+    case up
+    case down
+  }
+
   /// The EscapePath is updated and maintained during the up-walk and down-walk.
   ///
   /// It's passed to the EscapeVisitor's `visitUse` and `visitDef`.