[flang] Fix source line continuation in potential macro calls (bugzilla 46768)

[klausler]

Summary

The prescanner looks for implicit continuation lines when
there are unclosed parentheses at the end of a line, so that
source preprocessing macro references with arguments that span
lines are recognized. The condition that determines this
implicit continuation has been put into a predicate member
function and corrected to apply only when the following line
is source (not a preprocessing directive, comment, &c.).

Fixes bugzilla #46768.

[klausler]

Add test.

[sscalpone]

Thank you.

flang/lib/Parser/prescan.h

private:
   bool SkipCommentLine(bool afterAmpersand);
   bool IsFixedFormCommentLine(const char *) const;
   const char *IsFreeFormComment(const char *) const;
   std::optional<std::size_t> IsIncludeLine(const char *) const;
   void FortranInclude(const char *quote);
   const char *IsPreprocessorDirectiveLine(const char *) const;
   const char *FixedFormContinuationLine(bool mightNeedSpace);
   const char *FreeFormContinuationLine(bool ampersand);
+  bool IsImplicitContinuation() const;
   bool FixedFormContinuation(bool mightNeedSpace);
   bool FreeFormContinuation();
   bool Continuation(bool mightNeedFixedFormSpace);
   std::optional<LineClassification> IsFixedFormCompilerDirectiveLine(
       const char *) const;
   std::optional<LineClassification> IsFreeFormCompilerDirectiveLine(
       const char *) const;
   const char *IsCompilerDirectiveSentinel(const char *) const;

flang/lib/Parser/prescan.cpp

if (InCompilerDirective()) {
     }
     if (col1 == ' ' && nextLine_[1] == ' ' && nextLine_[2] == ' ' &&
         nextLine_[3] == ' ' && nextLine_[4] == ' ') {
       char col6{nextLine_[5]};
       if (col6 != '\n' && col6 != '\t' && col6 != ' ' && col6 != '0') {
         return nextLine_ + 6;
       }
     }
-    if (delimiterNesting_ > 0) {
-      if (!IsFixedFormCommentChar(col1)) {
-        return nextLine_;
-      }
-    }
-  }
+    if (IsImplicitContinuation()) {
   return nullptr; // not a continuation line
 }
 
 const char *Prescanner::FreeFormContinuationLine(bool ampersand) {
   const char *p{nextLine_};
   if (p >= limit_) {
     return nullptr;
   }
if (InCompilerDirective()) {
     } else {
       return nullptr;
     }
   } else {
     if (*p == '&') {
       return p + 1;
     } else if (*p == '!' || *p == '\n' || *p == '#') {
       return nullptr;
-    } else if (ampersand || delimiterNesting_ > 0) {
+    } else if (ampersand || IsImplicitContinuation()) {
       if (p > nextLine_) {
         --p;
       } else {
         insertASpace_ = true;
       }
       return p;
     } else {
       return nullptr;
if (const char *cont{FreeFormContinuationLine(ampersand)}) {
       BeginSourceLine(cont);
       NextLine();
       return true;
     }
   } while (SkipCommentLine(ampersand));
   return false;
 }
 
+// Implicit line continuation allows a preprocessor macro call with
+// arguments to span multiple lines.
+bool Prescanner::IsImplicitContinuation() const {
+  return !inPreprocessorDirective_ && !inCharLiteral_ &&
+      delimiterNesting_ > 0 && nextLine_ < limit_ &&
+      ClassifyLine(nextLine_).kind == LineClassification::Kind::Source;
+}
+
 bool Prescanner::Continuation(bool mightNeedFixedFormSpace) {
   if (*at_ == '\n' || *at_ == '&') {
     if (inFixedForm_) {
       return FixedFormContinuation(mightNeedFixedFormSpace);
     } else {
       return FreeFormContinuation();
     }
   } else {

flang/test/Parser/continuation-in-if.f

+! RUN: %f18 -funparse %s 2>&1 | FileCheck %s
+! CHECK: CALL foo("N","N")
+#ifdef transpose
+      call foo('T',
+#else
+      call foo('N',
+#endif
+     $     'N')
+      end