[llvm-cov] Refactor "export" command implementation and add support for SOURCES.

[Dor1s]

Summary

Define an interface for Exporter + split JSON exporter into .h and .cpp.

[Dor1s]

Added a test

[Dor1s]

Minor fixes of comments

[Dor1s]

Update the documentation

[vsk]

LGTM.

tools/llvm-cov/CodeCoverage.cpp

 //===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // The 'CodeCoverageTool' class implements a command line tool to analyze and
 // report coverage information using the profiling instrumentation and code
 // coverage mapping.
 //
 //===----------------------------------------------------------------------===//
 
+#include "CoverageExporterJson.h"
 #include "CoverageFilters.h"
 #include "CoverageReport.h"
 #include "CoverageSummaryInfo.h"
 #include "CoverageViewOptions.h"
 #include "RenderingSupport.h"
 #include "SourceCoverageView.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
private:
   void demangleSymbols(const CoverageMapping &Coverage);
 
   /// \brief Write out a source file view to the filesystem.
   void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage,
                            CoveragePrinter *Printer, bool ShowFilenames);
 
   typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;
 
-  int show(int argc, const char **argv,
+  int doShow(int argc, const char **argv,
              CommandLineParserType commandLineParser);
 
-  int report(int argc, const char **argv,
+  int doReport(int argc, const char **argv,
                CommandLineParserType commandLineParser);
 
-  int export_(int argc, const char **argv,
+  int doExport(int argc, const char **argv,
                CommandLineParserType commandLineParser);
 
   std::vector<StringRef> ObjectFilenames;
   CoverageViewOptions ViewOpts;
   CoverageFiltersMatchAll Filters;
 
   /// The path to the indexed profile.
   std::string PGOFilename;
 
auto commandLineParser = [&, this](int argc, const char **argv) -> int {
     ViewOpts.ShowInstantiationSummary = InstantiationSummary;
     ViewOpts.ExportSummaryOnly = SummaryOnly;
 
     return 0;
   };
 
   switch (Cmd) {
   case Show:
-    return show(argc, argv, commandLineParser);
+    return doShow(argc, argv, commandLineParser);
   case Report:
-    return report(argc, argv, commandLineParser);
+    return doReport(argc, argv, commandLineParser);
   case Export:
-    return export_(argc, argv, commandLineParser);
+    return doExport(argc, argv, commandLineParser);
   }
   return 0;
 }
 
-int CodeCoverageTool::show(int argc, const char **argv,
+int CodeCoverageTool::doShow(int argc, const char **argv,
                              CommandLineParserType commandLineParser) {
 
   cl::OptionCategory ViewCategory("Viewing options");
 
   cl::opt<bool> ShowLineExecutionCounts(
       "show-line-counts", cl::Optional,
       cl::desc("Show the execution counts for each line"), cl::init(true),
       cl::cat(ViewCategory));
 
for (const std::string &SourceFile : SourceFiles)
       Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
                  Coverage.get(), Printer.get(), ShowFilenames);
     Pool.wait();
   }
 
   return 0;
 }
 
-int CodeCoverageTool::report(int argc, const char **argv,
+int CodeCoverageTool::doReport(int argc, const char **argv,
                                CommandLineParserType commandLineParser) {
   cl::opt<bool> ShowFunctionSummaries(
       "show-functions", cl::Optional, cl::init(false),
       cl::desc("Show coverage summaries for each function"));
 
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
if (SourceFiles.empty()) {
       return 1;
     }
 
     Report.renderFunctionReports(SourceFiles, DC, llvm::outs());
   }
   return 0;
 }
 
-int CodeCoverageTool::export_(int argc, const char **argv,
+int CodeCoverageTool::doExport(int argc, const char **argv,
                                CommandLineParserType commandLineParser) {
 
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
   if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text) {
     error("Coverage data can only be exported as textual JSON.");
     return 1;
   }
 
   auto Coverage = load();
   if (!Coverage) {
     error("Could not load coverage information");
     return 1;
   }
 
-  exportCoverageDataToJson(*Coverage.get(), ViewOpts, outs());
+  // exportCoverageDataToJson(*Coverage.get(), ViewOpts, outs());
+  auto Exporter = CoverageExporterJson(*Coverage.get(), ViewOpts, outs());
+
+  if (SourceFiles.empty())
+    Exporter.renderRoot();
+  else
+    Exporter.renderRoot(SourceFiles);
 
   return 0;
 }
 
 int showMain(int argc, const char *argv[]) {
   CodeCoverageTool Tool;
   return Tool.run(CodeCoverageTool::Show, argc, argv);
 }

tools/llvm-cov/CoverageExporter.h

+//===- CoverageExporter.h - Code coverage exporter ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class implements a code coverage export functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_COV_COVERAGEEXPORTER_H
+#define LLVM_COV_COVERAGEEXPORTER_H
+
+#include "CoverageSummaryInfo.h"
+#include "CoverageViewOptions.h"
+#include "llvm/ProfileData/Coverage/CoverageMapping.h"
+
+namespace llvm {
+
+/// \brief Exports the code coverage information.
+class CoverageExporter {
+protected:
+  /// \brief The full CoverageMapping object to export.
+  const coverage::CoverageMapping &Coverage;
+
+  const CoverageViewOptions &Options;
+
+  /// \brief Output stream to print JSON to.
+  raw_ostream &OS;
+
+  CoverageExporter(const coverage::CoverageMapping &CoverageMapping,
+                   const CoverageViewOptions &Options, raw_ostream &OS)
+      : Coverage(CoverageMapping), Options(Options), OS(OS) {}
+
+public:
+  virtual ~CoverageExporter(){};
+
+  /// \brief Render the CoverageMapping object.
+  virtual void renderRoot() = 0;
+
+  /// \brief Render the CoverageMapping object for specified source files.
+  virtual void renderRoot(const std::vector<std::string> &SourceFiles) = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_COV_COVERAGEEXPORTER_H

tools/llvm-cov/CoverageExporterJson.h

+//===- CoverageExport.h - Code coverage export ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class implements a code coverage export functionality.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_COV_COVERAGEEXPORTERJSON_H
+#define LLVM_COV_COVERAGEEXPORTERJSON_H
+
+#include "CoverageExporter.h"
+#include <stack>
+
+namespace llvm {
+
+class CoverageExporterJson : public CoverageExporter {
+  /// \brief States that the JSON rendering machine can be in.
+  enum JsonState { None, NonEmptyElement, EmptyElement };
+
+  /// \brief Tracks state of the JSON output.
+  std::stack<JsonState> State;
+
+  /// \brief Emit a serialized scalar.
+  void emitSerialized(const int64_t Value);
+
+  /// \brief Emit a serialized string.
+  void emitSerialized(const std::string &Value);
+
+  /// \brief Emit a comma if there is a previous element to delimit.
+  void emitComma();
+
+  /// \brief Emit a starting dictionary/object character.
+  void emitDictStart();
+
+  /// \brief Emit a dictionary/object key but no value.
+  void emitDictKey(const std::string &Key);
+
+  /// \brief Emit a dictionary/object key/value pair.
+  template <typename V>
+  void emitDictElement(const std::string &Key, const V &Value) {
+    emitComma();
+    emitSerialized(Key);
+    OS << ":";
+    emitSerialized(Value);
+  }
+
+  /// \brief Emit a closing dictionary/object character.
+  void emitDictEnd();
+
+  /// \brief Emit a starting array character.
+  void emitArrayStart();
+
+  /// \brief Emit an array element.
+  template <typename V> void emitArrayElement(const V &Value) {
+    emitComma();
+    emitSerialized(Value);
+  }
+
+  /// \brief emit a closing array character.
+  void emitArrayEnd();
+
+  /// \brief Render an array of all the given functions.
+  void renderFunctions(
+      const iterator_range<coverage::FunctionRecordIterator> &Functions);
+
+  /// \brief Render an array of all the source files, also pass back a Summary.
+  void renderFiles(ArrayRef<std::string> SourceFiles,
+                   ArrayRef<FileCoverageSummary> FileReports);
+
+  /// \brief Render a single file.
+  void renderFile(const coverage::CoverageData &FileCoverage,
+                  const FileCoverageSummary &FileReport);
+
+  /// \brief Render a CoverageSegment.
+  void renderSegment(const coverage::CoverageSegment &Segment);
+
+  /// \brief Render an ExpansionRecord.
+  void renderExpansion(const coverage::ExpansionRecord &Expansion);
+
+  /// \brief Render a list of CountedRegions.
+  void renderRegions(ArrayRef<coverage::CountedRegion> Regions);
+
+  /// \brief Render a single CountedRegion.
+  void renderRegion(const coverage::CountedRegion &Region);
+
+  /// \brief Render a FileCoverageSummary.
+  void renderSummary(const FileCoverageSummary &Summary);
+
+public:
+  CoverageExporterJson(const coverage::CoverageMapping &CoverageMapping,
+                       const CoverageViewOptions &Options, raw_ostream &OS);
+
+  /// \brief Render the CoverageMapping object.
+  void renderRoot() override;
+
+  /// \brief Render the CoverageMapping object for specified source files.
+  void renderRoot(const std::vector<std::string> &SourceFiles) override;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_COV_COVERAGEEXPORTERJSON_H

tools/llvm-cov/CoverageExporterJson.cpp

 // ---- Summary: dict => Object summarizing the coverage for the entire binary
 // ------ LineCoverage: dict => Object summarizing line coverage
 // ------ FunctionCoverage: dict => Object summarizing function coverage
 // ------ InstantiationCoverage: dict => Object summarizing inst. coverage
 // ------ RegionCoverage: dict => Object summarizing region coverage
 //
 //===----------------------------------------------------------------------===//
 
+#include "CoverageExporterJson.h"
 #include "CoverageReport.h"
-#include "CoverageSummaryInfo.h"
-#include "CoverageViewOptions.h"
-#include "llvm/ProfileData/Coverage/CoverageMapping.h"
-#include <stack>
 
 /// \brief The semantic version combined as a string.
 #define LLVM_COVERAGE_EXPORT_JSON_STR "2.0.0"
 
 /// \brief Unique type identifier for JSON coverage export.
 #define LLVM_COVERAGE_EXPORT_JSON_TYPE_STR "llvm.coverage.json.export"
 
 using namespace llvm;
-using namespace coverage;
 
-class CoverageExporterJson {
-  const CoverageViewOptions &Options;
-
-  /// \brief Output stream to print JSON to.
-  raw_ostream &OS;
-
-  /// \brief The full CoverageMapping object to export.
-  const CoverageMapping &Coverage;
-
-  /// \brief States that the JSON rendering machine can be in.
-  enum JsonState { None, NonEmptyElement, EmptyElement };
-
-  /// \brief Tracks state of the JSON output.
-  std::stack<JsonState> State;
+CoverageExporterJson::CoverageExporterJson(
+    const coverage::CoverageMapping &CoverageMapping,
+    const CoverageViewOptions &Options, raw_ostream &OS)
+    : CoverageExporter(CoverageMapping, Options, OS) {
+  State.push(JsonState::None);
+}
 
-  /// \brief Emit a serialized scalar.
-  void emitSerialized(const int64_t Value) { OS << Value; }
+void CoverageExporterJson::emitSerialized(const int64_t Value) { OS << Value; }
 
-  /// \brief Emit a serialized string.
-  void emitSerialized(const std::string &Value) {
-    OS << "\"";
-    for (char C : Value) {
-      if (C != '\\')
-        OS << C;
-      else
-        OS << "\\\\";
-    }
-    OS << "\"";
-  }
+void CoverageExporterJson::emitSerialized(const std::string &Value) {
 
-  /// \brief Emit a comma if there is a previous element to delimit.
-  void emitComma() {
-    if (State.top() == JsonState::NonEmptyElement) {
-      OS << ",";
-    } else if (State.top() == JsonState::EmptyElement) {
-      State.pop();
-      assert((State.size() >= 1) && "Closed too many JSON elements");
-      State.push(JsonState::NonEmptyElement);
-    }
-  }
+void CoverageExporterJson::emitComma() {
 
-  /// \brief Emit a starting dictionary/object character.
-  void emitDictStart() {
-    emitComma();
-    State.push(JsonState::EmptyElement);
-    OS << "{";
-  }
+void CoverageExporterJson::emitDictStart() {
 
-  /// \brief Emit a dictionary/object key but no value.
-  void emitDictKey(const std::string &Key) {
-    emitComma();
-    emitSerialized(Key);
-    OS << ":";
-    State.pop();
-    assert((State.size() >= 1) && "Closed too many JSON elements");
+void CoverageExporterJson::emitDictKey(const std::string &Key) {
 
-    // We do not want to emit a comma after this key.
-    State.push(JsonState::EmptyElement);
-  }
 
-  /// \brief Emit a dictionary/object key/value pair.
-  template <typename V>
-  void emitDictElement(const std::string &Key, const V &Value) {
-    emitComma();
-    emitSerialized(Key);
-    OS << ":";
-    emitSerialized(Value);
-  }
-
-  /// \brief Emit a closing dictionary/object character.
-  void emitDictEnd() {
-    State.pop();
-    assert((State.size() >= 1) && "Closed too many JSON elements");
-    OS << "}";
-  }
+void CoverageExporterJson::emitDictEnd() {
 
-  /// \brief Emit a starting array character.
-  void emitArrayStart() {
-    emitComma();
-    State.push(JsonState::EmptyElement);
-    OS << "[";
-  }
+void CoverageExporterJson::emitArrayStart() {
 
-  /// \brief Emit an array element.
-  template <typename V> void emitArrayElement(const V &Value) {
-    emitComma();
-    emitSerialized(Value);
-  }
-
-  /// \brief emit a closing array character.
-  void emitArrayEnd() {
-    State.pop();
-    assert((State.size() >= 1) && "Closed too many JSON elements");
-    OS << "]";
-  }
+void CoverageExporterJson::emitArrayEnd() {
 
-  /// \brief Render the CoverageMapping object.
-  void renderRoot() {
-    // Start Root of JSON object.
-    emitDictStart();
+void CoverageExporterJson::renderRoot() {
+  std::vector<std::string> SourceFiles;
+  for (StringRef SF : Coverage.getUniqueSourceFiles())
+    SourceFiles.emplace_back(SF);
+  renderRoot(SourceFiles);
+}
+
+void CoverageExporterJson::renderRoot(
+    const std::vector<std::string> &SourceFiles) {
 
-    emitDictElement("version", LLVM_COVERAGE_EXPORT_JSON_STR);
-    emitDictElement("type", LLVM_COVERAGE_EXPORT_JSON_TYPE_STR);
-    emitDictKey("data");
 
-    // Start List of Exports.
-    emitArrayStart();
 
-    // Start Export.
-    emitDictStart();
 
-    emitDictKey("files");
 
-    FileCoverageSummary Totals = FileCoverageSummary("Totals");
-    std::vector<std::string> SourceFiles;
-    for (StringRef SF : Coverage.getUniqueSourceFiles())
-      SourceFiles.emplace_back(SF);
-    auto FileReports = CoverageReport::prepareFileReports(Coverage, Totals,
-                                                          SourceFiles, Options);
-    renderFiles(SourceFiles, FileReports);
 
-    // Skip functions-level information for summary-only export mode.
-    if (!Options.ExportSummaryOnly) {
-      emitDictKey("functions");
-      renderFunctions(Coverage.getCoveredFunctions());
-    }
 
-    emitDictKey("totals");
-    renderSummary(Totals);
 
-    // End Export.
-    emitDictEnd();
 
-    // End List of Exports.
-    emitArrayEnd();
 
-    // End Root of JSON Object.
-    emitDictEnd();
 
-    assert((State.top() == JsonState::None) &&
-           "All Elements In JSON were Closed");
-  }
 
-  /// \brief Render an array of all the given functions.
-  void
-  renderFunctions(const iterator_range<FunctionRecordIterator> &Functions) {
-    // Start List of Functions.
-    emitArrayStart();
+void CoverageExporterJson::renderFunctions(
+    const iterator_range<coverage::FunctionRecordIterator> &Functions) {
 
-    for (const auto &Function : Functions) {
-      // Start Function.
-      emitDictStart();
 
-      emitDictElement("name", Function.Name);
-      emitDictElement("count", Function.ExecutionCount);
-      emitDictKey("regions");
 
-      renderRegions(Function.CountedRegions);
 
-      emitDictKey("filenames");
 
-      // Start Filenames for Function.
-      emitArrayStart();
 
-      for (const auto &FileName : Function.Filenames)
-        emitArrayElement(FileName);
 
-      // End Filenames for Function.
-      emitArrayEnd();
 
-      // End Function.
-      emitDictEnd();
-    }
 
-    // End List of Functions.
-    emitArrayEnd();
-  }
 
-  /// \brief Render an array of all the source files, also pass back a Summary.
-  void renderFiles(ArrayRef<std::string> SourceFiles,
-                   ArrayRef<FileCoverageSummary> FileReports) {
-    // Start List of Files.
-    emitArrayStart();
+void CoverageExporterJson::renderFiles(
+    ArrayRef<std::string> SourceFiles,
 
-    for (unsigned I = 0, E = SourceFiles.size(); I < E; ++I) {
-      // Render the file.
-      auto FileCoverage = Coverage.getCoverageForFile(SourceFiles[I]);
-      renderFile(FileCoverage, FileReports[I]);
-    }
 
-    // End List of Files.
-    emitArrayEnd();
-  }
 
-  /// \brief Render a single file.
-  void renderFile(const CoverageData &FileCoverage,
-                  const FileCoverageSummary &FileReport) {
-    // Start File.
-    emitDictStart();
+void CoverageExporterJson::renderFile(
+    const coverage::CoverageData &FileCoverage,
 
-    emitDictElement("filename", FileCoverage.getFilename());
 
-    // Skip segments and expansions for summary-only export mode.
-    if (!Options.ExportSummaryOnly) {
-      emitDictKey("segments");
 
-      // Start List of Segments.
-      emitArrayStart();
 
-      for (const auto &Segment : FileCoverage)
-        renderSegment(Segment);
 
-      // End List of Segments.
-      emitArrayEnd();
 
-      emitDictKey("expansions");
 
-      // Start List of Expansions.
-      emitArrayStart();
 
-      for (const auto &Expansion : FileCoverage.getExpansions())
-        renderExpansion(Expansion);
 
-      // End List of Expansions.
-      emitArrayEnd();
-    }
 
-    emitDictKey("summary");
-    renderSummary(FileReport);
 
-    // End File.
-    emitDictEnd();
-  }
 
-  /// \brief Render a CoverageSegment.
-  void renderSegment(const CoverageSegment &Segment) {
-    // Start Segment.
-    emitArrayStart();
+void CoverageExporterJson::renderSegment(
+    const coverage::CoverageSegment &Segment) {
 
-    emitArrayElement(Segment.Line);
-    emitArrayElement(Segment.Col);
-    emitArrayElement(Segment.Count);
-    emitArrayElement(Segment.HasCount);
-    emitArrayElement(Segment.IsRegionEntry);
 
-    // End Segment.
-    emitArrayEnd();
-  }
 
-  /// \brief Render an ExpansionRecord.
-  void renderExpansion(const ExpansionRecord &Expansion) {
-    // Start Expansion.
-    emitDictStart();
+void CoverageExporterJson::renderExpansion(
+    const coverage::ExpansionRecord &Expansion) {
 
-    // Mark the beginning and end of this expansion in the source file.
-    emitDictKey("source_region");
-    renderRegion(Expansion.Region);
 
-    // Enumerate the coverage information for the expansion.
-    emitDictKey("target_regions");
-    renderRegions(Expansion.Function.CountedRegions);
 
-    emitDictKey("filenames");
-    // Start List of Filenames to map the fileIDs.
-    emitArrayStart();
-    for (const auto &Filename : Expansion.Function.Filenames)
-      emitArrayElement(Filename);
-    // End List of Filenames.
-    emitArrayEnd();
 
-    // End Expansion.
-    emitDictEnd();
-  }
 
-  /// \brief Render a list of CountedRegions.
-  void renderRegions(ArrayRef<CountedRegion> Regions) {
-    // Start List of Regions.
-    emitArrayStart();
+void CoverageExporterJson::renderRegions(
+    ArrayRef<coverage::CountedRegion> Regions) {
 
-    for (const auto &Region : Regions)
-      renderRegion(Region);
 
-    // End List of Regions.
-    emitArrayEnd();
-  }
 
-  /// \brief Render a single CountedRegion.
-  void renderRegion(const CountedRegion &Region) {
-    // Start CountedRegion.
-    emitArrayStart();
+void CoverageExporterJson::renderRegion(const coverage::CountedRegion &Region) {
 
-    emitArrayElement(Region.LineStart);
-    emitArrayElement(Region.ColumnStart);
-    emitArrayElement(Region.LineEnd);
-    emitArrayElement(Region.ColumnEnd);
-    emitArrayElement(Region.ExecutionCount);
-    emitArrayElement(Region.FileID);
-    emitArrayElement(Region.ExpandedFileID);
-    emitArrayElement(Region.Kind);
 
-    // End CountedRegion.
-    emitArrayEnd();
-  }
 
-  /// \brief Render a FileCoverageSummary.
-  void renderSummary(const FileCoverageSummary &Summary) {
-    // Start Summary for the file.
-    emitDictStart();
+void CoverageExporterJson::renderSummary(const FileCoverageSummary &Summary) {
 
-    emitDictKey("lines");
 
-    // Start Line Coverage Summary.
-    emitDictStart();
-    emitDictElement("count", Summary.LineCoverage.getNumLines());
-    emitDictElement("covered", Summary.LineCoverage.getCovered());
-    emitDictElement("percent", Summary.LineCoverage.getPercentCovered());
-    // End Line Coverage Summary.
-    emitDictEnd();
 
-    emitDictKey("functions");
 
-    // Start Function Coverage Summary.
-    emitDictStart();
-    emitDictElement("count", Summary.FunctionCoverage.getNumFunctions());
-    emitDictElement("covered", Summary.FunctionCoverage.getExecuted());
-    emitDictElement("percent", Summary.FunctionCoverage.getPercentCovered());
-    // End Function Coverage Summary.
-    emitDictEnd();
 
-    emitDictKey("instantiations");
 
-    // Start Instantiation Coverage Summary.
-    emitDictStart();
-    emitDictElement("count", Summary.InstantiationCoverage.getNumFunctions());
-    emitDictElement("covered", Summary.InstantiationCoverage.getExecuted());
-    emitDictElement("percent",
-                    Summary.InstantiationCoverage.getPercentCovered());
-    // End Function Coverage Summary.
-    emitDictEnd();
+  emitDictElement("percent", Summary.InstantiationCoverage.getPercentCovered());
 
-    emitDictKey("regions");
 
-    // Start Region Coverage Summary.
-    emitDictStart();
-    emitDictElement("count", Summary.RegionCoverage.getNumRegions());
-    emitDictElement("covered", Summary.RegionCoverage.getCovered());
-    emitDictElement("notcovered",
-                    Summary.RegionCoverage.getNumRegions() -
+  emitDictElement("notcovered", Summary.RegionCoverage.getNumRegions() -
                                     Summary.RegionCoverage.getCovered());
-    emitDictElement("percent", Summary.RegionCoverage.getPercentCovered());
-    // End Region Coverage Summary.
-    emitDictEnd();
 
-    // End Summary for the file.
-    emitDictEnd();
-  }
-
-public:
-  CoverageExporterJson(const CoverageMapping &CoverageMapping,
-                       const CoverageViewOptions &Options, raw_ostream &OS)
-      : Options(Options), OS(OS), Coverage(CoverageMapping) {
-    State.push(JsonState::None);
-  }
-
-  /// \brief Print the CoverageMapping.
-  void print() { renderRoot(); }
-};
-
-/// \brief Export the given CoverageMapping to a JSON Format.
-void exportCoverageDataToJson(const CoverageMapping &CoverageMapping,
-                              const CoverageViewOptions &Options,
-                              raw_ostream &OS) {
-  auto Exporter = CoverageExporterJson(CoverageMapping, Options, OS);
-
-  Exporter.print();
-}

tools/llvm-cov/CoverageReport.h

-//===- CoverageReport.h - Code coverage report ---------------------------===//
+//===- CoverageReport.h - Code coverage report ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //