Swift SIL: add ProjectedValue.

A projected value consists of the original value and a projection path.
For example, if the `value` is of type `struct S { var x: Int }` and `path` is `s0`, then the projected value represents field `x` of the original value.

Also, use ProjectedValue instead of AccessStoragePath.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -50,9 +50,9 @@ let accessDumper = FunctionPass(name: "dump-access", {
 
 private struct AccessStoragePathVisitor : AccessStoragePathWalker {
   var walkUpCache = WalkerCache<Path>()
-  mutating func visit(access: AccessStoragePath) {
-    print("    Storage: \(access.storage)")
-    print("    Path: \"\(access.path)\"")
+  mutating func visit(accessStoragePath: ProjectedValue) {
+    print("    Storage: \(accessStoragePath.value)")
+    print("    Path: \"\(accessStoragePath.path)\"")
   }
 }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -15,12 +15,12 @@
 // - `AccessPath`: a pair of an `AccessBase` and `SmallProjectionPath` with the
 //   the path describing the specific address (in terms of projections) of the
 //   access.
-// - `AccessStoragePath`: identifies the reference (or a value which contains a
-//   reference) an address originates from.
+// - Access storage path (which is of type `ProjectedValue`): identifies the
+//   reference (or a value which contains a reference) an address originates from.
 //
 // The snippet below shows the relationship between the access concepts.
 // ```
-// %ref = struct_extract %value, #f1                                         AccessStoragePath
+// %ref = struct_extract %value, #f1                                        access storage path
 // %base = ref_element_addr %ref, #f2         AccessBase       AccessPath            |
 // %scope = begin_access %base                AccessScope          |                 |
 // %t = tuple_element_addr %scope, 0                               |                 |
@@ -253,22 +253,6 @@ struct AccessPath : CustomStringConvertible {
   }
 }
 
-/// An `AccessStoragePath` is the reference (or a value which contains a reference)
-/// an address originates from.
-/// In the following example the `storage` is `contains_ref` with `path` `"s0.c0.s0"`
-/// ```
-///   %ref = struct_extract %contains_ref : $S, #S.l
-///   %base = ref_element_addr %ref : $List, #List.x
-///   %addr = struct_element_addr %base : $X, #X.e
-///   store %v to [trivial] %addr : $*Int
-/// ```
-struct AccessStoragePath {
-  let storage: Value
-
-  /// Only valid paths are: `"<sequence of value projections>.<one reference projection>.<sequence of address projections>"`
-  let path: SmallProjectionPath
-}
-
 private func canBeOperandOfIndexAddr(_ value: Value) -> Bool {
   switch value {
   case is IndexAddrInst, is RefTailAddrInst, is PointerToAddressInst:
@@ -506,10 +490,19 @@ extension Value {
   }
 }
 
-/// A ValueUseDef walker that identifies which values a reference of an access path might
-/// originate from.
+/// A ValueUseDef walker that that visits access storage paths of an address.
+///
+/// An access storage path is the reference (or a value which contains a reference)
+/// an address originates from.
+/// In the following example the `storage` is `contains_ref` with `path` `"s0.c0.s0"`
+/// ```
+///   %ref = struct_extract %contains_ref : $S, #S.l
+///   %base = ref_element_addr %ref : $List, #List.x
+///   %addr = struct_element_addr %base : $X, #X.e
+///   store %v to [trivial] %addr : $*Int
+/// ```
 protocol AccessStoragePathWalker : ValueUseDefWalker where Path == SmallProjectionPath {
-  mutating func visit(access: AccessStoragePath)
+  mutating func visit(accessStoragePath: ProjectedValue)
 }
 
 extension AccessStoragePathWalker {
@@ -534,7 +527,7 @@ extension AccessStoragePathWalker {
   }
 
   mutating func rootDef(value: Value, path: SmallProjectionPath) -> WalkResult {
-    visit(access: AccessStoragePath(storage: value, path: path))
+    visit(accessStoragePath: value.at(path))
     return .continueWalk
   }
 }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -118,6 +118,30 @@ public func !=(_ lhs: Value, _ rhs: Value) -> Bool {
   return !(lhs === rhs)
 }
 
+/// A projected value, which is defined by the original value and a projection path.
+///
+/// For example, if the `value` is of type `struct S { var x: Int }` and `path` is `s0`,
+/// then the projected value represents field `x` of the original value.
+/// An empty path means represents the "whole" original value.
+///
+public struct ProjectedValue {
+  public let value: Value
+  public let path: SmallProjectionPath
+}
+
+extension Value {
+  /// Returns a projected value, defined by this value and `path`.
+  public func at(_ path: SmallProjectionPath) -> ProjectedValue {
+    ProjectedValue(value: self, path: path)
+  }
+
+  /// Returns a projected value, defined by this value and path containig a single field of `kind` and `index`.
+  public func at(_ kind: SmallProjectionPath.FieldKind, index: Int = 0) -> ProjectedValue {
+    ProjectedValue(value: self, path: SmallProjectionPath(kind, index: index))
+  }
+}
+
+
 extension BridgedValue {
   public func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }
 

docs/SIL-Utilities.md

@@ -40,6 +40,20 @@ To be used for all kind of basic-block work-list algorithms.
 **Related C++ utilities:** `BasicBlockWorklist`
 **Status:** done
 
+## SIL data structures
+
+#### `SmallProjectionPath`
+Describes a path of projections.
+
+**Related C++ utilities:** `AccessPath`, `ProjectionPath`  
+**Status:** done
+
+### `ProjectedValue`
+A projected value is defined by the original value and a projection path.
+
+**Related C++ utilities:** `AccessPath`
+**Status:** done
+
 ## Building SIL
 
 #### `static Builder.insert(after:, insertFunc: (Builder) -> ())`
@@ -61,12 +75,6 @@ This consists of four protocols, which can be implemented to walk up or down the
 **Related C++ utilities:** `AccessPath`, `RCIdentityAnalysis`, various def-use/use-def walkers in optimization passes.  
 **Status:** done
 
-#### `SmallProjectionPath`
-Describes a path of projections.
-
-**Related C++ utilities:** `AccessPath`, `ProjectionPath`  
-**Status:** done
-
 #### `EscapeInfo`
 Escape analysis, which is used e.g. in stack promotion or alias analysis.