[flang][preprocessing] Allow keyword macro to rename a function-like macro

[klausler]

Summary

#define FOO(x) ((x)+1)
#define BAR FOO
print *, BAR(1)

should work as one would expect.

Fixes https://github.com/llvm/llvm-project/issues/47162.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Parser/preprocessor.cpp

if (!token.empty() && IsLegalIdentifierStart(token[0]) &&
       break;
     }
   }
   if (j == tokens) {
     return std::nullopt; // input contains nothing that would be replaced
   }
   TokenSequence result{input, 0, j};
   for (; j < tokens; ++j) {
-    const CharBlock &token{input.TokenAt(j)};
+    CharBlock token{input.TokenAt(j)};
     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;
     }
-    Definition &def{it->second};
-    if (def.isDisabled()) {
+    Definition *def{&it->second};
+    if (def->isDisabled()) {
       result.Put(input, j);
       continue;
     }
-    if (!def.isFunctionLike()) {
-      if (def.isPredefined()) {
-        std::string name{def.replacement().TokenAt(0).ToString()};
+    if (!def->isFunctionLike()) {
+      bool isRenaming{false};
+      if (def->isPredefined()) {
+        std::string name{def->replacement().TokenAt(0).ToString()};
         std::string repl;
         if (name == "__FILE__") {
           repl = "\""s +
               allSources_.GetPath(prescanner.GetCurrentProvenance()) + '"';
         } else if (name == "__LINE__") {
           std::string buf;
           llvm::raw_string_ostream ss{buf};
           ss << allSources_.GetLineNumber(prescanner.GetCurrentProvenance());
           repl = ss.str();
         }
         if (!repl.empty()) {
           ProvenanceRange insert{allSources_.AddCompilerInsertion(repl)};
           ProvenanceRange call{allSources_.AddMacroCall(
               insert, input.GetTokenProvenanceRange(j), repl)};
           result.Put(repl, call.start());
           continue;
         }
       }
-      def.set_isDisabled(true);
+      def->set_isDisabled(true);
       TokenSequence replaced{
-          TokenPasting(ReplaceMacros(def.replacement(), prescanner))};
-      def.set_isDisabled(false);
+          TokenPasting(ReplaceMacros(def->replacement(), prescanner))};
+      def->set_isDisabled(false);
+      // Allow a keyword-like macro replacement to be the name of
+      // a function-like macro, possibly surrounded by blanks.
+      std::size_t k{0}, repTokens{replaced.SizeInTokens()};
+      for (; k < repTokens && replaced.TokenAt(k).IsBlank(); ++k) {
+      }
+      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()) {
+            def = &it->second;
+            isRenaming = true;
+          }
+        }
+      }
+      if (!isRenaming) {
         if (!replaced.empty()) {
-        ProvenanceRange from{def.replacement().GetProvenanceRange()};
+          ProvenanceRange from{def->replacement().GetProvenanceRange()};
           ProvenanceRange use{input.GetTokenProvenanceRange(j)};
           ProvenanceRange newRange{
               allSources_.AddMacroCall(from, use, replaced.ToString())};
           result.Put(replaced, newRange);
         }
         continue;
       }
+    }
     // Possible function-like macro call.  Skip spaces and newlines to see
     // whether '(' is next.
     std::size_t k{j};
     bool leftParen{false};
     while (++k < tokens) {
       const CharBlock &lookAhead{input.TokenAt(k)};
       if (!lookAhead.IsBlank() && lookAhead[0] != '\n') {
         leftParen = lookAhead[0] == '(' && lookAhead.size() == 1;
for (int nesting{0}; k < tokens; ++k) {
             break;
           }
           --nesting;
         } else if (ch == ',' && nesting == 0) {
           argStart.push_back(k + 1);
         }
       }
     }
-    if (argStart.size() == 1 && k == argStart[0] && def.argumentCount() == 0) {
+    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 || argStart.size() < def->argumentCount() ||
+        (argStart.size() > def->argumentCount() && !def->isVariadic())) {
       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};
       args.emplace_back(TokenSequence(input, at, count));
     }
-    def.set_isDisabled(true);
+    def->set_isDisabled(true);
     TokenSequence replaced{
-        ReplaceMacros(def.Apply(args, prescanner), prescanner)};
-    def.set_isDisabled(false);
+        ReplaceMacros(def->Apply(args, prescanner), prescanner)};
+    def->set_isDisabled(false);
     if (!replaced.empty()) {
-      ProvenanceRange from{def.replacement().GetProvenanceRange()};
+      ProvenanceRange from{def->replacement().GetProvenanceRange()};
       ProvenanceRange use{input.GetIntervalProvenanceRange(j, k - j)};
       ProvenanceRange newRange{
           allSources_.AddMacroCall(from, use, replaced.ToString())};
       result.Put(replaced, newRange);
     }
     j = k; // advance to the terminal ')'
   }
   return result;

flang/test/Preprocessing/renaming.F

+! RUN: %flang -E %s | FileCheck %s
+! CHECK: ((1)*10000+(11)*100)
+! Ensure that a keyword-like macro can be used to rename a
+! function-like macro.
+#define TO_VERSION2(MAJOR, MINOR) ((MAJOR) * 10000 + (MINOR) * 100)
+#define TO_VERSION TO_VERSION2
+      print *, TO_VERSION(1,11)
+      end