[flang] NFC: change non-nullable pointer arguments to references

[klausler]

Summary

Ticking off a Parser TODO: Preprocessor::Directive()'s Prescanner
argument should be a reference, not a pointer.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/lib/Parser/preprocessor.h

public:
   void Define(std::string macro, std::string value);
   void Undefine(std::string macro);
   bool IsNameDefined(const CharBlock &);
 
   std::optional<TokenSequence> MacroReplacement(
       const TokenSequence &, Prescanner &);
 
   // Implements a preprocessor directive.
-  void Directive(const TokenSequence &, Prescanner *);
+  void Directive(const TokenSequence &, Prescanner &);
 
 private:
   enum class IsElseActive { No, Yes };
   enum class CanDeadElseAppear { No, Yes };
 
   CharBlock SaveTokenAsName(const CharBlock &);
   TokenSequence ReplaceMacros(const TokenSequence &, Prescanner &);
   void SkipDisabledConditionalCode(
-      const std::string &, IsElseActive, Prescanner *, ProvenanceRange);
+      const std::string &, IsElseActive, Prescanner &, ProvenanceRange);
   bool IsIfPredicateTrue(const TokenSequence &expr, std::size_t first,
-      std::size_t exprTokens, Prescanner *);
+      std::size_t exprTokens, Prescanner &);
 
   AllSources &allSources_;
   std::list<std::string> names_;
   std::unordered_map<CharBlock, Definition> definitions_;
   std::stack<CanDeadElseAppear> ifStack_;
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PREPROCESSOR_H_

flang/lib/Parser/preprocessor.cpp

 TokenSequence Preprocessor::ReplaceMacros(
     const TokenSequence &tokens, Prescanner &prescanner) {
   if (std::optional<TokenSequence> repl{MacroReplacement(tokens, prescanner)}) {
     return std::move(*repl);
   }
   return tokens;
 }
 
