[flang] Introduce DiagnosticConsumer classes in libflangFrontend

[awarzynski]

Summary

Currently Flang uses TextDiagnostic, TextDiagnosticPrinter &
TestDiagnosticBuffer from Clang (more specifically, from
libclangFrontend). This patch introduces simplified versions of these
classes in Flang (i.e. it removes the depdendency on libclangFrontend).

Note that currently, Flang needs these diagnostics classes only for the
compiler driver diagnostics. This is unlike in Clang in which similar
diagnostic classes are used for (among others) Lexing/Parsing/Sema
diagnostics. For this reason the implementations introduced here are
rather basic.

This patch also enhances how the diagnostics are printed. In particular,
this is what you'd get _before_ (no text formatting):

$ bin/flang-new
error: no input files

This is what you get _after_ (in terminals that support it,
the text is formatted - bold + red):

$ bin/flang-new
flang-new: error: no input files

Tests are updated accordingly and options related to enabling/disabling
color diagnostics are flagged as supported by Flang.

[kiranchandramohan]

I had a quick look through this patch. Have a few comments (mostly nits and questions) inline.

flang/include/flang/Frontend/CompilerInvocation.h

18

Nit: Opts -> opts?

20

Nit: Diags -> diags? Or is that convention?

flang/include/flang/Frontend/TextDiagnostic.h

10

An -> A

42

Nit: diagonstic -> diagnostic

45

Nit: missed doxygen comments? Or is it because it is a helper function?

57

Nit: OS->os?

flang/include/flang/Frontend/TextDiagnosticPrinter.h

15

Nit: Nos->NOS?

[kiranchandramohan]

flang/include/flang/Frontend/TextDiagnosticPrinter.h

11

Where it prints depends on what stream is passed to the constructor of this class right? So is this standard error usage correct here?

flang/lib/Frontend/CompilerInvocation.cpp

75

Is diags not needed now?

flang/lib/Frontend/TextDiagnostic.cpp

23–24

Is the plan to make all these colors configurable?

70–75

Tempted to suggest saving a break here by reordering. :)

flang/lib/Frontend/TextDiagnosticBuffer.cpp

29

Is that a different smallstring from the one in LLVM?

flang/lib/Frontend/TextDiagnosticPrinter.cpp

38

100? Will this contain path names by any chance?

43

Is there an assumption that the prefix will not be empty?

flang/test/Flang-Driver/driver-help.f90

10

Should there be tests for gcc style as well?

flang/tools/flang-driver/driver.cpp

45

Nit: Inore->Ignore

105

Not clear why the stem needs to be taken here. Is this for windows compatibility?

flang/tools/flang-driver/fc1_main.cpp

39

Anyreason why this was moved up here (compared to the previous version which was close to its use)?

40

#JustAsking: Should this be deleted somewhere?

[CarolineConcatto]

Thank you @awarzynski for this patch.
Very good that you added color feature for Fortran.
It is just a shame that we do not test. Is there a way to add a regression test for it?
I don't see any inconsistency with what we have on clang side, so it is good.
My comments are in the code, but two things that need an overall look:
1- style is not yet according to Flang, mainly functions and variables in the classes
2 -I believe that the name space is Fortran::frontend to be consistent with the other files at Frontend.

clang/include/clang/Driver/Options.td

874

Is it possible to also add when using FC1Option?

clang/tools/driver/driver.cpp

281 ↗

