[5.6] Upstream defer handling for the move function

include/swift/Basic/BlotSetVector.h

@@ -113,7 +113,7 @@ class BlotSetVector {
     return {index, true};
   }
 
-  bool count(const ValueT &value) { return map.count(value); }
+  bool count(const ValueT &value) const { return map.count(value); }
 
   /// Replace \p value1 with \p value2 placing \p value2 into the position in
   /// the array where value1 used to be. If \p value2 is already in the set,

include/swift/Demangling/Demangle.h

@@ -108,6 +108,7 @@ enum class FunctionSigSpecializationParamKind : unsigned {
   ClosureProp = 5,
   BoxToValue = 6,
   BoxToStack = 7,
+  InOutToOut = 8,
 
   // Option Set Flags use bits 6-31. This gives us 26 bits to use for option
   // flags.
@@ -144,6 +145,7 @@ enum class SpecializationPass : uint8_t {
   CapturePropagation,
   FunctionSignatureOpts,
   GenericSpecializer,
+  MoveDiagnosticInOutToOut,
 };
 
 static inline char encodeSpecializationPass(SpecializationPass Pass) {

include/swift/SIL/SILCloner.h

@@ -128,6 +128,14 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
                          ArrayRef<SILValue> entryArgs,
                          bool replaceOriginalFunctionInPlace = false);
 
+  /// The same as clone function body, except the caller can provide a callback
+  /// that allows for an entry arg to be assigned to a custom old argument. This
+  /// is useful if one re-arranges parameters when converting from inout to out.
+  void
+  cloneFunctionBody(SILFunction *F, SILBasicBlock *clonedEntryBB,
+                    ArrayRef<SILValue> entryArgs,
+                    llvm::function_ref<SILValue(SILValue)> entryArgToOldArgMap);
+
   /// MARK: Callback utilities used from CRTP extensions during cloning.
   /// These should only be called from within an instruction cloning visitor.
 
@@ -613,6 +621,29 @@ void SILCloner<ImplClass>::cloneFunctionBody(SILFunction *F,
   commonFixUp(F);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::cloneFunctionBody(
+    SILFunction *F, SILBasicBlock *clonedEntryBB, ArrayRef<SILValue> entryArgs,
+    llvm::function_ref<SILValue(SILValue)> entryArgIndexToOldArgIndex) {
+  assert(F != clonedEntryBB->getParent() && "Must clone into a new function.");
+  assert(BBMap.empty() && "This API does not allow clients to map blocks.");
+  assert(ValueMap.empty() && "Stale ValueMap.");
+
+  assert(entryArgs.size() == F->getArguments().size());
+  for (unsigned i = 0, e = entryArgs.size(); i != e; ++i) {
+    ValueMap[entryArgIndexToOldArgIndex(entryArgs[i])] = entryArgs[i];
+  }
+
+  BBMap.insert(std::make_pair(&*F->begin(), clonedEntryBB));
+
+  Builder.setInsertionPoint(clonedEntryBB);
+
+  // This will layout all newly cloned blocks immediate after clonedEntryBB.
+  visitBlocksDepthFirst(&*F->begin());
+
+  commonFixUp(F);
+}
+
 template<typename ImplClass>
 void SILCloner<ImplClass>::clonePhiArgs(SILBasicBlock *oldBB) {
   auto *mappedBB = BBMap[oldBB];

include/swift/SIL/SILFunction.h

@@ -1029,6 +1029,19 @@ class SILFunction
   /// generic.
   SubstitutionMap getForwardingSubstitutionMap();
 
+  /// Returns true if this SILFunction must be a defer statement.
+  ///
+  /// NOTE: This may return false for defer statements that have been
+  /// deserialized without a DeclContext. This means that this is guaranteed to
+  /// be correct for SILFunctions in Raw SIL that were not deserialized as
+  /// canonical. Thus one can use it for diagnostics.
+  bool isDefer() const {
+    if (auto *dc = getDeclContext())
+      if (auto *decl = dyn_cast_or_null<FuncDecl>(dc->getAsDecl()))
+        return decl->isDeferBody();
+    return false;
+  }
+
   //===--------------------------------------------------------------------===//
   // Block List Access
   //===--------------------------------------------------------------------===//

include/swift/SILOptimizer/Utils/SpecializationMangler.h

@@ -62,20 +62,24 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   using ArgumentModifierIntBase = uint16_t;
   enum class ArgumentModifier : ArgumentModifierIntBase {
     // Option Space 4 bits (i.e. 16 options).
-    Unmodified=0,
-    ConstantProp=1,
-    ClosureProp=2,
-    BoxToValue=3,
-    BoxToStack=4,
-    First_Option=0, Last_Option=31,
+    Unmodified = 0,
+    ConstantProp = 1,
+    ClosureProp = 2,
+    BoxToValue = 3,
+    BoxToStack = 4,
+    InOutToOut = 5,
+
+    First_Option = 0,
+    Last_Option = 31,
 
     // Option Set Space. 12 bits (i.e. 12 option).
-    Dead=32,
-    OwnedToGuaranteed=64,
-    SROA=128,
-    GuaranteedToOwned=256,
-    ExistentialToGeneric=512,
-    First_OptionSetEntry=32, LastOptionSetEntry=32768,
+    Dead = 32,
+    OwnedToGuaranteed = 64,
+    SROA = 128,
+    GuaranteedToOwned = 256,
+    ExistentialToGeneric = 512,
+    First_OptionSetEntry = 32,
+    LastOptionSetEntry = 32768,
   };
 
   using ArgInfo = std::pair<ArgumentModifierIntBase,
@@ -102,6 +106,7 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   void setArgumentSROA(unsigned OrigArgIdx);
   void setArgumentBoxToValue(unsigned OrigArgIdx);
   void setArgumentBoxToStack(unsigned OrigArgIdx);
+  void setArgumentInOutToOut(unsigned OrigArgIdx);
   void setReturnValueOwnedToUnowned();
 
   std::string mangle();

lib/Demangling/Demangler.cpp

@@ -2939,6 +2939,11 @@ NodePointer Demangler::demangleFuncSpecParam(Node::Kind Kind) {
       return addChild(Param, createNode(
                 Node::Kind::FunctionSignatureSpecializationParamKind,
                 unsigned(FunctionSigSpecializationParamKind::BoxToStack)));
+    case 'r':
+      return addChild(
+          Param,
+          createNode(Node::Kind::FunctionSignatureSpecializationParamKind,
+                     unsigned(FunctionSigSpecializationParamKind::InOutToOut)));
     default:
       return nullptr;
   }

lib/Demangling/NodePrinter.cpp

@@ -1012,6 +1012,7 @@ void NodePrinter::printFunctionSigSpecializationParams(NodePointer Node,
     switch (K) {
     case FunctionSigSpecializationParamKind::BoxToValue:
     case FunctionSigSpecializationParamKind::BoxToStack:
+    case FunctionSigSpecializationParamKind::InOutToOut:
       print(Node->getChild(Idx++), depth + 1);
       break;
     case FunctionSigSpecializationParamKind::ConstantPropFunction:
@@ -1582,6 +1583,9 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     case FunctionSigSpecializationParamKind::BoxToStack:
       Printer << "Stack Promoted from Box";
       return nullptr;
+    case FunctionSigSpecializationParamKind::InOutToOut:
+      Printer << "InOut Converted to Out";
+      return nullptr;
     case FunctionSigSpecializationParamKind::ConstantPropFunction:
       Printer << "Constant Propagated Function";
       return nullptr;

lib/Demangling/OldDemangler.cpp

@@ -645,6 +645,11 @@ class OldDemangler {
         if (!result)
           return nullptr;
         param->addChild(result, Factory);
+      } else if (Mangled.nextIf("r_")) {
+        auto result = FUNCSIGSPEC_CREATE_PARAM_KIND(InOutToOut);
+        if (!result)
+          return nullptr;
+        param->addChild(result, Factory);
       } else {
         // Otherwise handle option sets.
         unsigned Value = 0;

lib/Demangling/Remangler.cpp

@@ -1407,6 +1407,9 @@ Remangler::mangleFunctionSignatureSpecializationParam(Node *node,
     case FunctionSigSpecializationParamKind::BoxToStack:
       Buffer << 's';
       break;
+    case FunctionSigSpecializationParamKind::InOutToOut:
+      Buffer << 'r';
+      break;
     case FunctionSigSpecializationParamKind::SROA:
       Buffer << 'x';
       break;