[flang][Preprocessor] Diagnose incorrect invocation of function-like macros

[rogfer01]

Summary

During preprocessor expansion of a function-like macro, if the number of arguments is not acceptable for the macro or we fail to find the right parenthesis, we silently skip the expansion. This may be confusing to a user that is using a macro incorrectly (specially if the unexpanded stream of tokens is still valid Fortran). This change adds a diagnostic for these cases.

[rogfer01]

Any thoughts on this @klausler ?

[klausler]

This check would preclude defining some cases of a function with a Fortran generic interface and using a function-like macro to define or override another case.

If the preprocessor doesn't catch this condition, semantics or the linker will get it later.

flang/lib/Parser/preprocessor.cpp

if (token.IsBlank() || !IsLegalIdentifierStart(token[0])) {
       result.Put(input, j);
       continue;
     }
     auto it{definitions_.find(token)};
     if (it == definitions_.end()) {
       result.Put(input, j);
       continue;
     }
+    auto dirName{token.ToString()};
     Definition *def{&it->second};
     if (def->isDisabled()) {
       result.Put(input, j);
       continue;
     }
     if (!def->isFunctionLike()) {
       bool isRenaming{false};
       if (def->isPredefined()) {
if (!def->isFunctionLike()) {
       if (k < repTokens) {
         token = replaced.TokenAt(k);
         for (++k; k < repTokens && replaced.TokenAt(k).IsBlank(); ++k) {
         }
         if (k == repTokens && IsLegalIdentifierStart(token[0])) {
           auto it{definitions_.find(token)};
           if (it != definitions_.end() && !it->second.isDisabled() &&
               it->second.isFunctionLike()) {
+            dirName = token.ToString();
             def = &it->second;
             isRenaming = true;
           }
         }
       }
       if (!isRenaming) {
         if (!replaced.empty()) {
           ProvenanceRange from{def->replacement().GetProvenanceRange()};
for (; j < tokens; ++j) {
     }
     if (argStart.size() == 1 && k == argStart[0] && def->argumentCount() == 0) {
       // Subtle: () is zero arguments, not one empty argument,
       // unless one argument was expected.
       argStart.clear();
     }
     if (k >= tokens || argStart.size() < def->argumentCount() ||
         (argStart.size() > def->argumentCount() && !def->isVariadic())) {
+      if (k >= tokens) {
+        prescanner.Say(input.GetTokenProvenance(j),
+            "unterminated argument list invoking macro '%s'"_err_en_US,
+            dirName);
+      } else if (argStart.size() < def->argumentCount()) {
+        // FIXME: argStart is never zero if def->argumentCount() > 0
+        // so this will at least diagnose "but only 1 given".
+        prescanner.Say(input.GetTokenProvenance(j),
+            "macro '%s' requires %d arguments, but only %d given"_err_en_US,
+            dirName, def->argumentCount(), argStart.size());
+      } else if (argStart.size() > def->argumentCount()) {
+        prescanner.Say(input.GetTokenProvenance(j),
+            "macro '%s' passed %d arguments, but takes just %d"_err_en_US,
+            dirName, argStart.size(), def->argumentCount());
+      }
       result.Put(input, j);
       continue;
     }
     std::vector<TokenSequence> args;
     for (std::size_t n{0}; n < argStart.size(); ++n) {
       std::size_t at{argStart[n]};
       std::size_t count{
           (n + 1 == argStart.size() ? k : argStart[n + 1] - 1) - at};

flang/test/Preprocessing/diag-macro1.F90

+! RUN: not %flang -E %s 2>&1 | FileCheck %s
+! Check that we diagnose wrong arguments passed to function-like macros.
+subroutine foo()
+  implicit none
+
+#define sub(x, y) foo2(x, y)
+#define sub0() foo2(1, 2)
+   call sub()
+   call sub(1)
+   call sub(1, 2, 3)
+   call sub0(1, 2)
+end subroutine foo
+
+!CHECK: error: macro 'sub' requires 2 arguments, but only 1 given
+!CHECK: error: macro 'sub' requires 2 arguments, but only 1 given
+!CHECK: error: macro 'sub' passed 3 arguments, but takes just 2
+!CHECK: error: macro 'sub0' passed 2 arguments, but takes just 0

flang/test/Preprocessing/diag-macro2.F90

+! RUN: not %flang -E %s 2>&1 | FileCheck %s
+! Check that we diagnose unterminated function-like macro invocations
+subroutine foo()
+  implicit none
+#define sub(x, y) foo2(x, y)
+   call sub(1, 2
+   print *, "hello"
+end subroutine foo
+
+!CHECK: error: unterminated argument list invoking macro 'sub'

flang/test/Preprocessing/diag-macro3.F90

+! RUN: not %flang -E %s 2>&1 | FileCheck %s
+! Check that we diagnose unterminated function-like macro invocations
+subroutine foo()
+  implicit none
+#define sub(x, y) foo2(x, y)
+#define bar )
+   call sub(1, 2 bar
+   print *, "hello"
+end subroutine foo
+
+!CHECK: error: unterminated argument list invoking macro 'sub'

flang/test/Preprocessing/diag-macro4.F90

+! RUN: not %flang -E %s 2>&1 | FileCheck %s
+! Check that we diagnose wrong arguments passed to function-like macros,
+! this time indirectly using another object-like macro.
+subroutine foo()
+  implicit none
+
+#define presub sub
+#define presub0 sub0
+#define sub(x, y) foo2(x, y)
+#define sub0() foo2(1, 2)
+   call presub()
+   call presub(1)
+   call presub(1, 2, 3)
+   call presub0(1, 2)
+end subroutine foo
+
+!CHECK: error: macro 'sub' requires 2 arguments, but only 1 given
+!CHECK: error: macro 'sub' requires 2 arguments, but only 1 given
+!CHECK: error: macro 'sub' passed 3 arguments, but takes just 2
+!CHECK: error: macro 'sub0' passed 2 arguments, but takes just 0