WIP [clang] adds capabilities for SARIF to be written to file

[cjdb]

Summary

The original -fdiagnostics-format=sarif wrote directly to standard
error. This commit renames that mode to sarif-stderr and introduces a
sarif-file mode that allows the compiler to write .sarif files to
the current working directory. It also removes SARIF as an option so
that there's a single canonical approach for each option.

IMPORTANT: There are two different designs for writing SARIF to file, so I've pulled the common parts of the design out into their own patch. This ensures it only gets reviewed once, and so that the divergence is apparent in the other two patches. Once a design is settled on, this patch will be joined with the selected design.

Depends on D145201.

[cjdb]

adds dependency

[cjdb]

tidies up some stuff that I overlooked

[cjdb]

merges in D145438. This patch is ready for review now.

[erichkeane]

Patch topic needs "WIP" out of it I think?

Just some WIP comments, I don't believe I'd be the one to approve this anyway.

clang/include/clang/Basic/DiagnosticOptions.h

109

typically Clang uses the 'American' spelling of things.

110

I'm a touch disturbed by there being 3 very similar file names with very similar comments here. Is there a reason we need all 3?

clang/include/clang/Driver/Options.td

5850

Another 'TODO' here?

clang/include/clang/Frontend/CompilerInstance.h

610

This comment seems inaccurate.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

39

What do we do with the DiagnosticsOptions here? Does this have to be a pointer, instead of a ref?

EDIT: I see the rest of the printers seem to do this, but I don't know if we ever have a case where these are null. I guess having them consistent here is important, but if the next person came through and made these all 'refs', it would be nice :)

clang/lib/Driver/ToolChains/Clang.cpp

4036

are we intentionally getting rid of the SARIF spellings intentionally? If so, and because we have this warning, should we report they are no longer supported?

clang/lib/Frontend/CompilerInstance.cpp

362

Oh my... I'll leave it to the Clang code owner/driver code owner (@jansvoboda11) to decide what they think of this.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

37

Isn't TargetPath a 'Path'? If so, are you just creating a dot-file? Aren't those really nasty on Windows, and not a nice thing to do here on Linux?

45

I know these are nice/readable/etc, but llvm doesn't use these.

Also, you KNOW what EC equals here: it is a default constructed std::error_code, so the 'if' condition here is always hit. I suspect just removing the whole body and replacing with an llvm_unreachable is appropriate instead.

[cjdb]

clang/include/clang/Basic/DiagnosticOptions.h

110

Agreed. I tried to get this to work with -serialize-diagnostics but that seems to activate a path that causes a different diagnostic engine to take over based on the value of DiagnosticSerializationFile. I didn't notice DiagnosticLogFile, so I'll see what happens if that is used.

clang/lib/Driver/ToolChains/Clang.cpp

4036

Yes. SARIF support isn't documented at all, and as such, I suspect the number of people who know about it (and use it for more than simple curiosity) would be hand-countable, so I'm not sure that it's worth the effort?

(The reason it's not documented is because I forgot to ask for that last year, but that's currently to our advantage.)

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

37

TargetPath should be a filename, not a directory. When implicit, this is whatever the compiler will generate as its target program. When explicit... I should probably add a check and diagnostic for this.

45

I'm not sure this code is unreachable, hence the assert message. If the file can't be opened for some reason, it's not appropriate for Clang to simply crash.

[vaibhav.y]

clang/lib/Tooling/SarifLinker.cpp

21 ↗

