Add AccessBase::hasLocalOwnershipLifetime()

Replaces AccessStorage::isGuaranteedForFunction().

OSSA utilities need to determine whether two addresses with the same
AccessStorage are directly substitutable without "fixing-up" the OSSA
lifetime. Checking whether the access base is within a local borrow
scope is the first step.

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -610,6 +610,16 @@ class AccessBase : public AccessRepresentation {
   /// determined. Otherwise returns null.
   const ValueDecl *getDecl() const;
 
+  /// Return true if this base address may be derived from a reference that is
+  /// only valid within a locally scoped OSSA lifetime. This is not true for
+  /// scoped storage such as alloc_stack and @in argument. It can be
+  /// independently assumed that addresses are only used within the scope of the
+  /// storage object.
+  ///
+  /// Useful to determine whether addresses with the same AccessStorage are in
+  /// fact substitutable without fixing OSSA lifetime.
+  bool hasLocalOwnershipLifetime() const;
+
   void print(raw_ostream &os) const;
   void dump() const;
 };
@@ -745,10 +755,6 @@ class AccessStorage : public AccessRepresentation {
     return hasIdenticalAccessInfo(other);
   }
 
-  /// Return true if this storage is valid for all uses in a function without
-  /// checking its lifetime.
-  bool isGuaranteedForFunction() const;
-
   /// Returns the ValueDecl for the underlying storage, if it can be
   /// determined. Otherwise returns null.
   const ValueDecl *getDecl() const;

lib/SIL/Utils/MemAccessUtils.cpp

@@ -642,6 +642,30 @@ const ValueDecl *AccessBase::getDecl() const {
   }
 }
 
+bool AccessBase::hasLocalOwnershipLifetime() const {
+  switch (getKind()) {
+  case AccessBase::Argument:
+  case AccessBase::Stack:
+  case AccessBase::Global:
+    return false;
+  case AccessBase::Unidentified:
+    // Unidentified storage may be nested within object access, but this is an
+    // "escaped pointer", so it is not restricted to the object's borrow scope.
+    return false;
+  case AccessBase::Yield:
+    // Yielded values have a local apply scope, but they never have the same
+    // storage as yielded values from a different scope, so there is no need to
+    // consider their local scope during substitution.
+    return false;
+  case AccessBase::Box:
+  case AccessBase::Class:
+  case AccessBase::Tail:
+    return getReference()->getOwnershipKind() != OwnershipKind::None;
+  case AccessBase::Nested:
+    llvm_unreachable("unexpected storage");
+  };
+}
+
 void AccessBase::print(raw_ostream &os) const {
   AccessRepresentation::print(os);
   switch (getKind()) {
@@ -835,17 +859,6 @@ void AccessStorage::visitRoots(
   }
 }
 
-bool AccessStorage::isGuaranteedForFunction() const {
-  if (getKind() == AccessStorage::Argument) {
-    return getArgument()->getArgumentConvention().isGuaranteedConvention();
-  }
-  if (isObjectAccess()) {
-    return getRoot().getOwnershipKind() == OwnershipKind::Guaranteed
-           && isa<SILFunctionArgument>(getRoot());
-  }
-  return false;
-}
-
 const ValueDecl *AccessStorage::getDecl() const {
   switch (getKind()) {
   case Box: