[clang-tidy] Add check name to YAML export

[Alpha]

Summary

Add a field indicating the associated check for every replacement to the YAML report generated with the '-export-fixes' option.
Update clang-apply-replacements to handle the new format.

Follow-up to D16183

[Alpha]

Fix diagnostic deserialization bug for clang-apply-replacements.

[Alpha]

Remove debug symbols.

[Alpha]

Ping

[Alpha]

Ignore export of empty fixes.

[alexfh]

Thank you for resurrecting this patch! A few comments inline.

include/clang/Tooling/Core/Diagnostic.h

36

What are the constraints on the location? Should it be a file location or macro locations are fine too? Please add a (doxygen-style) comment.

58

CheckName is somewhat clang-tidy specific. We need something more generic here, e.g. DiagnosticName, Category or somesuch.

Please add a (doxygen-style) comment to this and other fields here.

69–72

That's too vague. Are you intending to use it only for reporting problems with replacement deduplication? Should it be in this structure at all?

include/clang/Tooling/DiagnosticsYaml.h

83

nit: Formatting is off.

tools/extra/clang-tidy/ClangTidy.cpp

574–575

This function neither fills TUD.MainSourceFile nor TUD.Context (which I'm not sure even belongs to this structure).

575

I somewhat dislike the implicit object slicing that happens here. I'd prefer to make this a loop with explicit conversion.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

116

No need for clang:: here.

[Alpha]

include/clang/Tooling/Core/Diagnostic.h

36

Indeed, this should be a file location.

69–72

This was actually left to keep compatibility with TranslationUnitReplacements which was used for the export.
But it seems that even for that structure, there is in all likelihood no reference to any use of the Context field, except in test cases and in the Yaml IO mapping, where it is marked as an optional entry.
Should it be discarded instead (here, and thus also in TranslationUnitReplacements)?

tools/extra/clang-tidy/ClangTidy.cpp

574–575

Done for MainSourceFile which was surprisingly never exported with the fixes.
For Context, see above comment about the 'TranslationUnitDiagnostics' structure.

[Alpha]

Export effectively MainSourceFile.
Change CheckName field.
Add doxygen-style comments.

[Alpha]

Ping

[Alpha]

Ping

[malcolm.parsons]

What happens to diagnostics without fixes? e.g. from the readability-function-size check.

[Alpha]

This shouldn't affect diagnostics without fixes. If there is no fix, there won't be anything to export, and the diagnostic just behaves normally.

[malcolm.parsons]

In D26137#602591, @Alpha wrote:

This shouldn't affect diagnostics without fixes. If there is no fix, there won't be anything to export, and the diagnostic just behaves normally.

That's a shame; I need a machine readable report of all diagnostics.

[Alpha]

In D26137#602602, @malcolm.parsons wrote:

In D26137#602591, @Alpha wrote:

This shouldn't affect diagnostics without fixes. If there is no fix, there won't be anything to export, and the diagnostic just behaves normally.

That's a shame; I need a machine readable report of all diagnostics.

This is not the aim of this change-set. The objective here is only to associate a replacement to the diagnostic from which it was emitted. But having a parse-able output for all clang-tidy's diagnostics can indeed be a nice feature to add in a different patch.

[Alpha]

Ping

[alexfh]

I'll try to get back to this code review soon. Sorry for the delay.

[alexfh]

Looks mostly good. A few more nits.

include/clang/Tooling/Core/Diagnostic.h

37

nit: Add a trailing period.

69–72

Yes, it seems we can just remove the Context field.

include/clang/Tooling/DiagnosticsYaml.h

36

Initializers for non-trivial members are superfluous. Looks like only DiagLevel initializer makes sense, but I'd use an explicit value for it.

59

clang-format, please

80

Should we copy all diagnostics instead?

tools/extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

38

clang-format, please

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

48–49

It might make sense to move BuildDirectory to clang::Tooling::Diagnostic as well.

[Alpha]

include/clang/Tooling/DiagnosticsYaml.h

80

I am not sure about that. Copying all diagnostics will mean having empty entries in the replacement files with just a check name. This might seem useless, the problem being that at the moment, the only useful exported information in diagnostics are the replacements. I think that if all diagnostics are copied, it must be done in a different patch, with a proper export of all the meaningful information about the diagnostics.
Then, the exported info in clang-tidy will not solely be fixes, but every diagnostic info (which could mean changing the name and meaning of output file and option). What is your feeling about this?

[alexfh]

LG with a comment.

include/clang/Tooling/DiagnosticsYaml.h

80

Please add a FIXME to MappingTraits<clang::tooling::Diagnostic>::mapping to properly export locations, messages, notes, diagnostic levels and all other fields. And a FIXME here to export all diagnostics, not just the ones with fixes.

[alexfh]

Do you have commit access? If you need me to commit the patch for you, please rebase it on top of HEAD.

[Alpha]

Rebase on top of HEAD.

[Alpha]

I don't have commit access.

Thank you for the review @alexfh

[Alpha]

Rebase on top of HEAD.
Ping.

[alexfh]

The patch spans two repos, so I couldn't apply it using arcanist. Just made it "manually" (patch -p0 -i ...); now running tests...

[alexfh]

Looks like compiler has found a couple of bugs:

In file included from llvm.git/tools/clang/tools/extra/clang-tidy/ClangTidy.cpp:38:
llvm.git/tools/clang/include/clang/Tooling/DiagnosticsYaml.h:38:53: error: field 'Message' is uninitialized when used here [-Werror,-Wuninitialized]
        : DiagnosticName(D.DiagnosticName), Message(Message), Fix(D.Fix),
                                                    ^
llvm.git/tools/clang/include/clang/Tooling/DiagnosticsYaml.h:70:7: error: ignoring return value of function declared with warn_unused_result attribute [-Werror,-Wunused-result]
      Keys->Fix[Fix.getFilePath()].add(Fix);
      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~
2 errors generated.

Please fix.

[Alpha]

Fix clang compilation warnings. These didn't appear when compiled on Windows.
Tested on a Linux distribution, should be fixed.

[alexfh]

Have you run the tests? I see a number of failures:

$ ninja check-clang-tools
...
Failing Tests (6):
    Clang Tools :: clang-apply-replacements/basic.cpp
    Clang Tools :: clang-apply-replacements/conflict.cpp
    Clang Tools :: clang-apply-replacements/crlf.cpp
    Clang Tools :: clang-apply-replacements/format.cpp
    Clang Tools :: clang-rename/ClassReplacements.cpp
    Clang Tools :: clang-tidy/clang-tidy-run-with-database.cpp

  Expected Passes    : 488
  Expected Failures  : 1
  Unexpected Failures: 6

[Alpha]

It was tested against the clang extra unit tests, but not tests run with check-clang-tools.
Updated Yaml test files to match the new format, this might need further review.

[Alpha]

Ping.

[Alpha]

Rebase on top of HEAD.
Ping.

[alexfh]

Err, looks like I forgot to post comments I entered a few days ago.

Just a few nits.

include/clang/Tooling/Core/Diagnostic.h

63

nit: No need for tooling::.

lib/Tooling/Core/Diagnostic.cpp

40

nit: No need for tooling::.

tools/extra/clang-tidy/ClangTidy.cpp

106

Why this change?

tools/extra/clang-tidy/ClangTidy.h

245–246

Top-level const on function parameters in function declarations is useless (it's not a part of the function prototype and it tells nothing to the function users). It might make sense on a function definition, if used consistently (same way as on local variables). However, is not very common in LLVM/Clang.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

36

Do we actually need this typedef? How much is the old type name used?

48–49

nit: No need for clang::.

[alexfh]

Looks good.

Fixed the issues myself and running tests before committing this.

Thank you for working on this!

tools/extra/clang-tidy/ClangTidy.cpp

106

Assuming, it was unintentional, changing back to reference.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

36

Removed.

[Alpha]

Thanks for the review!

tools/extra/clang-tidy/ClangTidy.cpp

106

It is indeed unintentional.

tools/extra/clang-tidy/ClangTidy.h

245–246

Ok, this is good to know.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

36

I was quite hesitant with this one, wondering if it would be better to keep clang-tidy specific naming in that case.

include/clang/Tooling/Core/Diagnostic.h

+//===--- Diagnostic.h - Framework for clang diagnostics tools --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+//  Structures supporting diagnostics and refactorings that span multiple
+//  translation units. Indicate diagnostics reports and replacements
+//  suggestions for the analyzed sources.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_CORE_DIAGNOSTIC_H
+#define LLVM_CLANG_TOOLING_CORE_DIAGNOSTIC_H
+
+#include "Replacement.h"
+#include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace clang {
+namespace tooling {
+
+/// \brief Represents the diagnostic message with the error message associated
+/// and the information on the location of the problem.
+struct DiagnosticMessage {
+  DiagnosticMessage(llvm::StringRef Message = "");
+
+  /// \brief Constructs a diagnostic message with anoffset to the diagnostic
+  /// within the file where the problem occured.
+  ///
+  /// \param Loc Should be a file location, it is not meaningful for a macro
+  /// location.
+  ///
+  DiagnosticMessage(llvm::StringRef Message, const SourceManager &Sources,
+                    SourceLocation Loc);
+  std::string Message;
+  std::string FilePath;
+  unsigned FileOffset;
+};
+
+/// \brief Represents the diagnostic with the level of severity and possible
+/// fixes to be applied.
+struct Diagnostic {
+  enum Level {
+    Warning = DiagnosticsEngine::Warning,
+    Error = DiagnosticsEngine::Error
+  };
+
+  Diagnostic() = default;
+
+  Diagnostic(llvm::StringRef DiagnosticName, Level DiagLevel,
+             StringRef BuildDirectory);
+
+  Diagnostic(llvm::StringRef DiagnosticName, DiagnosticMessage &Message,
+             llvm::StringMap<tooling::Replacements> &Fix,
+             SmallVector<DiagnosticMessage, 1> &Notes, Level DiagLevel,
+             llvm::StringRef BuildDirectory);
+
+  /// \brief Name identifying the Diagnostic.
+  std::string DiagnosticName;
+
+  /// \brief Message associated to the diagnostic.
+  DiagnosticMessage Message;
+
+  /// \brief Fixes to apply, grouped by file path.
+  llvm::StringMap<tooling::Replacements> Fix;
+
+  /// \brief Potential notes about the diagnostic.
+  SmallVector<DiagnosticMessage, 1> Notes;
+
+  /// \brief Diagnostic level. Can indicate either an error or a warning.
+  Level DiagLevel;
+
+  /// \brief A build directory of the diagnostic source file.
+  ///
+  /// It's an absolute path which is `directory` field of the source file in
+  /// compilation database. If users don't specify the compilation database
+  /// directory, it is the current directory where clang-tidy runs.
+  ///
+  /// Note: it is empty in unittest.
+  std::string BuildDirectory;
+};
+
+/// \brief Collection of Diagnostics generated from a single translation unit.
+struct TranslationUnitDiagnostics {
+  /// Name of the main source for the translation unit.
+  std::string MainSourceFile;
+  std::vector<Diagnostic> Diagnostics;
+};
+
+} // end namespace tooling
+} // end namespace clang
+#endif // LLVM_CLANG_TOOLING_CORE_DIAGNOSTIC_H

include/clang/Tooling/Core/Replacement.h

 /// `llvm::toString()` and 'std::error_code` in the `Error` should be ignored).
 llvm::Expected<std::string> applyAllReplacements(StringRef Code,
                                                  const Replacements &Replaces);
 
 /// \brief Collection of Replacements generated from a single translation unit.
 struct TranslationUnitReplacements {
   /// Name of the main source for the translation unit.
   std::string MainSourceFile;
-
-  /// A freeform chunk of text to describe the context of the replacements.
-  /// Will be printed, for example, when detecting conflicts during replacement
-  /// deduplication.
-  std::string Context;
-
   std::vector<Replacement> Replacements;
 };
 
 /// \brief Calculates the new ranges after \p Replaces are applied. These
 /// include both the original \p Ranges and the affected ranges of \p Replaces
 /// in the new code.
 ///
 /// \pre Replacements must be for the same file.

include/clang/Tooling/DiagnosticsYaml.h

+//===-- DiagnosticsYaml.h -- Serialiazation for Diagnosticss ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file defines the structure of a YAML document for serializing
+/// diagnostics.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_DIAGNOSTICSYAML_H
+#define LLVM_CLANG_TOOLING_DIAGNOSTICSYAML_H
+
+#include "clang/Tooling/Core/Diagnostic.h"
+#include "clang/Tooling/ReplacementsYaml.h"
+#include "llvm/Support/YAMLTraits.h"
+#include <string>
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(clang::tooling::Diagnostic)
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<clang::tooling::Diagnostic> {
+  /// \brief Helper to (de)serialize a Diagnostic since we don't have direct
+  /// access to its data members.
+  class NormalizedDiagnostic {
+  public:
+    NormalizedDiagnostic(const IO &)
+        : DiagLevel(clang::tooling::Diagnostic::Level::Warning) {}
+
+    NormalizedDiagnostic(const IO &, const clang::tooling::Diagnostic &D)
+        : DiagnosticName(D.DiagnosticName), Message(Message), Fix(D.Fix),
+          Notes(D.Notes), DiagLevel(D.DiagLevel),
+          BuildDirectory(D.BuildDirectory) {}
+
+    clang::tooling::Diagnostic denormalize(const IO &) {
+      return clang::tooling::Diagnostic(DiagnosticName, Message, Fix, Notes,
+                                        DiagLevel, BuildDirectory);
+    }
+
+    std::string DiagnosticName;
+    clang::tooling::DiagnosticMessage Message;
+    llvm::StringMap<clang::tooling::Replacements> Fix;
+    SmallVector<clang::tooling::DiagnosticMessage, 1> Notes;
+    clang::tooling::Diagnostic::Level DiagLevel;
+    std::string BuildDirectory;
+  };
+
+  static void mapping(IO &Io, clang::tooling::Diagnostic &D) {
+    MappingNormalization<NormalizedDiagnostic, clang::tooling::Diagnostic> Keys(
+        Io, D);
+    Io.mapRequired("DiagnosticName", Keys->DiagnosticName);
+
+    // FIXME: Export properly all the different fields.
+
+    std::vector<clang::tooling::Replacement> Fixes;
+    for (auto &Replacements : Keys->Fix) {
+      for (auto &Replacement : Replacements.second) {
+        Fixes.push_back(Replacement);
+      }
+    }
+    Io.mapRequired("Replacements", Fixes);
+    for (auto &Fix : Fixes) {
+      Keys->Fix[Fix.getFilePath()].add(Fix);
+    }
+  }
+};
+
+/// \brief Specialized MappingTraits to describe how a
+/// TranslationUnitDiagnostics is (de)serialized.
+template <> struct MappingTraits<clang::tooling::TranslationUnitDiagnostics> {
+  static void mapping(IO &Io, clang::tooling::TranslationUnitDiagnostics &Doc) {
+    Io.mapRequired("MainSourceFile", Doc.MainSourceFile);
+    std::vector<clang::tooling::Diagnostic> Diagnostics;
+    for (auto &Diagnostic : Doc.Diagnostics) {
+      // FIXME: Export all diagnostics, not just the ones with fixes.
+      // Update MappingTraits<clang::tooling::Diagnostic>::mapping.
+      if (Diagnostic.Fix.size() > 0) {
+        Diagnostics.push_back(Diagnostic);
+      }
+    }
+    Io.mapRequired("Diagnostics", Diagnostics);
+    Doc.Diagnostics = Diagnostics;
+  }
+};
+} // end namespace yaml
+} // end namespace llvm
+
+#endif // LLVM_CLANG_TOOLING_DIAGNOSTICSYAML_H