(On Diff #504309)

Is this for link diagnostics reported as SARIF?

[kolrami]

Hi @cjdb , I would be interested in this change also since GCC supports the same sarif-stderr and sarif-file options. Is there a further plan that it might be integrated?

[aaron.ballman]

@cjdb -- how would you like to proceed with this review? There's already quite a bit of discussion on the current Phab patch set, but it seems unlikely that we'd be able to wrap everything up by the Nov 15th deadline. But then again, GitHub has no ability to do stacked patches and so moving the review there might be an even bigger challenge. (No pressure, it's also totally fine to say "I have to abandon this for now".)

clang/include/clang/Basic/DiagnosticOptions.h

 /// Options for controlling the compiler diagnostics engine.
 class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
   friend bool ParseDiagnosticArgs(DiagnosticOptions &, llvm::opt::ArgList &,
                                   clang::DiagnosticsEngine *, bool);
 
   friend class CompilerInvocation;
 
 public:
-  enum TextDiagnosticFormat { Clang, MSVC, Vi, SARIF };
+  enum TextDiagnosticFormat { Clang, MSVC, Vi, SARIFStderr, SARIFFile };
 
   // Default values.
   enum {
     DefaultTabStop = 8,
     MaxTabStop = 100,
     DefaultMacroBacktraceLimit = 6,
     DefaultTemplateBacktraceLimit = 10,
     DefaultConstexprBacktraceLimit = 10,

 
 public:
   /// The file to log diagnostic output to.
   std::string DiagnosticLogFile;
 
   /// The file to serialize diagnostics to (non-appending).
   std::string DiagnosticSerializationFile;
 
   /// The list of -W... options used to alter the diagnostic mappings, with the
   /// prefixes removed.
   std::vector<std::string> Warnings;
 
   /// The list of prefixes from -Wundef-prefix=... used to generate warnings
   /// for undefined macros.
   std::vector<std::string> UndefPrefixes;
 
   /// The list of -R... options used to alter the diagnostic mappings, with the
   /// prefixes removed.

clang/include/clang/Basic/DiagnosticOptions.def

 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
 DIAGOPT(ShowPresumedLoc, 1, 0)  /// Show presumed location for diagnostics.
 DIAGOPT(ShowOptionNames, 1, 0)  /// Show the option name for mappable
                                 /// diagnostics.
 DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes.
 VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number,
                                     /// 2 -> Full Name.
 
-ENUM_DIAGOPT(Format, TextDiagnosticFormat, 2, Clang) /// Format for diagnostics:
+ENUM_DIAGOPT(Format, TextDiagnosticFormat, 3, Clang) /// Format for diagnostics:
 
 DIAGOPT(ShowColors, 1, 0)       /// Show diagnostics with ANSI color sequences.
 DIAGOPT(UseANSIEscapeCodes, 1, 0)
 ENUM_DIAGOPT(ShowOverloads, OverloadsShown, 1,
              Ovl_All)    /// Overload candidates to show.
 DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected
                                  /// diagnostics, indicated by markers in the
                                  /// input source file.

clang/include/clang/Driver/Options.td

def diagnostic_log_file : Separate<["-"], "diagnostic-log-file">,
   HelpText<"Filename (or -) to log diagnostics to">,
   MarshallingInfoString<DiagnosticOpts<"DiagnosticLogFile">>;
 def diagnostic_serialized_file : Separate<["-"], "serialize-diagnostic-file">,
   MetaVarName<"<filename>">,
   HelpText<"File for serializing diagnostics in a binary format">;
 
 def fdiagnostics_format : Separate<["-"], "fdiagnostics-format">,
   HelpText<"Change diagnostic formatting to match IDE and command line tools">,
-  Values<"clang,msvc,vi,sarif,SARIF">,
-  NormalizedValuesScope<"DiagnosticOptions">, NormalizedValues<["Clang", "MSVC", "Vi", "SARIF", "SARIF"]>,
+  Values<"clang,msvc,vi,sarif-stderr,sarif-file">,
+  NormalizedValuesScope<"DiagnosticOptions">, NormalizedValues<["Clang", "MSVC", "Vi", "SARIFStderr", "SARIFFile"]>,
   MarshallingInfoEnum<DiagnosticOpts<"Format">, "Clang">;
 def fdiagnostics_show_category : Separate<["-"], "fdiagnostics-show-category">,
   HelpText<"Print diagnostic category">,
   Values<"none,id,name">,
   NormalizedValues<["0", "1", "2"]>,
   MarshallingInfoEnum<DiagnosticOpts<"ShowCategories">, "0">;
 def fno_diagnostics_use_presumed_location : Flag<["-"], "fno-diagnostics-use-presumed-location">,
   HelpText<"Ignore #line directives when displaying diagnostic locations">,
   MarshallingInfoNegativeFlag<DiagnosticOpts<"ShowPresumedLoc">>;
 def ftabstop : Separate<["-"], "ftabstop">, MetaVarName<"<N>">,
   HelpText<"Set the tab stop distance.">,

clang/include/clang/Frontend/CompilerInstance.h

public:
   /// allocating one if one is not provided.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
   /// unit.
   ///
   /// \param ShouldOwnClient If Client is non-NULL, specifies whether
   /// the diagnostic object should take ownership of the client.
+  ///
+  /// \param ToFile Determines if Clang should write diagnostics to a file.
   void createDiagnostics(DiagnosticConsumer *Client = nullptr,
-                         bool ShouldOwnClient = true);
+                         bool ShouldOwnClient = true, bool ToFile = false);
+
+  std::string MakeInputPath() const;
 
   /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
   ///
   /// If no diagnostic client is provided, this creates a
   /// DiagnosticConsumer that is owned by the returned diagnostic
   /// object, if using directly the caller is responsible for
   /// releasing the returned DiagnosticsEngine's client eventually.
   ///
   /// \param Opts - The diagnostic options; note that the created text
   /// diagnostic object contains a reference to these options.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the returned DiagnosticsEngine
   /// object.
   ///
   /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
   /// used by some diagnostics printers (for logging purposes only).
   ///
+  /// \param TargetPath Path to the target that Clang is currently producing.
+  /// This will be used as the prefix of any file that Clang may write
+  /// diagnostics to (e.g. `-fdiagnostics-format=sarif-file -o /tmp/hello` would
+  /// lead to there being a file called `/tmp/hello.sarif`).
+  ///
   /// \return The new object on success, or null on failure.
-  static IntrusiveRefCntPtr<DiagnosticsEngine>
-  createDiagnostics(DiagnosticOptions *Opts,
-                    DiagnosticConsumer *Client = nullptr,
-                    bool ShouldOwnClient = true,
-                    const CodeGenOptions *CodeGenOpts = nullptr);
+  static IntrusiveRefCntPtr<DiagnosticsEngine> createDiagnostics(
+      DiagnosticOptions *Opts, DiagnosticConsumer *Client = nullptr,
+      bool ShouldOwnClient = true, const CodeGenOptions *CodeGenOpts = nullptr,
+      StringRef TargetPath = "");
 
   /// Create the file manager and replace any existing one with it.
   ///
   /// \return The new file manager on success, or null on failure.
   FileManager *
   createFileManager(IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr);
 
   /// Create the source manager and replace any existing one with it.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

 #define LLVM_CLANG_FRONTEND_SARIFDIAGNOSTICPRINTER_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Sarif.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
+#include <optional>
+#include <variant>
 
 namespace clang {
 class DiagnosticOptions;
 class LangOptions;
 class SARIFDiagnostic;
 class SarifDocumentWriter;
 
 class SARIFDiagnosticPrinter : public DiagnosticConsumer {
 public:
   SARIFDiagnosticPrinter(raw_ostream &OS, DiagnosticOptions *Diags);
+
+  /// Constructs a SARIFDiagnosticPrinter so that it writes to a file mimicing
+  /// Clang's current output target. The diagnostics file target has the same
+  /// name suffixed with `.sarif`.
+  SARIFDiagnosticPrinter(StringRef TargetPath, DiagnosticOptions *Diags);
+
   ~SARIFDiagnosticPrinter() = default;
 
   SARIFDiagnosticPrinter &operator=(const SARIFDiagnosticPrinter &&) = delete;
   SARIFDiagnosticPrinter(SARIFDiagnosticPrinter &&) = delete;
   SARIFDiagnosticPrinter &operator=(const SARIFDiagnosticPrinter &) = delete;
   SARIFDiagnosticPrinter(const SARIFDiagnosticPrinter &) = delete;
 
   /// setPrefix - Set the diagnostic printer prefix string, which will be
public:
   }
 
   void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override;
   void EndSourceFile() override;
   void HandleDiagnostic(DiagnosticsEngine::Level Level,
                         const Diagnostic &Info) override;
 
 private:
-  raw_ostream &OS;
+  std::optional<std::error_code> EC;
+  std::variant<raw_ostream *, std::unique_ptr<raw_ostream>> OS;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
   /// Handle to the currently active SARIF diagnostic emitter.
   std::unique_ptr<SARIFDiagnostic> SARIFDiag;
 
   /// A string to prefix to error messages.
   std::string Prefix;
 
   std::unique_ptr<SarifDocumentWriter> Writer;
+
+  raw_ostream &getOS() {
+    // Deliberately not using std::visit due to there being exactly two known
+    // types.
+    if (std::holds_alternative<raw_ostream *>(OS)) {
+      return *std::get<raw_ostream *>(OS);
+    } else {
+      return *std::get<std::unique_ptr<raw_ostream>>(OS);
+    }
+  }
 };
 
 } // end namespace clang
 
 #endif

clang/lib/Driver/ToolChains/Clang.cpp

if (const Arg *A =
     std::string Opt =
         std::string("-fdiagnostics-hotness-threshold=") + A->getValue();
     CmdArgs.push_back(Args.MakeArgString(Opt));
   }
 
   if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) {
     CmdArgs.push_back("-fdiagnostics-format");
     CmdArgs.push_back(A->getValue());
-    if (StringRef(A->getValue()) == "sarif" ||
-        StringRef(A->getValue()) == "SARIF")
+    if (StringRef(A->getValue()).starts_with("sarif"))
       D.Diag(diag::warn_drv_sarif_format_unstable);
   }
 
   if (const Arg *A = Args.getLastArg(
           options::OPT_fdiagnostics_show_note_include_stack,
           options::OPT_fno_diagnostics_show_note_include_stack)) {
     const Option &O = A->getOption();
     if (O.matches(options::OPT_fdiagnostics_show_note_include_stack))
       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");

clang/lib/Frontend/CompilerInstance.cpp

Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.takeClient(), std::move(SerializedConsumer)));
   } else {
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.getClient(), std::move(SerializedConsumer)));
   }
 }
 
 void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
