Swift Optimizer: add SmallProjectionWalkingPaths in WalkUtils

- This protocol with its default implementations simplifies
  writing walkers, requiring only `merge` for conformance

Author: Anxhelo Xhebraj

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeInfo.swift

@@ -65,8 +65,7 @@ struct EscapeInfo<V: EscapeInfoVisitor> {
   /// The EscapePath is updated and maintained during the up-walk and down-walk.
   ///
   /// It's passed to the EscapeInfoVisitor's `visitUse` and `visitDef`.
-  struct EscapePath: WalkingPath {
-
+  struct EscapePath: SmallProjectionWalkingPath {
     /// During the walk, a projection path indicates where the initial value is
     /// contained in an aggregate.
     /// Example for a walk-down:
@@ -115,12 +114,16 @@ struct EscapeInfo<V: EscapeInfoVisitor> {
     /// \endcode
     let knownType: Type?
 
+    func with(projectionPath: SmallProjectionPath) -> Self {
+      return Self(projectionPath: projectionPath, followStores: self.followStores, knownType: self.knownType)
+    }
+
     func with(followStores: Bool) -> Self {
-      return Self(projectionPath: projectionPath, followStores: followStores, knownType: self.knownType)
+      return Self(projectionPath: self.projectionPath, followStores: followStores, knownType: self.knownType)
     }
 
     func with(knownType: Type?) -> Self {
-      return Self(projectionPath: projectionPath, followStores: self.followStores, knownType: knownType)
+      return Self(projectionPath: self.projectionPath, followStores: self.followStores, knownType: knownType)
     }
 
     func merge(with other: EscapePath) -> EscapePath {
@@ -138,25 +141,6 @@ struct EscapeInfo<V: EscapeInfoVisitor> {
       }
       return EscapePath(projectionPath: mergedPath, followStores: mergedFollowStores, knownType: mergedKnownType)
     }
-
-    // The following push and pop functions simply forward to the projectionPath.
-
-    func pop(kind: FieldKind) -> (index: Int, path: Self)? {
-      if let (idx, p) = projectionPath.pop(kind: kind) {
-        return (idx, EscapePath(projectionPath: p, followStores: followStores, knownType: knownType))
-      }
-      return nil
-    }
-    func popIfMatches(_ kind: FieldKind, index: Int?) -> Self? {
-      if let p = projectionPath.popIfMatches(kind, index: index) {
-        return EscapePath(projectionPath: p, followStores: followStores, knownType: knownType)
-      }
-      return nil
-    }
-    func push(_ kind: FieldKind, index: Int) -> Self {
-      return EscapePath(projectionPath: projectionPath.push(kind, index:index), followStores: followStores, knownType: knownType)
-    }
-
   }
 
   enum DefVisitResult {

SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift

@@ -69,6 +69,43 @@ protocol WalkingPath : Equatable {
 
 extension SmallProjectionPath : WalkingPath { }
 
+/// A `WalkingPath` where `push` and `pop` instructions
+/// are forwarded to an underlying `projectionPath`.
+protocol SmallProjectionWalkingPath : WalkingPath {
+  /// During the walk, a projection path indicates where the initial value is
+  /// contained in an aggregate.
+  /// Example for a walk-down:
+  /// \code
+  ///   %1 = alloc_ref                   // 1. initial value, path = empty
+  ///   %2 = struct $S (%1)              // 2. path = s0
+  ///   %3 = tuple (%other, %1)          // 3. path = t1.s0
+  ///   %4 = tuple_extract %3, 1         // 4. path = s0
+  ///   %5 = struct_extract %4, #field   // 5. path = empty
+  /// \endcode
+  ///
+  var projectionPath: SmallProjectionPath { get }
+  func with(projectionPath: SmallProjectionPath) -> Self
+}
+
+extension SmallProjectionWalkingPath {
+  func pop(kind: FieldKind) -> (index: Int, path: Self)? {
+    if let (idx, p) = projectionPath.pop(kind: kind) {
+      return (idx, with(projectionPath: p))
+    }
+    return nil
+  }
+
+  func popIfMatches(_ kind: FieldKind, index: Int?) -> Self? {
+    if let p = projectionPath.popIfMatches(kind, index: index) {
+      return with(projectionPath: p)
+    }
+    return nil
+  }
+  func push(_ kind: FieldKind, index: Int) -> Self {
+    return with(projectionPath: projectionPath.push(kind, index: index))
+  }
+}
+
 /// Caches the state of a walk.
 ///
 /// A client must provide this cache in a `walkUpCache` or `walkDownCache` property.