include/clang/Tooling/ReplacementsYaml.h

 };
 
 /// \brief Specialized MappingTraits to describe how a
 /// TranslationUnitReplacements is (de)serialized.
 template <> struct MappingTraits<clang::tooling::TranslationUnitReplacements> {
   static void mapping(IO &Io,
                       clang::tooling::TranslationUnitReplacements &Doc) {
     Io.mapRequired("MainSourceFile", Doc.MainSourceFile);
-    Io.mapOptional("Context", Doc.Context, std::string());
     Io.mapRequired("Replacements", Doc.Replacements);
   }
 };
 } // end namespace yaml
 } // end namespace llvm
 
 #endif

lib/Tooling/Core/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangToolingCore
   Lookup.cpp
   Replacement.cpp
   QualTypeNames.cpp
+  Diagnostic.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   clangRewrite
   )

lib/Tooling/Core/Diagnostic.cpp

+//===--- Diagnostic.cpp - Framework for clang diagnostics tools ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  Implements classes to support/store diagnostics refactoring.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Tooling/Core/Diagnostic.h"
+#include "clang/Basic/SourceManager.h"
+
+namespace clang {
+namespace tooling {
+
+DiagnosticMessage::DiagnosticMessage(llvm::StringRef Message)
+    : Message(Message), FileOffset(0) {}
+
+DiagnosticMessage::DiagnosticMessage(llvm::StringRef Message,
+                                     const SourceManager &Sources,
+                                     SourceLocation Loc)
+    : Message(Message) {
+  assert(Loc.isValid() && Loc.isFileID());
+  FilePath = Sources.getFilename(Loc);
+  FileOffset = Sources.getFileOffset(Loc);
+}
+
+Diagnostic::Diagnostic(llvm::StringRef DiagnosticName,
+                       Diagnostic::Level DiagLevel, StringRef BuildDirectory)
+    : DiagnosticName(DiagnosticName), DiagLevel(DiagLevel) {}
+
+Diagnostic::Diagnostic(llvm::StringRef DiagnosticName,
+                       DiagnosticMessage &Message,
+                       llvm::StringMap<tooling::Replacements> &Fix,
+                       SmallVector<DiagnosticMessage, 1> &Notes,
+                       Level DiagLevel, llvm::StringRef BuildDirectory)
+    : DiagnosticName(DiagnosticName), Message(Message), Fix(Fix), Notes(Notes),
+      DiagLevel(DiagLevel), BuildDirectory(BuildDirectory) {}
+
+} // end namespace tooling
+} // end namespace clang