(On Diff #292248)

undo

flang/include/flang/Frontend/TextDiagnostic.h

19

Do we need clang/Frontend here?

61

According to Flang style It should be PrintDiagnosticMessage, no?

flang/include/flang/Frontend/TextDiagnosticBuffer.h

24

It is inside Frontend, why you are not using Fortran::frontend?

43

a given

flang/include/flang/Frontend/TextDiagnosticPrinter.h

49

style

flang/lib/Frontend/CompilerInvocation.cpp

75

Why do you have clang::DiagnosticsEngine *diags

flang/lib/Frontend/TextDiagnostic.cpp

33

Why do static is commented?

flang/lib/Frontend/TextDiagnosticPrinter.cpp

53

Why when it is clang::DiagnosticsEngine::Note it is Supplemental?

flang/tools/flang-driver/driver.cpp

48

This is an odd part of the code, because missingArgIndex, missingArgCount are not set or even used in this part of the code.

52

can you do only diagOpts.showcolor= parseShowColorsArgs(args, defaultDiagColor)?
this function is not doing much now and it only adds another layer to understand the code.

[sameeranjoshi]

Thanks for working on it.
Few comments inline:

1. For an out-of-tree build, I see check-flang target failing with

/unittests/Frontend/CompilerInstanceTest.cpp:17:10: fatal error: filesystem: No such file or directory
 #include <filesystem>
          ^~~~~~~~~~~~

I used gcc/g++ 7.5 version.
I haven't checked in-tree still, and others/bots might have checked it.

2. Either the documentation comments are wrong or code.

README mentions DBUILD_FLANG_NEW_DRIVER where as cmake ignores the flag for me.
Whereas, CMakeLists.txt mentions FLANG_BUILD_NEW_DRIVER.

flang/include/flang/Frontend/TextDiagnosticBuffer.h

37

How about simplifying this with using keyword?

flang/include/flang/Frontend/TextDiagnosticPrinter.h

38

Where is this used? I don't see any reference.

flang/lib/Frontend/TextDiagnostic.cpp

13

Is this header used ?

27

Unless Flang is not changing the color scheme w.r.t clang, can't the code be shared between both projects?

flang/lib/Frontend/TextDiagnosticPrinter.cpp

25

A silly question from what I see usually in Flang coding style.
Why isn't it defined in header file?

38

Can we use at places where LLVM data structures are used explicit llvm:: so an unknown user can easily identify where they come from?

[awarzynski]

Move code from Fortran to Fortran::frontend namespace, address PR comments

[awarzynski]

Thank you for reviewing! I think that I've addressed all your comments.. Please see the updated patch.

clang/include/clang/Driver/Options.td

874

I skipped it intentionally. In fc1_main.cpp we use TextDiagnosticBuffer instead of TextDiagnosticPrinter. The former will just print the diagnostics without pretty-formatting them, so this option wouldn't make much sense.

We could use TextDiagnosticPrinter in flang-new -fc1 (frontend driver) as we do for flang-new (compiler driver), but at this stage I would prefer to keep the design consistent with clang (i.e. this is the main reason why we use TextDiagnosticBuffer instead of TextDiagnosticPrinter in the frontend driver).

Having said all that, your comment makes me realise that I should improve the documentation, thanks!

flang/include/flang/Frontend/CompilerInvocation.h

20

Copy and paste error, thanks!

flang/include/flang/Frontend/TextDiagnostic.h

19

This should be replaced with #include "clang/Basic/Diagnostic.h". Thanks for pointing out!

61

Correct, thanks for catching this!

flang/include/flang/Frontend/TextDiagnosticBuffer.h

24

I've just copied the design from Clang - that's a rather disappointing explanation. But I agree that Fortran::frontend would be better. Updated.

flang/include/flang/Frontend/TextDiagnosticPrinter.h

11

Good catch. I've updated this and also the description of TextDiagnosticBuffer. Hopefully that will make the distinction clearer.

38

We won't be needing this :) Thanks for catching this!

49

I think that this is correct as is:

Accessor member functions are named with the non-public data member's name, less the trailing underscore.

https://github.com/llvm/llvm-project/blob/master/flang/docs/C%2B%2Bstyle.md#naming
3rd point

flang/lib/Frontend/CompilerInvocation.cpp

75

I missed that one. Thank you @CarolineConcatto and @kiranchandramohan !

flang/lib/Frontend/TextDiagnostic.cpp

13

Nope, thanks for catching this!

23–24

No, why? This is a copy & paste from Clang: https://github.com/llvm/llvm-project/blob/master/clang/lib/Frontend/TextDiagnostic.cpp#L26-L42.

27

That would be preferable, I agree. However, keep in mind that in Clang these enums are defined in llvm-project/clang/lib/Frontend/TextDiagnostic.cpp , i.e. in libclangFrontend. As suggested in [1], we shouldn't be re-using anything from libclangFrontend.

We could move these enums out of libclangFrontend to some other library. That's not difficult and not that much work, but IMO that's a separate change that should happen on top of this patch (i.e. once this patch is approved). Also - where do we move them to? Currently there is no good candidate, but once the refactoring proposed in [1] is complete, there should be a dedicated library with infrastructure for the drivers to share.

I suggest that for now we just add a comment that recommends sharing these enums with Clang in the future. This could happen once we start refactoring Clang. In the meantime I'd like to keep the changes in Clang to the required minimum.

How does this sound? And does it make sense?

[1] http://lists.llvm.org/pipermail/cfe-dev/2020-July/066393.html

33

https://en.cppreference.com/w/cpp/language/static

The static keyword is only used with the declaration of a static member, inside the class definition, but not with the definition of that static member

70–75

Do suggest it and paste an example - my C++ foo is failing me here :)

flang/lib/Frontend/TextDiagnosticBuffer.cpp

29

It's the same SmallString. I'm using a forward declaration from clang/Basic/LLVM.h, which I do include, but I shouldn't. Fixed!

flang/lib/Frontend/TextDiagnosticPrinter.cpp

25

No such thing as silly questions! :)

AFAIK, there are no rules in the coding guidelines with regard to

• where things should be defined, and
• where things should be declared.

I use this rather generic rule of thumb: declare in headers, define in source files. In this particular case - I followed what was already in Clang. It made sense to me.

Do you think that it would better to define this in a header file?

38

If we do that, the code is likely to be bloated with llvm::, which IMO could be detrimental to readability in the long term.

In Clang you will find a header file with all the forward declarations to avoid this: https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/LLVM.h.

I definitely want to make reading this code easier to users, but I also think that instead of llvm:: one could use code-navigation tools (e.g. clangd). And forward declarations are fairly standard AFAIK.

However, if you still think that llvm:: would be better, I'm happy to update :)

38

It shouldn't. Currently these diagnostics are only used to report errors from the command line, so no paths are involved.

In Clang, similar class is used both for the driver diagnostics (i..e command line errors - no source location) and frontend diagnostics (source code errors - with source locations). However, AFAIK, this string is not used for the source location (e.g. path).

If we do use this class for more Flang diagnostics, we shouldn't use outStr for paths. This is just the message.

43

The prefix is optional. With prefix:

$ bin/flang-new
flang-new: error: no input files

Without prefix:

$ bin/flang-new
error: no input files

Both are valid.

53

I'm not aware of any documentation for this, so here's my understanding :)

A clang::DiagnosticsEngine::Note is an additional piece of information for the user. It's neither a warning nor an error. Hence it's something _supplemental_ (i.e. additional info that could otherwise be skipped) and should not be pretty-printed. And that's the purpose of this argument.

flang/test/Flang-Driver/driver-help.f90

10

That's a good point,thanks! However, I'd like to defer this decision till later.

Currently we have enough options to support what is implemented in this driver. At some point we will need to have a discussion with regard to what options should be supported and displayed. This is not obvious to me just now. For example, Clang supports GCC style flags for diagnostic colors, but doesn't display them when running clang --help.

And once we do start discussing this in the context of Flang, any changes will very likely affect Clang too. I would prefer to focus on the required minimum before offering a complete set of supported option variants :)

flang/tools/flang-driver/driver.cpp

48