-void Preprocessor::Directive(const TokenSequence &dir, Prescanner *prescanner) {
+void Preprocessor::Directive(const TokenSequence &dir, Prescanner &prescanner) {
   std::size_t tokens{dir.SizeInTokens()};
   std::size_t j{dir.SkipBlanks(0)};
   if (j == tokens) {
     return;
   }
-  CHECK(prescanner); // TODO: change to reference
   if (dir.TokenAt(j).ToString() != "#") {
-    prescanner->Say(dir.GetTokenProvenanceRange(j), "missing '#'"_err_en_US);
+    prescanner.Say(dir.GetTokenProvenanceRange(j), "missing '#'"_err_en_US);
     return;
   }
   j = dir.SkipBlanks(j + 1);
   while (tokens > 0 && dir.TokenAt(tokens - 1).IsBlank()) {
     --tokens;
   }
   if (j == tokens) {
     return;
   }
   if (IsDecimalDigit(dir.TokenAt(j)[0]) || dir.TokenAt(j)[0] == '"') {
     return; // treat like #line, ignore it
   }
   std::size_t dirOffset{j};
   std::string dirName{ToLowerCaseLetters(dir.TokenAt(dirOffset).ToString())};
   j = dir.SkipBlanks(j + 1);
   CharBlock nameToken;
   if (j < tokens && IsLegalIdentifierStart(dir.TokenAt(j)[0])) {
     nameToken = dir.TokenAt(j);
   }
   if (dirName == "line") {
     // #line is ignored
   } else if (dirName == "define") {
     if (nameToken.empty()) {
-      prescanner->Say(dir.GetTokenProvenanceRange(j < tokens ? j : tokens - 1),
+      prescanner.Say(dir.GetTokenProvenanceRange(j < tokens ? j : tokens - 1),
           "#define: missing or invalid name"_err_en_US);
       return;
     }
     nameToken = SaveTokenAsName(nameToken);
     definitions_.erase(nameToken);
     if (++j < tokens && dir.TokenAt(j).size() == 1 &&
         dir.TokenAt(j)[0] == '(') {
       j = dir.SkipBlanks(j + 1);
       std::vector<std::string> argName;
       bool isVariadic{false};
       if (dir.TokenAt(j).ToString() != ")") {
         while (true) {
           std::string an{dir.TokenAt(j).ToString()};
           if (an == "...") {
             isVariadic = true;
           } else {
             if (an.empty() || !IsLegalIdentifierStart(an[0])) {
-              prescanner->Say(dir.GetTokenProvenanceRange(j),
+              prescanner.Say(dir.GetTokenProvenanceRange(j),
                   "#define: missing or invalid argument name"_err_en_US);
               return;
             }
             argName.push_back(an);
           }
           j = dir.SkipBlanks(j + 1);
           if (j == tokens) {
-            prescanner->Say(dir.GetTokenProvenanceRange(tokens - 1),
+            prescanner.Say(dir.GetTokenProvenanceRange(tokens - 1),
                 "#define: malformed argument list"_err_en_US);
             return;
           }
           std::string punc{dir.TokenAt(j).ToString()};
           if (punc == ")") {
             break;
           }
           if (isVariadic || punc != ",") {
-            prescanner->Say(dir.GetTokenProvenanceRange(j),
+            prescanner.Say(dir.GetTokenProvenanceRange(j),
                 "#define: malformed argument list"_err_en_US);
             return;
           }
           j = dir.SkipBlanks(j + 1);
           if (j == tokens) {
-            prescanner->Say(dir.GetTokenProvenanceRange(tokens - 1),
+            prescanner.Say(dir.GetTokenProvenanceRange(tokens - 1),
                 "#define: malformed argument list"_err_en_US);
             return;
           }
         }
         if (std::set<std::string>(argName.begin(), argName.end()).size() !=
             argName.size()) {
-          prescanner->Say(dir.GetTokenProvenance(dirOffset),
+          prescanner.Say(dir.GetTokenProvenance(dirOffset),
               "#define: argument names are not distinct"_err_en_US);
           return;
         }
       }
       j = dir.SkipBlanks(j + 1);
       definitions_.emplace(std::make_pair(
           nameToken, Definition{argName, dir, j, tokens - j, isVariadic}));
     } else {
       j = dir.SkipBlanks(j + 1);
       definitions_.emplace(
           std::make_pair(nameToken, Definition{dir, j, tokens - j}));
     }
   } else if (dirName == "undef") {
     if (nameToken.empty()) {
-      prescanner->Say(
+      prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "# missing or invalid name"_err_en_US);
     } else {
       if (dir.IsAnythingLeft(++j)) {
-        prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+        prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
             "#undef: excess tokens at end of directive"_en_US);
       } else {
         definitions_.erase(nameToken);
       }
     }
   } else if (dirName == "ifdef" || dirName == "ifndef") {
     bool doThen{false};
     if (nameToken.empty()) {
-      prescanner->Say(
+      prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "#%s: missing name"_err_en_US, dirName);
     } else {
       if (dir.IsAnythingLeft(++j)) {
-        prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+        prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
             "#%s: excess tokens at end of directive"_en_US, dirName);
       }
       doThen = IsNameDefined(nameToken) == (dirName == "ifdef");
     }
     if (doThen) {
       ifStack_.push(CanDeadElseAppear::Yes);
     } else {
       SkipDisabledConditionalCode(dirName, IsElseActive::Yes, prescanner,
           dir.GetTokenProvenance(dirOffset));
     }
   } else if (dirName == "if") {
     if (IsIfPredicateTrue(dir, j, tokens - j, prescanner)) {
       ifStack_.push(CanDeadElseAppear::Yes);
     } else {
       SkipDisabledConditionalCode(dirName, IsElseActive::Yes, prescanner,
           dir.GetTokenProvenanceRange(dirOffset));
     }
   } else if (dirName == "else") {
     if (dir.IsAnythingLeft(j)) {
-      prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+      prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
           "#else: excess tokens at end of directive"_en_US);
     } else if (ifStack_.empty()) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#else: not nested within #if, #ifdef, or #ifndef"_err_en_US);
     } else if (ifStack_.top() != CanDeadElseAppear::Yes) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#else: already appeared within this #if, #ifdef, or #ifndef"_err_en_US);
     } else {
       ifStack_.pop();
       SkipDisabledConditionalCode("else", IsElseActive::No, prescanner,
           dir.GetTokenProvenanceRange(dirOffset));
     }
   } else if (dirName == "elif") {
     if (ifStack_.empty()) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#elif: not nested within #if, #ifdef, or #ifndef"_err_en_US);
     } else if (ifStack_.top() != CanDeadElseAppear::Yes) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#elif: #else previously appeared within this #if, #ifdef, or #ifndef"_err_en_US);
     } else {
       ifStack_.pop();
       SkipDisabledConditionalCode("elif", IsElseActive::No, prescanner,
           dir.GetTokenProvenanceRange(dirOffset));
     }
   } else if (dirName == "endif") {
     if (dir.IsAnythingLeft(j)) {
-      prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+      prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
           "#endif: excess tokens at end of directive"_en_US);
     } else if (ifStack_.empty()) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#endif: no #if, #ifdef, or #ifndef"_err_en_US);
     } else {
       ifStack_.pop();
     }
   } else if (dirName == "error") {
-    prescanner->Say(
+    prescanner.Say(
         dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
         "%s"_err_en_US, dir.ToString());
   } else if (dirName == "warning" || dirName == "comment" ||
       dirName == "note") {
-    prescanner->Say(
+    prescanner.Say(
         dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
         "%s"_en_US, dir.ToString());
   } else if (dirName == "include") {
     if (j == tokens) {
-      prescanner->Say(
+      prescanner.Say(
           dir.GetIntervalProvenanceRange(dirOffset, tokens - dirOffset),
           "#include: missing name of file to include"_err_en_US);
       return;
     }
     std::string include;
     std::optional<std::string> prependPath;
     if (dir.TokenAt(j).ToString() == "<") { // #include <foo>
       std::size_t k{j + 1};
       if (k >= tokens) {
-        prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+        prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
             "#include: file name missing"_err_en_US);
         return;
       }
       while (k < tokens && dir.TokenAt(k) != ">") {
         ++k;
       }
       if (k >= tokens) {
-        prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+        prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
             "#include: expected '>' at end of included file"_en_US);
       }
       TokenSequence braced{dir, j + 1, k - j - 1};
-      include = ReplaceMacros(braced, *prescanner).ToString();
+      include = ReplaceMacros(braced, prescanner).ToString();
       j = k;
     } else if ((include = dir.TokenAt(j).ToString()).substr(0, 1) == "\"" &&
         include.substr(include.size() - 1, 1) == "\"") { // #include "foo"
       include = include.substr(1, include.size() - 2);
       // #include "foo" starts search in directory of file containing
       // the directive
       auto prov{dir.GetTokenProvenanceRange(dirOffset).start()};
       if (const auto *currentFile{allSources_.GetSourceFile(prov)}) {
         prependPath = DirectoryName(currentFile->path());
       }
     } else {
-      prescanner->Say(dir.GetTokenProvenanceRange(j < tokens ? j : tokens - 1),
+      prescanner.Say(dir.GetTokenProvenanceRange(j < tokens ? j : tokens - 1),
           "#include: expected name of file to include"_err_en_US);
       return;
     }
     if (include.empty()) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#include: empty include file name"_err_en_US);
       return;
     }
     j = dir.SkipBlanks(j + 1);
     if (j < tokens && dir.TokenAt(j).ToString() != "!") {
-      prescanner->Say(dir.GetIntervalProvenanceRange(j, tokens - j),
+      prescanner.Say(dir.GetIntervalProvenanceRange(j, tokens - j),
           "#include: extra stuff ignored after file name"_en_US);
     }
     std::string buf;
     llvm::raw_string_ostream error{buf};
     const SourceFile *included{
         allSources_.Open(include, error, std::move(prependPath))};
     if (!included) {
-      prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+      prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
           "#include: %s"_err_en_US, error.str());
     } else if (included->bytes() > 0) {
       ProvenanceRange fileRange{
           allSources_.AddIncludedFile(*included, dir.GetProvenanceRange())};
-      Prescanner{*prescanner}
+      Prescanner{prescanner}
           .set_encoding(included->encoding())
           .Prescan(fileRange);
     }
   } else {
-    prescanner->Say(dir.GetTokenProvenanceRange(dirOffset),
+    prescanner.Say(dir.GetTokenProvenanceRange(dirOffset),
         "#%s: unknown or unimplemented directive"_err_en_US, dirName);
   }
 }
 
 CharBlock Preprocessor::SaveTokenAsName(const CharBlock &t) {
   names_.push_back(t.ToString());
   return {names_.back().data(), names_.back().size()};
 }
if (j == tokens) {
     *rest = tokens;
     return "";
   }
   *rest = line.SkipBlanks(j + 1);
   return ToLowerCaseLetters(line.TokenAt(j).ToString());
 }
 
 void Preprocessor::SkipDisabledConditionalCode(const std::string &dirName,
-    IsElseActive isElseActive, Prescanner *prescanner,
+    IsElseActive isElseActive, Prescanner &prescanner,
     ProvenanceRange provenanceRange) {
   int nesting{0};
-  while (!prescanner->IsAtEnd()) {
-    if (!prescanner->IsNextLinePreprocessorDirective()) {
-      prescanner->NextLine();
+  while (!prescanner.IsAtEnd()) {
+    if (!prescanner.IsNextLinePreprocessorDirective()) {
+      prescanner.NextLine();
       continue;
     }
-    TokenSequence line{prescanner->TokenizePreprocessorDirective()};
+    TokenSequence line{prescanner.TokenizePreprocessorDirective()};
     std::size_t rest{0};
     std::string dn{GetDirectiveName(line, &rest)};
     if (dn == "ifdef" || dn == "ifndef" || dn == "if") {
       ++nesting;
     } else if (dn == "endif") {
       if (nesting-- == 0) {
         return;
       }
     } else if (isElseActive == IsElseActive::Yes && nesting == 0) {
       if (dn == "else") {
         ifStack_.push(CanDeadElseAppear::No);
         return;
       }
       if (dn == "elif" &&
           IsIfPredicateTrue(
               line, rest, line.SizeInTokens() - rest, prescanner)) {
         ifStack_.push(CanDeadElseAppear::Yes);
         return;
       }
     }
   }
-  prescanner->Say(provenanceRange, "#%s: missing #endif"_err_en_US, dirName);
+  prescanner.Say(provenanceRange, "#%s: missing #endif"_err_en_US, dirName);
 }
 
 // Precedence level codes used here to accommodate mixed Fortran and C:
 // 15: parentheses and constants, logical !, bitwise ~
 // 14: unary + and -
 // 13: **
 // 12: *, /, % (modulus)
 // 11: + and -
while (*atToken < tokens) {
     default:
       CRASH_NO_CASE;
     }
   }
   return left;
 }
 
 bool Preprocessor::IsIfPredicateTrue(const TokenSequence &expr,
-    std::size_t first, std::size_t exprTokens, Prescanner *prescanner) {
+    std::size_t first, std::size_t exprTokens, Prescanner &prescanner) {
   TokenSequence expr1{expr, first, exprTokens};
   if (expr1.HasBlanks()) {
     expr1.RemoveBlanks();
   }
   TokenSequence expr2;
   for (std::size_t j{0}; j < expr1.SizeInTokens(); ++j) {
     if (ToLowerCaseLetters(expr1.TokenAt(j).ToString()) == "defined") {
       CharBlock name;
if (ToLowerCaseLetters(expr1.TokenAt(j).ToString()) == "defined") {
       if (!name.empty()) {
         char truth{IsNameDefined(name) ? '1' : '0'};
         expr2.Put(&truth, 1, allSources_.CompilerInsertionProvenance(truth));
         continue;
       }
     }
     expr2.Put(expr1, j);
   }
-  TokenSequence expr3{ReplaceMacros(expr2, *prescanner)};
+  TokenSequence expr3{ReplaceMacros(expr2, prescanner)};
   if (expr3.HasBlanks()) {
     expr3.RemoveBlanks();
   }
   if (expr3.empty()) {
-    prescanner->Say(expr.GetProvenanceRange(), "empty expression"_err_en_US);
+    prescanner.Say(expr.GetProvenanceRange(), "empty expression"_err_en_US);
     return false;
   }
   std::size_t atToken{0};
   std::optional<Message> error;
   bool result{ExpressionValue(expr3, 0, &atToken, &error) != 0};
   if (error) {
-    prescanner->Say(std::move(*error));
+    prescanner.Say(std::move(*error));
   } else if (atToken < expr3.SizeInTokens() &&
       expr3.TokenAt(atToken).ToString() != "!") {
-    prescanner->Say(expr3.GetIntervalProvenanceRange(
-                        atToken, expr3.SizeInTokens() - atToken),
+    prescanner.Say(expr3.GetIntervalProvenanceRange(
         atToken == 0 ? "could not parse any expression"_err_en_US
                      : "excess characters after expression"_err_en_US);
   }
   return result;
 }
 } // namespace Fortran::parser

flang/lib/Parser/prescan.cpp

void Prescanner::Statement() {
   case LineClassification::Kind::IncludeLine:
     FortranInclude(nextLine_ + line.payloadOffset);
     NextLine();
     return;
   case LineClassification::Kind::ConditionalCompilationDirective:
   case LineClassification::Kind::IncludeDirective:
   case LineClassification::Kind::DefinitionDirective:
   case LineClassification::Kind::PreprocessorDirective:
-    preprocessor_.Directive(TokenizePreprocessorDirective(), this);
+    preprocessor_.Directive(TokenizePreprocessorDirective(), *this);
     return;
   case LineClassification::Kind::CompilerDirective:
     directiveSentinel_ = line.sentinel;
     CHECK(InCompilerDirective());
     BeginStatementAndAdvance();
     if (inFixedForm_) {
       CHECK(IsFixedFormCommentChar(*at_));
     } else {
return false;
           LineClassification::Kind::ConditionalCompilationDirective ||
       lineClass.kind == LineClassification::Kind::PreprocessorDirective) {
     // Allow conditional compilation directives (e.g., #ifdef) to affect
     // continuation lines.
     // Allow other preprocessor directives, too, except #include
     // (when it does not follow '&'), #define, and #undef (because
     // they cannot be allowed to affect preceding text on a
     // continued line).
-    preprocessor_.Directive(TokenizePreprocessorDirective(), this);
+    preprocessor_.Directive(TokenizePreprocessorDirective(), *this);
     return true;
   } else if (afterAmpersand &&
       (lineClass.kind == LineClassification::Kind::IncludeDirective ||
           lineClass.kind == LineClassification::Kind::IncludeLine)) {
     SkipToEndOfLine();
     omitNewline_ = true;
     skipLeadingAmpersand_ = true;
     return false;