[clang] Enable output of SARIF diagnostics

[abrahamcd]

Summary

Enables Clang to emit diagnostics in SARIF format when
-fdiagnostics-format=sarif. Adds a new DiagnosticConsumer named
SARIFDiagnosticPrinter and a new DiagnosticRenderer named SARIFDiagnostic
to constuct and emit a SARIF object containing the run's basic diagnostic info.

[abrahamcd]

Removed unused remaining parts of traditional text diagnostics.

[abrahamcd]

Minor cleanup.

[abrahamcd]

Naming fixes.

[abrahamcd]

clang/lib/Frontend/SARIFDiagnostic.cpp

76

@vaibhav.y , just wanted to confirm, the SarifDiagnosticWriter can only add locations that include row/column numbers, correct?

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

72

Does anyone know specific kinds of diagnostics that might be covered here in traditional diagnostics? I'm having trouble thinking of how we can support a simpler path for these kinds of diagnostics in SARIF since the Writer requires a source manager.

clang/test/Frontend/sarif-diagnostics.cpp

4

In regards to testing this, my understanding is that we are moving away from the unit test GTest testing, correct? I included a FileCheck implementation as well, but I wasn't sure how effective just checking the whole SARIF object like this would be.

[abrahamcd]

Fixed FileCheck test case and added multiple source range error.

[vaibhav.y]

clang/lib/Frontend/SARIFDiagnostic.cpp

76

Yes, this is currently not supported.

[abrahamcd]

Removed Clang name from FileCheck test.

[vaibhav.y]

clang/lib/Frontend/SARIFDiagnostic.cpp

155

Does this need an llvm_unreachable after the switch?

177

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

71

The location maybe if the diagnostic's source is located in the scratch buffer. Likely for macro expansions where token pasting is involved. Another case would be errors on the command line.

I'm not entirely sure how the SARIF spec would handle this case, it might require an extension.

A few ways that might work could be:

Using the logicalLocations property to specify (logicalLocation object), this might need an extension for kind: "macro", another case that might need extension is diagnostics about invalid command line flags which are also diagnostics without a valid

The parentIndex for these logical locations could be set to the physical location that produced them.

I think this definitely warrants some discussion since the spec doesn't provide a clear way to express these cases.

WDYT @aaron.ballman @cjdb @denik

[vaibhav.y]

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

71

The spec does say for "kind":

If none of those strings accurately describes the construct, kind MAY contain any value specified by the analysis tool.

So an extension might not be necessary, but might be worth discussing.

[aaron.ballman]

Precommit CI found a relevant failure.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

71

From looking through the spec, I think logicalLocations is probably the right choice and we'd want to make up our own kind for things like the scratch buffer or the command line. I think an extension would be worth discussing.

[abrahamcd]

Commented out unfinished test case

[abrahamcd]

In D131632#3733068, @aaron.ballman wrote:

Precommit CI found a relevant failure.

I think this was just from the unfinished unit test. I can go ahead and remove clang/unittests/Frontend/SARIFDiagnosticTest.cpp entirely if we don't plan to use unit tests and the FileCheck test in clang/test/Frontend/sarif-diagnostics.cpp is enough.

[denik]

Thanks Abraham!

Please mention in the summary that some part of SARIF Diag implementation was copied from Text Diag and further refactoring is needed.

Also, like we discussed:

• drop the unittest;
• replace strict match of json output in FileCheck with partial matches of the fields that we are interested in (if possible);
• rebase and incorporate setDefaultConfiguration from D131084.
• on the logicalLocations I have to take a look if we can add it in this patch or defer it and add a warning that this diagnostic is currently unsupported.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

41

std::unique_ptr<SarifDocumentWriter> Writer;

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

49

Value(Writer->createDocument());

[abrahamcd]

Added diagnostic level and default configuration to SARIF output.
Removed unit test file.

[denik]

clang/lib/Frontend/SARIFDiagnostic.cpp

155

I guess no, because of breaks. But...
Although case DiagnosticsEngine::Ignored unreachable was copied from TextDiagnostic it looks a bit confusing to me.
Do we want to store Ignored with SarifResultLevel::None or keep it unreachable?
With the latter I would replace case DiagnosticsEngine::Ignored with default to cover new unhandled types.

[abrahamcd]

Addressed review style comments.

[aaron.ballman]

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

43

There's not a lot of benefit to using bit-fields here yet, so I'd make this field a bool instead for the time being. If we add more fields here where packing them into a bit-field helps, then we can revisit at that time.

46

64–66

This interface seems dangerous to me -- the caller has no idea that the pointer will be stashed off as a unique_ptr and so the caller might expect to still be able to use its (now not unique) pointer value.

clang/lib/Frontend/SARIFDiagnostic.cpp

44

44–48

60–62

91–93

106–108

128

147

This is reachable and it's a programmer mistake if we get here.

163–164

170–174

175

Please spell out the type since it's not spelled out in the initialization. Also, the next line is checking for a file -- what if File is null?

190

I'm not certain we want a difference in behavior here. For starters, Windows also has hardlinks and symlinks (they're not exactly the same as on *nix systems though), so I think the assumption these paths point to the same place is valid. But also, platform-specific behavior should be exceedingly rare in most parts of the compiler. Is there significant harm in unifying the behavior across platforms?

192

Note: this is not a particularly small string when it requires 4k by default.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

28–31

It's ugly but it's the pattern we use all over the codebase (and it corrects the naming convention issues).

57–58

72

[cjdb]

This looks great, thank you so much @abrahamcd!

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

32

Please make OS a pointer instead of a reference, since member references make usage very unpleasant.

32–43

Nit: please move all private members below the public interface, where possible.

43