-                                         bool ShouldOwnClient) {
-  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
-                                  ShouldOwnClient, &getCodeGenOpts());
+                                         bool ShouldOwnClient, bool ToFile) {
+  StringRef Input =
+      llvm::sys::path::filename(getFrontendOpts().Inputs.front().getFile());
+  StringRef Output = getFrontendOpts().OutputFile;
+  Diagnostics =
+      createDiagnostics(&getDiagnosticOpts(), Client, ShouldOwnClient,
+                        &getCodeGenOpts(), Output.empty() ? Input : Output);
 }
 
-IntrusiveRefCntPtr<DiagnosticsEngine>
-CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
-                                    DiagnosticConsumer *Client,
-                                    bool ShouldOwnClient,
-                                    const CodeGenOptions *CodeGenOpts) {
+IntrusiveRefCntPtr<DiagnosticsEngine> CompilerInstance::createDiagnostics(
+    DiagnosticOptions *Opts, DiagnosticConsumer *Client, bool ShouldOwnClient,
+    const CodeGenOptions *CodeGenOpts, StringRef TargetPath) {
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   IntrusiveRefCntPtr<DiagnosticsEngine>
       Diags(new DiagnosticsEngine(DiagID, Opts));
 
   // Create the diagnostic client for reporting errors or for
   // implementing -verify.
   if (Client) {
     Diags->setClient(Client, ShouldOwnClient);
-  } else if (Opts->getFormat() == DiagnosticOptions::SARIF) {
+  } else if (Opts->getFormat() == DiagnosticOptions::SARIFStderr) {
     Diags->setClient(new SARIFDiagnosticPrinter(llvm::errs(), Opts));
+  } else if (Opts->getFormat() == DiagnosticOptions::SARIFFile) {
+    Diags->setClient(new SARIFDiagnosticPrinter(TargetPath, Opts));
   } else
     Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
 
   // Chain in -verify checker, if requested.
   if (Opts->VerifyDiagnostics)
     Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
 
   // Chain in -diagnostic-log-file dumper, if requested.
   if (!Opts->DiagnosticLogFile.empty())
     SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
 
compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
   // Construct a compiler instance that will be used to actually create the
   // module.  Since we're sharing an in-memory module cache,
   // CompilerInstance::CompilerInstance is responsible for finalizing the
   // buffers to prevent use-after-frees.
   CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
                             &ImportingInstance.getModuleCache());
   auto &Inv = *Invocation;
   Instance.setInvocation(std::move(Invocation));
-
   Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
                                    ImportingInstance.getDiagnosticClient()),
                              /*ShouldOwnClient=*/true);
 
   if (FrontendOpts.ModulesShareFileManager) {
     Instance.setFileManager(&ImportingInstance.getFileManager());
   } else {
     Instance.createFileManager(&ImportingInstance.getVirtualFileSystem());

clang/lib/Frontend/FrontendAction.cpp

bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
   // Set up the file and source managers, if needed.
   if (!CI.hasFileManager()) {
     if (!CI.createFileManager()) {
       return false;
     }
   }
   if (!CI.hasSourceManager()) {
     CI.createSourceManager(CI.getFileManager());
-    if (CI.getDiagnosticOpts().getFormat() == DiagnosticOptions::SARIF) {
+    if (TextDiagnosticFormat Format = CI.getDiagnosticOpts().getFormat();
+        Format == DiagnosticOptions::SARIFStderr ||
+        Format == DiagnosticOptions::SARIFFile) {
       static_cast<SARIFDiagnosticPrinter *>(&CI.getDiagnosticClient())
           ->setSarifWriter(
               std::make_unique<SarifDocumentWriter>(CI.getSourceManager()));
     }
   }
 
   // Set up embedding for any specified files. Do this before we load any
   // source files, including the primary module map for the compilation.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Frontend/SARIFDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <memory>
 
 namespace clang {
 
 SARIFDiagnosticPrinter::SARIFDiagnosticPrinter(raw_ostream &OS,
                                                DiagnosticOptions *Diags)
-    : OS(OS), DiagOpts(Diags) {}
+    : OS(&OS), DiagOpts(Diags) {}
+
+static std::unique_ptr<llvm::raw_ostream>
+OpenDiagnosticFile(StringRef TargetPath, std::error_code &EC) {
+  assert(!TargetPath.empty());
+  return std::make_unique<llvm::raw_fd_ostream>(
+      std::string(TargetPath) + ".sarif", EC);
+}
+
+SARIFDiagnosticPrinter::SARIFDiagnosticPrinter(StringRef TargetPath,
+                                               DiagnosticOptions *Diags)
+    : EC(std::error_code()), OS(OpenDiagnosticFile(TargetPath, *EC)),
+      DiagOpts(Diags) {
+  if (*EC) {
+    assert(false and "not implemented yet: not even sure what to do");
+  }
+}
 
 void SARIFDiagnosticPrinter::BeginSourceFile(const LangOptions &LO,
                                              const Preprocessor *PP) {
   // Build the SARIFDiagnostic utility.
   assert(hasSarifWriter() && "Writer not set!");
   assert(!SARIFDiag && "SARIFDiagnostic already set.");
-  SARIFDiag = std::make_unique<SARIFDiagnostic>(OS, LO, &*DiagOpts, &*Writer);
+  SARIFDiag =
+      std::make_unique<SARIFDiagnostic>(getOS(), LO, &*DiagOpts, &*Writer);
   // Initialize the SARIF object.
   Writer->createRun("clang", Prefix);
 }
 
 void SARIFDiagnosticPrinter::EndSourceFile() {
   assert(SARIFDiag && "SARIFDiagnostic has not been set.");
   Writer->endRun();
   llvm::json::Value Value(Writer->createDocument());
-  OS << "\n" << Value << "\n\n";
-  OS.flush();
+  getOS() << '\n' << Value << '\n';
+  getOS().flush();
+  if (EC and *EC) {
+    llvm::errs() << "error: " << EC->message() << '\n';
+    llvm::errs() << "outputting to stderr as a backup\n";
+    llvm::errs() << Value << '\n';
+  }
   SARIFDiag.reset();
 }
 
 void SARIFDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
                                               const Diagnostic &Info) {
   assert(SARIFDiag && "SARIFDiagnostic has not been set.");
   // Default implementation (Warnings/errors count). Keeps track of the
   // number of errors.

clang/lib/Frontend/TextDiagnostic.cpp

void TextDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
   if (!DiagOpts->ShowLocation)
     return;
 
   if (DiagOpts->ShowColors)
     OS.changeColor(savedColor, true);
 
   emitFilename(PLoc.getFilename(), Loc.getManager());
   switch (DiagOpts->getFormat()) {
-  case DiagnosticOptions::SARIF:
+  case DiagnosticOptions::SARIFStderr:
+  case DiagnosticOptions::SARIFFile:
   case DiagnosticOptions::Clang:
     if (DiagOpts->ShowLine)
       OS << ':' << LineNo;
     break;
   case DiagnosticOptions::MSVC:  OS << '('  << LineNo; break;
   case DiagnosticOptions::Vi:    OS << " +" << LineNo; break;
   }
 
   if (DiagOpts->ShowColumn)
     // Compute the column number.
     if (unsigned ColNo = PLoc.getColumn()) {
       if (DiagOpts->getFormat() == DiagnosticOptions::MSVC) {
         OS << ',';
         // Visual Studio 2010 or earlier expects column number to be off by one
         if (LangOpts.MSCompatibilityVersion &&
             !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
           ColNo--;
       } else
         OS << ':';
       OS << ColNo;
     }
   switch (DiagOpts->getFormat()) {
-  case DiagnosticOptions::SARIF:
+  case DiagnosticOptions::SARIFStderr:
+  case DiagnosticOptions::SARIFFile:
   case DiagnosticOptions::Clang:
   case DiagnosticOptions::Vi:    OS << ':';    break;
   case DiagnosticOptions::MSVC:
     // MSVC2013 and before print 'file(4) : error'. MSVC2015 gets rid of the
     // space and prints 'file(4): error'.
     OS << ')';
     if (LangOpts.MSCompatibilityVersion &&
         !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2015))

clang/lib/Tooling/Tooling.cpp

bool FrontendActionFactory::runInvocation(
   Compiler.setFileManager(Files);
 
   // The FrontendAction can have lifetime requirements for Compiler or its
   // members, and we need to ensure it's deleted earlier than Compiler. So we
   // pass it to an std::unique_ptr declared after the Compiler variable.
   std::unique_ptr<FrontendAction> ScopedToolAction(create());
 
   // Create the compiler's actual diagnostics engine.
-  Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
+  Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false,
+                             Invocation->DiagnosticOpts->getFormat() ==
+                                 DiagnosticOptions::SARIFFile);
   if (!Compiler.hasDiagnostics())
     return false;
 
   Compiler.createSourceManager(*Files);
 
   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 
   Files->clearStatCache();
std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
   for (auto &FilenameWithContent : VirtualMappedFiles) {
     InMemoryFileSystem->addFile(
         FilenameWithContent.first, 0,
         llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));
   }
 
   if (!Invocation.run())
     return nullptr;
- 
   assert(ASTs.size() == 1);
   return std::move(ASTs[0]);
 }
 
 } // namespace tooling
 } // namespace clang

