Swift AccessUtils: improve ergonomics of getAccessPathWithScope

It doesn't make sense to let getAccessPathWithScope return an `EnclosingScope` as the second tuple element, because in case it's a `base`, it duplicates the `AccessBase` (which is returned in the first tuple element).
Instead just return an optional `BeginAccessInst` which is not nil if such an "scope" is found.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -61,10 +61,9 @@ private func printAccessInfo(address: Value) {
 
   var apw = AccessPathWalker()
   let (ap, scope) = apw.getAccessPathWithScope(of: address)
-  switch scope {
-  case let .scope(ba):
-    print("  Scope: \(ba)")
-  case .base(_):
+  if let beginAccess = scope {
+    print("  Scope: \(beginAccess)")
+  } else {
     print("  Scope: base")
   }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -381,34 +381,31 @@ struct AccessPathWalker {
     return walker.result
   }
 
-  mutating func getAccessPathWithScope(of address: Value) -> (AccessPath, EnclosingScope) {
+  mutating func getAccessPathWithScope(of address: Value) -> (AccessPath, scope: BeginAccessInst?) {
     let ap = getAccessPath(of: address)
-    return (ap, walker.scope)
+    return (ap, walker.foundBeginAccess)
   }
 
   mutating func getAccessBase(of address: Value) -> AccessBase {
     getAccessPath(of: address).base
   }
 
-  mutating func getAccessScope(of address: Value) -> EnclosingScope {
-    getAccessPathWithScope(of: address).1
+  mutating func getEnclosingScope(of address: Value) -> EnclosingScope {
+    let accessPath = getAccessPath(of: address)
+  
+    if let ba = walker.foundBeginAccess {
+      return .scope(ba)
+    }
+    return .base(accessPath.base)
   }
 
   private var walker = Walker()
 
   private struct Walker : AddressUseDefWalker {
     private(set) var result = AccessPath.unidentified()
-    private var foundBeginAccess: BeginAccessInst? = nil
+    private(set) var foundBeginAccess: BeginAccessInst?
     private var pointerId = PointerIdentification()
 
-    var scope: EnclosingScope {
-      if let ba = foundBeginAccess {
-        return .scope(ba)
-      } else {
-        return .base(result.base)
-      }
-    }
-
     mutating func start() {
       result = .unidentified()
       foundBeginAccess = nil
@@ -489,11 +486,23 @@ extension Value {
     var apWalker = AccessPathWalker()
     return apWalker.getAccessBase(of: self)
   }
-  
+
+  /// Computes the access path of this address value.
+  var accessPath: AccessPath {
+    var apWalker = AccessPathWalker()
+    return apWalker.getAccessPath(of: self)
+  }
+
+  /// Computes the access path of this address value and also returns the scope.
+  var accessPathWithScope: (AccessPath, scope: BeginAccessInst?) {
+    var apWalker = AccessPathWalker()
+    return apWalker.getAccessPathWithScope(of: self)
+  }
+
   /// Computes the enclosing access scope of this address value.
-  var accessScope: EnclosingScope {
+  var enclosingAccessScope: EnclosingScope {
     var apWalker = AccessPathWalker()
-    return apWalker.getAccessScope(of: self)
+    return apWalker.getEnclosingScope(of: self)
   }
 }