Can we make this a bool instead? Unless I'm mistaken, there's 31 bits of padding for OwnsOutputStream, as opposed to a bool's (almost certainly) eight bits.

53

We should be passing in a StringRef rather than a string, since this will unnecessarily construct a string for C string literals.

clang/lib/Frontend/FrontendAction.cpp

724–727

We shouldn't have raw owning pointers, since they're vulnerable to memory leaks. Even though LLVM doesn't throw exceptions, it's still good practice to avoid them.

clang/lib/Frontend/SARIFDiagnostic.cpp

31–32

Please replace this using-directive with a namespace scope.

79

I think it would be good to file an issue on GitHub and change to FIXME(llvm-project/<issue>). @aaron.ballman WDYT?

87–89

I haven't seen any use of RI or RE in this loop, except to dereference RI, so we should change this to a range-for loop.

163

211–224

If these aren't called, then they should probably assert and say that they're not implemented.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

25–26

Please replace with a namespace scope.

71

We should defer this to a future CL, so that Abraham isn't blocked by our decision-making (and so we can make the right decision). I can start a GitHub issue to get the discussion in a good spot?

clang/test/Frontend/sarif-diagnostics.cpp

4

In regards to testing this, my understanding is that we are moving away from the unit test GTest testing, correct?

Yep, that's correct.

I included a FileCheck implementation as well, but I wasn't sure how effective just checking the whole SARIF object like this would be.

Isn't this the FileCheck test?

[aaron.ballman]

clang/lib/Frontend/SARIFDiagnostic.cpp

79

I'd be fine with that.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

71

SGTM (I don't consider this to be blocking for this patch, FWIW).

[denik]

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

71

I agree that logicalLocations is a good use for the mentioned cases.

In addition, the spec mentions that location object can miss both physical and logical location properties in which cases it has to include the message property (see 3.28.1). I think this also could be a good use case for the command line flag errors.

To unblock this change we can leave result.locations empty. It's allowed by the spec (see 3.27.12). From what I see, Sarif.cpp doesn't use the source manager if Locations is empty.
But locations still has to be present with the empty list. This might need a fix in https://clang.llvm.org/doxygen/Sarif_8cpp_source.html#l00387.

[abrahamcd]

Addressed review comments on formatting, style, C++ best practices.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

64–66

Would it be best to store as a regular pointer instead of a unique pointer in this case then?

clang/lib/Frontend/SARIFDiagnostic.cpp

163

This creates -Wcovered-switch-default warning so I just removed the unreachable.

175

If I am interpreting it correctly (this is adapted from TextDiagnostic.cpp), I believe the passed-in Filename will just be returned unaltered. This is probably one of those functions that would be good to pull out during refactoring.

190

There seems to be Windows-specific tests that rely on this behavior, but I'm not too sure what the harm in unifying it would be. There's some discussion on it here: D59415.

[abrahamcd]

clang/test/Frontend/sarif-diagnostics.cpp

4

Yes, I meant "this FileCheck implementation" (back then I had the unit test implementation in here as well but I have since removed it).

[aaron.ballman]

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

64–66

My preference is to use a unique_ptr whenever possible so that ownership semantics are clear. So my recommendation is to have the user construct the unique_ptr and hand it off through this interface with a move.

clang/lib/Frontend/SARIFDiagnostic.cpp

190

Then let's skip this for now -- if there's something we want to address, we can do it in a follow-up.

[abrahamcd]

Modified Printer's interface to use unique pointers when setting the SARIF writer.

[abrahamcd]

Documented issue with representing PresumedLocs modified by #line directives.

[abrahamcd]

clang/lib/Frontend/SARIFDiagnostic.cpp

117

I noticed that when processing additional source ranges, regular source locations are used instead of the presumed locations. Is this an intentional difference from single location diagnostics? (This issue is present in the current TextDiagnostics as well.)

130–133

There's an issue I encountered with adding presumed locations that have been modified by a #line directive to SARIF. To add a location, the Writer requires a CharSourceRange, which uses regular SourceLocations. If the presumed location has a modified line number, the source manager will still interpret it as a regular line number in the source file and can cause the wrong column number to be added to the SARIF object.

@vaibhav.y Do you have an idea of how involved it would be to add an option to the document writer that adds locations without first creating a CharSourceRange?

[cjdb]

clang/lib/Frontend/FrontendAction.cpp

726–727

Now that the interface is using unique_ptr, we should replace with std::make_unique.

clang/lib/Frontend/SARIFDiagnostic.cpp

130

Please assign this a GitHub issue. You can assign the issue to me.

192

There's a bug either here or in the function's interface: the function returns a StringRef to a stack object. Do we really need ownership here?

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

36–37

This makes me very uncomfortable. @aaron.ballman do we have a smart-pointer that works like variant<T*, unique_ptr<T>>?

44

Please replace with make_unique.

[abrahamcd]

Added use of std::make_unique.

[cjdb]

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

42

We don't need to move a StringRef.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

44

This won't work because .get() only returns an observer, so the object will be deleted when this statement completes. We'll need to do

SARIFDiag = std::make_unique<SARIFDiagnostic>(*OS, LO, &*DiagOpts, &*Writer);

[abrahamcd]

Removed use of pointer reset in Printer.

[cjdb]

Open comments notwithstanding, I'm happy with this patch. Thank you for working on this, it's a huge step towards getting more helpful diagnostics for C++!

@aaron.ballman, @vaibhav.y, do you folks have any further concerns? (@denik has some commentary incoming)

clang/include/clang/Frontend/SARIFDiagnostic.h

25–27

These can go in the private section below.

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

73

This can't ever happen, because there's no constructor that doesn't set OwnsOutputStream.

clang/lib/Frontend/SARIFDiagnostic.cpp

87–89

It seems @aaron.ballman has finally trained me :(

[aaron.ballman]

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

32

Please make OS a pointer instead of a reference, since member references make usage very unpleasant.

Err... I disagree (and just deleted a comment above asking for OS to turn into a reference rather than a pointer because it can never be null). I think we want to use a reference here because 1) it conveys the correct "I can never be null" semantics so maintainers don't have to ask when that can happen, and 2) copies of this class are a bad idea to begin with (we should probably delete the copy and move operations).

We use reference members elsewhere: https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Sema/Sema.h#L407 (not that I would hold Sema up as an example of best practices, lol).

[aaron.ballman]

clang/lib/Frontend/SARIFDiagnostic.cpp

87–89

My work here is done. ;-)

