[flang][runtime] Don't let random seed queries change the sequence

[klausler]

Summary

When the current seed of the pseudo-random generator is queried
with CALL RANDOM_SEED(GET=n), that query should not change the
stream of pseudo-random numbers produced by CALL RANDOM_NUMBER().

[klausler]

Clean up after a rebase gone somewhat wrong.

flang/runtime/random.cpp

 static constexpr std::uint64_t range{
     static_cast<std::uint64_t>(Generator::max() - Generator::min() + 1)};
 static constexpr bool rangeIsPowerOfTwo{(range & (range - 1)) == 0};
 static constexpr int rangeBits{
     64 - common::LeadingZeroBitCount(range) - !rangeIsPowerOfTwo};
 
 static Lock lock;
 static Generator generator;
+static std::optional<GeneratedWord> nextValue;
+
+// Call only with lock held
+static GeneratedWord GetNextValue() {
+  GeneratedWord result;
+  if (nextValue.has_value()) {
+    result = *nextValue;
+    nextValue.reset();
+  } else {
+    result = generator();
+  }
+  return result;
+}
 
 template <typename REAL, int PREC>
 inline void Generate(const Descriptor &harvest) {
   static constexpr std::size_t minBits{
       std::max<std::size_t>(PREC, 8 * sizeof(GeneratedWord))};
   using Int = common::HostUnsignedIntType<minBits>;
   static constexpr std::size_t words{
       static_cast<std::size_t>(PREC + rangeBits - 1) / rangeBits};
   std::size_t elements{harvest.Elements()};
   SubscriptValue at[maxRank];
   harvest.GetLowerBounds(at);
   {
     CriticalSection critical{lock};
     for (std::size_t j{0}; j < elements; ++j) {
       while (true) {
-        Int fraction{generator()};
+        Int fraction{GetNextValue()};
         if constexpr (words > 1) {
           for (std::size_t k{1}; k < words; ++k) {
             static constexpr auto rangeMask{
                 (GeneratedWord{1} << rangeBits) - 1};
-            GeneratedWord word{(generator() - generator.min()) & rangeMask};
+            GeneratedWord word{(GetNextValue() - generator.min()) & rangeMask};
             fraction = (fraction << rangeBits) | word;
           }
         }
         fraction >>= words * rangeBits - PREC;
         REAL next{std::ldexp(static_cast<REAL>(fraction), -(PREC + 1))};
         if (next >= 0.0 && next < 1.0) {
           *harvest.Element<REAL>(at) = next;
           break;
case 8:
     seed = *put.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>();
     break;
   default:
     terminator.Crash("not yet implemented: RANDOM_SEED(PUT=): kind %d\n", kind);
   }
   {
     CriticalSection critical{lock};
     generator.seed(seed);
+    nextValue = seed;
   }
 }
 
 void RTNAME(RandomSeedDefaultPut)() {
   // TODO: should this be time &/or image dependent?
   {
     CriticalSection critical{lock};
     generator.seed(0);
   }
 }
 
 void RTNAME(RandomSeedGet)(
     const Descriptor &got, const char *source, int line) {
   Terminator terminator{source, line};
   auto typeCode{got.type().GetCategoryAndKind()};
   RUNTIME_CHECK(terminator,
       got.rank() == 1 && typeCode && typeCode->first == TypeCategory::Integer &&
           got.GetDimension(0).Extent() >= 1);
   int kind{typeCode->second};
   GeneratedWord seed;
   {
     CriticalSection critical{lock};
-    seed = generator();
-    generator.seed(seed);
+    seed = GetNextValue();
+    nextValue = seed;
   }
   switch (kind) {
   case 4:
     *got.OffsetElement<CppTypeFor<TypeCategory::Integer, 4>>() = seed;
     break;
   case 8:
     *got.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>() = seed;
     break;
   default:
     terminator.Crash("not yet implemented: RANDOM_SEED(GET=): kind %d\n", kind);
   }
 }
 } // extern "C"
 } // namespace Fortran::runtime