Make it harder to forget to update an existing AtomicWaitQueue.

The existing uses of AWQ don't need arguments during construction,
but uses that do almost certainly need to update existing instances
if createQueue happens to re-use one.  Users probably aren't going
to think about this proactively by doing something wild like reading
the documentation.  We can point this mistake out to them by making
their code not compile if they call createQueue with arguments
without providing a special method.  This pattern also makes the
actual update code much easier to write, since callers don't need
to specially detect this case.

Author: rjmccall

include/swift/Runtime/AtomicWaitQueue.h

@@ -106,6 +106,17 @@ class AtomicWaitQueue {
     return referenceCount == 1;
   }
 
+  /// This queue is being re-used with new construction arguments.
+  /// Update it appropriately.
+  void updateForNewArguments() {
+    // We intentionally take no arguments so that only calls to
+    // createQueue with no arguments will succeed at calling this no-op
+    // implementation.  Queue types with construction arguments
+    // will need to implement this method to take the appropriate
+    // arguments.  Hopefully this discourages people from forgetting
+    // that queues can be re-used if created in a loop.
+  }
+
   /// An RAII helper class for signalling that the current thread is a
   /// worker thread which has acquired the lock.
   ///
@@ -195,14 +206,18 @@ class AtomicWaitQueue {
     ///
     /// The Worker object takes ownership of the queue until it's
     /// published, so you can safely call this even if publishing
-    /// might fail.  Note that the same queue will be returned on
-    /// successive invocations, so take care if the arguments might
-    /// change during the loop.
+    /// might fail.
+    ///
+    /// Note that the same queue will be returned on successive
+    /// invocations.  Queues that accept arguments for construction
+    /// should implement `updateForNewArguments`.
     template <class... Args>
     Impl *createQueue(Args &&...args) {
       assert(!Published);
       if (!CurrentQueue)
         CurrentQueue = asImpl().createNewQueue(std::forward<Args>(args)...);
+      else
+        CurrentQueue->updateForNewArguments(std::forward<Args>(args)...);
       return CurrentQueue;
     }