tools/extra/clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h

 /// \brief This file provides the interface for deduplicating, detecting
 /// conflicts in, and applying collections of Replacements.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_APPLYREPLACEMENTS_H
 #define LLVM_CLANG_APPLYREPLACEMENTS_H
 
+#include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <system_error>
 #include <vector>
 
 namespace clang {
 
 class DiagnosticsEngine;
 class Rewriter;
 
 namespace format {
 struct FormatStyle;
 } // end namespace format
 
 namespace replace {
 
 /// \brief Collection of source ranges.
 typedef std::vector<clang::tooling::Range> RangeVector;
 
-/// \brief Collection of TranslationUnitReplacements.
-typedef std::vector<clang::tooling::TranslationUnitReplacements> TUReplacements;
+/// \brief Collection of TranslationUniDiagnostics.
+typedef std::vector<clang::tooling::TranslationUnitDiagnostics> TUDiagnostics;
 
-/// \brief Collection of TranslationUnitReplacement files.
-typedef std::vector<std::string> TUReplacementFiles;
+/// \brief Collection of TranslationUnitDiagnostic files.
+typedef std::vector<std::string> TUDiagnosticFiles;
 
 /// \brief Map mapping file name to Replacements targeting that file.
 typedef llvm::DenseMap<const clang::FileEntry *,
                        std::vector<clang::tooling::Replacement>>
     FileToReplacementsMap;
 
 /// \brief Recursively descends through a directory structure rooted at \p
 /// Directory and attempts to deserialize *.yaml files as
 /// TranslationUnitReplacements. All docs that successfully deserialize are
 /// added to \p TUs.
 ///
 /// Directories starting with '.' are ignored during traversal.
 ///
 /// \param[in] Directory Directory to begin search for serialized
 /// TranslationUnitReplacements.
 /// \param[out] TUs Collection of all found and deserialized
 /// TranslationUnitReplacements.
 /// \param[out] TURFiles Collection of all TranslationUnitReplacement files
 /// found in \c Directory.
 /// \param[in] Diagnostics DiagnosticsEngine used for error output.
 ///
 /// \returns An error_code indicating success or failure in navigating the
 /// directory structure.
-std::error_code collectReplacementsFromDirectory(
-    const llvm::StringRef Directory, TUReplacements &TUs,
-    TUReplacementFiles &TURFiles, clang::DiagnosticsEngine &Diagnostics);
+std::error_code
+collectReplacementsFromDirectory(const llvm::StringRef Directory,
+                                 TUDiagnostics &TUs,
+                                 TUDiagnosticFiles &TURFiles,
+                                 clang::DiagnosticsEngine &Diagnostics);
 
 /// \brief Deduplicate, check for conflicts, and apply all Replacements stored
 /// in \c TUs. If conflicts occur, no Replacements are applied.
 ///
 /// \post For all (key,value) in GroupedReplacements, value[i].getOffset() <=
 /// value[i+1].getOffset().
 ///
 /// \param[in] TUs Collection of TranslationUnitReplacements to merge,
 /// deduplicate, and test for conflicts.
 /// \param[out] GroupedReplacements Container grouping all Replacements by the
 /// file they target.
 /// \param[in] SM SourceManager required for conflict reporting.
 ///
 /// \returns \parblock
 ///          \li true If all changes were applied successfully.
 ///          \li false If there were conflicts.
-bool mergeAndDeduplicate(const TUReplacements &TUs,
+bool mergeAndDeduplicate(const TUDiagnostics &TUs,
                          FileToReplacementsMap &GroupedReplacements,
                          clang::SourceManager &SM);
 
 // FIXME: Remove this function after changing clang-apply-replacements to use
 // Replacements class.
 bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
                           Rewriter &Rewrite);
 
bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
                        clang::Rewriter &Rewrites);
 
 /// \brief Given a collection of Replacements for a single file, produces a list
 /// of source ranges that enclose those Replacements.
 ///
 /// \pre Replacements[i].getOffset() <= Replacements[i+1].getOffset().
 ///
 /// \param[in] Replacements Replacements from a single file.
-///
+/// 
 /// \returns Collection of source ranges that enclose all given Replacements.
 /// One range is created for each replacement.
 RangeVector calculateChangedRanges(
     const std::vector<clang::tooling::Replacement> &Replacements);
 
 /// \brief Write the contents of \c FileContents to disk. Keys of the map are
 /// filenames and values are the new contents for those files.
 ///
 /// \param[in] Rewrites Rewriter containing written files to write to disk.
 bool writeFiles(const clang::Rewriter &Rewrites);
 
-/// \brief Delete the replacement files.
+/// \brief Delete the diagnostic files.
 ///
-/// \param[in] Files Replacement files to delete.
+/// \param[in] Files Diagnosic files to delete.
 /// \param[in] Diagnostics DiagnosticsEngine used for error output.
 ///
 /// \returns \parblock
 ///          \li true If all files have been deleted successfully.
 ///          \li false If at least one or more failures occur when deleting
 /// files.
-bool deleteReplacementFiles(const TUReplacementFiles &Files,
-                            clang::DiagnosticsEngine &Diagnostics);
+bool deleteDiagnosticFiles(const TUDiagnosticFiles &Files,
 
 } // end namespace replace
 } // end namespace clang
 
 #endif // LLVM_CLANG_APPLYREPLACEMENTS_H