[abrahamcd]

Deleted copy/move from renderer and returned OS to reference.

[denik]

clang/include/clang/Frontend/SARIFDiagnostic.h

25–27

In addition, I think it's worth putting a comment here about Writer's ownership and why it's a raw pointer here (like we discussed offline).

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

3

Please adjust the length to fit it in one line.

clang/lib/Frontend/SARIFDiagnostic.cpp

3

Same here.

39

Could you please add FIXME with a pointer to llvm-project/issues/57323 to refactor Diagnostic classes?

59

I think we should add a test case when Loc or/and Source Manager is not set.
If Loc is not set SarifDocumentWriter might not create the locations property which is required by the spec.
If this is the case we need to fix it. But I'm not sure if emitDiagnosticMessage() is going to be called when Loc.isInvalid() ).

79

@abrahamcd please file the llvm-project/issues and link it here.

117

Put FIXME here (if it's not already somewhere else).

192

Note: this is not a particularly small string when it requires 4k by default.

This still has to be addressed.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

3

Same as above. One line.

[aaron.ballman]

clang/include/clang/Frontend/SARIFDiagnostic.h

31–34

Formatting nits.

46–48

Move this implementation to live with the rest and give it an assertion?

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

73

This can go away, this never owns the output stream.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

36–37

No, but we shouldn't need it -- this object *never* owns the output stream, so I think we should remove the member variable and this code (we can default the dtor then).

43

Should we also assert that we don't already have a valid SARIFDiag object (in case someone calls BeginSourceFile() twice)?

54

Should we be invalidating that SARIFDiag object here so the printer cannot be used after the source file has ended?

[cjdb]

clang/lib/Frontend/SARIFDiagnostic.cpp

192

There's a bug either here or in the function's interface: the function returns a StringRef to a stack object. Do we really need ownership here?

Disregard, I misread TmpFilename as Filename and thought we were returning a dangling reference. That isn't the case, so there is no bug.

[abrahamcd]

Addressed some refactoring and reformatting comments.

clang/include/clang/Frontend/SARIFDiagnostic.h

46–48

This function is currently being called from the DiagnosticRenderer class that both Text and SARIFDiagnostics inherit from. Maybe this could be part of the refactoring, making sure that any text-specific function calls are moved to TextDiagnostic rather than being in the general Renderer base class?

clang/lib/Frontend/SARIFDiagnostic.cpp

59

I believe if Loc is invalid, it goes to one of those special cases I mentioned in this review.

[cjdb]

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

54

I suggested that we don't do this, because the next run of BeginSourceFile can take care of that when making the new SARIFDiagnostic. However, if we were to put an assert at the top of every member function other than BeginSourceFile to ensure that SARIFDiag isn't null (and one at the top of BeginSourceFile to ensure that it _is_), I think there might be good value in re-adding this.

[abrahamcd]

Ran clang-format.

[denik]

clang/lib/Frontend/SARIFDiagnostic.cpp

59

If it does then "if" is redundant here.

[aaron.ballman]

LGTM!

clang/include/clang/Frontend/SARIFDiagnostic.h

46–48

Ah, good call, the assert definitely would be wrong then. Let's leave it alone for now, it's fine as-is.

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

54

SGTM, thanks for weighing in!

[abrahamcd]

Resolved pending comments.

clang/lib/Frontend/SARIFDiagnostic.cpp

59

Looked closer and the base Renderer calls this function in both cases when Loc is valid and when it is invalid, so the extra check is necessary. In the case that Loc is invalid, you're right that results will not have locations. This might be something to add to the Writer, I couldn't find a way to add an empty locations object.

192

Made it smaller for now, but this should be revisited during refactoring, since text diag still uses 4096

[abrahamcd]

Deleted copy and move for Printer and added asserts.

[abrahamcd]

Reset SARIFDiag during EndSourceFile().

[thakis]

This adds warnings:

[498/568] CXX obj/clang/lib/Frontend/Frontend.SARIFDiagnostic.o
../../clang/lib/Frontend/SARIFDiagnostic.cpp:74:25: warning: unused variable 'Filename' [-Wunused-variable]
        llvm::StringRef Filename =
                        ^
In file included from ../../clang/lib/Frontend/SARIFDiagnostic.cpp:9:
../../clang/include/clang/Frontend/SARIFDiagnostic.h:58:16: warning: private field 'OS' is not used [-Wunused-private-field]
  raw_ostream &OS;
               ^

[dyung]

clang/test/Frontend/sarif-diagnostics.cpp

9

Can this CHECK line be broken into smaller pieces? This test is failing on our internal bot, and I'm going crosseyed trying to figure out what the difference is because the line is 3741 characters long!

[dyung]

clang/test/Frontend/sarif-diagnostics.cpp

9

Is there any significance to the "ruleId" and "Id" values in this test? If not, can we just use a regex to check for a number? Our internal build with private changes is failing due to slightly different numbers in some of the "ruleId" fields

[uabelho]

clang/test/Frontend/sarif-diagnostics.cpp

9

+1 on this. We also get different "ruleId" and "Id" values downstream and it's quite painful trying to figure out where the diffs are in a +3700 character CHECK.

[aaron.ballman]

clang/test/Frontend/sarif-diagnostics.cpp

9

I ran into this problem this morning as well. I've improved the situation somewhat in b345be177d03166add391f090fd0288a23413934, but I think we really could use some better diff tooling than FileCheck for diffing between two JSON files.

The test can still be made less fragile despite the changes I made, which were just enough to get the test passing for me locally again, but running considerably faster (it turns out long FileCheck lines take a while to process).

[tstellar]

clang/test/Frontend/sarif-diagnostics.cpp

9

This check line assumes the clang directory is called clang, which is not true for the release tarballs that we distribute. Need to drop the clang/ directory from the path name.

[aaron.ballman]

clang/test/Frontend/sarif-diagnostics.cpp

9

Good catch, I'll fix that up shortly.

[aaron.ballman]

clang/test/Frontend/sarif-diagnostics.cpp

9

This should be fixed by 0647f4a77a2f9aab84c961982193bea1a9eb1585; please let me know if there's still a problem.

clang/include/clang/Frontend/SARIFDiagnostic.h

+//===--- SARIFDiagnostic.h - SARIF Diagnostic Formatting -----*- 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 utility class that provides support for constructing a SARIF object
+// containing diagnostics.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_FRONTEND_SARIFDIAGNOSTIC_H
+#define LLVM_CLANG_FRONTEND_SARIFDIAGNOSTIC_H
+
+#include "clang/Basic/Sarif.h"
+#include "clang/Frontend/DiagnosticRenderer.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+
+class SARIFDiagnostic : public DiagnosticRenderer {
+  raw_ostream &OS;
+
+  SarifDocumentWriter *Writer;
+
+public:
+  SARIFDiagnostic(raw_ostream &OS, const LangOptions &LangOpts,
+                  DiagnosticOptions *DiagOpts, SarifDocumentWriter *Writer);
+
+  ~SARIFDiagnostic() = default;
+
+  /// Add the diagnostic level to a diagnostic's SARIF rule.
+  ///
+  /// This is used internally by the SARIFDiagnostic emission code, but it can 
+  /// also be used directly by consumers that don't have a source manager or
+  /// other state that the full SARIFDiagnostic logic requires.
+  static void printDiagnosticLevel(raw_ostream &OS,
+                                   DiagnosticsEngine::Level Level);
+
+protected:
+  void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+                             DiagnosticsEngine::Level Level, StringRef Message,
+                             ArrayRef<CharSourceRange> Ranges,
+                             DiagOrStoredDiag D) override;
+
+  void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+                         DiagnosticsEngine::Level Level,
+                         ArrayRef<CharSourceRange> Ranges) override;
+
+  void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+                       SmallVectorImpl<CharSourceRange> &Ranges,
+                       ArrayRef<FixItHint> Hints) override {
+    emitSnippetAndCaret(Loc, Level, Ranges, Hints);
+  }
+
+  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
+
+  void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+                          StringRef ModuleName) override;
+
+  void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+                                  StringRef ModuleName) override;
+
+private:
+  SarifResult addLocationToResult(SarifResult Result, FullSourceLoc Loc,
+                                  PresumedLoc PLoc,
+                                  ArrayRef<CharSourceRange> Ranges,
+                                  const Diagnostic &Diag);
+
+  llvm::StringRef emitFilename(StringRef Filename, const SourceManager &SM);
+
+  void emitSnippetAndCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+                           SmallVectorImpl<CharSourceRange> &Ranges,
+                           ArrayRef<FixItHint> Hints);
+};
+
+} // end namespace clang
+
+#endif

