Update code in buildCudaActions and BuildActions to latest idiom.

[jlebar]

Summary

Use llvm::make_unique, std::all_of, std::find, etc.

No functional changes.

Prerequisite for further changes to Driver.

[jlebar]

Rebasing onto D15911.

Depends on D15911.

[jlebar]

Fix rebase conflict.

[tra]

LGTM

lib/Driver/Driver.cpp

1300 ↗

(On Diff #44155)

style nit -- no need for {}

[jlebar]

Address tra's review comments.

cfe/trunk/lib/Driver/Driver.cpp

if (PartialCompilationArg &&
       PartialCompilationArg->getOption().matches(options::OPT_cuda_host_only))
     return std::unique_ptr<Action>(
         new CudaHostAction(std::move(HostAction), {}));
 
   // Collect all cuda_gpu_arch parameters, removing duplicates.
   SmallVector<const char *, 4> GpuArchList;
   llvm::StringSet<> GpuArchNames;
   for (Arg *A : Args) {
-    if (A->getOption().matches(options::OPT_cuda_gpu_arch_EQ)) {
-      A->claim();
-      if (GpuArchNames.insert(A->getValue()).second)
-        GpuArchList.push_back(A->getValue());
-    }
-  }
+    if (!A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
+      continue;
 
   // Default to sm_20 which is the lowest common denominator for supported GPUs.
   // sm_20 code should work correctly, if suboptimally, on all newer GPUs.
   if (GpuArchList.empty())
     GpuArchList.push_back("sm_20");
 
   // Replicate inputs for each GPU architecture.
   Driver::InputList CudaDeviceInputs;
   for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
     CudaDeviceInputs.push_back(std::make_pair(types::TY_CUDA_DEVICE, InputArg));
 
   // Build actions for all device inputs.
   assert(C.getCudaDeviceToolChain() &&
          "Missing toolchain for device-side compilation.");
   ActionList CudaDeviceActions;
   C.getDriver().BuildActions(C, *C.getCudaDeviceToolChain(), Args,
                              CudaDeviceInputs, CudaDeviceActions);
   assert(GpuArchList.size() == CudaDeviceActions.size() &&
          "Failed to create actions for all devices");
 
   // Check whether any of device actions stopped before they could generate PTX.
-  bool PartialCompilation = false;
-  for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
-    if (CudaDeviceActions[I]->getKind() != Action::BackendJobClass) {
-      PartialCompilation = true;
-      break;
-    }
-  }
+  bool PartialCompilation =
+      llvm::any_of(CudaDeviceActions, [](const Action *a) {
+        return a->getKind() != Action::BackendJobClass;
+      });
 
   // Figure out what to do with device actions -- pass them as inputs to the
   // host action or run each of them independently.
   bool DeviceOnlyCompilation = PartialCompilationArg != nullptr;
   if (PartialCompilation || DeviceOnlyCompilation) {
     // In case of partial or device-only compilation results of device actions
     // are not consumed by the host action device actions have to be added to
     // top-level actions list with AtTopLevel=true and run independently.
if (InitialPhase > FinalPhase) {
       else
         Diag(clang::diag::warn_drv_input_file_unused)
             << InputArg->getAsString(Args) << getPhaseName(InitialPhase)
             << !!FinalPhaseArg
             << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
       continue;
     }
 
-    phases::ID CudaInjectionPhase = FinalPhase;
-    for (const auto &Phase : PL)
-      if (Phase <= FinalPhase && Phase == phases::Compile) {
-        CudaInjectionPhase = Phase;
-        break;
-      }
+    phases::ID CudaInjectionPhase =
+        (phases::Compile < FinalPhase &&
+         llvm::find(PL, phases::Compile) != PL.end())
+            ? phases::Compile
+            : FinalPhase;
 
     // Build the pipeline for this file.
     std::unique_ptr<Action> Current(new InputAction(*InputArg, InputType));
     for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
          i != e; ++i) {
       phases::ID Phase = *i;
 
       // We are done if this step is past what the user requested.