Fix convert_escape_to_noescape non-dominance errors

include/swift/SIL/SILBuilder.h

@@ -794,9 +794,11 @@ class SILBuilder {
   }
 
   ConvertEscapeToNoEscapeInst *
-  createConvertEscapeToNoEscape(SILLocation Loc, SILValue Op, SILType Ty) {
+  createConvertEscapeToNoEscape(SILLocation Loc, SILValue Op, SILType Ty,
+                                bool lifetimeGuaranteed) {
     return insert(ConvertEscapeToNoEscapeInst::create(
-        getSILDebugLocation(Loc), Op, Ty, getFunction(), OpenedArchetypes));
+        getSILDebugLocation(Loc), Op, Ty, getFunction(), OpenedArchetypes,
+        lifetimeGuaranteed));
   }
 
   ThinFunctionToPointerInst *

include/swift/SIL/SILCloner.h

@@ -984,10 +984,10 @@ template <typename ImplClass>
 void SILCloner<ImplClass>::visitConvertEscapeToNoEscapeInst(
     ConvertEscapeToNoEscapeInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  doPostProcess(Inst, getBuilder().createConvertEscapeToNoEscape(
-                          getOpLocation(Inst->getLoc()),
-                          getOpValue(Inst->getOperand()),
-                          getOpType(Inst->getType())));
+  doPostProcess(
+      Inst, getBuilder().createConvertEscapeToNoEscape(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+                getOpType(Inst->getType()), Inst->isLifetimeGuaranteed()));
 }
 
 template<typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -3951,18 +3951,26 @@ class ConvertEscapeToNoEscapeInst final
           ConvertEscapeToNoEscapeInst, ConversionInst> {
   friend SILBuilder;
 
+  bool lifetimeGuaranteed;
+
   ConvertEscapeToNoEscapeInst(SILDebugLocation DebugLoc, SILValue Operand,
-                               ArrayRef<SILValue> TypeDependentOperands,
-                               SILType Ty)
+                              ArrayRef<SILValue> TypeDependentOperands,
+                              SILType Ty, bool isLifetimeGuaranteed)
       : UnaryInstructionWithTypeDependentOperandsBase(
-            DebugLoc, Operand, TypeDependentOperands, Ty) {
+            DebugLoc, Operand, TypeDependentOperands, Ty),
+        lifetimeGuaranteed(isLifetimeGuaranteed) {
     assert(!Operand->getType().castTo<SILFunctionType>()->isNoEscape());
     assert(Ty.castTo<SILFunctionType>()->isNoEscape());
   }
 
   static ConvertEscapeToNoEscapeInst *
   create(SILDebugLocation DebugLoc, SILValue Operand, SILType Ty,
-         SILFunction &F, SILOpenedArchetypesState &OpenedArchetypes);
+         SILFunction &F, SILOpenedArchetypesState &OpenedArchetypes,
+         bool lifetimeGuaranteed);
+public:
+  bool isLifetimeGuaranteed() const {
+    return lifetimeGuaranteed;
+  }
 };
 
 /// ThinFunctionToPointerInst - Convert a thin function pointer to a

include/swift/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
 
-const uint16_t VERSION_MINOR = 406; // Last change: EnumElementDecl resilience expansion
+const uint16_t VERSION_MINOR = 407; // Last change: convert_escape_to_noescape
 
 using DeclIDField = BCFixed<31>;
 

lib/IRGen/LoadableByAddress.cpp