clang/include/clang/Frontend/SARIFDiagnosticPrinter.h

+//===--- SARIFDiagnosticPrinter.h - SARIF 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, which prints the diagnostics to
+// standard error.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_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 <memory>
+
+namespace clang {
+class DiagnosticOptions;
+class LangOptions;
+class SARIFDiagnostic;
+class SarifDocumentWriter;
+
+class SARIFDiagnosticPrinter : public DiagnosticConsumer {
+  raw_ostream &OS;
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
+
+  /// Handle to the currently active text diagnostic emitter.
+  std::unique_ptr<SARIFDiagnostic> SARIFDiag;
+
+  /// A string to prefix to error messages.
+  std::string Prefix;
+
+  SarifDocumentWriter *Writer = nullptr;
+
+  unsigned OwnsOutputStream : 1;
+
+public:
+  SARIFDiagnosticPrinter(raw_ostream &os, DiagnosticOptions *diags,
+                         bool OwnsOutputStream = false);
+  ~SARIFDiagnosticPrinter() override;
+
+  /// setPrefix - Set the diagnostic printer prefix string, which will be
+  /// printed at the start of any diagnostics. If empty, no prefix string is
+  /// used.
+  void setPrefix(std::string Value) {
+    Prefix = std::move(Value);
+  }
+
+  bool hasSarifWriter() const { return Writer != nullptr; }
+
+  SarifDocumentWriter &getSarifWriter() const {
+    assert(Writer && "SarifWriter not set!");
+    return *Writer;
+  }
+
+  void setSarifWriter(SarifDocumentWriter *SarifWriter) {
+    Writer = SarifWriter;
+  }
+
+  void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override;
+  void EndSourceFile() override;
+  void HandleDiagnostic(DiagnosticsEngine::Level Level,
+                        const Diagnostic &Info) override;
+};
+
+} // end namespace clang
+
+#endif