They are required when calling ParseArgs (that's also where they are set). As mentioned in the comment above, we ignore them as any errors that these variables would indicate, will be captured elsewhere anyway.

52

That's a good point, but then I have to move the definition of parseShowColorsArgs into this file. This will bloat this file with stuff that should be abstracted away.

105

That too. In general, to canonicalise the path.

For example, we want:

$ bin/flang-new
flang-new: error: no input files

instead of:

$ bin/flang-new
<some-very-long-path>/bin/flang-new: error: no input files

flang/tools/flang-driver/fc1_main.cpp

39

Sorry, this is unrelated.

I wanted to better highlight that we are using TextDiagnosticBuffer (instead of e.g. TextDiagnosticPrinter) and to separate the creation of CompilerInvocation from this.

40

DiagnosticsConsumer (in this case, diagsBuffer), is required to construct diags, i.e. an instance of DiagnosticsEngine.

• the constructor for DiagnosticsEngine: https://github.com/llvm/llvm-project/blob/master/clang/lib/Basic/Diagnostic.cpp#L80-L89.

DiagnosticsEngine::DiagnosticsEngine(
    IntrusiveRefCntPtr<DiagnosticIDs> diags,
    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, DiagnosticConsumer *client,
    bool ShouldOwnClient)
    : Diags(std::move(diags)), DiagOpts(std::move(DiagOpts)) {
  setClient(client, ShouldOwnClient);
  ArgToStringFn = DummyArgToStringFn;

  Reset();
}

• the prototype: https://github.com/llvm/llvm-project/blob/master/clang/include/clang/Basic/Diagnostic.h#L494-L497.

explicit DiagnosticsEngine(IntrusiveRefCntPtr<DiagnosticIDs> Diags,
                           IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
                           DiagnosticConsumer *client = nullptr,
                           bool ShouldOwnClient = true);

Note that ShouldOwnClient defaults to true. So this should be fine #fingers-crossed :)

[awarzynski]

@sameeranjoshi Apologies, I missed some of your comments.

In D87774#2287927, @sameeranjoshi wrote:

Thanks for working on it.
Few comments inline:

1. For an out-of-tree build, I see check-flang target failing with

/unittests/Frontend/CompilerInstanceTest.cpp:17:10: fatal error: filesystem: No such file or directory
 #include <filesystem>
          ^~~~~~~~~~~~

I used gcc/g++ 7.5 version.
I haven't checked in-tree still, and others/bots might have checked it.

I haven't been able to reproduce it, but note that filesystem is a C++17 header. AFAIK, in GCC-7 you have to use <experimental/filesystem> instead of <filesystem>. This suggests README.md should be updated: https://github.com/llvm/llvm-project/blob/master/flang/README.md#supported-c-compilers (we probably need an RFC for this). Since this #include was introduced elsewhere, I suggest that we move this discussion either to Slack or flang-dev.

2. Either the documentation comments are wrong or code.

README mentions DBUILD_FLANG_NEW_DRIVER where as cmake ignores the flag for me.
Whereas, CMakeLists.txt mentions FLANG_BUILD_NEW_DRIVER.

Sorry, that's an unfortunate typo. Fixed here: https://github.com/llvm/llvm-project/commit/27da2875070ac00f6cd9f8040c6f994aca915406

[kiranchandramohan]

flang/lib/Frontend/TextDiagnosticPrinter.cpp

25

I think in flang the style is to declare the class in the source file if it is only used in that file. If it is used elsewhere then put it in the header. If it is used in another directory then move the header to include directory.

[awarzynski]

@sameeranjoshi Regarding <filesystem>, please see https://reviews.llvm.org/D88219. Sadly we missed that when adding that test, sorry!

[awarzynski]

Rebase on top of master

[sameeranjoshi]

flang/lib/Frontend/TextDiagnostic.cpp

27

Agreed.

[sameeranjoshi]

In D87774#2292034, @awarzynski wrote:

@sameeranjoshi Apologies, I missed some of your comments.

In D87774#2287927, @sameeranjoshi wrote:

Thanks for working on it.
Few comments inline:

1. For an out-of-tree build, I see check-flang target failing with

/unittests/Frontend/CompilerInstanceTest.cpp:17:10: fatal error: filesystem: No such file or directory
 #include <filesystem>
          ^~~~~~~~~~~~

I used gcc/g++ 7.5 version.
I haven't checked in-tree still, and others/bots might have checked it.

I haven't been able to reproduce it, but note that filesystem is a C++17 header. AFAIK, in GCC-7 you have to use <experimental/filesystem> instead of <filesystem>. This suggests README.md should be updated: https://github.com/llvm/llvm-project/blob/master/flang/README.md#supported-c-compilers (we probably need an RFC for this). Since this #include was introduced elsewhere, I suggest that we move this discussion either to Slack or flang-dev.

Do you know if there are any bots configured to handle out-of-tree changes?
That might be helpful to avoid configuration differences and test OFT patches.

[sameeranjoshi]

flang/lib/Frontend/TextDiagnosticPrinter.cpp

38

I think it's better to follow what FIR(fir-dev) and llvm-project/flang does.
They generally try to fully-qualify name of library and avoid using forward declarations.

[CarolineConcatto]

Thank you @awarzynski for updating the patch.
It looks good to me. I've build it locally and played a little bit.
It works fine with gcc9.3. I did not try to build out-of-tree. But I don't see any reason it should not work.
I have two minor comments. But besides that the patch looks good to me.
If you fix them it is all fine for me.

flang/lib/Frontend/CompilerInvocation.cpp

75

Am I missing something or this is still here?

flang/tools/flang-driver/driver.cpp

14

Why do we need invocation here?

[awarzynski]

In D87774#2293283, @sameeranjoshi wrote:

Do you know if there are any bots configured to handle out-of-tree changes?
That might be helpful to avoid configuration differences and test OFT patches.

I'm not aware of a buildbot that would test out-of-tree builds. I also don't know how hard it would be to set one up (AFAIK, there's no precedence of out-of-tree LLVM buildbots). Defending every sub-project/feature that people care about with a buildbot is important. Sadly I won't have the bandwidth to set one up for out-of-tree builds any time soon. This my gentle call for volunteers :)

flang/lib/Frontend/TextDiagnosticPrinter.cpp

25

This class is used in multiple files:

• flang/lib/Frontend/CompilerInstance.{cpp|h}
• flang/tools/flang-driver/driver.cpp
• flang/unittests/Frontend/CompilerInstanceTest.cpp

IIUC, this is now resolved.

flang/tools/flang-driver/driver.cpp

14

Required for ParseDiagnosticArgs.

[awarzynski]

Address the remaining PR comments, fix test

[kiranchandramohan]

In D87774#2298515, @awarzynski wrote:

In D87774#2293283, @sameeranjoshi wrote:

Do you know if there are any bots configured to handle out-of-tree changes?
That might be helpful to avoid configuration differences and test OFT patches.

I'm not aware of a buildbot that would test out-of-tree builds. I also don't know how hard it would be to set one up (AFAIK, there's no precedence of out-of-tree LLVM buildbots). Defending every sub-project/feature that people care about with a buildbot is important. Sadly I won't have the bandwidth to set one up for out-of-tree builds any time soon. This my gentle call for volunteers :)

https://reviews.llvm.org/D87085. Thanks @rovka.

[CarolineConcatto]

Hi Folks,
@awarzynski and @sameeranjoshi, Diana was working in an out-of-tree build.

This is the patch:
https://reviews.llvm.org/D87085

[awarzynski]

Ping :)

