Fix SILType::isEscapable for box types.

SILBoxTypes have their own generic signature and substitution
map. This means that every time we query isEscapable or mayEscape, we
need to extract the type of the box's field and perform type
substitution so that the AST query only sees types from the function's
generic environment.

Fixes rdar://124179106 (Assertion failed in SIL:
(!type->hasTypeParameter() && "caller forgot to mapTypeIntoContext!"))

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 : $()
+}