[flang] Support the color diagnostics on scanning, parsing, and semantics

[peixin]

Summary

The options -f{no-}color-diagnostics have been supported in driver. This
supports the behaviors in scanning, parsing, and semantics, and the
behaviors are exactly the same as the driver.

To illustrate the added behaviour, consider the following input file:

! file.f90
program m
  integer :: i = k
end

In the following invocations, "error: Must be a constant value" _will be_
formatted:

$ flang-new file.f90
error: Semantic errors in file.f90
./file.f90:2:18: error: Must be a constant value
    integer :: i = k

Note that "error: Semantic errors in file.f90" is also formatted, which
is supported in https://reviews.llvm.org/D126164.

Also note that only "error", "warning" and "portability" are formatted.
Check the following input file:

! file2.f90
program m
  integer :: i =
end

$ flang-new test2.f90
error: Could not parse test2.f90
./test2.f90:2:11: error: expected '('
    integer :: i =
            ^
./test2.f90:2:3: in the context: statement function definition
    integer :: i =
    ^
...

The "error: Could not parse test2.f90" and "error: expected '('" are
formatted. Others such as "in the context" are not formatted yet, which
may or may not be supported.

[peixin]

Please check the following test cases after applying this patch. This highlight the color of the keywords error before "Must be a constant value" and portability.

$ cat case.f90 
program m
  integer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  integer :: i = k
  integer :: j = k
end
$ flang-new -fc1 case.f90 
error: Semantic errors in case.f90
./case.f90:2:11: portability: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx has length 72, which is greater than the maximum name length 63
    integer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
./case.f90:3:18: error: Must be a constant value
    integer :: i = k
                   ^
./case.f90:4:18: error: Must be a constant value
    integer :: j = k
                   ^

[awarzynski]

Hi @peixin , thanks for proposing this!

