[flang] Emit error when a positional actual argument follows an argument with a keyword

[klausler]

Summary

A positional (non-keyword) actual argument or alternate return label is not
allowed to follow an actual argument with a keyword.

flang/lib/Evaluate/intrinsics.cpp

       dummy[dummyArgPatterns - 1].optionality == Optionality::repeats};
   std::vector<ActualArgument *> actualForDummy(
       isMaxMin ? 0 : dummyArgPatterns, nullptr);
-  int missingActualArguments{0};
+  bool anyMissingActualArgument{false};
   std::set<parser::CharBlock> maxMinKeywords;
+  bool anyKeyword{false};
+  int which{0};
   for (std::optional<ActualArgument> &arg : arguments) {
-    if (!arg) {
-      ++missingActualArguments;
-    } else if (arg->isAlternateReturn()) {
+    ++which;
+    if (arg) {
+      if (arg->isAlternateReturn()) {
         messages.Say(arg->sourceLocation(),
             "alternate return specifier not acceptable on call to intrinsic '%s'"_err_en_US,
             name);
         return std::nullopt;
-    } else if (isMaxMin) {
+      }
+      if (arg->keyword()) {
+        anyKeyword = true;
+      } else if (anyKeyword) {
+        messages.Say(arg ? arg->sourceLocation() : std::nullopt,
+            "actual argument #%d without a keyword may not follow an actual argument with a keyword"_err_en_US,
+            which);
+        return std::nullopt;
+      }
+    } else {
+      anyMissingActualArgument = true;
+      continue;
+    }
+    if (isMaxMin) {
       if (CheckMaxMinArgument(arg->keyword(), maxMinKeywords, name, messages)) {
         actualForDummy.push_back(&*arg);
       } else {

       }
     } else {
       bool found{false};
-      int slot{missingActualArguments};
       for (std::size_t j{0}; j < dummyArgPatterns && !found; ++j) {
         if (dummy[j].optionality == Optionality::missing) {
           continue;

             }
           }
         } else {
-          found = !actualForDummy[j] && slot-- == 0;
+          found = !actualForDummy[j] && !anyMissingActualArgument;
         }
         if (found) {
           actualForDummy[j] = &*arg;

flang/lib/Semantics/check-call.cpp

         actuals.size(), proc.dummyArguments.size());
   }
   std::map<std::string, evaluate::ActualArgument> kwArgs;
+  bool anyKeyword{false};
+  int which{1};
   for (auto &x : actuals) {
-    if (x && x->keyword()) {
+    if (!x) {
+    } else if (x->keyword()) {
       auto emplaced{
           kwArgs.try_emplace(x->keyword()->ToString(), std::move(*x))};
       if (!emplaced.second) {

             *x->keyword());
       }
       x.reset();
+      anyKeyword = true;
+    } else if (anyKeyword) {
+      messages.Say(x ? x->sourceLocation() : std::nullopt,
+          "Actual argument #%d without a keyword may not follow any actual argument with a keyword"_err_en_US,
+          which);
     }
+    ++which;
   }
   if (!kwArgs.empty()) {
     int index{0};

flang/test/Evaluate/fold-ishftc.f90

 ! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of ISHFTC
 module m
-  integer, parameter :: shift8s(*) = ishftc(257, shift = [(ict, ict = -8, 8)], 8)
+  integer, parameter :: shift8s(*) = ishftc(257, shift = [(ict, ict = -8, 8)], size=8)
   integer, parameter :: expect1(*) = 256 + [1, 2, 4, 8, 16, 32, 64, 128, &
                                             1, 2, 4, 8, 16, 32, 64, 128, 1]
   logical, parameter :: test_1 = all(shift8s == expect1)

flang/test/Semantics/collectives01.f90

   !ERROR: 'errmsg=' argument has unacceptable rank 1
   call co_sum(d, errmsg=character_array)
 
-  !ERROR: too many actual arguments for intrinsic 'co_sum'
+  !ERROR: actual argument #5 without a keyword may not follow an actual argument with a keyword
   call co_sum(r, result_image=1, stat=status, errmsg=message, 3.4)
 
   ! keyword argument with incorrect name

flang/test/Semantics/collectives02.f90

   !ERROR: 'errmsg=' argument has unacceptable rank 1
   call co_min(d, errmsg=character_array)
 
-  !ERROR: too many actual arguments for intrinsic 'co_min'
+  !ERROR: actual argument #5 without a keyword may not follow an actual argument with a keyword
   call co_min(r, result_image=1, stat=status, errmsg=message, 3.4)
 
   !ERROR: unknown keyword argument to intrinsic 'co_min'

flang/test/Semantics/collectives03.f90

   !ERROR: 'errmsg=' argument has unacceptable rank 1
   call co_max(d, errmsg=character_array)
 
-  !ERROR: too many actual arguments for intrinsic 'co_max'
+  !ERROR: actual argument #5 without a keyword may not follow an actual argument with a keyword
   call co_max(r, result_image=1, stat=status, errmsg=message, 3.4)
 
   !ERROR: unknown keyword argument to intrinsic 'co_max'

flang/test/Semantics/collectives04.f90

   !ERROR: 'errmsg=' argument has unacceptable rank 1
   call co_broadcast(d, errmsg=character_array, source_image=1)
 
-  !ERROR: too many actual arguments for intrinsic 'co_broadcast'
+  !ERROR: actual argument #5 without a keyword may not follow an actual argument with a keyword
   call co_broadcast(r, source_image=1, stat=status, errmsg=message, 3.4)
 
   !ERROR: unknown keyword argument to intrinsic 'co_broadcast'

flang/test/Semantics/lcobound.f90

   !ERROR: missing mandatory 'coarray=' argument
   n = lcobound(dim=i, kind=c_int32_t)
 
+  !ERROR: actual argument #2 without a keyword may not follow an actual argument with a keyword
   n = lcobound(coarray=scalar_coarray, i)
 
+  n = lcobound(coarray=scalar_coarray, dim=i)
+
   !ERROR: missing mandatory 'coarray=' argument
   lcobounds = lcobound()
 

flang/test/Semantics/ucobound.f90

   !ERROR: missing mandatory 'coarray=' argument
   n = ucobound(dim=i, kind=c_int32_t)
 
+  !ERROR: actual argument #2 without a keyword may not follow an actual argument with a keyword
   n = ucobound(coarray=scalar_coarray, i)
 
+  n = ucobound(coarray=scalar_coarray, dim=i)
+
   !ERROR: missing mandatory 'coarray=' argument
   ucobounds = ucobound()