[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

35 ↗

(On Diff #77029)

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.

57 ↗

(On Diff #77029)

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.

68–71 ↗

(On Diff #77029)

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

82 ↗

(On Diff #77029)

nit: Formatting is off.

tools/extra/clang-tidy/ClangTidy.cpp

578 ↗

(On Diff #77029)

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

579 ↗

(On Diff #77029)

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 ↗

(On Diff #77029)

No need for clang:: here.

[Alpha]

include/clang/Tooling/Core/Diagnostic.h

35 ↗

(On Diff #77029)

Indeed, this should be a file location.

68–71 ↗

(On Diff #77029)

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

578 ↗

(On Diff #77029)

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

36 ↗

(On Diff #77196)

nit: Add a trailing period.

68–71 ↗

(On Diff #77029)

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

include/clang/Tooling/DiagnosticsYaml.h

35 ↗

(On Diff #77196)

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

58 ↗

(On Diff #77196)

clang-format, please

79 ↗

(On Diff #77196)

Should we copy all diagnostics instead?

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

42 ↗

(On Diff #77196)

clang-format, please

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

56 ↗

(On Diff #77196)

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

[Alpha]

include/clang/Tooling/DiagnosticsYaml.h

79 ↗

(On Diff #77196)

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

79 ↗

(On Diff #77196)

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

62 ↗

(On Diff #82860)

nit: No need for tooling::.

lib/Tooling/Core/Diagnostic.cpp

39 ↗

(On Diff #82860)

nit: No need for tooling::.

tools/extra/clang-tidy/ClangTidy.cpp

106 ↗

(On Diff #81779)

Why this change?

tools/extra/clang-tidy/ClangTidy.h

245 ↗

(On Diff #81779)

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

45 ↗

(On Diff #82860)

nit: No need for clang::.

36 ↗

(On Diff #81779)

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

[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 ↗

(On Diff #81779)

Assuming, it was unintentional, changing back to reference.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

36 ↗

(On Diff #81779)

Removed.

[Alpha]

Thanks for the review!

tools/extra/clang-tidy/ClangTidy.cpp

106 ↗

(On Diff #81779)

It is indeed unintentional.

tools/extra/clang-tidy/ClangTidy.h

245 ↗

(On Diff #81779)

Ok, this is good to know.

tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h

36 ↗

(On Diff #81779)

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

cfe/trunk/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<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<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

cfe/trunk/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.

cfe/trunk/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(D.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) {
+      llvm::Error Err = Keys->Fix[Fix.getFilePath()].add(Fix);
+      if (Err) {
+        // FIXME: Implement better conflict handling.
+        llvm::errs() << "Fix conflicts with existing fix: "
+                     << llvm::toString(std::move(Err)) << "\n";
+      }
+    }
+  }
+};
+
+/// \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

cfe/trunk/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

cfe/trunk/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
   )

cfe/trunk/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),
+      BuildDirectory(BuildDirectory) {}
+
+Diagnostic::Diagnostic(llvm::StringRef DiagnosticName,
+                       DiagnosticMessage &Message,
+                       llvm::StringMap<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

cfe/trunk/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.emplace_back("/path/to/file1.h", 232, 56, "replacement #1");
+  Doc.Replacements.emplace_back("/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());
 }