clang/lib/Frontend/CMakeLists.txt

add_clang_library(clangFrontend
   HeaderIncludeGen.cpp
   InitPreprocessor.cpp
   LayoutOverrideSource.cpp
   LogDiagnosticPrinter.cpp
   ModuleDependencyCollector.cpp
   MultiplexConsumer.cpp
   PrecompiledPreamble.cpp
   PrintPreprocessedOutput.cpp
+  SARIFDiagnostic.cpp
+  SARIFDiagnosticPrinter.cpp
   SerializedDiagnosticPrinter.cpp
   SerializedDiagnosticReader.cpp
   TestModuleFileExtension.cpp
   TextDiagnostic.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnosticPrinter.cpp
   VerifyDiagnosticConsumer.cpp
   InterfaceStubFunctionsConsumer.cpp

clang/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 "clang/Frontend/CompilerInstance.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangStandard.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Stack.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Frontend/LogDiagnosticPrinter.h"
+#include "clang/Frontend/SARIFDiagnosticPrinter.h"
 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
   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) {
+    Diags->setClient(new SARIFDiagnosticPrinter(llvm::errs(), 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.

clang/lib/Frontend/FrontendAction.cpp

 //===--- FrontendAction.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 "clang/Frontend/FrontendAction.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclGroup.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/LangStandard.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Frontend/LayoutOverrideSource.h"
 #include "clang/Frontend/MultiplexConsumer.h"
+#include "clang/Frontend/SARIFDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/HLSLExternalSemaSource.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
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())
+  if (!CI.hasSourceManager()) {
     CI.createSourceManager(CI.getFileManager());
+    if (CI.getDiagnosticOpts().getFormat() == DiagnosticOptions::SARIF) {
+      auto *Writer = new SarifDocumentWriter(CI.getSourceManager());
+      static_cast<SARIFDiagnosticPrinter *>(&CI.getDiagnosticClient())
+          ->setSarifWriter(Writer);
+    }
+  }
 
   // Set up embedding for any specified files. Do this before we load any
   // source files, including the primary module map for the compilation.
   for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
     if (auto FE = CI.getFileManager().getFile(F, /*openFile*/true))
       CI.getSourceManager().setFileIsTransient(*FE);
     else
       CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;

clang/lib/Frontend/SARIFDiagnostic.cpp

+//===------- SARIFDiagnostic.cpp - SARIF Diagnostic Formatting
+//-------------===//
+//
+// 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 "clang/Frontend/SARIFDiagnostic.h"
+#include "clang/Basic/CharInfo.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/Sarif.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Locale.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <string>
+
+using namespace clang;
+
+SARIFDiagnostic::SARIFDiagnostic(raw_ostream &OS, const LangOptions &LangOpts,
+                                 DiagnosticOptions *DiagOpts,
+                                 SarifDocumentWriter *Writer)
+    : DiagnosticRenderer(LangOpts, DiagOpts), OS(OS), Writer(Writer) {}
+
+void SARIFDiagnostic::emitDiagnosticMessage(
+    FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
+    StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
+    DiagOrStoredDiag D) {
+
+  auto *Diag = D.dyn_cast<const Diagnostic *>();
+
+  if (!Diag) {
+    return;
+  }
+
+  const SarifRule &Rule =
+      SarifRule::create().setRuleId(std::to_string(Diag->getID()));
+
+  unsigned RuleIdx = Writer->createRule(Rule);
+
+  SarifResult Result =
+      SarifResult::create(RuleIdx).setDiagnosticMessage(Message);
+
+  if (Loc.isValid()) {
+    Result = addLocationToResult(Result, Loc, PLoc, Ranges, *Diag);
+  }
+
+  Writer->appendResult(Result);
+}
+
+SarifResult SARIFDiagnostic::addLocationToResult(
+    SarifResult Result, FullSourceLoc Loc, PresumedLoc PLoc,
+    ArrayRef<CharSourceRange> Ranges, const Diagnostic &Diag) {
+  SmallVector<CharSourceRange> Locations = {};
+
+  if (PLoc.isInvalid()) {
+    // At least add the file name if available:
+    FileID FID = Loc.getFileID();
+    if (FID.isValid()) {
+      if (const FileEntry *FE = Loc.getFileEntry()) {
+        llvm::StringRef Filename =
+            emitFilename(FE->getName(), Loc.getManager());
+        // FIXME: No current way to add file-only location to SARIF object
+      }
+    }
+    return Result;
+  }
+
+  FileID CaretFileID = Loc.getExpansionLoc().getFileID();
+
+  for (ArrayRef<CharSourceRange>::const_iterator RI = Ranges.begin(),
+                                                 RE = Ranges.end();
+       RI != RE; ++RI) {
+    // Ignore invalid ranges.
+    if (!RI->isValid()) {
+      continue;
+    }
+
+    auto &SM = Loc.getManager();
+    SourceLocation B = SM.getExpansionLoc(RI->getBegin());
+    CharSourceRange ERange = SM.getExpansionRange(RI->getEnd());
+    SourceLocation E = ERange.getEnd();
+    bool IsTokenRange = ERange.isTokenRange();
+
+    std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
+    std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);
+
+    // If the start or end of the range is in another file, just discard
+    // it.
+    if (BInfo.first != CaretFileID || EInfo.first != CaretFileID) {
+      continue;
+    }
+
+    // Add in the length of the token, so that we cover multi-char
+    // tokens.
+    unsigned TokSize = 0;
+    if (IsTokenRange)
+      TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
+
+    FullSourceLoc BF(B, SM), EF(E, SM);
+    SourceLocation BeginLoc = SM.translateLineCol(
+        BF.getFileID(), BF.getLineNumber(), BF.getColumnNumber());
+    SourceLocation EndLoc = SM.translateLineCol(
+        EF.getFileID(), EF.getLineNumber(), EF.getColumnNumber() + TokSize);
+
+    Locations.push_back(
+        CharSourceRange{SourceRange{BeginLoc, EndLoc}, /* ITR = */ false});
+  }
+
+  auto &SM = Loc.getManager();
+  auto FID = PLoc.getFileID();
+  // Visual Studio 2010 or earlier expects column number to be off by one
+  unsigned int ColNo = (LangOpts.MSCompatibilityVersion &&
+                        !LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
+                           ? PLoc.getColumn() - 1
+                           : PLoc.getColumn();
+  SourceLocation DiagLoc = SM.translateLineCol(FID, PLoc.getLine(), ColNo);
+
+  Locations.push_back(
+      CharSourceRange{SourceRange{DiagLoc, DiagLoc}, /* ITR = */ false});
+
+  return Result.setLocations(Locations);
+}
+
+/*static*/ void
+SARIFDiagnostic::printDiagnosticLevel(raw_ostream &OS,
+                                      DiagnosticsEngine::Level Level) {
+  // TODO: Change to set Level in Rule once implemented
+  switch (Level) {
+  case DiagnosticsEngine::Ignored:
+    llvm_unreachable("Invalid diagnostic type");
+  case DiagnosticsEngine::Note:
+    break;
+  case DiagnosticsEngine::Remark:
+    break;
+  case DiagnosticsEngine::Warning:
+    break;
+  case DiagnosticsEngine::Error:
+    break;
+  case DiagnosticsEngine::Fatal:
+    break;
+  }
+}
+
+llvm::StringRef SARIFDiagnostic::emitFilename(StringRef Filename,
+                                              const SourceManager &SM) {
+#ifdef _WIN32
+  SmallString<4096> TmpFilename;
+#endif
+  if (DiagOpts->AbsolutePath) {
+    auto File = SM.getFileManager().getFile(Filename);
+    if (File) {
+      // We want to print a simplified absolute path, i. e. without "dots".
+      //
+      // The hardest part here are the paths like "<part1>/<link>/../<part2>".
+      // On Unix-like systems, we cannot just collapse "<link>/..", because
+      // paths are resolved sequentially, and, thereby, the path
+      // "<part1>/<part2>" may point to a different location. That is why
+      // we use FileManager::getCanonicalName(), which expands all indirections
+      // with llvm::sys::fs::real_path() and caches the result.
+      //
+      // On the other hand, it would be better to preserve as much of the
+      // original path as possible, because that helps a user to recognize it.
+      // real_path() expands all links, which sometimes too much. Luckily,
+      // on Windows we can just use llvm::sys::path::remove_dots(), because,
+      // on that system, both aforementioned paths point to the same place.
+#ifdef _WIN32
+      TmpFilename = (*File)->getName();
+      llvm::sys::fs::make_absolute(TmpFilename);
+      llvm::sys::path::native(TmpFilename);
+      llvm::sys::path::remove_dots(TmpFilename, /* remove_dot_dot */ true);
+      Filename = StringRef(TmpFilename.data(), TmpFilename.size());
+#else
+      Filename = SM.getFileManager().getCanonicalName(*File);
+#endif
+    }
+  }
+
+  return Filename;
+}
+
+/// Print out the file/line/column information and include trace.
+///
+/// This method handlen the emission of the diagnostic location information.
+/// This includes extracting as much location information as is present for
+/// the diagnostic and printing it, as well as any include stack or source
+/// ranges necessary.
+void SARIFDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+                                        DiagnosticsEngine::Level Level,
+                                        ArrayRef<CharSourceRange> Ranges) {}
+
+void SARIFDiagnostic::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) {
+}
+
+void SARIFDiagnostic::emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+                                         StringRef ModuleName) {}
+
+void SARIFDiagnostic::emitBuildingModuleLocation(FullSourceLoc Loc,
+                                                 PresumedLoc PLoc,
+                                                 StringRef ModuleName) {}
+
+/// Emit a code snippet and caret line.
+///
+/// This routine emits a single line's code snippet and caret line..
+///
+/// \param Loc The location for the caret.
+/// \param Ranges The underlined ranges for this code snippet.
+/// \param Hints The FixIt hints active for this diagnostic.
+void SARIFDiagnostic::emitSnippetAndCaret(
+    FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+    SmallVectorImpl<CharSourceRange> &Ranges, ArrayRef<FixItHint> Hints) {}