tools/extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

 ///
 //===----------------------------------------------------------------------===//
 #include "clang-apply-replacements/Tooling/ApplyReplacements.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/ReplacementsYaml.h"
+#include "clang/Tooling/DiagnosticsYaml.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace clang;
 
 static void eatDiagnostics(const SMDiagnostic &, void *) {}
 
 namespace clang {
 namespace replace {
 
 std::error_code collectReplacementsFromDirectory(
-    const llvm::StringRef Directory, TUReplacements &TUs,
-    TUReplacementFiles &TURFiles, clang::DiagnosticsEngine &Diagnostics) {
+    const llvm::StringRef Directory, TUDiagnostics &TUs,
+    TUDiagnosticFiles &TURFiles, clang::DiagnosticsEngine &Diagnostics) {
   using namespace llvm::sys::fs;
   using namespace llvm::sys::path;
 
   std::error_code ErrorCode;
 
   for (recursive_directory_iterator I(Directory, ErrorCode), E;
        I != E && !ErrorCode; I.increment(ErrorCode)) {
     if (filename(I->path())[0] == '.') {
ErrorOr<std::unique_ptr<MemoryBuffer>> Out =
         MemoryBuffer::getFile(I->path());
     if (std::error_code BufferError = Out.getError()) {
       errs() << "Error reading " << I->path() << ": " << BufferError.message()
              << "\n";
       continue;
     }
 
     yaml::Input YIn(Out.get()->getBuffer(), nullptr, &eatDiagnostics);
-    tooling::TranslationUnitReplacements TU;
+    tooling::TranslationUnitDiagnostics TU;
     YIn >> TU;
     if (YIn.error()) {
       // File doesn't appear to be a header change description. Ignore it.
       continue;
     }
 
     // Only keep files that properly parse.
     TUs.push_back(TU);
for (const tooling::Range &Conflict : Conflicts) {
           &Replacements[Conflict.getOffset()], Conflict.getLength());
       reportConflict(Entry, ConflictingReplacements, SM);
     }
   }
 
   return conflictsFound;
 }
 
-bool mergeAndDeduplicate(const TUReplacements &TUs,
+bool mergeAndDeduplicate(const TUDiagnostics &TUs,
                          FileToReplacementsMap &GroupedReplacements,
                          clang::SourceManager &SM) {
 
   // Group all replacements by target file.
   std::set<StringRef> Warned;
   for (const auto &TU : TUs) {
-    for (const tooling::Replacement &R : TU.Replacements) {
+    for (const auto &D : TU.Diagnostics) {
+      for (const auto &Fix : D.Fix) {
+        for (const tooling::Replacement &R : Fix.second) {
           // Use the file manager to deduplicate paths. FileEntries are
           // automatically canonicalized.
           const FileEntry *Entry = SM.getFileManager().getFile(R.getFilePath());
           if (!Entry && Warned.insert(R.getFilePath()).second) {
             errs() << "Described file '" << R.getFilePath()
                    << "' doesn't exist. Ignoring...\n";
             continue;
           }
           GroupedReplacements[Entry].push_back(R);
         }
       }
+    }
+  }
 
   // Ask clang to deduplicate and report conflicts.
   return !deduplicateAndDetectConflicts(GroupedReplacements, SM);
 }
 
 bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
                        clang::Rewriter &Rewrites) {
 
if (EC) {
       continue;
     }
     BufferI->second.write(FileStream);
   }
 
   return true;
 }
 
-bool deleteReplacementFiles(const TUReplacementFiles &Files,
-                            clang::DiagnosticsEngine &Diagnostics) {
+bool deleteDiagnosticFiles(const TUDiagnosticFiles &Files,
   bool Success = true;
   for (const auto &Filename : Files) {
     std::error_code Error = llvm::sys::fs::remove(Filename);
     if (Error) {
       Success = false;
       // FIXME: Use Diagnostics for outputting errors.
       errs() << "Error deleting file: " << Filename << "\n";
       errs() << Error.message() << "\n";
       errs() << "Please delete the file manually\n";
     }
   }
   return Success;
 }
 
 } // end namespace replace
 } // end namespace clang

tools/extra/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

static cl::opt<std::string> Directory(cl::Positional, cl::Required,
                                       cl::desc("<Search Root Directory>"));
 
 static cl::OptionCategory ReplacementCategory("Replacement Options");
 static cl::OptionCategory FormattingCategory("Formatting Options");
 
 const cl::OptionCategory *VisibleCategories[] = {&ReplacementCategory,
                                                  &FormattingCategory};
 
-static cl::opt<bool> RemoveTUReplacementFiles(
+static cl::opt<bool> RemoveTUDiagnosticFiles(
     "remove-change-desc-files",
     cl::desc("Remove the change description files regardless of successful\n"
              "merging/replacing."),
     cl::init(false), cl::cat(ReplacementCategory));
 
 static cl::opt<bool> DoFormat(
     "format",
     cl::desc("Enable formatting of code changed by applying replacements.\n"
cl::desc("Path to a directory containing a .clang-format file\n"
              "code when -style=file.\n"),
     cl::init(""), cl::cat(FormattingCategory));
 
 static cl::opt<std::string>
     FormatStyleOpt("style", cl::desc(format::StyleOptionHelpDescription),
                    cl::init("LLVM"), cl::cat(FormattingCategory));
 
 namespace {
-// Helper object to remove the TUReplacement files (triggered by
+// Helper object to remove the TUDiagnostic files (triggered by
 // "remove-change-desc-files" command line option) when exiting current scope.
 class ScopedFileRemover {
 public:
-  ScopedFileRemover(const TUReplacementFiles &Files,
+  ScopedFileRemover(const TUDiagnosticFiles &Files,
                     clang::DiagnosticsEngine &Diagnostics)
-      : TURFiles(Files), Diag(Diagnostics) {}
+      : TUDFiles(Files), Diag(Diagnostics) {}
 
-  ~ScopedFileRemover() { deleteReplacementFiles(TURFiles, Diag); }
+  ~ScopedFileRemover() { deleteDiagnosticFiles(TUDFiles, Diag); }
 
 private:
-  const TUReplacementFiles &TURFiles;
+  const TUDiagnosticFiles &TUDFiles;
   clang::DiagnosticsEngine &Diag;
 };
 } // namespace
 
 static void printVersion() {
   outs() << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n";
 }
 
int main(int argc, char **argv) {
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), DiagOpts.get());
 
   // Determine a formatting style from options.
   format::FormatStyle FormatStyle;
   if (DoFormat)
     FormatStyle = format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
 
-  TUReplacements TUs;
-  TUReplacementFiles TURFiles;
-
+  TUDiagnostics TUs;
+  TUDiagnosticFiles TUDFiles;
   std::error_code ErrorCode =
-      collectReplacementsFromDirectory(Directory, TUs, TURFiles, Diagnostics);
+      collectReplacementsFromDirectory(Directory, TUs, TUDFiles, Diagnostics);
 
   if (ErrorCode) {
     errs() << "Trouble iterating over directory '" << Directory
            << "': " << ErrorCode.message() << "\n";
     return 1;
   }
 
-  // Remove the TUReplacementFiles (triggered by "remove-change-desc-files"
+  // Remove the TUDiagnosticFiles (triggered by "remove-change-desc-files"
   // command line option) when exiting main().
   std::unique_ptr<ScopedFileRemover> Remover;
-  if (RemoveTUReplacementFiles)
-    Remover.reset(new ScopedFileRemover(TURFiles, Diagnostics));
+  if (RemoveTUDiagnosticFiles)
+    Remover.reset(new ScopedFileRemover(TUDFiles, Diagnostics));
 
   FileManager Files((FileSystemOptions()));
   SourceManager SM(Diagnostics, Files);
 
   FileToReplacementsMap GroupedReplacements;
   if (!mergeAndDeduplicate(TUs, GroupedReplacements, SM))
     return 1;
 

tools/extra/clang-tidy/ClangTidy.h

 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied and reformatted. If no
 /// clang-format configuration file is found, the given \P FormatStyle is used.
 void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
                   StringRef FormatStyle, unsigned &WarningsAsErrorsCount);
 
 /// \brief Serializes replacements into YAML and writes them to the specified
 /// output stream.
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
+void exportReplacements(const StringRef MainFilePath,
+                        const std::vector<ClangTidyError> &Errors,
                         raw_ostream &OS);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H

tools/extra/clang-tidy/ClangTidy.cpp

 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
+#include "clang/Tooling/DiagnosticsYaml.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <algorithm>
 #include <utility>
 
ErrorReporter(bool ApplyFixes, StringRef FormatStyle)
         AppliedFixes(0), WarningsAsErrors(0), FormatStyle(FormatStyle) {
     DiagOpts->ShowColors = llvm::sys::Process::StandardOutHasColors();
     DiagPrinter->BeginSourceFile(LangOpts);
   }
 
   SourceManager &getSourceManager() { return SourceMgr; }
 
   void reportDiagnostic(const ClangTidyError &Error) {
     const ClangTidyMessage &Message = Error.Message;
     SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
     // Contains a pair for each attempted fix: location and whether the fix was
     // applied successfully.
     SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
     {
       auto Level = static_cast<DiagnosticsEngine::Level>(Error.DiagLevel);
-      std::string Name = Error.CheckName;
+      std::string Name = Error.DiagnosticName;
       if (Error.IsWarningAsError) {
         Name += ",-warnings-as-errors";
         Level = DiagnosticsEngine::Error;
         WarningsAsErrors++;
       }
       auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
                   << Message.Message << Name;
       for (const auto &FileAndReplacements : Error.Fix) {
for (const ClangTidyError &Error : Errors) {
     Reporter.reportDiagnostic(Error);
     // Return to the initial directory to correctly resolve next Error.
     FileSystem.setCurrentWorkingDirectory(InitialWorkingDir.get());
   }
   Reporter.Finish();
   WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
 }
 
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
+void exportReplacements(const llvm::StringRef MainFilePath,
+                        const std::vector<ClangTidyError> &Errors,
                         raw_ostream &OS) {
-  TranslationUnitReplacements TUR;
-  for (const ClangTidyError &Error : Errors) {
-    for (const auto &FileAndFixes : Error.Fix)
-      TUR.Replacements.insert(TUR.Replacements.end(),
-                              FileAndFixes.second.begin(),
-                              FileAndFixes.second.end());
+  TranslationUnitDiagnostics TUD;
+  TUD.MainSourceFile = MainFilePath;
+  for (const auto &Error : Errors) {
+    tooling::Diagnostic Diag = Error;
+    TUD.Diagnostics.insert(TUD.Diagnostics.end(), Diag);
   }
-
   yaml::Output YAML(OS);
-  YAML << TUR;
+  YAML << TUD;
 }
 
 } // namespace tidy
 } // namespace clang

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 //===--- ClangTidyDiagnosticConsumer.h - clang-tidy -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Timer.h"
 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
 namespace ast_matchers {
 class MatchFinder;
 }
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
-/// \brief A message from a clang-tidy check.
-///
-/// Note that this is independent of a \c SourceManager.
-struct ClangTidyMessage {
-  ClangTidyMessage(StringRef Message = "");
-  ClangTidyMessage(StringRef Message, const SourceManager &Sources,
-                   SourceLocation Loc);
-  std::string Message;
-  std::string FilePath;
-  unsigned FileOffset;
-};
+typedef clang::tooling::DiagnosticMessage ClangTidyMessage;
 
 /// \brief A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.
 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
-struct ClangTidyError {
-  enum Level {
-    Warning = DiagnosticsEngine::Warning,
-    Error = DiagnosticsEngine::Error
-  };
-
+struct ClangTidyError : clang::tooling::Diagnostic {
   ClangTidyError(StringRef CheckName, Level DiagLevel, bool IsWarningAsError,
                  StringRef BuildDirectory);
 
-  std::string CheckName;
-  ClangTidyMessage Message;
-  // Fixes grouped by file path.
-  llvm::StringMap<tooling::Replacements> Fix;
-  SmallVector<ClangTidyMessage, 1> Notes;
-
-  // A build directory of the diagnostic source file.
-  //
-  // It's an absolute path which is `directory` field of the source file in
-  // compilation database. If users don't specify the compilation database
-  // directory, it is the current directory where clang-tidy runs.
-  //
-  // Note: it is empty in unittest.
-  std::string BuildDirectory;
-
-  Level DiagLevel;
   bool IsWarningAsError;
 };
 
 /// \brief Read-only set of strings represented as a list of positive and
 /// negative globs. Positive globs add all matched strings to the set, negative
 /// globs remove them in the order of appearance in the list.
 class GlobList {
 public:
   /// \brief \p GlobList is a comma-separated list of globs (only '*'

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

void emitDiagnosticMessage(SourceLocation Loc, PresumedLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              const SourceManager *SM,
                              DiagOrStoredDiag Info) override {
     // Remove check name from the message.
     // FIXME: Remove this once there's a better way to pass check names than
     // appending the check name to the message in ClangTidyContext::diag and
     // using getCustomDiagID.
-    std::string CheckNameInMessage = " [" + Error.CheckName + "]";
+    std::string CheckNameInMessage = " [" + Error.DiagnosticName + "]";
     if (Message.endswith(CheckNameInMessage))
       Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
 
     ClangTidyMessage TidyMessage = Loc.isValid()
                                        ? ClangTidyMessage(Message, *SM, Loc)
                                        : ClangTidyMessage(Message);
     if (Level == DiagnosticsEngine::Note) {
       Error.Notes.push_back(TidyMessage);
void endDiagnostic(DiagOrStoredDiag D,
     assert(!Error.Message.Message.empty() && "Message has not been set");
   }
 
 private:
   ClangTidyError &Error;
 };
 } // end anonymous namespace
 
-ClangTidyMessage::ClangTidyMessage(StringRef Message)
-    : Message(Message), FileOffset(0) {}
-
-ClangTidyMessage::ClangTidyMessage(StringRef Message,
-                                   const SourceManager &Sources,
-                                   SourceLocation Loc)
-    : Message(Message) {
-  assert(Loc.isValid() && Loc.isFileID());
-  FilePath = Sources.getFilename(Loc);
-  FileOffset = Sources.getFileOffset(Loc);
-}
-
 ClangTidyError::ClangTidyError(StringRef CheckName,
                                ClangTidyError::Level DiagLevel,
                                bool IsWarningAsError, StringRef BuildDirectory)
-    : CheckName(CheckName), BuildDirectory(BuildDirectory),
-      DiagLevel(DiagLevel), IsWarningAsError(IsWarningAsError) {}
+    : tooling::Diagnostic(CheckName, DiagLevel, BuildDirectory),
+      IsWarningAsError(IsWarningAsError) {}
 
 // Returns true if GlobList starts with the negative indicator ('-'), removes it
 // from the GlobList.
 static bool ConsumeNegativeIndicator(StringRef &GlobList) {
   if (GlobList.startswith("-")) {
     GlobList = GlobList.substr(1);
     return true;
   }
Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
       /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
-    if (!Context.getChecksFilter().contains(Error.CheckName) &&
+    if (!Context.getChecksFilter().contains(Error.DiagnosticName) &&
         Error.DiagLevel != ClangTidyError::Error) {
       ++Context.Stats.ErrorsIgnoredCheckFilter;
       Errors.pop_back();
     } else if (!LastErrorRelatesToUserCode) {
       ++Context.Stats.ErrorsIgnoredNonUserCode;
       Errors.pop_back();
     } else if (!LastErrorPassesLineFilter) {
       ++Context.Stats.ErrorsIgnoredLineFilter;

tools/extra/clang-tidy/tool/ClangTidyMain.cpp

static int clangTidyMain(int argc, const char **argv) {
 
   if (!ExportFixes.empty() && !Errors.empty()) {
     std::error_code EC;
     llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
     if (EC) {
       llvm::errs() << "Error opening output file: " << EC.message() << '\n';
       return 1;
     }
-    exportReplacements(Errors, OS);
+    exportReplacements(FilePath.str(), Errors, OS);
   }
 
   printStats(Stats);
   if (DisableFixes)
     llvm::errs()
         << "Found compiler errors, but -fix-errors was not specified.\n"
            "Fixes have NOT been applied.\n\n";
 

unittests/Tooling/ReplacementsYamlTest.cpp

 using namespace llvm;
 using namespace clang::tooling;
 
 TEST(ReplacementsYamlTest, serializesReplacements) {
 
   TranslationUnitReplacements Doc;
 
   Doc.MainSourceFile = "/path/to/source.cpp";
-  Doc.Context = "some context";
-  Doc.Replacements
-      .push_back(Replacement("/path/to/file1.h", 232, 56, "replacement #1"));
-  Doc.Replacements
-      .push_back(Replacement("/path/to/file2.h", 301, 2, "replacement #2"));
+  Doc.Replacements.push_back(
+      Replacement("/path/to/file1.h", 232, 56, "replacement #1"));
+  Doc.Replacements.push_back(
+      Replacement("/path/to/file2.h", 301, 2, "replacement #2"));
 
   std::string YamlContent;
   llvm::raw_string_ostream YamlContentStream(YamlContent);
 
   yaml::Output YAML(YamlContentStream);
   YAML << Doc;
 
   // NOTE: If this test starts to fail for no obvious reason, check whitespace.
   ASSERT_STREQ("---\n"
                "MainSourceFile:  /path/to/source.cpp\n"
-               "Context:         some context\n"
                "Replacements:    \n" // Extra whitespace here!
                "  - FilePath:        /path/to/file1.h\n"
                "    Offset:          232\n"
                "    Length:          56\n"
                "    ReplacementText: 'replacement #1'\n"
                "  - FilePath:        /path/to/file2.h\n"
                "    Offset:          301\n"
                "    Length:          2\n"
                "    ReplacementText: 'replacement #2'\n"
                "...\n",
                YamlContentStream.str().c_str());
 }
 
 TEST(ReplacementsYamlTest, deserializesReplacements) {
   std::string YamlContent = "---\n"
                             "MainSourceFile:      /path/to/source.cpp\n"
-                            "Context:             some context\n"
                             "Replacements:\n"
                             "  - FilePath:        /path/to/file1.h\n"
                             "    Offset:          232\n"
                             "    Length:          56\n"
                             "    ReplacementText: 'replacement #1'\n"
                             "  - FilePath:        /path/to/file2.h\n"
                             "    Offset:          301\n"
                             "    Length:          2\n"
                             "    ReplacementText: 'replacement #2'\n"
                             "...\n";
   TranslationUnitReplacements DocActual;
   yaml::Input YAML(YamlContent);
   YAML >> DocActual;
   ASSERT_FALSE(YAML.error());
   ASSERT_EQ(2u, DocActual.Replacements.size());
   ASSERT_EQ("/path/to/source.cpp", DocActual.MainSourceFile);
-  ASSERT_EQ("some context", DocActual.Context);
   ASSERT_EQ("/path/to/file1.h", DocActual.Replacements[0].getFilePath());
   ASSERT_EQ(232u, DocActual.Replacements[0].getOffset());
   ASSERT_EQ(56u, DocActual.Replacements[0].getLength());
   ASSERT_EQ("replacement #1", DocActual.Replacements[0].getReplacementText());
   ASSERT_EQ("/path/to/file2.h", DocActual.Replacements[1].getFilePath());
   ASSERT_EQ(301u, DocActual.Replacements[1].getOffset());
   ASSERT_EQ(2u, DocActual.Replacements[1].getLength());
   ASSERT_EQ("replacement #2", DocActual.Replacements[1].getReplacementText());
std::string YamlContent = "---\n"
                             "    ReplacementText: replacement\n"
                             "...\n";
   TranslationUnitReplacements DocActual;
   yaml::Input YAML(YamlContent);
   YAML >> DocActual;
   ASSERT_FALSE(YAML.error());
   ASSERT_EQ("/path/to/source.cpp", DocActual.MainSourceFile);
   ASSERT_EQ(1u, DocActual.Replacements.size());
-  ASSERT_EQ(std::string(), DocActual.Context);
   ASSERT_EQ("target_file.h", DocActual.Replacements[0].getFilePath());
   ASSERT_EQ(1u, DocActual.Replacements[0].getOffset());
   ASSERT_EQ(10u, DocActual.Replacements[0].getLength());
   ASSERT_EQ("replacement", DocActual.Replacements[0].getReplacementText());
 }