Remove some Swift STLExtras that LLVM now provides (swiftlang#26443)

jrose-apple · web-flow · commit 844ae38722e1 · 2019-07-31T18:34:52.000-07:00
No functionality change.
diff --git a/include/swift/Basic/STLExtras.h b/include/swift/Basic/STLExtras.h
@@ -771,22 +771,6 @@ inline bool is_sorted_and_uniqued(const Container &C) {
   return is_sorted_and_uniqued(C.begin(), C.end());
 }
 
-template <typename Container, typename OutputIterator>
-inline void copy(const Container &C, OutputIterator iter) {
-  std::copy(C.begin(), C.end(), iter);
-}
-
-template <typename Container, typename OutputIterator, typename Predicate>
-inline void copy_if(const Container &C, OutputIterator result, Predicate pred) {
-  std::copy_if(C.begin(), C.end(), result, pred);
-}
-
-template <typename Container, typename OutputIterator, typename UnaryOperation>
-inline OutputIterator transform(const Container &C, OutputIterator result,
-                                UnaryOperation op) {
-  return std::transform(C.begin(), C.end(), result, op);
-}
-
 template <typename Container, typename T, typename BinaryOperation>
 inline T accumulate(const Container &C, T init, BinaryOperation op) {
   return std::accumulate(C.begin(), C.end(), init, op);
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -509,8 +509,8 @@ class SILFunctionCloner : public SILClonerWithScopes<SILFunctionCloner> {
     // resolve the type mismatch between SILArgument* and SILValue.
     SmallVector<SILValue, 8> entryArgs;
     entryArgs.reserve(newF->getArguments().size());
-    transform(newF->getArguments(), std::back_inserter(entryArgs),
-              [](SILArgument *arg) -> SILValue { return arg; });
+    llvm::transform(newF->getArguments(), std::back_inserter(entryArgs),
+                    [](SILArgument *arg) -> SILValue { return arg; });
 
     SuperTy::cloneFunctionBody(origF, newEntryBB, entryArgs);
   }
diff --git a/lib/SIL/LinearLifetimeChecker.cpp b/lib/SIL/LinearLifetimeChecker.cpp
@@ -399,8 +399,8 @@ void State::checkDataflowEndState(DeadEndBlocks &deBlocks) {
     // If we are asked to store any leaking blocks, put them in the leaking
     // blocks array.
     if (leakingBlocks) {
-      copy(successorBlocksThatMustBeVisited,
-           std::back_inserter(*leakingBlocks));
+      llvm::copy(successorBlocksThatMustBeVisited,
+                 std::back_inserter(*leakingBlocks));
     }
 
     // If we are supposed to error on leaks, do so now.
diff --git a/lib/SIL/OwnershipUtils.cpp b/lib/SIL/OwnershipUtils.cpp
@@ -112,8 +112,8 @@ bool swift::getUnderlyingBorrowIntroducers(SILValue inputValue,
     if (isGuaranteedForwardingValue(v)) {
       auto *i = v->getDefiningInstruction();
       assert(i);
-      transform(i->getAllOperands(), std::back_inserter(worklist),
-                [](const Operand &op) -> SILValue { return op.get(); });
+      llvm::transform(i->getAllOperands(), std::back_inserter(worklist),
+                      [](const Operand &op) -> SILValue { return op.get(); });
       continue;
     }
 
diff --git a/lib/SIL/SILBuilder.cpp b/lib/SIL/SILBuilder.cpp
@@ -519,17 +519,17 @@ void SILBuilder::emitDestructureValueOperation(
   // Otherwise, we want to destructure add the destructure and return.
   if (getFunction().hasOwnership()) {
     auto *i = emitDestructureValueOperation(loc, v);
-    copy(i->getResults(), std::back_inserter(results));
+    llvm::copy(i->getResults(), std::back_inserter(results));
     return;
   }
 
   // In non qualified ownership SIL, drop back to using projection code.
   SmallVector<Projection, 16> projections;
   Projection::getFirstLevelProjections(v->getType(), getModule(), projections);
-  transform(projections, std::back_inserter(results),
-            [&](const Projection &p) -> SILValue {
-              return p.createObjectProjection(*this, loc, v).get();
-            });
+  llvm::transform(projections, std::back_inserter(results),
+                  [&](const Projection &p) -> SILValue {
+                    return p.createObjectProjection(*this, loc, v).get();
+                  });
 }
 
 // TODO: Can we put this on type lowering? It would take a little bit of work
@@ -547,10 +547,10 @@ void SILBuilder::emitDestructureAddressOperation(
 
   SmallVector<Projection, 16> projections;
   Projection::getFirstLevelProjections(v->getType(), getModule(), projections);
-  transform(projections, std::back_inserter(results),
-            [&](const Projection &p) -> SILValue {
-              return p.createAddressProjection(*this, loc, v).get();
-            });
+  llvm::transform(projections, std::back_inserter(results),
+                  [&](const Projection &p) -> SILValue {
+                    return p.createAddressProjection(*this, loc, v).get();
+                  });
 }
 
 void SILBuilder::emitDestructureValueOperation(
diff --git a/lib/SIL/SILOwnershipVerifier.cpp b/lib/SIL/SILOwnershipVerifier.cpp
@@ -134,8 +134,8 @@ class SILValueOwnershipChecker {
       return false;
 
     SmallVector<BranchPropagatedUser, 32> allRegularUsers;
-    copy(regularUsers, std::back_inserter(allRegularUsers));
-    copy(implicitRegularUsers, std::back_inserter(allRegularUsers));
+    llvm::copy(regularUsers, std::back_inserter(allRegularUsers));
+    llvm::copy(implicitRegularUsers, std::back_inserter(allRegularUsers));
     auto linearLifetimeResult =
         valueHasLinearLifetime(value, lifetimeEndingUsers, allRegularUsers,
                                visitedBlocks, deadEndBlocks, errorBehavior);
@@ -331,8 +331,8 @@ bool SILValueOwnershipChecker::gatherUsers(
         for (unsigned i : indices(nonLifetimeEndingUsers)) {
           if (auto *bbi = dyn_cast<BeginBorrowInst>(
                   nonLifetimeEndingUsers[i].getInst())) {
-            copy(bbi->getEndBorrows(),
-                 std::back_inserter(implicitRegularUsers));
+            llvm::copy(bbi->getEndBorrows(),
+                       std::back_inserter(implicitRegularUsers));
           }
         }
       }
@@ -361,7 +361,7 @@ bool SILValueOwnershipChecker::gatherUsers(
         assert(result.getOwnershipKind() == ValueOwnershipKind::Guaranteed &&
                "Our value is guaranteed and this is a forwarding instruction. "
                "Should have guaranteed ownership as well.");
-        copy(result->getUses(), std::back_inserter(users));
+        llvm::copy(result->getUses(), std::back_inserter(users));
       }
 
       continue;
diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
@@ -653,7 +653,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       assert(!isa<SingleValueInstruction>(inst) && "SingleValueInstruction was "
                                                    "handled by the previous "
                                                    "value base check.");
-      copy(inst->getResults(), std::back_inserter(values));
+      llvm::copy(inst->getResults(), std::back_inserter(values));
     }
 
     // If the set of values is empty, we need to print the ID of
diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
@@ -491,7 +491,7 @@ struct ImmutableAddressUseVerifier {
   }
 
   bool isMutatingOrConsuming(SILValue address) {
-    copy(address->getUses(), std::back_inserter(worklist));
+    llvm::copy(address->getUses(), std::back_inserter(worklist));
     while (!worklist.empty()) {
       auto *use = worklist.pop_back_val();
       auto *inst = use->getUser();
@@ -584,7 +584,7 @@ struct ImmutableAddressUseVerifier {
       case SILInstructionKind::IndexRawPointerInst:
         // Add these to our worklist.
         for (auto result : inst->getResults()) {
-          copy(result->getUses(), std::back_inserter(worklist));
+          llvm::copy(result->getUses(), std::back_inserter(worklist));
         }
         break;
       default:
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -240,11 +240,11 @@ static void convertOwnershipConventionsGivenParamInfos(
     llvm::SmallVectorImpl<ManagedValue> &outVar) {
   assert(params.size() == values.size() &&
          "Different number of params from arguments");
-  transform(indices(params), std::back_inserter(outVar),
-            [&](unsigned i) -> ManagedValue {
-              return convertOwnershipConventionGivenParamInfo(
-                  SGF, params[i], values[i], loc, isForCoroutine);
-            });
+  llvm::transform(indices(params), std::back_inserter(outVar),
+                  [&](unsigned i) -> ManagedValue {
+                    return convertOwnershipConventionGivenParamInfo(
+                        SGF, params[i], values[i], loc, isForCoroutine);
+                  });
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/SILGen/SILGenBuilder.cpp b/lib/SILGen/SILGenBuilder.cpp
@@ -52,7 +52,8 @@ ManagedValue SILGenBuilder::createPartialApply(SILLocation loc, SILValue fn,
                                                ArrayRef<ManagedValue> args,
                                                ParameterConvention calleeConvention) {
   llvm::SmallVector<SILValue, 8> values;
-  transform(args, std::back_inserter(values), [&](ManagedValue mv) -> SILValue {
+  llvm::transform(args, std::back_inserter(values),
+                  [&](ManagedValue mv) -> SILValue {
     return mv.forward(getSILGenFunction());
   });
   SILValue result =
@@ -209,10 +210,9 @@ ManagedValue SILGenBuilder::createAllocRef(
   llvm::SmallVector<SILType, 8> elementTypes(inputElementTypes.begin(),
                                              inputElementTypes.end());
   llvm::SmallVector<SILValue, 8> elementCountOperands;
-  std::transform(std::begin(inputElementCountOperands),
-                 std::end(inputElementCountOperands),
-                 std::back_inserter(elementCountOperands),
-                 [](ManagedValue mv) -> SILValue { return mv.getValue(); });
+  llvm::transform(inputElementCountOperands,
+                  std::back_inserter(elementCountOperands),
+                  [](ManagedValue mv) -> SILValue { return mv.getValue(); });
 
   AllocRefInst *i = createAllocRef(loc, refType, objc, canAllocOnStack,
                                    elementTypes, elementCountOperands);
@@ -226,10 +226,9 @@ ManagedValue SILGenBuilder::createAllocRefDynamic(
   llvm::SmallVector<SILType, 8> elementTypes(inputElementTypes.begin(),
                                              inputElementTypes.end());
   llvm::SmallVector<SILValue, 8> elementCountOperands;
-  std::transform(std::begin(inputElementCountOperands),
-                 std::end(inputElementCountOperands),
-                 std::back_inserter(elementCountOperands),
-                 [](ManagedValue mv) -> SILValue { return mv.getValue(); });
+  llvm::transform(inputElementCountOperands,
+                  std::back_inserter(elementCountOperands),
+                  [](ManagedValue mv) -> SILValue { return mv.getValue(); });
 
   AllocRefDynamicInst *i =
       createAllocRefDynamic(loc, operand.getValue(), refType, objc,
@@ -743,8 +742,8 @@ BranchInst *SILGenBuilder::createBranch(SILLocation loc,
                                         SILBasicBlock *targetBlock,
                                         ArrayRef<ManagedValue> args) {
   llvm::SmallVector<SILValue, 8> newArgs;
-  transform(args, std::back_inserter(newArgs),
-            [&](ManagedValue mv) -> SILValue { return mv.forward(SGF); });
+  llvm::transform(args, std::back_inserter(newArgs),
+                  [&](ManagedValue mv) -> SILValue { return mv.forward(SGF); });
   return createBranch(loc, targetBlock, newArgs);
 }
 
@@ -771,10 +770,10 @@ ManagedValue SILGenBuilder::createTuple(SILLocation loc, SILType type,
   // If we have all trivial values, then just create the tuple and return. No
   // cleanups need to be cloned.
   if (iter == elements.end()) {
-    transform(elements, std::back_inserter(forwardedValues),
-              [&](ManagedValue mv) -> SILValue {
-                return mv.forward(getSILGenFunction());
-              });
+    llvm::transform(elements, std::back_inserter(forwardedValues),
+                    [&](ManagedValue mv) -> SILValue {
+                      return mv.forward(getSILGenFunction());
+                    });
     SILValue result = createTuple(loc, type, forwardedValues);
     return ManagedValue::forUnmanaged(result);
   }
@@ -783,10 +782,10 @@ ManagedValue SILGenBuilder::createTuple(SILLocation loc, SILType type,
   // instructions that forward ownership requiring that all input values have
   // the same ownership if they are non-trivial.
   CleanupCloner cloner(*this, *iter);
-  transform(elements, std::back_inserter(forwardedValues),
-            [&](ManagedValue mv) -> SILValue {
-              return mv.forward(getSILGenFunction());
-            });
+  llvm::transform(elements, std::back_inserter(forwardedValues),
+                  [&](ManagedValue mv) -> SILValue {
+                    return mv.forward(getSILGenFunction());
+                  });
   return cloner.clone(createTuple(loc, type, forwardedValues));
 }
 
diff --git a/lib/SILOptimizer/Analysis/RCIdentityAnalysis.cpp b/lib/SILOptimizer/Analysis/RCIdentityAnalysis.cpp
@@ -508,8 +508,8 @@ void RCIdentityFunctionInfo::getRCUsers(
   getRCUses(V, TmpUsers);
 
   // Then map our operands out of TmpUsers into Users.
-  transform(TmpUsers, std::back_inserter(Users),
-            [](Operand *Op) { return Op->getUser(); });
+  llvm::transform(TmpUsers, std::back_inserter(Users),
+                  [](Operand *Op) { return Op->getUser(); });
 
   // Finally sort/unique our users array.
   sortUnique(Users);
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/OwnedToGuaranteedTransform.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/OwnedToGuaranteedTransform.cpp
@@ -94,9 +94,9 @@ bool FunctionSignatureTransform::OwnedToGuaranteedAnalyzeParameters() {
         if (!ArgToThrowReleaseMap.hasBlock() || !ReleasesInThrow.empty()) {
           assert(A.CalleeRelease.empty());
           assert(A.CalleeReleaseInThrowBlock.empty());
-          copy(Releases, std::back_inserter(A.CalleeRelease));
-          copy(ReleasesInThrow,
-               std::back_inserter(A.CalleeReleaseInThrowBlock));
+          llvm::copy(Releases, std::back_inserter(A.CalleeRelease));
+          llvm::copy(ReleasesInThrow,
+                     std::back_inserter(A.CalleeReleaseInThrowBlock));
           // We can convert this parameter to a @guaranteed.
           A.OwnedToGuaranteed = true;
           SignatureOptimize = true;
diff --git a/lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp b/lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp
@@ -113,8 +113,10 @@ static void findReachableExitBlocks(SILInstruction *i,
       result.push_back(bb);
       continue;
     }
-    copy_if(bb->getSuccessorBlocks(), std::back_inserter(worklist),
-            [&](SILBasicBlock *bb) { return visitedBlocks.insert(bb).second; });
+    llvm::copy_if(bb->getSuccessorBlocks(), std::back_inserter(worklist),
+                  [&](SILBasicBlock *bb) {
+      return visitedBlocks.insert(bb).second;
+    });
   }
 }
 
@@ -186,11 +188,11 @@ cleanupDeadTrivialPhiArgs(SILValue initialValue,
 
       auto *termInst = cast<TermInst>(user);
       for (auto succBlockArgList : termInst->getSuccessorBlockArguments()) {
-        copy_if(succBlockArgList, std::back_inserter(worklist),
-                [&](SILPhiArgument *succArg) -> bool {
-                  auto it = lower_bound(insertedPhis, succArg);
-                  return it != insertedPhis.end() && *it == succArg;
-                });
+        llvm::copy_if(succBlockArgList, std::back_inserter(worklist),
+                      [&](SILPhiArgument *succArg) -> bool {
+                        auto it = lower_bound(insertedPhis, succArg);
+                        return it != insertedPhis.end() && *it == succArg;
+                      });
       }
     }
 
diff --git a/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp b/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp
@@ -471,7 +471,7 @@ static void getScalarizedElements(SILValue V,
                                   SmallVectorImpl<SILValue> &ElementVals,
                                   SILLocation Loc, SILBuilder &B) {
   auto *DTI = B.createDestructureTuple(Loc, V);
-  copy(DTI->getResults(), std::back_inserter(ElementVals));
+  llvm::copy(DTI->getResults(), std::back_inserter(ElementVals));
 }
 
 /// Scalarize a load down to its subelements.  If NewLoads is specified, this
@@ -1789,7 +1789,7 @@ collectClassInitSelfLoadUses(MarkUninitializedInst *MUI,
         isa<UpcastInst>(User) ||
         isa<UncheckedRefCastInst>(User)) {
       auto I = cast<SingleValueInstruction>(User);
-      copy(I->getUses(), std::back_inserter(Worklist));
+      llvm::copy(I->getUses(), std::back_inserter(Worklist));
       continue;
     }
 
diff --git a/lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp b/lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp
@@ -316,7 +316,7 @@ getAllocStackSingleInitializingInjectEnumAddr(SwitchEnumAddrInst *SEAI) {
     LLVM_DEBUG(llvm::dbgs() << "Visiting: " << *op->getUser());
     if (auto *svi = Projection::isAddressProjection(op->getUser())) {
       LLVM_DEBUG(llvm::dbgs() << "Address projection. Continuing\n");
-      copy(svi->getUses(), std::back_inserter(worklist));
+      llvm::copy(svi->getUses(), std::back_inserter(worklist));
       continue;
     }
 
@@ -392,15 +392,15 @@ getAllocStackSingleInitializingInjectEnumAddr(SwitchEnumAddrInst *SEAI) {
 
   // Otherwise, make sure we are initialized only once and never
   // escape.
-  copy(singleInitializerAddr->getUses(), std::back_inserter(worklist));
+  llvm::copy(singleInitializerAddr->getUses(), std::back_inserter(worklist));
   bool foundInitializer = false;
   while (worklist.size()) {
     auto *op = worklist.pop_back_val();
     LLVM_DEBUG(llvm::dbgs() << "Read only check for: " << *op->getUser());
 
     // Look through projections.
     if (auto *svi = Projection::isAddressProjection(op->getUser())) {
-      copy(svi->getUses(), std::back_inserter(worklist));
+      llvm::copy(svi->getUses(), std::back_inserter(worklist));
       continue;
     }
 
diff --git a/lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp b/lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp
@@ -91,7 +91,7 @@ static bool isConsumed(
         for (SILValue v : user->getResults()) {
           if (v.getOwnershipKind() != ValueOwnershipKind::Owned)
             continue;
-          copy(v->getUses(), std::back_inserter(worklist));
+          llvm::copy(v->getUses(), std::back_inserter(worklist));
         }
         continue;
       }
diff --git a/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp b/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp
diff --git a/lib/SILOptimizer/Utils/CFG.cpp b/lib/SILOptimizer/Utils/CFG.cpp
diff --git a/lib/SILOptimizer/Utils/ConstantFolding.cpp b/lib/SILOptimizer/Utils/ConstantFolding.cpp
diff --git a/lib/SILOptimizer/Utils/Local.cpp b/lib/SILOptimizer/Utils/Local.cpp

Original file line number	Diff line number	Diff line change
`@@ -653,7 +653,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {`
`653`	`653`	`assert(!isa<SingleValueInstruction>(inst) && "SingleValueInstruction was "`
`654`	`654`	`"handled by the previous "`
`655`	`655`	`"value base check.");`
`656`		`- copy(inst->getResults(), std::back_inserter(values));`
	`656`	`+ llvm::copy(inst->getResults(), std::back_inserter(values));`
`657`	`657`	`}`
`658`	`658`
`659`	`659`	`// If the set of values is empty, we need to print the ID of`