@@ -2495,7 +2495,8 @@ void LoadableByAddress::recreateConvInstrs() {
     case SILInstructionKind::ConvertEscapeToNoEscapeInst: {
       auto instr = cast<ConvertEscapeToNoEscapeInst>(convInstr);
       newInstr = convBuilder.createConvertEscapeToNoEscape(
-          instr->getLoc(), instr->getOperand(), newType);
+          instr->getLoc(), instr->getOperand(), newType,
+          instr->isLifetimeGuaranteed());
       break;
     }
     case SILInstructionKind::MarkDependenceInst: {

lib/ParseSIL/ParseSIL.cpp

@@ -2979,6 +2979,10 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     SILType Ty;
     Identifier ToToken;
     SourceLoc ToLoc;
+    bool guaranteed = true;
+    if (Opcode == SILInstructionKind::ConvertEscapeToNoEscapeInst)
+      if(parseSILOptional(guaranteed, *this, "not_guaranteed"))
+        return true;
     if (parseTypedValueRef(Val, B) ||
         parseSILIdentifier(ToToken, ToLoc,
                            diag::expected_tok_in_sil_instr, "to") ||
@@ -3012,7 +3016,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
       ResultVal = B.createConvertFunction(InstLoc, Val, Ty);
       break;
     case SILInstructionKind::ConvertEscapeToNoEscapeInst:
-      ResultVal = B.createConvertEscapeToNoEscape(InstLoc, Val, Ty);
+      ResultVal = B.createConvertEscapeToNoEscape(InstLoc, Val, Ty, guaranteed);
       break;
     case SILInstructionKind::AddressToPointerInst:
       ResultVal = B.createAddressToPointer(InstLoc, Val, Ty);

lib/SIL/SILInstructions.cpp

@@ -1998,7 +1998,7 @@ ConvertFunctionInst::create(SILDebugLocation DebugLoc, SILValue Operand,
 
 ConvertEscapeToNoEscapeInst *ConvertEscapeToNoEscapeInst::create(
     SILDebugLocation DebugLoc, SILValue Operand, SILType Ty, SILFunction &F,
-    SILOpenedArchetypesState &OpenedArchetypes) {
+    SILOpenedArchetypesState &OpenedArchetypes, bool isLifetimeGuaranteed) {
   SILModule &Mod = F.getModule();
   SmallVector<SILValue, 8> TypeDependentOperands;
   collectTypeDependentOperands(TypeDependentOperands, OpenedArchetypes, F,
@@ -2007,7 +2007,7 @@ ConvertEscapeToNoEscapeInst *ConvertEscapeToNoEscapeInst::create(
     totalSizeToAlloc<swift::Operand>(1 + TypeDependentOperands.size());
   void *Buffer = Mod.allocateInst(size, alignof(ConvertEscapeToNoEscapeInst));
   auto *CFI = ::new (Buffer) ConvertEscapeToNoEscapeInst(
-      DebugLoc, Operand, TypeDependentOperands, Ty);
+      DebugLoc, Operand, TypeDependentOperands, Ty, isLifetimeGuaranteed);
   // If we do not have lowered SIL, make sure that are not performing
   // ABI-incompatible conversions.
   //

lib/SIL/SILPrinter.cpp

@@ -1435,7 +1435,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     printUncheckedConversionInst(CI, CI->getOperand());
   }
   void visitConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *CI) {
-    printUncheckedConversionInst(CI, CI->getOperand());
+    *this << (CI->isLifetimeGuaranteed() ? "" : "[not_guaranteed] ")
+          << getIDAndType(CI->getOperand()) << " to " << CI->getType();
   }
   void visitThinFunctionToPointerInst(ThinFunctionToPointerInst *CI) {
     printUncheckedConversionInst(CI, CI->getOperand());

lib/SILGen/SILGenBuilder.cpp

@@ -207,9 +207,10 @@ ManagedValue SILGenBuilder::createConvertFunction(SILLocation loc,
   return cloner.clone(result);
 }
 
-ManagedValue SILGenBuilder::createConvertEscapeToNoEscape(SILLocation loc,
-                                                          ManagedValue fn,
-                                                          SILType resultTy) {
+ManagedValue SILGenBuilder::createConvertEscapeToNoEscape(
+    SILLocation loc, ManagedValue fn, SILType resultTy,
+    bool postponeToNoEscapeCleanup) {
+
   auto fnType = fn.getType().castTo<SILFunctionType>();
   auto resultFnType = resultTy.castTo<SILFunctionType>();
 
@@ -221,9 +222,13 @@ ManagedValue SILGenBuilder::createConvertEscapeToNoEscape(SILLocation loc,
          !fnType->isNoEscape() && resultFnType->isNoEscape() &&
          "Expect a escaping to noescape conversion");
 
-  SILValue fnValue = fn.ensurePlusOne(SGF, loc).forward(SGF);
-  SILValue result = createConvertEscapeToNoEscape(loc, fnValue, resultTy);
-  getSILGenFunction().enterPostponedCleanup(fnValue);
+  SILValue fnValue = postponeToNoEscapeCleanup
+                         ? fn.ensurePlusOne(SGF, loc).forward(SGF)
+                         : fn.getValue();
+  SILValue result = createConvertEscapeToNoEscape(loc, fnValue, resultTy,
+                                                  postponeToNoEscapeCleanup);
+  if (postponeToNoEscapeCleanup)
+    getSILGenFunction().enterPostponedCleanup(fnValue);
   return ManagedValue::forTrivialObjectRValue(result);
 }
 

lib/SILGen/SILGenBuilder.h

@@ -361,8 +361,10 @@ class SILGenBuilder : public SILBuilder {
                                      SILType resultTy);
 
   using SILBuilder::createConvertEscapeToNoEscape;
-  ManagedValue createConvertEscapeToNoEscape(SILLocation loc, ManagedValue fn,
-                                             SILType resultTy);
+  ManagedValue
+  createConvertEscapeToNoEscape(SILLocation loc, ManagedValue fn,
+                                SILType resultTy,
+                                bool postponeToNoEscapeCleanup = true);
 
   using SILBuilder::createStore;
   /// Forward \p value into \p address.

lib/SILGen/SILGenExpr.cpp

@@ -2090,8 +2090,11 @@ RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
   if (srcRepTy != srcTy)
     result = convertFunctionRepresentation(SGF, e, result, srcRepTy, srcTy);
 
-  if (srcTy != destTy)
-    result = SGF.emitTransformedValue(e, result, srcTy, destTy);
+  if (srcTy != destTy) {
+    bool postponeToNoEscapeCleanup = !isa<BindOptionalExpr>(e->getSubExpr());
+    result = SGF.emitTransformedValue(e, result, srcTy, destTy, SGFContext(),
+                                      postponeToNoEscapeCleanup);
+  }
 
   if (destTy != destRepTy)
     result = convertFunctionRepresentation(SGF, e, result, destTy, destRepTy);

lib/SILGen/SILGenFunction.h

@@ -1617,15 +1617,17 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ManagedValue emitTransformedValue(SILLocation loc, ManagedValue input,
                                     CanType inputType,
                                     CanType outputType,
-                                    SGFContext ctx = SGFContext());
+                                    SGFContext ctx = SGFContext(),
+                                    bool postponeToNoEscapeCleanup = true);
 
   /// Most general form of the above.
   ManagedValue emitTransformedValue(SILLocation loc, ManagedValue input,
                                     AbstractionPattern inputOrigType,
                                     CanType inputSubstType,
                                     AbstractionPattern outputOrigType,
                                     CanType outputSubstType,
-                                    SGFContext ctx = SGFContext());
+                                    SGFContext ctx = SGFContext(),
+                                    bool postponeToNoEscapeCleanup = true);
   RValue emitTransformedValue(SILLocation loc, RValue &&input,
                               AbstractionPattern inputOrigType,
                               CanType inputSubstType,

lib/SILGen/SILGenPoly.cpp

@@ -136,7 +136,8 @@ namespace {
                            CanType inputSubstType,
                            AbstractionPattern outputOrigType,
                            CanType outputSubstType,
-                           SGFContext ctxt);
+                           SGFContext ctxt,
+                           bool postponeToNoEscapeCleanup = true);
 
     /// Transform a metatype value.
     ManagedValue transformMetatype(ManagedValue fn,
@@ -159,7 +160,8 @@ namespace {
                                    CanAnyFunctionType inputSubstType,
                                    AbstractionPattern outputOrigType,
                                    CanAnyFunctionType outputSubstType,
-                                   const TypeLowering &expectedTL);
+                                   const TypeLowering &expectedTL,
+                                   bool postponeToNoEscapeCleanup = true);
   };
 } // end anonymous namespace
 ;
@@ -356,7 +358,8 @@ ManagedValue Transform::transform(ManagedValue v,
                                   CanType inputSubstType,
                                   AbstractionPattern outputOrigType,
                                   CanType outputSubstType,
-                                  SGFContext ctxt) {
+                                  SGFContext ctxt,
+                                  bool postponeToNoEscapeCleanup) {
   // Look through inout types.
   if (isa<InOutType>(inputSubstType))
     inputSubstType = CanType(inputSubstType->getInOutObjectType());
@@ -440,7 +443,8 @@ ManagedValue Transform::transform(ManagedValue v,
     return transformFunction(v,
                              inputOrigType, inputFnType,
                              outputOrigType, outputFnType,
-                             expectedTL);
+                             expectedTL,
+                             postponeToNoEscapeCleanup);
   }
 
   //  - tuples of transformable values
@@ -3041,7 +3045,8 @@ ManagedValue Transform::transformFunction(ManagedValue fn,
                                           CanAnyFunctionType inputSubstType,
                                           AbstractionPattern outputOrigType,
                                           CanAnyFunctionType outputSubstType,
-                                          const TypeLowering &expectedTL) {
+                                          const TypeLowering &expectedTL,
+                                          bool postponeToNoEscapeCleanup) {
   assert(fn.getType().isObject() &&
          "expected input to emitTransformedFunctionValue to be loaded");
 
@@ -3100,7 +3105,8 @@ ManagedValue Transform::transformFunction(ManagedValue fn,
   } else if (newFnType != expectedFnType) {
     // Escaping to noescape conversion.
     SILType resTy = SILType::getPrimitiveObjectType(expectedFnType);
-    fn = SGF.B.createConvertEscapeToNoEscape(Loc, fn, resTy);
+    fn = SGF.B.createConvertEscapeToNoEscape(Loc, fn, resTy,
+                                             postponeToNoEscapeCleanup);
   }
 
   return fn;
@@ -3196,11 +3202,12 @@ ManagedValue
 SILGenFunction::emitTransformedValue(SILLocation loc, ManagedValue v,
                                      CanType inputType,
                                      CanType outputType,
-                                     SGFContext ctxt) {
+                                     SGFContext ctxt,
+                                     bool postponeToNoEscapeCleanup) {
   return emitTransformedValue(loc, v,
                               AbstractionPattern(inputType), inputType,
                               AbstractionPattern(outputType), outputType,
-                              ctxt);
+                              ctxt, postponeToNoEscapeCleanup);
 }
 
 ManagedValue
@@ -3209,12 +3216,14 @@ SILGenFunction::emitTransformedValue(SILLocation loc, ManagedValue v,
                                      CanType inputSubstType,
                                      AbstractionPattern outputOrigType,
                                      CanType outputSubstType,
-                                     SGFContext ctxt) {
+                                     SGFContext ctxt,
+                                     bool postponeToNoEscapeCleanup) {
   return Transform(*this, loc).transform(v,
                                          inputOrigType,
                                          inputSubstType,
                                          outputOrigType,
-                                         outputSubstType, ctxt);
+                                         outputSubstType, ctxt,
+                                         postponeToNoEscapeCleanup);
 }
 
 RValue

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -662,8 +662,8 @@ SILValue ClosureSpecCloner::cloneCalleeConversion(SILValue calleeValue,
 
   auto *Cvt = cast<ConvertEscapeToNoEscapeInst>(calleeValue);
   calleeValue = cloneCalleeConversion(Cvt->getOperand(), NewClosure, Builder);
-  return Builder.createConvertEscapeToNoEscape(CallSiteDesc.getLoc(),
-                                               calleeValue, Cvt->getType());
+  return Builder.createConvertEscapeToNoEscape(
+      CallSiteDesc.getLoc(), calleeValue, Cvt->getType(), true);
 }
 
 /// \brief Populate the body of the cloned closure, modifying instructions as