Merge pull request #75225 from atrick/init-proj

LocalVariableUtils: handle projections inside initializers.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift

@@ -149,7 +149,11 @@ class LocalVariableAccessInfo: CustomStringConvertible {
     case .load:
       self._isFullyAssigned = false
     case .store:
-      self._isFullyAssigned = true
+      if let store = localAccess.instruction as? StoringInstruction {
+        self._isFullyAssigned = LocalVariableAccessInfo.isBase(address: store.source)
+      } else {
+        self._isFullyAssigned = true
+      }
     case .apply:
       let apply = localAccess.instruction as! FullApplySite
       if let convention = apply.convention(of: localAccess.operand!) {
@@ -191,6 +195,18 @@ class LocalVariableAccessInfo: CustomStringConvertible {
     return "full-assign: \(_isFullyAssigned == nil ? "unknown" : String(describing: _isFullyAssigned!)) "
       + "\(access)"
   }
+
+  // Does this address correspond to the local variable's base address? Any writes to this address will be a full
+  // assignment. This should match any instructions that the LocalVariableAccessMap initializer below recognizes as an
+  // allocation.
+  static private func isBase(address: Value) -> Bool {
+    switch address {
+    case is AllocBoxInst, is AllocStackInst, is BeginAccessInst:
+      return true
+    default:
+      return false
+    }
+  }
 }
 
 /// Model the formal accesses of an addressible variable introduced by an alloc_box, alloc_stack, or indirect
@@ -363,24 +379,14 @@ extension LocalVariableAccessWalker: AddressUseVisitor {
     return .continueWalk
   }
 
-  // Handle storage type projections, like MarkUninitializedInst. Path projections should not be visited. They only
-  // occur inside the access.
+  // Handle storage type projections, like MarkUninitializedInst. Path projections are visited for field
+  // initialization because SILGen does not emit begin_access [init] consistently.
   //
-  // Exception: stack-allocated temporaries may be treated like local variables for the purpose of finding all
-  // uses. Such temporaries do not have access scopes, so we need to walk down any projection that may be used to
-  // initialize the temporary.
+  // Stack-allocated temporaries are also treated like local variables for the purpose of finding all uses. Such
+  // temporaries do not have access scopes, so we need to walk down any projection that may be used to initialize the
+  // temporary.
   mutating func projectedAddressUse(of operand: Operand, into value: Value) -> WalkResult {
-    // TODO: we need an abstraction for path projections. For local variables, these cannot occur outside of an access.
-    switch operand.instruction {
-    case is StructElementAddrInst, is TupleElementAddrInst, is IndexAddrInst, is TailAddrInst,
-         is UncheckedTakeEnumDataAddrInst, is OpenExistentialAddrInst:
-      return .abortWalk
-    // Projections used to initialize a temporary
-    case is InitEnumDataAddrInst, is InitExistentialAddrInst:
-      fallthrough
-    default:
-      return walkDownAddressUses(address: value)
-    }
+    return walkDownAddressUses(address: value)
   }
 
   mutating func scopedAddressUse(of operand: Operand) -> WalkResult {

test/SILOptimizer/lifetime_dependence/initializer.swift

@@ -0,0 +1,46 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -enable-experimental-feature NonescapableTypes
+
+// REQUIRES: asserts
+// REQUIRES: swift_in_compiler
+
+struct Span<T>: ~Escapable {
+  private var base: UnsafePointer<T>
+  private var count: Int
+
+  @_unsafeNonescapableResult
+  init(base: UnsafePointer<T>, count: Int) {
+    self.base = base
+    self.count = count
+  }
+
+  init<S>(base: UnsafePointer<T>, count: Int, generic: borrowing S) -> dependsOn(generic) Self {
+    self.base = base
+    self.count = count
+  }
+}
+
+struct Wrapper<T: BitwiseCopyable>: ~Escapable {
+  private let span: Span<T>
+
+  init(span: borrowing Span<T>) {
+    self.span = copy span
+  }
+}
+
+struct SuperWrapper<T: BitwiseCopyable>: ~Escapable {
+  private let wrapper: Wrapper<T>
+
+  // An extra field forces a projection on 'self' within the initializer without any access scope.
+  var depth: Int = 0
+
+  // Make sure that LocalVariableUtils can successfully analyze 'self'. That's required to determine that the assignment
+  // of `wrapper` is returned without escaping
+  init(span: borrowing Span<T>) {
+    self.wrapper = Wrapper(span: span)
+  }
+}