[CarolineConcatto]

Thank you @awarzynski for working on this.
It is good because now we do not depend on clang frontend to build flang frontend.
LGTM

[sameeranjoshi]

Thanks for patch.
Looks good.

clang/include/clang/Driver/Options.td

 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>, Flags<[CoreOption]>;
 def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
   Flags<[DriverOption]>, HelpText<"Load the clang builtins module map file.">;
 defm caret_diagnostics : OptOutFFlag<"caret-diagnostics", "", "">;
 def fclang_abi_compat_EQ : Joined<["-"], "fclang-abi-compat=">, Group<f_clang_Group>,
   Flags<[CC1Option]>, MetaVarName<"<version>">, Values<"<major>.<minor>,latest">,
   HelpText<"Attempt to match the ABI of Clang <version>">;
 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
-defm color_diagnostics : OptInFFlag<"color-diagnostics", "Enable", "Disable", " colors in diagnostics", [CoreOption]>;
+defm color_diagnostics : OptInFFlag<"color-diagnostics", "Enable", "Disable", " colors in diagnostics",
+  [CoreOption, FlangOption]>;
 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
   Flags<[CoreOption, DriverOption]>;
 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
   Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">,
   MarshallingInfoFlag<"DiagnosticOpts->UseANSIEscapeCodes", "false">;
 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,