clang/lib/Frontend/SARIFDiagnosticPrinter.cpp

+//===------- SARIFDiagnosticPrinter.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 in SARIF format.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Frontend/SARIFDiagnosticPrinter.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/Sarif.h"
+#include "clang/Basic/SourceManager.h"
+#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>
+using namespace clang;
+
+SARIFDiagnosticPrinter::SARIFDiagnosticPrinter(raw_ostream &os,
+                                               DiagnosticOptions *diags,
+                                               bool _OwnsOutputStream)
+    : OS(os), DiagOpts(diags), OwnsOutputStream(_OwnsOutputStream) {}
+
+SARIFDiagnosticPrinter::~SARIFDiagnosticPrinter() {
+  if (OwnsOutputStream)
+    delete &OS;
+}
+
+void SARIFDiagnosticPrinter::BeginSourceFile(const LangOptions &LO,
+                                             const Preprocessor *PP) {
+  // Build the SARIFDiagnostic utility.
+  assert(hasSarifWriter() && "Writer not set!");
+  SARIFDiag.reset(new SARIFDiagnostic(OS, LO, &*DiagOpts, &*Writer));
+  // Initialize the SARIF object.
+  Writer->createRun("clang", Prefix);
+}
+
+void SARIFDiagnosticPrinter::EndSourceFile() {
+  Writer->endRun();
+  llvm::json::Value value(Writer->createDocument());
+  OS << "\n" << value << "\n\n";
+  OS.flush();
+  SARIFDiag.reset();
+}
+
+void SARIFDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
+                                              const Diagnostic &Info) {
+  // Default implementation (Warnings/errors count). // Keeps track of the
+  // number of errors
+  DiagnosticConsumer::HandleDiagnostic(Level, Info);
+
+  // Render the diagnostic message into a temporary buffer eagerly. We'll use
+  // this later as we add the diagnostic to the SARIF object.
+  SmallString<100> OutStr;
+  Info.FormatDiagnostic(OutStr);
+
+  llvm::raw_svector_ostream DiagMessageStream(OutStr);
+
+  // Use a dedicated, simpler path for diagnostics without a valid location.
+  // This is important as if the location is missing, we may be emitting
+  // diagnostics in a context that lacks language options, a source manager, or
+  // other infrastructure necessary when emitting more rich diagnostics.
+  if (!Info.getLocation().isValid()) { // TODO: What is this case? 
+    // SARIFDiag->addDiagnosticWithoutLocation(
+    //     DiagMessageStream.str(), Info.getID());
+    return;
+  }
+
+  // Assert that the rest of our infrastructure is setup properly.
+  assert(DiagOpts && "Unexpected diagnostic without options set");
+  assert(Info.hasSourceManager() &&
+         "Unexpected diagnostic with no source manager");
+  assert(SARIFDiag && "Unexpected diagnostic outside source file processing");
+
+  SARIFDiag->emitDiagnostic(
+      FullSourceLoc(Info.getLocation(), Info.getSourceManager()), Level,
+      DiagMessageStream.str(), Info.getRanges(), Info.getFixItHints(), &Info);
+
+}

