Fix variable names.

[ruiu]

Summary

Fix variable names in TaskGroup.{cpp,h}.

[zturner]

Not sure if this will be necessary. I already applied these changes as part of D33024. chandlerc@ said it's fine to do it in the same patch as the move. Sorry for forgetting about it earlier though.

lld/include/lld/Core/TaskGroup.h

 /// \brief Allows one or more threads to wait on a potentially unknown number of
 ///   events.
 ///
 /// A latch starts at \p count. inc() increments this, and dec() decrements it.
 /// All calls to sync() will block while the count is not 0.
 ///
 /// Calling dec() on a Latch with a count of 0 has undefined behaivor.
 class Latch {
-  uint32_t _count;
-  mutable std::mutex _condMut;
-  mutable std::condition_variable _cond;
+  uint32_t Count;
+  mutable std::mutex Mutex;
+  mutable std::condition_variable Cond;
 
 public:
-  explicit Latch(uint32_t count = 0) : _count(count) {}
+  explicit Latch(uint32_t Count = 0) : Count(Count) {}
   ~Latch() { sync(); }
 
   void inc() {
-    std::unique_lock<std::mutex> lock(_condMut);
-    ++_count;
+    std::unique_lock<std::mutex> Lock(Mutex);
+    ++Count;
   }
 
   void dec() {
-    std::unique_lock<std::mutex> lock(_condMut);
-    if (--_count == 0)
-      _cond.notify_all();
+    std::unique_lock<std::mutex> Lock(Mutex);
+    if (--Count == 0)
+      Cond.notify_all();
   }
 
   void sync() const {
-    std::unique_lock<std::mutex> lock(_condMut);
-    _cond.wait(lock, [&] { return _count == 0; });
+    std::unique_lock<std::mutex> Lock(Mutex);
+    Cond.wait(Lock, [&] { return Count == 0; });
   }
 };
 
 /// \brief Allows launching a number of tasks and waiting for them to finish
 ///   either explicitly via sync() or implicitly on destruction.
 class TaskGroup {
-  Latch _latch;
+  Latch Done;
 
 public:
   void spawn(std::function<void()> f);
-
-  void sync() const { _latch.sync(); }
+  void sync() const { Done.sync(); }
 };
 }
 
 #endif

lld/lib/Core/TaskGroup.cpp

 public:
   virtual void add(std::function<void()> F) {
     Concurrency::CurrentScheduler::ScheduleTask(
         Taskish::run, new (concurrency::Alloc(sizeof(Taskish))) Taskish(F));
   }
 };
 
 Executor *Executor::getDefaultExecutor() {
-  static ConcRTExecutor exec;
-  return &exec;
+  static ConcRTExecutor Exec;
+  return &Exec;
 }
 
 #else
 /// \brief An implementation of an Executor that runs closures on a thread pool
 ///   in filo order.
 class ThreadPoolExecutor : public Executor {
 public:
   explicit ThreadPoolExecutor(
       unsigned ThreadCount = std::thread::hardware_concurrency())
       : Done(ThreadCount) {
     // Spawn all but one of the threads in another thread as spawning threads
     // can take a while.
     std::thread([&, ThreadCount] {
-      for (size_t i = 1; i < ThreadCount; ++i) {
+      for (size_t I = 1; I < ThreadCount; ++I)
         std::thread([=] { work(); }).detach();
-      }
       work();
     }).detach();
   }
 
   ~ThreadPoolExecutor() override {
     std::unique_lock<std::mutex> Lock(Mutex);
     Stop = true;
     Lock.unlock();
private:
   std::atomic<bool> Stop{false};
   std::stack<std::function<void()>> WorkStack;
   std::mutex Mutex;
   std::condition_variable Cond;
   Latch Done;
 };
 
 Executor *Executor::getDefaultExecutor() {
-  static ThreadPoolExecutor exec;
-  return &exec;
+  static ThreadPoolExecutor Exec;
+  return &Exec;
 }
 #endif
 }
 
-void TaskGroup::spawn(std::function<void()> f) {
-  _latch.inc();
-  Executor::getDefaultExecutor()->add([&, f] {
-    f();
-    _latch.dec();
+void TaskGroup::spawn(std::function<void()> F) {
+  Done.inc();
+  Executor::getDefaultExecutor()->add([&, F] {
+    F();
+    Done.dec();
   });
 }