flang/include/flang/Frontend/CompilerInvocation.h

 //===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 #define LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 
 #include "flang/Frontend/FrontendOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "llvm/Option/ArgList.h"
 
 namespace Fortran::frontend {
+
+/// Fill out Opts based on the options given in Args.
+///
+/// When errors are encountered, return false and, if Diags is non-null,
+/// report the error(s).
+bool ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
+    llvm::opt::ArgList &args, clang::DiagnosticsEngine *diags = nullptr,
+    bool defaultDiagColor = true);
+
 class CompilerInvocationBase {
 public:
   /// Options controlling the diagnostic engine.$
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagnosticOpts_;
 
   CompilerInvocationBase();
   CompilerInvocationBase(const CompilerInvocationBase &x);
   ~CompilerInvocationBase();

flang/include/flang/Frontend/TextDiagnostic.h

+//===--- TextDiagnostic.h - Text Diagnostic Pretty-Printing -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A utility class that provides support for textual pretty-printing of
+// diagnostics. Based on clang::TextDiagnostic (this is a trimmed version).
+//
+// TODO: If expanding, consider sharing the implementation with Clang.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_FRONTEND_TEXTDIAGNOSTIC_H
+#define LLVM_FLANG_FRONTEND_TEXTDIAGNOSTIC_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+
+namespace Fortran::frontend {
+
+/// Class to encapsulate the logic for formatting and printing a textual
+/// diagnostic message.
+///
+/// The purpose of this class is to isolate the implementation of printing
+/// beautiful text diagnostics from any particular interfaces. Currently only
+/// simple diagnostics that lack source location information are supported (e.g.
+/// Flang driver errors).
+///
+/// In the future we can extend this class (akin to Clang) to support more
+/// complex diagnostics that would include macro backtraces, caret diagnostics,
+/// FixIt Hints and code snippets.
+///
+class TextDiagnostic {
+public:
+  TextDiagnostic();
+
+  ~TextDiagnostic();
+
+  /// Print the diagnostic level to a llvm::raw_ostream.
+  ///
+  /// This is a static helper that handles colorizing the level and formatting
+  /// it into an arbitrary output stream.
+  ///
+  /// \param os Where the message is printed
+  /// \param level The diagnostic level (e.g. error or warning)
+  /// \param showColors Enable colorizing of the message.
+  static void PrintDiagnosticLevel(llvm::raw_ostream &os,
+      clang::DiagnosticsEngine::Level level, bool showColors);
+
+  /// Pretty-print a diagnostic message to a llvm::raw_ostream.
+  ///
+  /// This is a static helper to handle the colorizing and rendering diagnostic
+  /// message to a particular ostream. In the future we can
+  /// extend it to support e.g. line wrapping. It is
+  /// publicly visible as at this stage we don't require any state data to
+  /// print a diagnostic.
+  ///
+  /// \param os Where the message is printed
+  /// \param isSupplemental true if this is a continuation note diagnostic
+  /// \param message The text actually printed
+  /// \param showColors Enable colorizing of the message.
+  static void PrintDiagnosticMessage(llvm::raw_ostream &os, bool isSupplemental,
+      llvm::StringRef message, bool showColors);
+};
+
+} // namespace Fortran::frontend
+
+#endif

flang/include/flang/Frontend/TextDiagnosticBuffer.h

+//===- TextDiagnosticBuffer.h - Buffer Text Diagnostics ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a concrete diagnostic client. The diagnostics are buffered rather
+// than printed. In order to print them, use the FlushDiagnostics method.
+// Pretty-printing is not supported.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_FRONTEND_TEXTDIAGNOSTICBUFFER_H
+#define LLVM_FLANG_FRONTEND_TEXTDIAGNOSTICBUFFER_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/SourceLocation.h"
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace Fortran::frontend {
+
+class TextDiagnosticBuffer : public clang::DiagnosticConsumer {
+public:
+  using DiagList = std::vector<std::pair<clang::SourceLocation, std::string>>;
+  using DiagnosticsLevelAndIndexPairs =
+      std::vector<std::pair<clang::DiagnosticsEngine::Level, size_t>>;
+
+private:
+  DiagList errors_, warnings_, remarks_, notes_;
+
+  /// All diagnostics in the order in which they were generated. That order
+  /// likely doesn't correspond to user input order, but at least it keeps
+  /// notes in the right places. Each pair is a diagnostic level and an index
+  /// into the corresponding DiagList above.
+  DiagnosticsLevelAndIndexPairs all_;
+
+public:
+  void HandleDiagnostic(clang::DiagnosticsEngine::Level diagLevel,
+      const clang::Diagnostic &info) override;
+
+  /// Flush the buffered diagnostics to a given diagnostic engine.
+  void FlushDiagnostics(clang::DiagnosticsEngine &diags) const;
+};
+
+} // namespace Fortran::frontend
+
+#endif // LLVM_CLANG_FRONTEND_TEXTDIAGNOSTICBUFFER_H

flang/include/flang/Frontend/TextDiagnosticPrinter.h

+//===--- TextDiagnosticPrinter.h - Text Diagnostic Client -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a concrete diagnostic client. In terminals that support it, the
+// diagnostics are pretty-printed (colors + bold). The printing/flushing
+// happens in HandleDiagnostics (usually called at the point when the
+// diagnostic is generated).
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLANG_FRONTEND_TEXTDIAGNOSTICPRINTER_H
+#define LLVM_FLANG_FRONTEND_TEXTDIAGNOSTICPRINTER_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace clang {
+class DiagnosticOptions;
+class DiagnosticsEngine;
+}; // namespace clang
+
+using llvm::IntrusiveRefCntPtr;
+using llvm::raw_ostream;
+
+namespace Fortran::frontend {
+class TextDiagnostic;
+
+class TextDiagnosticPrinter : public clang::DiagnosticConsumer {
+  raw_ostream &os_;
+  llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts_;
+
+  /// A string to prefix to error messages.
+  std::string prefix_;
+
+public:
+  TextDiagnosticPrinter(raw_ostream &os, clang::DiagnosticOptions *diags);
+  ~TextDiagnosticPrinter() override;
+
+  /// Set the diagnostic printer prefix string, which will be printed at the
+  /// start of any diagnostics. If empty, no prefix string is used.
+  void set_prefix(std::string value) { prefix_ = std::move(value); }
+
+  void HandleDiagnostic(clang::DiagnosticsEngine::Level level,
+      const clang::Diagnostic &info) override;
+};
+
+} // namespace Fortran::frontend
+
+#endif

flang/lib/Frontend/CMakeLists.txt

 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   FrontendOptions.cpp
+  TextDiagnosticPrinter.cpp
+  TextDiagnosticBuffer.cpp
+  TextDiagnostic.cpp
 
   LINK_LIBS
   clangBasic
   clangDriver
-  # TODO: Added to re-use clang's TextDiagnosticBuffer & TextDiagnosticPrinter.
-  # Add a custom implementation for Flang and remove this dependency.
-  clangFrontend
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/Frontend/CompilerInstance.cpp

 //===--- CompilerInstance.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/CompilerInvocation.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "flang/Frontend/TextDiagnosticPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
 CompilerInstance::CompilerInstance() : invocation_(new CompilerInvocation()) {}
 
 CompilerInstance::~CompilerInstance() = default;
 
CompilerInstance::CreateDiagnostics(clang::DiagnosticOptions *opts,
   clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diags(
       new clang::DiagnosticsEngine(diagID, opts));
 
   // Create the diagnostic client for reporting errors or for
   // implementing -verify.
   if (client) {
     diags->setClient(client, shouldOwnClient);
   } else {
-    diags->setClient(new clang::TextDiagnosticPrinter(llvm::errs(), opts));
+    diags->setClient(new TextDiagnosticPrinter(llvm::errs(), opts));
   }
   return diags;
 }

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Initialization.
 //===----------------------------------------------------------------------===//
 CompilerInvocationBase::CompilerInvocationBase()
     : diagnosticOpts_(new clang::DiagnosticOptions()) {}
 
 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &x)
     : diagnosticOpts_(new clang::DiagnosticOptions(x.GetDiagnosticOpts())) {}
 
 CompilerInvocationBase::~CompilerInvocationBase() = default;
 
 //===----------------------------------------------------------------------===//
 // Deserialization (from args)
 //===----------------------------------------------------------------------===//
