Merge pull request #72150 from atrick/fix-isescapable

Fix SILType::isEscapable for box types.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -414,7 +414,7 @@ private struct ComputeNonEscapingLiferange : EscapeVisitorWithResult {
       if dominates {
         liferange.insert(user)
       }
-      if !apply.type.isEscapable {
+      if !apply.isEscapable {
         return .abort
       }
       return .ignore

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -35,7 +35,9 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
   log(" --- Diagnosing lifetime dependence in \(function.name)")
   log("\(function)")
 
-  for argument in function.arguments where !argument.type.isEscapable {
+  for argument in function.arguments
+      where !argument.type.isEscapable(in: function)
+  {
     // Indirect results are not checked here. Type checking ensures
     // that they have a lifetime dependence.
     if let lifetimeDep = LifetimeDependence(argument, context) {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -219,7 +219,7 @@ extension LifetimeDependence {
   //
   // TODO: handle indirect results
   init?(unsafeApplyResult value: Value, _ context: some Context) {
-    if value.type.isEscapable {
+    if value.isEscapable {
       return nil
     }
     if (value.definingInstruction as! FullApplySite).hasResultDependence {
@@ -832,7 +832,7 @@ extension LifetimeDependenceDefUseWalker {
   mutating func walkDownUses(of value: Value, using operand: Operand?)
     -> WalkResult {
     // Only track ~Escapable and @noescape types.
-    if value.type.mayEscape {
+    if value.mayEscape {
       return .continueWalk
     }
     return walkDownUsesDefault(forwarding: value, using: operand)
@@ -857,10 +857,10 @@ extension LifetimeDependenceDefUseWalker {
     if let apply = operand.instruction as? FullApplySite {
       return visitAppliedUse(of: operand, by: apply)
     }
-    if operand.instruction is ReturnInst, !operand.value.type.isEscapable {
+    if operand.instruction is ReturnInst, !operand.value.isEscapable {
       return returnedDependence(result: operand)
     }
-    if operand.instruction is YieldInst, !operand.value.type.isEscapable {
+    if operand.instruction is YieldInst, !operand.value.isEscapable {
       return yieldedDependence(result: operand)
     }
     return escapingDependence(on: operand)
@@ -1025,10 +1025,10 @@ extension LifetimeDependenceDefUseWalker {
       assert(!mdi.isUnresolved && !mdi.isNonEscaping,
              "should be handled as a dependence by AddressUseVisitor")
     }
-    if operand.instruction is ReturnInst, !operand.value.type.isEscapable {
+    if operand.instruction is ReturnInst, !operand.value.isEscapable {
       return returnedDependence(result: operand)
     }
-    if operand.instruction is YieldInst, !operand.value.type.isEscapable {
+    if operand.instruction is YieldInst, !operand.value.isEscapable {
       return yieldedDependence(result: operand)
     }
     return escapingDependence(on: operand)
@@ -1088,19 +1088,19 @@ extension LifetimeDependenceDefUseWalker {
     case let .argument(arg):
       if arg.convention.isIndirectIn || arg.convention.isInout {
         allocation = arg
-      } else if arg.convention.isIndirectOut, !arg.type.isEscapable {
+      } else if arg.convention.isIndirectOut, !arg.isEscapable {
         return returnedDependence(address: arg, using: operand)
       }
       break
     case .global, .class, .tail, .yield, .pointer, .unidentified:
       break
     }
     if let allocation = allocation {
-      if !allocation.type.objectType.isEscapable {
+      if !allocation.isEscapable {
         return visitLocalStore(allocation: allocation, storedOperand: operand, storeAddress: address)
       }
     }
-    if address.type.objectType.isEscapable {
+    if address.isEscapable {
       return .continueWalk
     }
     return escapingDependence(on: operand)
@@ -1179,13 +1179,13 @@ extension LifetimeDependenceDefUseWalker {
       // If the lifetime dependence is scoped, then we can ignore it
       // because a mark_dependence [nonescaping] represents the
       // dependence.
-      if let result = apply.singleDirectResult, !result.type.isEscapable {
+      if let result = apply.singleDirectResult, !result.isEscapable {
         if dependentUse(of: operand, into: result) == .abortWalk {
           return .abortWalk
         }
       }
       for resultAddr in apply.indirectResultOperands
-          where !resultAddr.value.type.isEscapable {
+          where !resultAddr.value.isEscapable {
         if visitStoredUses(of: operand, into: resultAddr.value) == .abortWalk {
           return .abortWalk
         }

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -63,8 +63,12 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
 
   public var isMoveOnly: Bool { bridged.isMoveOnly() }
 
-  public var isEscapable: Bool { bridged.isEscapable() }
-  public var mayEscape: Bool { !isNoEscapeFunction && isEscapable }
+  public func isEscapable(in function: Function) -> Bool {
+    bridged.isEscapable(function.bridged)
+  }
+  public func mayEscape(in function: Function) -> Bool {
+    !isNoEscapeFunction && isEscapable(in: function)
+  }
 
   /// Can only be used if the type is in fact a nominal type (`isNominal` is true).
   public var nominal: NominalTypeDecl {
@@ -146,6 +150,16 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   }
 }
 
+extension Value {
+  public var isEscapable: Bool {
+    type.objectType.isEscapable(in: parentFunction)
+  }
+
+  public var mayEscape: Bool {
+    type.objectType.mayEscape(in: parentFunction)
+  }
+}
+
 extension Type: Equatable {
   public static func ==(lhs: Type, rhs: Type) -> Bool { 
     lhs.bridged.opaqueValue == rhs.bridged.opaqueValue

include/swift/SIL/SILBridging.h

@@ -350,7 +350,7 @@ struct BridgedType {
   BRIDGED_INLINE bool isEmpty(BridgedFunction f) const;
   BRIDGED_INLINE TraitResult canBeClass() const;
   BRIDGED_INLINE bool isMoveOnly() const;
-  BRIDGED_INLINE bool isEscapable() const;
+  BRIDGED_INLINE bool isEscapable(BridgedFunction f) const;
   BRIDGED_INLINE bool isOrContainsObjectiveCClass() const;
   BRIDGED_INLINE bool isBuiltinInteger() const;
   BRIDGED_INLINE bool isBuiltinFloat() const;

include/swift/SIL/SILBridgingImpl.h

@@ -274,8 +274,8 @@ bool BridgedType::isMoveOnly() const {
   return unbridged().isMoveOnly();
 }
 
-bool BridgedType::isEscapable() const {
-  return unbridged().isEscapable();
+bool BridgedType::isEscapable(BridgedFunction f) const {
+  return unbridged().isEscapable(*f.getFunction());
 }
 
 bool BridgedType::isOrContainsObjectiveCClass() const {

include/swift/SIL/SILType.h

@@ -897,13 +897,15 @@ class SILType {
 
   /// False if SILValues of this type cannot be used outside the scope of their
   /// lifetime dependence.
-  bool isEscapable() const;
+  bool isEscapable(const SILFunction &function) const;
 
   /// True for (isEscapable && !isNoEscapeFunction)
   ///
   /// Equivalent to getASTType()->mayEscape(), but handles SIL-specific types,
   /// namely SILFunctionType.
-  bool mayEscape() const { return !isNoEscapeFunction() && isEscapable(); }
+  bool mayEscape(const SILFunction &function) const {
+    return !isNoEscapeFunction() && isEscapable(function);
+  }
 
   //
   // Accessors for types used in SIL instructions:

lib/SIL/IR/SILType.cpp

@@ -1051,7 +1051,7 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
   return SILType();
 }
 
-bool SILType::isEscapable() const {
+bool SILType::isEscapable(const SILFunction &function) const {
   CanType ty = getASTType();
 
   // For storage with reference ownership, check the referent.
@@ -1065,7 +1065,8 @@ bool SILType::isEscapable() const {
   if (auto boxTy = getAs<SILBoxType>()) {
     auto fields = boxTy->getLayout()->getFields();
     assert(fields.size() == 1);
-    ty = fields[0].getLoweredType();
+    ty = ::getSILBoxFieldLoweredType(function.getTypeExpansionContext(), boxTy,
+                                     function.getModule().Types, 0);
   }
 
   // TODO: Support ~Escapable in parameter packs.

test/SILOptimizer/lifetime_dependence_diagnostics_generic.sil

@@ -0,0 +1,18 @@
+// RUN: %target-sil-opt %s \
+// RUN:   -o /dev/null \
+// RUN:   -sil-verify-all \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -enable-experimental-feature NoncopyableGenerics \
+// RUN:   -lifetime-dependence-diagnostics
+
+// REQUIRES: asserts
+// REQUIRES: swift_in_compiler
+
+sil_stage raw
+
+// Test that SILType.isEscpable does not crash on a generic box when NoncopyableGenerics is enabled.
+sil shared [serialized] [ossa] @testLocalFunc : $@convention(thin) <T, U> (@guaranteed <τ_0_0> { var τ_0_0 } <U>) -> () {
+bb0(%1 : @closureCapture @guaranteed $<τ_0_0> { var τ_0_0 } <U>):
+  %33 = tuple ()
+  return %33 : $()
+}