clang/test/Driver/fdiagnostics-format-sarif.cpp

-// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif %s -### 2>&1 | FileCheck %s --check-prefix=WARN
+// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif-stderr %s -### 2>&1 | FileCheck %s --check-prefix=WARN
 // WARN: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]
 
-// RUN: %clang -fsyntax-only -fdiagnostics-format=SARIF %s -### 2>&1 | FileCheck %s --check-prefix=WARN2
+// RUN: %clang -fsyntax-only -fdiagnostics-format=sarif-file %s -### 2>&1 | FileCheck %s --check-prefix=WARN2
 // WARN2: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]

clang/tools/driver/cc1_main.cpp

int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
       CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
 
   // Create the actual diagnostics engine.
-  Clang->createDiagnostics();
+  auto diagnostics_format_option =
+      llvm::find(Argv, StringRef("-fdiagnostics-format"));
+  bool IsSarifFile =
+      std::distance(diagnostics_format_option, Argv.end()) > 1 &&
+      *std::next(diagnostics_format_option) == StringRef("sarif-file");
+  Clang->createDiagnostics(nullptr, true, IsSarifFile);
   if (!Clang->hasDiagnostics())
     return 1;
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   llvm::install_fatal_error_handler(LLVMErrorHandler,
                                   static_cast<void*>(&Clang->getDiagnostics()));