I think that Flang end users will really appreciate this. However (I already hinted this in https://reviews.llvm.org/D126164), we should be able to disable this formatting (with e.g. -fno-color-diagnostics) and have plain text messages in tests (i.e. default to -fno-color-diagnostics there). Let me know if you need any help with this!

[peixin]

In D126166#3547361, @awarzynski wrote:

Hi @peixin , thanks for proposing this!

I think that Flang end users will really appreciate this. However (I already hinted this in https://reviews.llvm.org/D126164), we should be able to disable this formatting (with e.g. -fno-color-diagnostics) and have plain text messages in tests (i.e. default to -fno-color-diagnostics there). Let me know if you need any help with this!

Thanks @awarzynski . Currently, I have no idea of how to add one option. Could you please help me provide the direction where I can follow?

[awarzynski]

In D126166#3547414, @peixin wrote:

In D126166#3547361, @awarzynski wrote:

Hi @peixin , thanks for proposing this!

I think that Flang end users will really appreciate this. However (I already hinted this in https://reviews.llvm.org/D126164), we should be able to disable this formatting (with e.g. -fno-color-diagnostics) and have plain text messages in tests (i.e. default to -fno-color-diagnostics there). Let me know if you need any help with this!

Thanks @awarzynski . Currently, I have no idea of how to add one option. Could you please help me provide the direction where I can follow?

Here are some relevant docs:

• adding-new-compiler-options (Flang docs)
• adding-new-command-line-option (Clang docs)

Some grasp of how things work in Clang is both helpful (Flang's driver has been inspired by Clang) and required (Flang and Clang share Options.td).

As for -f{no-}color-diagnostics specifically, there's parseShowColorsArgs that processes these options in the frontend driver (CompilerInvocation belongs to the frontend driver). In other words, these options are already enabled in Flang, but clearly some plumbing is missing. In the compiler driver, I see this in Clang.cpp, but nothing of this sort in Flang.cpp 🤔 .

Note that the above is mostly about parsing the option as provided by the user. Once an option is parsed, you will need to make sure that it is used to configure the frontend. You could use FrontendOptions in the driver. You will also have to tweak the frontend API (e.g. AllSources::EmitMessage) to make sure that the formatting is not unconditional.

Lastly, I would skip any changes "bbc.cpp". Whatever logic is added in flang-new, it won't work in bbc. So you can either leave bbc as is or you will have to add -f{no-}color-diagnostics there independently. Unconditional formatting of the diagnostics is not desirable IMHO.

Apologies if this feels like "waving hands" - happy to answer more questions!

[peixin]

In D126166#3549676, @awarzynski wrote:

In D126166#3547414, @peixin wrote:

In D126166#3547361, @awarzynski wrote:

Hi @peixin , thanks for proposing this!

I think that Flang end users will really appreciate this. However (I already hinted this in https://reviews.llvm.org/D126164), we should be able to disable this formatting (with e.g. -fno-color-diagnostics) and have plain text messages in tests (i.e. default to -fno-color-diagnostics there). Let me know if you need any help with this!

Thanks @awarzynski . Currently, I have no idea of how to add one option. Could you please help me provide the direction where I can follow?

Here are some relevant docs:

• adding-new-compiler-options (Flang docs)
• adding-new-command-line-option (Clang docs)

Some grasp of how things work in Clang is both helpful (Flang's driver has been inspired by Clang) and required (Flang and Clang share Options.td).

As for -f{no-}color-diagnostics specifically, there's parseShowColorsArgs that processes these options in the frontend driver (CompilerInvocation belongs to the frontend driver). In other words, these options are already enabled in Flang, but clearly some plumbing is missing. In the compiler driver, I see this in Clang.cpp, but nothing of this sort in Flang.cpp 🤔 .

Note that the above is mostly about parsing the option as provided by the user. Once an option is parsed, you will need to make sure that it is used to configure the frontend. You could use FrontendOptions in the driver. You will also have to tweak the frontend API (e.g. AllSources::EmitMessage) to make sure that the formatting is not unconditional.

Lastly, I would skip any changes "bbc.cpp". Whatever logic is added in flang-new, it won't work in bbc. So you can either leave bbc as is or you will have to add -f{no-}color-diagnostics there independently. Unconditional formatting of the diagnostics is not desirable IMHO.

Apologies if this feels like "waving hands" - happy to answer more questions!

@awarzynski Thanks so much for there references. These are very helpful. I will look into these and will let know if I have further questions.

[peixin]

ping

[awarzynski]

These changes nicely complement what you did in https://reviews.llvm.org/D126164 and will definitely improve the end-user experience. Thank you for working on this!

The implementation makes sense to me, but since I've not contributed any code in this area, I'd prefer to defer to somebody more familiar with the frontend. Perhaps @klausler or @jeanPerier ?

[peixin]

In D126166#3659509, @awarzynski wrote:

These changes nicely complement what you did in https://reviews.llvm.org/D126164 and will definitely improve the end-user experience. Thank you for working on this!

The implementation makes sense to me, but since I've not contributed any code in this area, I'd prefer to defer to somebody more familiar with the frontend. Perhaps @klausler or @jeanPerier ?

OK. Thanks.

[awarzynski]

@peixin, I think that it would be great to have this available in LLVM Flang. Ideally, folks most active in this area would review it, but sometimes that's not possible. IMHO, this is rather straightforward and looks good to me, thanks for working on it!

I've left a few small suggestions, but nothing major. Feel free to ignore. Please way at least a day or two before merging in case people leave some extra comments!

flang/lib/Parser/provenance.cpp

232

[nit] I don't think that you need a switch statement here. Instead, I would write something like (pseudo code):

if (color && showColors) {
  o.changeColor(color, true);
  o << prefix;
  o.resetColor();
  return;
}

o << prefix;

or:

if (color && showColors)
  o.changeColor(color, true);

o << prefix;

if (color && showColors)
  o.resetColor();

(you may need to use std::optional for color for this to work).

flang/test/Driver/color-diagnostics-parse.f90

2

flang/test/Driver/color-diagnostics-scan.f

2

flang/test/Driver/color-diagnostics-sema.f90

2

[peixin]

Thanks @awarzynski for the review. Address the comments.

I will land this patch tomorrow if there is no further comments.

flang/docs/ReleaseNotes.md

* In contrast to Clang, Flang will not default to using `-fpie` when linking
   -fc1`). Once that is available, support for the `-fpie` can officially be
   added and the default behaviour updated.
 
 ## New Compiler Flags
 * Refined how `-f{no-}color-diagnostics` is treated to better align with Clang.
   In particular, both `-fcolor-diagnostics` and `-fno-color-diagnostics` are
   now available in `flang-new` (the diagnostics are formatted by default). In
   the frontend driver, `flang-new -fc1`, only `-fcolor-diagnostics` is
-  available (by default, the diagnostics are not formatted). Note that this
-  will only affect the diagnostics printed by driver (scanning, parsing and
-  semantic diagnostics are not affected).
+  available (by default, the diagnostics are not formatted).
 
 ## Windows Support
 
 ## Fortran Language Changes in Flang
 
 ## Build System Changes
 
 ## New Issues Found

flang/include/flang/Parser/parsing.h

struct Options {
   std::vector<std::string> searchDirectories;
   std::vector<std::string> intrinsicModuleDirectories;
   std::vector<Predefinition> predefinitions;
   bool instrumentedParse{false};
   bool isModuleFile{false};
   bool needProvenanceRangeToCharBlockMappings{false};
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
   bool prescanAndReformat{false}; // -E
+  bool showColors{false};
 };
 
 class Parsing {
 public:
   explicit Parsing(AllCookedSources &);
   ~Parsing();
 
   bool consumedWholeFile() const { return consumedWholeFile_; }
void EmitPreprocessedSource(
       llvm::raw_ostream &, bool lineDirectives = true) const;
   void DumpCookedChars(llvm::raw_ostream &) const;
   void DumpProvenance(llvm::raw_ostream &) const;
   void DumpParsingLog(llvm::raw_ostream &) const;
   void Parse(llvm::raw_ostream &debugOutput);
   void ClearLog();
 
   void EmitMessage(llvm::raw_ostream &o, const char *at,
-      const std::string &message, bool echoSourceLine = false) const {
+      const std::string &message, const std::string &prefix,
+      llvm::raw_ostream::Colors color = llvm::raw_ostream::SAVEDCOLOR,
+      bool echoSourceLine = false) const {
     allCooked_.allSources().EmitMessage(o,
-        allCooked_.GetProvenanceRange(CharBlock(at)), message, echoSourceLine);
+        allCooked_.GetProvenanceRange(CharBlock(at)), message, prefix, color,
+        echoSourceLine);
   }
 
 private:
   Options options_;
   AllCookedSources &allCooked_;
   CookedSource *currentCooked_{nullptr};
   Messages messages_;
   bool consumedWholeFile_{false};
   const char *finalRestingPlace_{nullptr};
   std::optional<Program> parseTree_;
   ParsingLog log_;
 };
 } // namespace Fortran::parser
 #endif // FORTRAN_PARSER_PARSING_H_

flang/include/flang/Parser/provenance.h

public:
   ProvenanceRange AddMacroCall(
       ProvenanceRange def, ProvenanceRange use, const std::string &expansion);
   ProvenanceRange AddCompilerInsertion(std::string);
 
   bool IsValid(Provenance at) const { return range_.Contains(at); }
   bool IsValid(ProvenanceRange range) const {
     return range.size() > 0 && range_.Contains(range);
   }
+  void setShowColors(bool showColors) { showColors_ = showColors; }
+  bool getShowColors() const { return showColors_; }
   void EmitMessage(llvm::raw_ostream &, const std::optional<ProvenanceRange> &,
-      const std::string &message, bool echoSourceLine = false) const;
+      const std::string &message, const std::string &prefix,
+      llvm::raw_ostream::Colors color, bool echoSourceLine = false) const;
   const SourceFile *GetSourceFile(
       Provenance, std::size_t *offset = nullptr) const;
   const char *GetSource(ProvenanceRange) const;
   std::optional<SourcePosition> GetSourcePosition(Provenance) const;
   std::optional<ProvenanceRange> GetFirstFileProvenance() const;
   std::string GetPath(Provenance) const; // __FILE__
   int GetLineNumber(Provenance) const; // __LINE__
   Provenance CompilerInsertionProvenance(char ch);
private:
 
   // Elements are in ascending & contiguous order of .covers.
   std::vector<Origin> origin_;
   ProvenanceRange range_;
   std::map<char, Provenance> compilerInsertionProvenance_;
   std::vector<std::unique_ptr<SourceFile>> ownedSourceFiles_;
   std::list<std::string> searchPath_;
   Encoding encoding_{Encoding::UTF_8};
+  bool showColors_{false};
 };
 
 // Represents the result of preprocessing and prescanning a single source
 // file (and all its inclusions) or module file.  Parsers operate within
 // single instances of CookedSource.
 class CookedSource {
 public:
   int number() const { return number_; }

flang/lib/Frontend/CompilerInvocation.cpp

void CompilerInvocation::setFortranOpts() {
   // Add the directory supplied through -J/-module-dir to the list of search
   // directories
   if (moduleDirJ.compare(".") != 0)
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 
   if (frontendOptions.instrumentedParse)
     fortranOptions.instrumentedParse = true;
 
+  if (frontendOptions.showColors)
+    fortranOptions.showColors = true;
+
   if (frontendOptions.needProvenanceRangeToCharBlockMappings)
     fortranOptions.needProvenanceRangeToCharBlockMappings = true;
 
   if (getEnableConformanceChecks()) {
     fortranOptions.features.WarnOnAllNonstandard();
   }
 }
 

flang/lib/Parser/message.cpp

static std::string Prefix(Severity severity) {
   case Severity::Todo:
     return "error: not yet implemented: ";
   case Severity::None:
     break;
   }
   return "";
 }
 
+static llvm::raw_ostream::Colors PrefixColor(Severity severity) {
+  switch (severity) {
+  case Severity::Error:
+  case Severity::Todo:
+    return llvm::raw_ostream::RED;
+  case Severity::Warning:
+  case Severity::Portability:
+    return llvm::raw_ostream::MAGENTA;
+  default:
+    // TODO: Set the color.
+    break;
+  }
+  return llvm::raw_ostream::SAVEDCOLOR;
+}
+
 void Message::Emit(llvm::raw_ostream &o, const AllCookedSources &allCooked,
     bool echoSourceLine) const {
   std::optional<ProvenanceRange> provenanceRange{GetProvenanceRange(allCooked)};
   const AllSources &sources{allCooked.allSources()};
-  sources.EmitMessage(
-      o, provenanceRange, Prefix(severity()) + ToString(), echoSourceLine);
+  sources.EmitMessage(o, provenanceRange, ToString(), Prefix(severity()),
+      PrefixColor(severity()), echoSourceLine);
   bool isContext{attachmentIsContext_};
   for (const Message *attachment{attachment_.get()}; attachment;
        attachment = attachment->attachment_.get()) {
+    Severity severity = isContext ? Severity::Context : attachment->severity();
     sources.EmitMessage(o, attachment->GetProvenanceRange(allCooked),
-        Prefix(isContext ? Severity::Context : attachment->severity()) +
-            attachment->ToString(),
+        attachment->ToString(), Prefix(severity), PrefixColor(severity),
         echoSourceLine);
   }
 }
 
 // Messages are equal if they're for the same location and text, and the user
 // visible aspects of their attachments are the same
 bool Message::operator==(const Message &that) const {
   if (!AtSameLocation(that) || ToString() != that.ToString() ||

flang/lib/Parser/parsing.cpp

if (currentCooked_->BufferedBytes() == 0 && !options.isModuleFile) {
     // Input is empty.  Append a newline so that any warning
     // message about nonstandard usage will have provenance.
     currentCooked_->Put('\n', range.start());
   }
   currentCooked_->Marshal(allCooked_);
   if (options.needProvenanceRangeToCharBlockMappings) {
     currentCooked_->CompileProvenanceRangeToOffsetMappings(allSources);
   }
+  if (options.showColors) {
+    allSources.setShowColors(/*showColors=*/true);
+  }
   return sourceFile;
 }
 
 void Parsing::EmitPreprocessedSource(
     llvm::raw_ostream &out, bool lineDirectives) const {
   const SourceFile *sourceFile{nullptr};
   int sourceLine{0};
   int column{1};

flang/lib/Parser/provenance.cpp

 ProvenanceRange AllSources::AddCompilerInsertion(std::string text) {
   ProvenanceRange covers{range_.NextAfter(), text.size()};
   CHECK(range_.AnnexIfPredecessor(covers));
   CHECK(origin_.back().covers.ImmediatelyPrecedes(covers));
   origin_.emplace_back(covers, text);
   return covers;
 }
 
+static void EmitPrefix(llvm::raw_ostream &o, llvm::raw_ostream::Colors color,
+    const std::string &prefix, bool showColors) {
+  if (prefix.empty()) {
+    return;
+  }
+  if (showColors) {
+    o.changeColor(color, true);
+  }
+  o << prefix;
+  if (showColors) {
+    o.resetColor();
+  }
+}
+
 void AllSources::EmitMessage(llvm::raw_ostream &o,
     const std::optional<ProvenanceRange> &range, const std::string &message,
+    const std::string &prefix, llvm::raw_ostream::Colors color,
     bool echoSourceLine) const {
   if (!range) {
+    EmitPrefix(o, color, prefix, this->getShowColors());
     o << message << '\n';
     return;
   }
   CHECK(IsValid(*range));
   const Origin &origin{MapToOrigin(range->start())};
   common::visit(
       common::visitors{
           [&](const Inclusion &inc) {
             o << inc.source.path();
             std::size_t offset{origin.covers.MemberOffset(range->start())};
             SourcePosition pos{inc.source.FindOffsetLineAndColumn(offset)};
-            o << ':' << pos.line << ':' << pos.column;
-            o << ": " << message << '\n';
+            o << ':' << pos.line << ':' << pos.column << ": ";
+            EmitPrefix(o, color, prefix, this->getShowColors());
+            o << message << '\n';
             if (echoSourceLine) {
               const char *text{inc.source.content().data() +
                   inc.source.GetLineStartOffset(pos.line)};
               o << "  ";
               for (const char *p{text}; *p != '\n'; ++p) {
                 o << *p;
               }
               o << "\n  ";
common::visit(
                     }
                   }
                 }
               }
               o << '\n';
             }
             if (IsValid(origin.replaces)) {
               EmitMessage(o, origin.replaces,
-                  inc.isModule ? "used here"s : "included here"s,
+                  inc.isModule ? "used here"s : "included here"s, prefix, color,
                   echoSourceLine);
             }
           },
           [&](const Macro &mac) {
-            EmitMessage(o, origin.replaces, message, echoSourceLine);
             EmitMessage(
-                o, mac.definition, "in a macro defined here", echoSourceLine);
+                o, origin.replaces, message, prefix, color, echoSourceLine);
+            EmitMessage(o, mac.definition, "in a macro defined here", prefix,
+                color, echoSourceLine);
             if (echoSourceLine) {
               o << "that expanded to:\n  " << mac.expansion << "\n  ";
               for (std::size_t j{0};
                    origin.covers.OffsetMember(j) < range->start(); ++j) {
                 o << (mac.expansion[j] == '\t' ? '\t' : ' ');
               }
               o << "^\n";
             }
           },
-          [&](const CompilerInsertion &) { o << message << '\n'; },
+          [&](const CompilerInsertion &) {
+            EmitPrefix(o, color, prefix, this->getShowColors());
+            o << message << '\n';
+          },
       },
       origin.u);
 }
 
 const SourceFile *AllSources::GetSourceFile(
     Provenance at, std::size_t *offset) const {
   const Origin &origin{MapToOrigin(at)};
   return common::visit(common::visitors{

flang/test/Driver/color-diagnostics-parse.f90

+! Test the behaviors of -f{no-}color-diagnostics when emitting parsing
+! diagnostics.
+! Windows command prompt doesn't support ANSI escape sequences.
+! REQUIRES: shell
+
+! RUN: not %flang %s -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang %s -fno-color-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_NCD
+! RUN: not %flang_fc1 %s -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang_fc1 %s 2>&1 | FileCheck %s --check-prefix=CHECK_NCD
+
+! CHECK_CD: {{.*}}[0;1;31merror: {{.*}}[0mexpected '('
+
+! CHECK_NCD: error: expected '('
+
+program m
+  integer :: i =
+end

flang/test/Driver/color-diagnostics-scan.f

+! Test the behaviors of -f{no-}color-diagnostics when emitting scanning
+! diagnostics.
+! Windows command prompt doesn't support ANSI escape sequences.
+! REQUIRES: shell
+
+! RUN: not %flang %s -E -Werror -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang %s -E -Werror -fno-color-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_NCD
+! RUN: not %flang_fc1 -E -Werror %s -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang_fc1 -E -Werror %s 2>&1 | FileCheck %s --check-prefix=CHECK_NCD
+
+! CHECK_CD: {{.*}}[0;1;35mwarning: {{.*}}[0mCharacter in fixed-form label field must be a digit
+
+! CHECK_NCD: warning: Character in fixed-form label field must be a digit
+
+1 continue
+end

flang/test/Driver/color-diagnostics-sema.f90

+! Test the behaviors of -f{no-}color-diagnostics when emitting semantic
+! diagnostics.
+! Windows command prompt doesn't support ANSI escape sequences.
+! REQUIRES: shell
+
+! RUN: not %flang %s -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang %s -fno-color-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_NCD
+! RUN: not %flang_fc1 %s -fcolor-diagnostics 2>&1 \
+! RUN:     | FileCheck %s --check-prefix=CHECK_CD
+! RUN: not %flang_fc1 %s 2>&1 | FileCheck %s --check-prefix=CHECK_NCD
+
+! CHECK_CD: {{.*}}[0;1;31merror: {{.*}}[0mMust be a constant value
+
+! CHECK_NCD: error: Must be a constant value
+
+program m
+  integer :: i = k
+end

flang/tools/bbc/bbc.cpp

if (!parsing.messages().empty() && (parsing.messages().AnyFatalError())) {
     return mlir::failure();
   }
 
   // parse the input Fortran
   parsing.Parse(llvm::outs());
   parsing.messages().Emit(llvm::errs(), parsing.allCooked());
   if (!parsing.consumedWholeFile()) {
     parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
-                        "parser FAIL (final position)");
+                        "parser FAIL (final position)",
+                        "error: ", llvm::raw_ostream::RED);
     return mlir::failure();
   }
   if ((!parsing.messages().empty() && (parsing.messages().AnyFatalError())) ||
       !parsing.parseTree().has_value()) {
     llvm::errs() << programPrefix << "could not parse " << path << '\n';
     return mlir::failure();
   }
 

flang/tools/f18-parse-demo/f18-parse-demo.cpp

if (canTime) {
       llvm::outs() << "no timing information due to lack of clock_gettime()\n";
     }
   }
 
   parsing.ClearLog();
   parsing.messages().Emit(llvm::errs(), parsing.allCooked());
   if (!parsing.consumedWholeFile()) {
     parsing.EmitMessage(llvm::errs(), parsing.finalRestingPlace(),
-        "parser FAIL (final position)");
+        "parser FAIL (final position)", "error: ", llvm::raw_ostream::RED);
     exitStatus = EXIT_FAILURE;
     return {};
   }
   if ((!parsing.messages().empty() &&
           (driver.warningsAreErrors || parsing.messages().AnyFatalError())) ||
       !parsing.parseTree()) {
     llvm::errs() << driver.prefix << "could not parse " << path << '\n';
     exitStatus = EXIT_FAILURE;