[llvm-cov] Hide files with no coverage from the index when filtering by name

[seaneveson]

Summary

Remove the "Files which contain no functions" section from the index page when filtering (using -name*= options) with an output directory. The coverage for those files is not produced in the directory structure.

[vsk]

Could you upload a diff with some source context (e.g 'git diff -U1000')?

test/tools/llvm-cov/dir-with-filtering.test

38

This test looks like it would pass without this patch's functionality change. Could you "CHECK-NOT" against "Files which ..."?

[seaneveson]

Add context.

[seaneveson]

test/tools/llvm-cov/dir-with-filtering.test

38

The test checks that dir-with-filtering2.cpp does not appear in the index file. Before the change it appears listed under the "Files which ..." sections, so the test doesn't pass.

I'll add a check for "Files which ..." since that shouldn't be in the output either.

Thanks for the review!

[seaneveson]

Improve test to check for absence of "Files which contain no functions" message.

[vsk]

Thanks!

test/tools/llvm-cov/dir-with-filtering.test

 RUN: llvm-cov show %S/Inputs/dir-with-filtering.covmapping -o %t.text_one_file -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs -name=main -name=f2 %S/Inputs/dir-with-filtering1.cpp
 
 RUN: FileCheck -input-file=%t.text_one_file/index.txt %s -check-prefix=TEXT-INDEX-ONE-FILE
 TEXT-INDEX-ONE-FILE: dir-with-filtering1.cpp 1 0 100.00% 1 0 100.00% 4 0 100.00%
 TEXT-INDEX-ONE-FILE-NOT: dir-with-filtering2.cpp
 
 RUN: FileCheck -input-file=%t.text_one_file/coverage/tmp/dir-with-filtering1.cpp.txt %s -check-prefix=TEXT-FILE1
 
+// Test TEXT index file with all functions in one file filtered out
+
+RUN: llvm-cov show %S/Inputs/dir-with-filtering.covmapping -o %t.text_one_func -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs -name=main
+RUN: FileCheck -input-file=%t.text_one_func/index.txt %s -check-prefix=TEXT-INDEX-ONE-FUNC
+
+TEXT-INDEX-ONE-FUNC-NOT: Files which contain no functions
+TEXT-INDEX-ONE-FUNC-NOT: dir-with-filtering2.cpp
+
 // Test HTML both files
 
 RUN: llvm-profdata merge %S/Inputs/dir-with-filtering.proftext -o %t.profdata
 RUN: llvm-cov show %S/Inputs/dir-with-filtering.covmapping -format html -o %t.html -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs -name=main -name=f2
 
 RUN: FileCheck -input-file=%t.html/index.html %s -check-prefix=HTML-INDEX
 HTML-INDEX: <h2>Coverage Report</h2>
 HTML-INDEX: dir-with-filtering1.cpp{{.*}}100.00% (1/1){{.*}}100.00% (4/4){{.*}}100.00% (1/1)

 RUN: llvm-cov show %S/Inputs/dir-with-filtering.covmapping -format html -o %t.html_one_file -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs -name=main -name=f2 %S/Inputs/dir-with-filtering1.cpp
 
 RUN: FileCheck -input-file=%t.html_one_file/index.html %s -check-prefix=HTML-INDEX-ONE-FILE
 HTML-INDEX-ONE-FILE: <h2>Coverage Report</h2>
 HTML-INDEX-ONE-FILE: dir-with-filtering1.cpp{{.*}}100.00% (1/1){{.*}}100.00% (4/4){{.*}}100.00% (1/1)
 HTML-INDEX-ONE-FILE-NOT: dir-with-filtering2.cpp
 
 RUN: FileCheck -input-file=%t.html_one_file/coverage/tmp/dir-with-filtering1.cpp.html %s -check-prefix=HTML-FILE1
+
+// Test HTML index file with all functions in one file filtered out
+
+RUN: llvm-cov show %S/Inputs/dir-with-filtering.covmapping -format html -o %t.html_one_func -instr-profile %t.profdata -path-equivalence=/tmp,%S/Inputs -name=main
+RUN: FileCheck -input-file=%t.html_one_func/index.html %s -check-prefix=HTML-INDEX-ONE-FUNC
+
+HTML-INDEX-ONE-FUNC-NOT: Files which contain no functions
+HTML-INDEX-ONE-FUNC-NOT: dir-with-filtering2.cpp