+static bool parseShowColorsArgs(
+    const llvm::opt::ArgList &args, bool defaultColor) {
+  // Color diagnostics default to auto ("on" if terminal supports) in the driver
+  // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
+  // Support both clang's -f[no-]color-diagnostics and gcc's
+  // -f[no-]diagnostics-colors[=never|always|auto].
+  enum {
+    Colors_On,
+    Colors_Off,
+    Colors_Auto
+  } ShowColors = defaultColor ? Colors_Auto : Colors_Off;
+
+  for (auto *a : args) {
+    const llvm::opt::Option &O = a->getOption();
+    if (O.matches(clang::driver::options::OPT_fcolor_diagnostics) ||
+        O.matches(clang::driver::options::OPT_fdiagnostics_color)) {
+      ShowColors = Colors_On;
+    } else if (O.matches(clang::driver::options::OPT_fno_color_diagnostics) ||
+        O.matches(clang::driver::options::OPT_fno_diagnostics_color)) {
+      ShowColors = Colors_Off;
+    } else if (O.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) {
+      llvm::StringRef value(a->getValue());
+      if (value == "always")
+        ShowColors = Colors_On;
+      else if (value == "never")
+        ShowColors = Colors_Off;
+      else if (value == "auto")
+        ShowColors = Colors_Auto;
+    }
+  }
+
+  return ShowColors == Colors_On ||
+      (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors());
+}
+
+bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
+    llvm::opt::ArgList &args, clang::DiagnosticsEngine *diags,
+    bool defaultDiagColor) {
+  opts.ShowColors = parseShowColorsArgs(args, defaultDiagColor);
+
+  return true;
+}
+
 static InputKind ParseFrontendArgs(FrontendOptions &opts,
     llvm::opt::ArgList &args, clang::DiagnosticsEngine &diags) {
   // Identify the action (i.e. opts.ProgramAction)
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_Action_Group)) {
     switch (a->getOption().getID()) {
     default: {
       llvm_unreachable("Invalid option in group!");

flang/lib/Frontend/TextDiagnostic.cpp

+//===--- TextDiagnostic.cpp - Text Diagnostic Pretty-Printing -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Frontend/TextDiagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace Fortran::frontend;
+
+// TODO: Similar enums are defined in clang/lib/Frontend/TextDiagnostic.cpp.
+// It would be best to share them
+static const enum llvm::raw_ostream::Colors noteColor =
+    llvm::raw_ostream::BLACK;
+static const enum llvm::raw_ostream::Colors remarkColor =
+    llvm::raw_ostream::BLUE;
+static const enum llvm::raw_ostream::Colors warningColor =
+    llvm::raw_ostream::MAGENTA;
+static const enum llvm::raw_ostream::Colors errorColor = llvm::raw_ostream::RED;
+static const enum llvm::raw_ostream::Colors fatalColor = llvm::raw_ostream::RED;
+// Used for changing only the bold attribute.
+static const enum llvm::raw_ostream::Colors savedColor =
+    llvm::raw_ostream::SAVEDCOLOR;
+
+TextDiagnostic::TextDiagnostic() {}
+
+TextDiagnostic::~TextDiagnostic() {}
+
+/*static*/ void TextDiagnostic::PrintDiagnosticLevel(llvm::raw_ostream &os,
+    clang::DiagnosticsEngine::Level level, bool showColors) {
+  if (showColors) {
+    // Print diagnostic category in bold and color
+    switch (level) {
+    case clang::DiagnosticsEngine::Ignored:
+      llvm_unreachable("Invalid diagnostic type");
+    case clang::DiagnosticsEngine::Note:
+      os.changeColor(noteColor, true);
+      break;
+    case clang::DiagnosticsEngine::Remark:
+      os.changeColor(remarkColor, true);
+      break;
+    case clang::DiagnosticsEngine::Warning:
+      os.changeColor(warningColor, true);
+      break;
+    case clang::DiagnosticsEngine::Error:
+      os.changeColor(errorColor, true);
+      break;
+    case clang::DiagnosticsEngine::Fatal:
+      os.changeColor(fatalColor, true);
+      break;
+    }
+  }
+
+  switch (level) {
+  case clang::DiagnosticsEngine::Ignored:
+    llvm_unreachable("Invalid diagnostic type");
+  case clang::DiagnosticsEngine::Note:
+    os << "note";
+    break;
+  case clang::DiagnosticsEngine::Remark:
+    os << "remark";
+    break;
+  case clang::DiagnosticsEngine::Warning:
+    os << "warning";
+    break;
+  case clang::DiagnosticsEngine::Error:
+    os << "error";
+    break;
+  case clang::DiagnosticsEngine::Fatal:
+    os << "fatal error";
+    break;
+  }
+
+  os << ": ";
+
+  if (showColors)
+    os.resetColor();
+}
+
+/*static*/
+void TextDiagnostic::PrintDiagnosticMessage(llvm::raw_ostream &os,
+    bool isSupplemental, llvm::StringRef message, bool showColors) {
+  if (showColors && !isSupplemental) {
+    // Print primary diagnostic messages in bold and without color.
+    os.changeColor(savedColor, true);
+  }
+
+  os << message;
+
+  if (showColors)
+    os.resetColor();
+  os << '\n';
+}

flang/lib/Frontend/TextDiagnosticBuffer.cpp

+//===- TextDiagnosticBuffer.cpp - Buffer Text Diagnostics -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a concrete diagnostic client, which buffers the diagnostic messages.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Frontend/TextDiagnosticBuffer.h"
+#include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/ErrorHandling.h"
+
+using namespace Fortran::frontend;
+
+/// HandleDiagnostic - Store the errors, warnings, and notes that are
+/// reported.
+void TextDiagnosticBuffer::HandleDiagnostic(
+    clang::DiagnosticsEngine::Level level, const clang::Diagnostic &info) {
+  // Default implementation (warnings_/errors count).
+  DiagnosticConsumer::HandleDiagnostic(level, info);
+
+  llvm::SmallString<100> buf;
+  info.FormatDiagnostic(buf);
+  switch (level) {
+  default:
+    llvm_unreachable("Diagnostic not handled during diagnostic buffering!");
+  case clang::DiagnosticsEngine::Note:
+    all_.emplace_back(level, notes_.size());
+    notes_.emplace_back(info.getLocation(), std::string(buf.str()));
+    break;
+  case clang::DiagnosticsEngine::Warning:
+    all_.emplace_back(level, warnings_.size());
+    warnings_.emplace_back(info.getLocation(), std::string(buf.str()));
+    break;
+  case clang::DiagnosticsEngine::Remark:
+    all_.emplace_back(level, remarks_.size());
+    remarks_.emplace_back(info.getLocation(), std::string(buf.str()));
+    break;
+  case clang::DiagnosticsEngine::Error:
+  case clang::DiagnosticsEngine::Fatal:
+    all_.emplace_back(level, errors_.size());
+    errors_.emplace_back(info.getLocation(), std::string(buf.str()));
+    break;
+  }
+}
+
+void TextDiagnosticBuffer::FlushDiagnostics(
+    clang::DiagnosticsEngine &Diags) const {
+  for (const auto &i : all_) {
+    auto Diag = Diags.Report(Diags.getCustomDiagID(i.first, "%0"));
+    switch (i.first) {
+    default:
+      llvm_unreachable("Diagnostic not handled during diagnostic flushing!");
+    case clang::DiagnosticsEngine::Note:
+      Diag << notes_[i.second].second;
+      break;
+    case clang::DiagnosticsEngine::Warning:
+      Diag << warnings_[i.second].second;
+      break;
+    case clang::DiagnosticsEngine::Remark:
+      Diag << remarks_[i.second].second;
+      break;
+    case clang::DiagnosticsEngine::Error:
+    case clang::DiagnosticsEngine::Fatal:
+      Diag << errors_[i.second].second;
+      break;
+    }
+  }
+}

flang/lib/Frontend/TextDiagnosticPrinter.cpp

+//===--- TextDiagnosticPrinter.cpp - Diagnostic Printer -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This diagnostic client prints out their diagnostic messages.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Frontend/TextDiagnosticPrinter.h"
+#include "flang/Frontend/TextDiagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace Fortran::frontend;
+
+using llvm::SmallString;
+
+TextDiagnosticPrinter::TextDiagnosticPrinter(
+    raw_ostream &os, clang::DiagnosticOptions *diags)
+    : os_(os), diagOpts_(diags) {}
+
+TextDiagnosticPrinter::~TextDiagnosticPrinter() {}
+
+void TextDiagnosticPrinter::HandleDiagnostic(
+    clang::DiagnosticsEngine::Level level, const clang::Diagnostic &info) {
+  // Default implementation (Warnings/errors count).
+  DiagnosticConsumer::HandleDiagnostic(level, info);
+
+  // Render the diagnostic message into a temporary buffer eagerly. We'll use
+  // this later as we print out the diagnostic to the terminal.
+  SmallString<100> outStr;
+  info.FormatDiagnostic(outStr);
+
+  llvm::raw_svector_ostream DiagMessageStream(outStr);
+
+  if (!prefix_.empty())
+    os_ << prefix_ << ": ";
+
+  // We only emit diagnostics in contexts that lack valid source locations.
+  assert(!info.getLocation().isValid() &&
+      "Diagnostics with valid source location are not supported");
+
+  Fortran::frontend::TextDiagnostic::PrintDiagnosticLevel(
+      os_, level, diagOpts_->ShowColors);
+  Fortran::frontend::TextDiagnostic::PrintDiagnosticMessage(os_,
+      /*IsSupplemental=*/level == clang::DiagnosticsEngine::Note,
+      DiagMessageStream.str(), diagOpts_->ShowColors);
+
+  os_.flush();
+  return;
+}

flang/test/Flang-Driver/driver-error-cc1.c

 // RUN: not %flang-new %s 2>&1 | FileCheck %s
 
 // REQUIRES: new-flang-driver
 
 // C files are currently not supported (i.e. `flang -cc1`)
 
-// CHECK:error: unknown integrated tool '-cc1'. Valid tools include '-fc1'.
+// CHECK: error: unknown integrated tool '-cc1'. Valid tools include '-fc1'.

flang/test/Flang-Driver/driver-error-cc1.cpp

 // RUN: not %flang-new %s 2>&1 | FileCheck %s
 
 // REQUIRES: new-flang-driver
 
 // C++ files are currently not supported (i.e. `flang -cc1`)
 
-// CHECK:error: unknown integrated tool '-cc1'. Valid tools include '-fc1'.
+// CHECK: error: unknown integrated tool '-cc1'. Valid tools include '-fc1'.

flang/test/Flang-Driver/driver-help.f90

 ! RUN: %flang-new -help 2>&1 | FileCheck %s
 ! RUN: %flang-new -fc1 -help 2>&1 | FileCheck %s
 ! RUN: not %flang-new -helps 2>&1 | FileCheck %s --check-prefix=ERROR
 
 ! REQUIRES: new-flang-driver
 
 ! CHECK:USAGE: flang-new
 ! CHECK-EMPTY:
 ! CHECK-NEXT:OPTIONS:
+! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: --version Print version information
 
-! ERROR: error: unknown argument '-helps'; did you mean '-help'
+! ERROR: flang-new: error: unknown argument '-helps'; did you mean '-help'

flang/test/Flang-Driver/driver-version.f90

 ! RUN: %flang-new --version 2>&1 | FileCheck %s
 ! RUN: not %flang-new --versions 2>&1 | FileCheck %s --check-prefix=ERROR
 
 ! REQUIRES: new-flang-driver
 
 ! CHECK:flang-new version 
 ! CHECK-NEXT:Target:
 ! CHECK-NEXT:Thread model:
 ! CHECK-NEXT:InstalledDir:
 
-! ERROR: error: unsupported option '--versions'; did you mean '--version'?
+! ERROR: flang-new: error: unsupported option '--versions'; did you mean '--version'?

flang/test/Flang-Driver/missing-input.f90

 ! RUN: not %flang-new  2>&1 | FileCheck %s
 
 ! REQUIRES: new-flang-driver
 
-! CHECK: error: no input files
+! CHECK: flang-new: error: no input files

flang/tools/flang-driver/driver.cpp

 //===-- driver.cpp - Flang Driver -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the entry point to the flang driver; it is a thin wrapper
 // for functionality in the Driver flang library.
 //
 //===----------------------------------------------------------------------===//
 #include "clang/Driver/Driver.h"
+#include "flang/Frontend/CompilerInvocation.h"
+#include "flang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/Compilation.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/VirtualFileSystem.h"
+#include <clang/Driver/Options.h>
+
+using llvm::StringRef;
 
 // main frontend method. Lives inside fc1_main.cpp
 extern int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0);
 
 std::string GetExecutablePath(const char *argv0) {
   // This just needs to be some symbol in the binary
   void *p = (void *)(intptr_t)GetExecutablePath;
   return llvm::sys::fs::getMainExecutable(argv0, p);
 }
 
 // This lets us create the DiagnosticsEngine with a properly-filled-out
 // DiagnosticOptions instance
 static clang::DiagnosticOptions *CreateAndPopulateDiagOpts(
     llvm::ArrayRef<const char *> argv) {
   auto *diagOpts = new clang::DiagnosticOptions;
+
+  // Ignore missingArgCount and the return value of ParseDiagnosticArgs.
+  // Any errors that would be diagnosed here will also be diagnosed later,
+  // when the DiagnosticsEngine actually exists.
+  unsigned missingArgIndex, missingArgCount;
+  llvm::opt::InputArgList args = clang::driver::getDriverOptTable().ParseArgs(
+      argv.slice(1), missingArgIndex, missingArgCount,
+      /*FlagsToInclude=*/clang::driver::options::FlangOption);
+
+  (void)Fortran::frontend::ParseDiagnosticArgs(*diagOpts, args);
+
   return diagOpts;
 }
 
 static int ExecuteFC1Tool(llvm::SmallVectorImpl<const char *> &argV) {
   llvm::StringRef tool = argV[1];
   if (tool == "-fc1")
     return fc1_main(makeArrayRef(argV).slice(2), argV[0]);
 
int main(int argc_, const char **argv_) {
 
   // Not in the frontend mode - continue in the compiler driver mode.
 
   // Create DiagnosticsEngine for the compiler driver
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts =
       CreateAndPopulateDiagOpts(argv);
   llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagID(
       new clang::DiagnosticIDs());
-  clang::TextDiagnosticPrinter *diagClient =
-      new clang::TextDiagnosticPrinter(llvm::errs(), &*diagOpts);
+  Fortran::frontend::TextDiagnosticPrinter *diagClient =
+      new Fortran::frontend::TextDiagnosticPrinter(llvm::errs(), &*diagOpts);
+
+  diagClient->set_prefix(
+      std::string(llvm::sys::path::stem(GetExecutablePath(argv[0]))));
+
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagClient);
 
   // Prepare the driver
   clang::driver::Driver theDriver(driverPath,
       llvm::sys::getDefaultTargetTriple(), diags, "flang LLVM compiler");
   theDriver.setTargetAndMode(targetandMode);
   std::unique_ptr<clang::driver::Compilation> c(
       theDriver.BuildCompilation(argv));

flang/tools/flang-driver/fc1_main.cpp

 //===-- fc1_main.cpp - Flang FC1 Compiler Frontend ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the entry point to the flang -fc1 functionality, which implements the
 // core compiler functionality along with a number of additional tools for
 // demonstration and testing purposes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/CompilerInvocation.h"
+#include "flang/Frontend/TextDiagnosticBuffer.h"
 #include "flang/FrontendTool/Utils.h"
 #include "clang/Driver/DriverDiagnostic.h"
-#include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 
 #include <cstdio>
 
 using namespace Fortran::frontend;
 
 int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
   // Create CompilerInstance
   std::unique_ptr<CompilerInstance> flang(new CompilerInstance());
 
   // Create DiagnosticsEngine for the frontend driver
   flang->CreateDiagnostics();
   if (!flang->HasDiagnostics())
     return 1;
 
+  // We will buffer diagnostics from argument parsing so that we can output
+  // them using a well formed diagnostic object.
+  TextDiagnosticBuffer *diagsBuffer = new TextDiagnosticBuffer;
+
   // Create CompilerInvocation - use a dedicated instance of DiagnosticsEngine
   // for parsing the arguments
   llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagID(
       new clang::DiagnosticIDs());
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts =
       new clang::DiagnosticOptions();
-  clang::TextDiagnosticBuffer *diagsBuffer = new clang::TextDiagnosticBuffer;
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagsBuffer);
   bool success =
       CompilerInvocation::CreateFromArgs(flang->GetInvocation(), argv, diags);
 
   diagsBuffer->FlushDiagnostics(flang->getDiagnostics());
+
   if (!success)
     return 1;
 
   // Execute the frontend actions.
   success = ExecuteCompilerInvocation(flang.get());
 
   return !success;
 }

flang/unittests/Frontend/CompilerInstanceTest.cpp

 //===- unittests/Frontend/CompilerInstanceTest.cpp - CI tests -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
 #include "gtest/gtest.h"
 #include "flang/Frontend/CompilerInvocation.h"
+#include "flang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/Options.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <filesystem>
 using namespace llvm;
 using namespace Fortran::frontend;
 
 namespace {
 
 TEST(CompilerInstance, AllowDiagnosticLogWithUnownedDiagnosticConsumer) {
   // 1. Set-up a basic DiagnosticConsumer
   std::string diagnosticOutput;
   llvm::raw_string_ostream diagnosticsOS(diagnosticOutput);
-  auto diagPrinter = std::make_unique<clang::TextDiagnosticPrinter>(
+  auto diagPrinter = std::make_unique<Fortran::TextDiagnosticPrinter>(
       diagnosticsOS, new clang::DiagnosticOptions());
 
   // 2. Create a CompilerInstance (to manage a DiagnosticEngine)
   CompilerInstance compInst;
 
   // 3. Set-up DiagnosticOptions
   auto diagOpts = new clang::DiagnosticOptions();
   // Tell the diagnostics engine to emit the diagnostic log to STDERR. This