[LLVM-COV] Replace tabs to 2-space indentation in the HTML coverage report.

[MaggieYi]

Summary

When using llvm-cov.exe to generate the HTML report, the HTML report can look quite different to the source file if it includes tabs. The patch includes:

1. Use the default tab size is 2 spaces instead of 8 spaces.
2. Add a command line switch (-tab-size) that allows user to set the tab size.

[vsk]

Mostly looks good. The logic in escape() looks correct.

test/tools/llvm-cov/showTabsHTML.cpp

3 ↗

(On Diff #66566)

Does the second RUN line achieve any additional test coverage for this patch? If not, please remove it.

21 ↗

(On Diff #66566)

Since this test is just checking whether tabs are expanded properly, please keep the CHECKs on lines {9, 14, 18} and remove the rest. That should make the test easier to maintain.

38 ↗

(On Diff #66566)

Ditto, please trim this set of CHECKs.

tools/llvm-cov/CoverageViewOptions.h

37 ↗

(On Diff #66566)

Please don't introduce static members -- it should be possible to pass a CoverageViewOptions instance instead.

tools/llvm-cov/SourceCoverageViewHTML.cpp

46 ↗

(On Diff #66566)

Capitalize the iterator variable name.

[MaggieYi]

Thanks Vedant, I have updated the patch following your comments.

[MaggieYi]

Following Vedant's comments, all issues have been fixed.

[vsk]

Great! LGTM.

llvm/trunk/test/tools/llvm-cov/Inputs/showTabsHTML.proftext

+main
+# Func Hash:
+0
+# Num Counters:
+1
+# Counter Values:
+1
+

llvm/trunk/test/tools/llvm-cov/showTabsHTML.cpp

+// RUN: llvm-profdata merge -o %t.profdata %S/Inputs/showTabsHTML.proftext
+// RUN: llvm-cov show %S/Inputs/showTabsHTML.covmapping -format html -instr-profile %t.profdata -filename-equivalence %s | FileCheck -check-prefix=CHECK %s
+
+int main(int argc, char ** argv) {
+  (void) "This tab starts at column 0";            // CHECK:   (void) "This tab starts at column 0";
+  (void) "  This tab starts at column 10";           // CHECK: (void) "  This tab starts at column 10";
+  (void) "This    tab starts at column 15";           // CHECK: (void) "This   tab starts at column 15";
+
+  return 0;
+}
+
+// RUN: llvm-cov show %S/Inputs/showTabsHTML.covmapping -format html -tab-size=3 -instr-profile %t.profdata -filename-equivalence %s | FileCheck -check-prefix=CHECK-TABSIZE %s
+
+// CHECK-TABSIZE:    (void) "This tab starts at column 0";
+// CHECK-TABSIZE: (void) "  This tab starts at column 10";
+// CHECK-TABSIZE: (void) "This     tab starts at column 15";
 No newline at end of file

llvm/trunk/tools/llvm-cov/CodeCoverage.cpp

cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
                                    cl::cat(ViewCategory));
 
   cl::opt<std::string> ShowOutputDirectory(
       "output-dir", cl::init(""),
       cl::desc("Directory in which coverage information is written out"));
   cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
                                  cl::aliasopt(ShowOutputDirectory));
 
+  cl::opt<uint32_t> TabSize(
+      "tab-size", cl::Hidden, cl::init(2),
+      cl::desc("Set tab size for the HTML coverage report (default = 2)"));
+
   auto Err = commandLineParser(argc, argv);
   if (Err)
     return Err;
 
   ViewOpts.ShowLineNumbers = true;
   ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
                            !ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
   ViewOpts.ShowLineStatsOrRegionMarkers = ShowBestLineRegionsCounts;
   ViewOpts.ShowExpandedRegions = ShowExpansions;
   ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
   ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
+  ViewOpts.TabSize = TabSize;
 
   if (ViewOpts.hasOutputDirectory()) {
     if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
       error("Could not create output directory!", E.message());
       return 1;
     }
   }
 

llvm/trunk/tools/llvm-cov/CoverageViewOptions.h

struct CoverageViewOptions {
   bool ShowRegionMarkers;
   bool ShowLineStatsOrRegionMarkers;
   bool ShowExpandedRegions;
   bool ShowFunctionInstantiations;
   bool ShowFullFilenames;
   OutputFormat Format;
   std::string ShowOutputDirectory;
   std::vector<std::string> DemanglerOpts;
+  uint32_t TabSize;
 
   /// \brief Change the output's stream color if the colors are enabled.
   ColoredRawOstream colored_ostream(raw_ostream &OS,
                                     raw_ostream::Colors Color) const {
     return llvm::colored_ostream(OS, Color, Colors);
   }
 
   /// \brief Check if an output directory has been specified.
   bool hasOutputDirectory() const { return !ShowOutputDirectory.empty(); }
 
   /// \brief Check if a demangler has been specified.
   bool hasDemangler() const { return !DemanglerOpts.empty(); }
 };
 }
 
 #endif // LLVM_COV_COVERAGEVIEWOPTIONS_H

llvm/trunk/tools/llvm-cov/SourceCoverageViewHTML.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 
 namespace {
 
 // Return a string with the special characters in \p Str escaped.
-std::string escape(StringRef Str) {
+std::string escape(StringRef Str, const CoverageViewOptions &Opts) {
   std::string Result;
+  unsigned ColNum = 0; // Record the column number.
   for (char C : Str) {
+    ++ColNum;
     if (C == '&')
       Result += "&";
     else if (C == '<')
       Result += "&lt;";
     else if (C == '>')
       Result += "&gt;";
     else if (C == '\"')
       Result += "&quot;";
-    else
+    else if (C == '\n' || C == '\r') {
+      Result += C;
+      ColNum = 0;
+    } else if (C == '\t') {
+      // Replace '\t' with TabSize spaces.
+      unsigned NumSpaces = Opts.TabSize - (--ColNum % Opts.TabSize);
+      for (unsigned I = 0; I < NumSpaces; ++I)
+        Result += "&nbsp;";
+      ColNum += NumSpaces;
+    } else
       Result += C;
   }
   return Result;
 }
 
 // Create a \p Name tag around \p Str, and optionally set its \p ClassName.
 std::string tag(const std::string &Name, const std::string &Str,
                 const std::string &ClassName = "") {
std::string getPathToStyle(StringRef ViewPath) {
   std::string PathToStyle = "";
   std::string PathSep = sys::path::get_separator();
   unsigned NumSeps = ViewPath.count(PathSep);
   for (unsigned I = 0, E = NumSeps; I < E; ++I)
     PathToStyle += ".." + PathSep;
   return PathToStyle + "style.css";
 }
 
-void emitPrelude(raw_ostream &OS, const std::string &PathToStyle = "") {
+void emitPrelude(raw_ostream &OS, const CoverageViewOptions &Opts,
+                 const std::string &PathToStyle = "") {
   OS << "<!doctype html>"
         "<html>"
      << BeginHeader;
 
   // Link to a stylesheet if one is available. Otherwise, use the default style.
   if (PathToStyle.empty())
     OS << "<style>" << CSSForCoverage << "</style>";
   else
-    OS << "<link rel='stylesheet' type='text/css' href='" << escape(PathToStyle)
-       << "'>";
+    OS << "<link rel='stylesheet' type='text/css' href='"
+       << escape(PathToStyle, Opts) << "'>";
 
   OS << EndHeader << "<body>" << BeginCenteredDiv;
 }
 
 void emitEpilog(raw_ostream &OS) {
   OS << EndCenteredDiv << "</body>"
                           "</html>";
 }
 
 } // anonymous namespace
 
 Expected<CoveragePrinter::OwnedStream>
 CoveragePrinterHTML::createViewFile(StringRef Path, bool InToplevel) {
   auto OSOrErr = createOutputStream(Path, "html", InToplevel);
   if (!OSOrErr)
     return OSOrErr;
 
   OwnedStream OS = std::move(OSOrErr.get());
 
   if (!Opts.hasOutputDirectory()) {
-    emitPrelude(*OS.get());
+    emitPrelude(*OS.get(), Opts);
   } else {
     std::string ViewPath = getOutputPath(Path, "html", InToplevel);
-    emitPrelude(*OS.get(), getPathToStyle(ViewPath));
+    emitPrelude(*OS.get(), Opts, getPathToStyle(ViewPath));
   }
 
   return std::move(OS);
 }
 
 void CoveragePrinterHTML::closeViewFile(OwnedStream OS) {
   emitEpilog(*OS.get());
 }
 
 Error CoveragePrinterHTML::createIndexFile(ArrayRef<StringRef> SourceFiles) {
   auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
   if (Error E = OSOrErr.takeError())
     return E;
   auto OS = std::move(OSOrErr.get());
   raw_ostream &OSRef = *OS.get();
 
   // Emit a table containing links to reports for each file in the covmapping.
   assert(Opts.hasOutputDirectory() && "No output directory for index file");
-  emitPrelude(OSRef, getPathToStyle(""));
+  emitPrelude(OSRef, Opts, getPathToStyle(""));
   OSRef << BeginSourceNameDiv << "Index" << EndSourceNameDiv;
   OSRef << BeginTable;
   for (StringRef SF : SourceFiles) {
-    std::string LinkText = escape(sys::path::relative_path(SF));
+    std::string LinkText = escape(sys::path::relative_path(SF), Opts);
     std::string LinkTarget =
-        escape(getOutputPath(SF, "html", /*InToplevel=*/false));
+        escape(getOutputPath(SF, "html", /*InToplevel=*/false), Opts);
     OSRef << tag("tr", tag("td", tag("pre", a(LinkTarget, LinkText), "code")));
   }
   OSRef << EndTable;
   emitEpilog(OSRef);
 
   // Emit the default stylesheet.
   auto CSSOrErr = createOutputStream("style", "css", /*InToplevel=*/true);
   if (Error E = CSSOrErr.takeError())
void SourceCoverageViewHTML::renderViewHeader(raw_ostream &OS) {
   OS << BeginTable;
 }
 
 void SourceCoverageViewHTML::renderViewFooter(raw_ostream &OS) {
   OS << EndTable;
 }
 
 void SourceCoverageViewHTML::renderSourceName(raw_ostream &OS) {
-  OS << BeginSourceNameDiv << tag("pre", escape(getSourceName()))
+  OS << BeginSourceNameDiv << tag("pre", escape(getSourceName(), getOptions()))
      << EndSourceNameDiv;
 }
 
 void SourceCoverageViewHTML::renderLinePrefix(raw_ostream &OS, unsigned) {
   OS << "<tr>";
 }
 
 void SourceCoverageViewHTML::renderLineSuffix(raw_ostream &OS, unsigned) {
void SourceCoverageViewHTML::renderLine(
 
   // |Line| + 1 is needed to avoid underflow when, e.g |Line| = 0 and LCol = 1.
   Snip(LCol - 1, Line.size() + 1 - LCol);
   assert(LCol == Line.size() + 1 && "Final snippet doesn't reach the EOL");
 
   // 2. Escape all of the snippets.
 
   for (unsigned I = 0, E = Snippets.size(); I < E; ++I)
-    Snippets[I] = escape(Snippets[I]);
+    Snippets[I] = escape(Snippets[I], getOptions());
 
   // 3. Use \p WrappedSegment to set the highlight for snippet 0. Use segment
   //    1 to set the highlight for snippet 2, segment 2 to set the highlight for
   //    snippet 3, and so on.
 
   Optional<std::string> Color;
   SmallVector<std::pair<unsigned, unsigned>, 4> HighlightedRanges;
   auto Highlight = [&](const std::string &Snippet, unsigned LC, unsigned RC) {