tools/llvm-cov/CoverageReport.h

prepareFileReports(const coverage::CoverageMapping &Coverage,
                      const CoverageFilter &Filters = CoverageFiltersMatchAll());
 
   /// Render file reports for every unique file in the coverage mapping.
   void renderFileReports(raw_ostream &OS) const;
 
   /// Render file reports for the files specified in \p Files and the functions
   /// in \p Filters.
   void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files,
-                         const CoverageFilter &Filters) const;
+                         const CoverageFiltersMatchAll &Filters) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_COV_COVERAGEREPORT_H

tools/llvm-cov/CoverageReport.cpp

 
 void CoverageReport::renderFileReports(raw_ostream &OS) const {
   std::vector<std::string> UniqueSourceFiles;
   for (StringRef SF : Coverage.getUniqueSourceFiles())
     UniqueSourceFiles.emplace_back(SF.str());
   renderFileReports(OS, UniqueSourceFiles, CoverageFiltersMatchAll());
 }
 
-void CoverageReport::renderFileReports(raw_ostream &OS,
-                                       ArrayRef<std::string> Files,
-                                       const CoverageFilter &Filters) const {
+void CoverageReport::renderFileReports(
+    raw_ostream &OS, ArrayRef<std::string> Files,
+    const CoverageFiltersMatchAll &Filters) const {
   FileCoverageSummary Totals("TOTAL");
   auto FileReports =
       prepareFileReports(Coverage, Totals, Files, Options, Filters);
 
   std::vector<StringRef> Filenames;
   for (const FileCoverageSummary &FCS : FileReports)
     Filenames.emplace_back(FCS.Name);
   adjustColumnWidths(Filenames, {});
void CoverageReport::renderFileReports(
   bool EmptyFiles = false;
   for (const FileCoverageSummary &FCS : FileReports) {
     if (FCS.FunctionCoverage.getNumFunctions())
       render(FCS, OS);
     else
       EmptyFiles = true;
   }
 
-  if (EmptyFiles) {
+  if (EmptyFiles && Filters.empty()) {
     OS << "\n"
        << "Files which contain no functions:\n";
 
     for (const FileCoverageSummary &FCS : FileReports)
       if (!FCS.FunctionCoverage.getNumFunctions())
         render(FCS, OS);
   }
 
   renderDivider(FileReportColumns, OS);
   OS << "\n";
   render(Totals, OS);
 }
 
 } // end namespace llvm

tools/llvm-cov/SourceCoverageView.h

 #include "CoverageViewOptions.h"
 #include "CoverageSummaryInfo.h"
 #include "llvm/ProfileData/Coverage/CoverageMapping.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
 namespace llvm {
 
-class CoverageFilter;
+class CoverageFiltersMatchAll;
 class SourceCoverageView;
 
 /// \brief A view that represents a macro or include expansion.
 struct ExpansionView {
   coverage::CounterMappingRegion Region;
   std::unique_ptr<SourceCoverageView> View;
 
   ExpansionView(const coverage::CounterMappingRegion &Region,
virtual Expected<OwnedStream> createViewFile(StringRef Path,
                                                bool InToplevel) = 0;
 
   /// \brief Close a file which has been used to print a coverage view.
   virtual void closeViewFile(OwnedStream OS) = 0;
 
   /// \brief Create an index which lists reports for the given source files.
   virtual Error createIndexFile(ArrayRef<std::string> SourceFiles,
                                 const coverage::CoverageMapping &Coverage,
-                                const CoverageFilter &Filters) = 0;
+                                const CoverageFiltersMatchAll &Filters) = 0;
 
   /// @}
 };
 
 /// \brief A code coverage view of a source file or function.
 ///
 /// A source coverage view and its nested sub-views form a file-oriented
 /// representation of code coverage data. This view can be printed out by a

tools/llvm-cov/SourceCoverageViewHTML.h

 public:
   Expected<OwnedStream> createViewFile(StringRef Path,
                                        bool InToplevel) override;
 
   void closeViewFile(OwnedStream OS) override;
 
   Error createIndexFile(ArrayRef<std::string> SourceFiles,
                         const coverage::CoverageMapping &Coverage,
-                        const CoverageFilter &Filters) override;
+                        const CoverageFiltersMatchAll &Filters) override;
 
   CoveragePrinterHTML(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 
 private:
   void emitFileSummary(raw_ostream &OS, StringRef SF,
                        const FileCoverageSummary &FCS,
                        bool IsTotals = false) const;

tools/llvm-cov/SourceCoverageViewHTML.cpp

AddCoverageTripleToColumn(FCS.RegionCoverage.getCovered(),
                               FCS.RegionCoverage.getNumRegions(),
                               FCS.RegionCoverage.getPercentCovered());
 
   OS << tag("tr", join(Columns.begin(), Columns.end(), ""), "light-row");
 }
 
 Error CoveragePrinterHTML::createIndexFile(
     ArrayRef<std::string> SourceFiles,
-    const coverage::CoverageMapping &Coverage, const CoverageFilter &Filters) {
+    const coverage::CoverageMapping &Coverage,
+    const CoverageFiltersMatchAll &Filters) {
   // Emit the default stylesheet.
   auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
   if (Error E = CSSOrErr.takeError())
     return E;
 
   OwnedStream CSS = std::move(CSSOrErr.get());
   CSS->operator<<(CSSForCoverage);
 
else
       EmptyFiles = true;
   }
   emitFileSummary(OSRef, "Totals", Totals, /*IsTotals=*/true);
   OSRef << EndTable << EndCenteredDiv;
 
   // Emit links to files which don't contain any functions. These are normally
   // not very useful, but could be relevant for code which abuses the
   // preprocessor.
-  if (EmptyFiles) {
+  if (EmptyFiles && Filters.empty()) {
     OSRef << tag("p", "Files which contain no functions. (These "
                       "files contain code pulled into other files "
                       "by the preprocessor.)\n");
     OSRef << BeginCenteredDiv << BeginTable;
     for (unsigned I = 0, E = FileReports.size(); I < E; ++I)
       if (!FileReports[I].FunctionCoverage.getNumFunctions()) {
         std::string Link = buildLinkToFile(SourceFiles[I], FileReports[I]);
         OSRef << tag("tr", tag("td", tag("pre", Link)), "light-row") << '\n';

tools/llvm-cov/SourceCoverageViewText.h

 public:
   Expected<OwnedStream> createViewFile(StringRef Path,
                                        bool InToplevel) override;
 
   void closeViewFile(OwnedStream OS) override;
 
   Error createIndexFile(ArrayRef<std::string> SourceFiles,
                         const coverage::CoverageMapping &Coverage,
-                        const CoverageFilter &Filters) override;
+                        const CoverageFiltersMatchAll &Filters) override;
 
   CoveragePrinterText(const CoverageViewOptions &Opts)
       : CoveragePrinter(Opts) {}
 };
 
 /// \brief A code coverage view which supports text-based rendering.
 class SourceCoverageViewText : public SourceCoverageView {
   void renderViewHeader(raw_ostream &OS) override;

tools/llvm-cov/SourceCoverageViewText.cpp

 }
 
 void CoveragePrinterText::closeViewFile(OwnedStream OS) {
   OS->operator<<('\n');
 }
 
 Error CoveragePrinterText::createIndexFile(
     ArrayRef<std::string> SourceFiles,
-    const coverage::CoverageMapping &Coverage, const CoverageFilter &Filters) {
+    const coverage::CoverageMapping &Coverage,
+    const CoverageFiltersMatchAll &Filters) {
   auto OSOrErr = createOutputStream("index", "txt", /*InToplevel=*/true);
   if (Error E = OSOrErr.takeError())
     return E;
   auto OS = std::move(OSOrErr.get());
   raw_ostream &OSRef = *OS.get();
 
   CoverageReport Report(Opts, Coverage);
   Report.renderFileReports(OSRef, SourceFiles, Filters);