Merge pull request #40846 from gottesmm/release/5.6/remove-_copy-_move-other-things

[5.6] Disable _move, _copy, _noImplicitCopy on 5.6 since we don't need it.

Author: gottesmm

include/swift/Basic/BlotSetVector.h

@@ -113,7 +113,7 @@ class BlotSetVector {
     return {index, true};
   }
 
-  bool count(const ValueT &value) const { return map.count(value); }
+  bool count(const ValueT &value) { 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,7 +108,6 @@ 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.
@@ -145,7 +144,6 @@ enum class SpecializationPass : uint8_t {
   CapturePropagation,
   FunctionSignatureOpts,
   GenericSpecializer,
-  MoveDiagnosticInOutToOut,
 };
 
 static inline char encodeSpecializationPass(SpecializationPass Pass) {

include/swift/SIL/SILCloner.h

@@ -128,14 +128,6 @@ 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.
 
@@ -621,29 +613,6 @@ 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,19 +1029,6 @@ 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,24 +62,20 @@ 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,
-    InOutToOut = 5,
-
-    First_Option = 0,
-    Last_Option = 31,
+    Unmodified=0,
+    ConstantProp=1,
+    ClosureProp=2,
+    BoxToValue=3,
+    BoxToStack=4,
+    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,
@@ -106,7 +102,6 @@ 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,11 +2939,6 @@ 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,7 +1012,6 @@ 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:
@@ -1583,9 +1582,6 @@ 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,11 +645,6 @@ 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,9 +1407,6 @@ Remangler::mangleFunctionSignatureSpecializationParam(Node *node,
     case FunctionSigSpecializationParamKind::BoxToStack:
       Buffer << 's';
       break;
-    case FunctionSigSpecializationParamKind::InOutToOut:
-      Buffer << 'r';
-      break;
     case FunctionSigSpecializationParamKind::SROA:
       Buffer << 'x';
       break;