clang/test/Frontend/sarif-diagnostics.cpp

+// RUN: %clang -fsyntax-only -Wall -Wextra -fdiagnostics-format=sarif %s > %t 2>&1 || true
+// RUN: FileCheck -dump-input=always %s --input-file=%t
+// CHECK: warning: diagnostic formatting in SARIF mode is currently unstable [-Wsarif-format-unstable]
+// CHECK: {"$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json","runs":[{"artifacts":[{"length":
+// Omit exact length of this file
+// CHECK: ,"location":{"index":0,"uri":"file://
+// Omit filepath to llvm project directory
+// CHECK: clang/test/Frontend/sarif-diagnostics.cpp"},"mimeType":"text/plain","roles":["resultFile"]}],"columnKind":"unicodeCodePoints","results":[{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":1,"startColumn":1,"startLine":12}}}],"message":{"text":"'main' must return 'int'"},"ruleId":"3463","ruleIndex":0},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":11,"startColumn":11,"startLine":13}}}],"message":{"text":"use of undeclared identifier 'hello'"},"ruleId":"4601","ruleIndex":1},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":17,"startColumn":17,"startLine":15}}}],"message":{"text":"invalid digit 'a' in decimal constant"},"ruleId":"898","ruleIndex":2},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":5,"startColumn":5,"startLine":19}}}],"message":{"text":"misleading indentation; statement is not part of the previous 'if'"},"ruleId":"1806","ruleIndex":3},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":3,"startColumn":3,"startLine":17}}}],"message":{"text":"previous statement is here"},"ruleId":"1730","ruleIndex":4},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":10,"startColumn":10,"startLine":18}}}],"message":{"text":"unused variable 'Yes'"},"ruleId":"6536","ruleIndex":5},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":12,"startColumn":12,"startLine":21}}}],"message":{"text":"use of undeclared identifier 'hi'"},"ruleId":"4601","ruleIndex":6},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":1,"startColumn":1,"startLine":23}}}],"message":{"text":"extraneous closing brace ('}')"},"ruleId":"1399","ruleIndex":7},{"locations":[{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":6,"endLine":27,"startColumn":5,"startLine":27}}},{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":10,"endLine":27,"startColumn":9,"startLine":27}}},{"physicalLocation":{"artifactLocation":{"index":0},"region":{"endColumn":7,"startColumn":7,"startLine":27}}}],"message":{"text":"invalid operands to binary expression ('t1' and 't1')"},"ruleId":"4536","ruleIndex":8}],"tool":{"driver":{"fullName":"","informationUri":"https://clang.llvm.org/docs/UsersManual.html","language":"en-US","name":"clang","rules":[{"fullDescription":{"text":""},"id":"3463","name":""},{"fullDescription":{"text":""},"id":"4601","name":""},{"fullDescription":{"text":""},"id":"898","name":""},{"fullDescription":{"text":""},"id":"1806","name":""},{"fullDescription":{"text":""},"id":"1730","name":""},{"fullDescription":{"text":""},"id":"6536","name":""},{"fullDescription":{"text":""},"id":"4601","name":""},{"fullDescription":{"text":""},"id":"1399","name":""},{"fullDescription":{"text":""},"id":"4536","name":""}],"version":"16.0.0"}}}],"version":"2.1.0"}
+// CHECK: 2 warnings and 6 errors generated.
+
+
+void main() {
+  int i = hello;
+
+  float test = 1a.0;
+
+  if (true)
+    bool Yes = true;
+    return;
+
+  bool j = hi;
+}
+}
+
+struct t1 { };
+void f1(t1 x, t1 y) {
+    x + y;
+}

