[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

std::optional<SpecificCall> IntrinsicInterface::Match(
   // MAX and MIN (and others that map to them) allow their last argument to
   // be repeated indefinitely.  The actualForDummy vector is sized
   // and null-initialized to the non-repeated dummy argument count
   // for other instrinsics.
   bool isMaxMin{dummyArgPatterns > 0 &&
       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 {
         return std::nullopt;
       }
     } else {
       bool found{false};
-      int slot{missingActualArguments};
       for (std::size_t j{0}; j < dummyArgPatterns && !found; ++j) {
         if (dummy[j].optionality == Optionality::missing) {
           continue;
         }
         if (arg->keyword()) {
           found = *arg->keyword() == dummy[j].keyword;
           if (found) {
             if (const auto *previous{actualForDummy[j]}) {
               if (previous->keyword()) {
                 messages.Say(*arg->keyword(),
                     "repeated keyword argument to intrinsic '%s'"_err_en_US,
                     name);
               } else {
                 messages.Say(*arg->keyword(),
                     "keyword argument to intrinsic '%s' was supplied "
                     "positionally by an earlier actual argument"_err_en_US,
                     name);
               }
               return std::nullopt;
             }
           }
         } else {
-          found = !actualForDummy[j] && slot-- == 0;
+          found = !actualForDummy[j] && !anyMissingActualArgument;
         }
         if (found) {
           actualForDummy[j] = &*arg;
         }
       }
       if (!found) {
         if (arg->keyword()) {
           messages.Say(*arg->keyword(),

flang/lib/Semantics/check-call.cpp

static void RearrangeArguments(const characteristics::Procedure &proc,
   if (actuals.size() < proc.dummyArguments.size()) {
     actuals.resize(proc.dummyArguments.size());
   } else if (actuals.size() > proc.dummyArguments.size()) {
     messages.Say(
         "Too many actual arguments (%zd) passed to procedure that expects only %zd"_err_en_US,
         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) {
         messages.Say(*x->keyword(),
             "Argument keyword '%s=' appears on more than one effective argument in this procedure reference"_err_en_US,
             *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};
     for (const auto &dummy : proc.dummyArguments) {
       if (!dummy.name.empty()) {
         auto iter{kwArgs.find(dummy.name)};
         if (iter != kwArgs.end()) {
           evaluate::ActualArgument &x{iter->second};

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)
   integer, parameter :: sizes(*) = [(ishftc(257, ict, [(isz, isz = 1, 8)]), ict = -1, 1)]
   integer, parameter :: expect2(*) = 256 + [[1, 2, 4, 8, 16, 32, 64, 128], &
                                             [(1, j = 1, 8)], &
                                             [1, (2, j = 2, 8)]]
   logical, parameter :: test_2 = all(sizes == expect2)
 end module
 

flang/test/Semantics/collectives01.f90

program test_co_sum
   ! 'errmsg' argument shall be a character
   !ERROR: Actual argument for 'errmsg=' has bad type 'INTEGER(4)'
   call co_sum(c, errmsg=i)
 
   ! 'errmsg' argument shall be character scalar
   !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
   !ERROR: unknown keyword argument to intrinsic 'co_sum'
   call co_sum(fake=3.4)
 
   !ERROR: 'a' argument to 'co_sum' may not be a coindexed object
   !ERROR: 'errmsg' argument to 'co_sum' may not be a coindexed object
   !ERROR: 'stat' argument to 'co_sum' may not be a coindexed object
   call co_sum(result_image=coindexed_result_image[1], a=coindexed_real[1], errmsg=coindexed_character[1], stat=coindexed_integer[1])
 
 end program test_co_sum

flang/test/Semantics/collectives02.f90

program test_co_min
 
   ! 'errmsg' argument shall be a character
   !ERROR: Actual argument for 'errmsg=' has bad type 'INTEGER(4)'
   call co_min(c, errmsg=i)
 
   !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'
   call co_min(fake=3.4)
 
   !ERROR: 'a' argument to 'co_min' may not be a coindexed object
   !ERROR: 'errmsg' argument to 'co_min' may not be a coindexed object
   !ERROR: 'stat' argument to 'co_min' may not be a coindexed object
   call co_min(result_image=coindexed_result_image[1], a=coindexed_real[1], errmsg=coindexed_character[1], stat=coindexed_integer[1])
 
 end program test_co_min

flang/test/Semantics/collectives03.f90

program test_co_max
 
   ! 'errmsg' argument shall be a character
   !ERROR: Actual argument for 'errmsg=' has bad type 'INTEGER(4)'
   call co_max(c, errmsg=i)
 
   !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'
   call co_max(fake=3.4)
 
   !ERROR: 'a' argument to 'co_max' may not be a coindexed object
   !ERROR: 'errmsg' argument to 'co_max' may not be a coindexed object
   !ERROR: 'stat' argument to 'co_max' may not be a coindexed object
   call co_max(result_image=coindexed_result_image[1], a=coindexed_real[1], errmsg=coindexed_character[1], stat=coindexed_integer[1])
 
 end program test_co_max

flang/test/Semantics/collectives04.f90

program test_co_broadcast
 
   ! 'errmsg' argument shall be a character
   !ERROR: Actual argument for 'errmsg=' has bad type 'INTEGER(4)'
   call co_broadcast(c, errmsg=i, source_image=1)
 
   !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'
   call co_broadcast(fake=3.4)
 
   !ERROR: unknown keyword argument to intrinsic 'co_broadcast'
   call co_broadcast(a=i, result_image=1, stat=status, errmsg=message)
 
   !ERROR: 'a' argument to 'co_broadcast' may not be a coindexed object
   !ERROR: 'errmsg' argument to 'co_broadcast' may not be a coindexed object
   !ERROR: 'stat' argument to 'co_broadcast' may not be a coindexed object
   call co_broadcast(source_image=coindexed_source_image[1], a=coindexed_real[1], errmsg=coindexed_character[1], stat=coindexed_integer[1])
 
 end program test_co_broadcast

flang/test/Semantics/lcobound.f90

program lcobound_tests
   n = lcobound(scalar_coarray, dim=1, kind=non_constant)
 
   !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
   n = lcobound(scalar_coarray, 1, non_constant)
 
   !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()
 
   !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'lcobound'
   lcobounds = lcobound(3.4)
 
   !ERROR: keyword argument to intrinsic 'lcobound' was supplied positionally by an earlier actual argument
   n = lcobound(scalar_coarray, 1, coarray=scalar_coarray)

flang/test/Semantics/ucobound.f90

program ucobound_tests
   n = ucobound(scalar_coarray, dim=1, kind=non_constant)
 
   !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
   n = ucobound(scalar_coarray, 1, non_constant)
 
   !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()
 
   !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'ucobound'
   ucobounds = ucobound(3.4)
 
   !ERROR: keyword argument to intrinsic 'ucobound' was supplied positionally by an earlier actual argument
   n = ucobound(scalar_coarray, 1, coarray=scalar_coarray)