clang/unittests/Frontend/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(FrontendTests
   ASTUnitTest.cpp
   CompilerInvocationTest.cpp
   CompilerInstanceTest.cpp
   FixedPointString.cpp
   FrontendActionTest.cpp
   CodeGenActionTest.cpp
   ParsedSourceLocationTest.cpp
   PCHPreambleTest.cpp
   OutputStreamTest.cpp
+  SARIFDiagnosticTest.cpp
   TextDiagnosticTest.cpp
   UtilsTest.cpp
   )
 clang_target_link_libraries(FrontendTests
   PRIVATE
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangSema
   clangCodeGen
   clangFrontendTool
   clangSerialization
   )

clang/unittests/Frontend/SARIFDiagnosticTest.cpp

+// RUN: %clang -fdiagnostics-format=sarif %s -o %t.exe -DGTEST
+// RUN: %clang -fsyntax-only -Wall -Wextra -fdiagnostics-format=sarif %s 2>
+// %t.diags || true RUN: %t.exe < %t.diags
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Program.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <filesystem>
+#include <vector>
+
+namespace {
+
+constexpr llvm::StringRef BrokenProgram = R"(// Example errors below start on line 2
+void main() {
+  int i = hello;
+
+  float test = 1a.0;
+
+  if (true)
+    bool Yes = true;
+    return;
+
+  bool j = hi;
+}
+})";
+
+TEST(SARIFDiagnosticTest, TestFields) {
+  llvm::SmallString<256> SearchDir;
+  llvm::sys::fs::current_path(SearchDir);
+  
+  SearchDir.append("/../../../bin");
+
+  llvm::ErrorOr<std::string> ClangPathOrErr =
+  llvm::sys::findProgramByName("clang", {SearchDir});
+  ASSERT_TRUE(ClangPathOrErr);
+  const std::string &ClangPath = *ClangPathOrErr;
+
+  llvm::ErrorOr<std::string> EchoPathOrErr =
+      llvm::sys::findProgramByName("echo");
+  ASSERT_TRUE(EchoPathOrErr);
+  const std::string &EchoPath = *EchoPathOrErr;
+
+  int EchoInputFD;
+  llvm::SmallString<32> EchoInputFile, EchoOutputFile;
+  llvm::sys::fs::createTemporaryFile("echo-input", "", EchoInputFD,
+                                     EchoInputFile);
+  llvm::sys::fs::createTemporaryFile("echo-output", "", EchoOutputFile);
+  llvm::FileRemover InputRemover(EchoInputFile.c_str());
+  llvm::FileRemover OutputRemover(EchoOutputFile.c_str());
+
+  llvm::Optional<llvm::StringRef> Redirects[] = {
+      EchoInputFile.str(), EchoOutputFile.str(), llvm::StringRef("")};
+
+  int RunResult = llvm::sys::ExecuteAndWait(EchoPath, {"echo", BrokenProgram},
+                                            llvm::None, Redirects);
+  ASSERT_EQ(RunResult, 0);
+
+  llvm::SmallString<32> ClangErrFile;
+  llvm::sys::fs::createTemporaryFile("clang-err", "", ClangErrFile);
+  llvm::FileRemover ClangErrRemover(ClangErrFile.c_str());
+
+  llvm::Optional<llvm::StringRef> ClangRedirects[] = {
+      EchoOutputFile.str(), llvm::StringRef(""), ClangErrFile.str()};
+  llvm::StringRef Args[] = {"clang",
+                            "-xc++",
+                            "-",
+                            "-fsyntax-only",
+                            "-Wall",
+                            "-Wextra",
+                            "-fdiagnostics-format=sarif"};
+
+  int ClangResult =
+      llvm::sys::ExecuteAndWait(ClangPath, Args, llvm::None, ClangRedirects);
+  ASSERT_EQ(ClangResult, 1);
+
+  auto ClangErrBuf = llvm::MemoryBuffer::getFile(ClangErrFile.c_str());
+  ASSERT_TRUE(ClangErrBuf);
+  llvm::StringRef ClangErr = ClangErrBuf.get()->getBuffer();
+  ASSERT_EQ(ClangErr.str(), "hi");
+
+  llvm::Expected<llvm::json::Value> Value = llvm::json::parse(ClangErr.str());
+  ASSERT_FALSE(!Value);
+
+  llvm::json::Object *SarifDoc = Value->getAsObject();
+
+  const llvm::json::Array *Runs = SarifDoc->getArray("runs");
+  const llvm::json::Object *TheRun = Runs->back().getAsObject();
+  const llvm::json::Array *Results = TheRun->getArray("results");
+  
+  // Check Artifacts
+  const llvm::json::Array *Artifacts = TheRun->getArray("artifacts");
+  const llvm::json::Object *TheArtifact = Artifacts->back().getAsObject();
+  const llvm::json::Object *Location = TheArtifact->getObject("location");
+
+  ASSERT_TRUE(Location->getInteger("index").has_value());
+  ASSERT_TRUE(Location->getString("uri").has_value());
+
+  EXPECT_EQ(Location->getInteger("index").value(), 0);
+  EXPECT_EQ(Location->getString("uri").value(), "file://<stdin>");
+
+  // Check Driver
+  const llvm::json::Object *Driver =
+      TheRun->getObject("tool")->getObject("driver");
+
+  ASSERT_TRUE(Driver->getString("name").has_value());
+  ASSERT_TRUE(Driver->getString("fullName").has_value());
+
+  EXPECT_EQ(Driver->getString("name").value(), "clang");
+  EXPECT_EQ(Driver->getString("fullName").value(), "clang-15");
+
+  // Check Rules
+  const llvm::json::Array *Rules = Driver->getArray("rules");
+  std::vector<std::string> IDs;
+
+}
+
+} // namespace