1//===- SourceCoverageViewHTML.cpp - A html code coverage view -------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file This file implements the html coverage renderer.
11///
12//===----------------------------------------------------------------------===//
13
14#include "SourceCoverageViewHTML.h"
15#include "llvm/ADT/Optional.h"
16#include "llvm/ADT/SmallString.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/Support/Path.h"
19
20using namespace llvm;
21
22namespace {
23
24const char *BeginHeader =
25  "<head>"
26    "<meta name='viewport' content='width=device-width,initial-scale=1'>"
27    "<meta charset='UTF-8'>";
28
29const char *CSSForCoverage =
30  "<style>"
31R"(
32
33.red {
34  background-color: #FFD0D0;
35}
36.cyan {
37  background-color: cyan;
38}
39.black {
40  background-color: black;
41  color: white;
42}
43.green {
44  background-color: #98FFA6;
45  color: white;
46}
47.magenta {
48  background-color: #F998FF;
49  color: white;
50}
51body {
52  font-family: -apple-system, sans-serif;
53}
54pre {
55  margin-top: 0px !important;
56  margin-bottom: 0px !important;
57}
58.source-name-title {
59  padding: 5px 10px;
60  border-bottom: 1px solid #dbdbdb;
61  background-color: #eee;
62}
63.centered {
64  display: table;
65  margin-left: auto;
66  margin-right: auto;
67  border: 1px solid #dbdbdb;
68  border-radius: 3px;
69}
70.expansion-view {
71  background-color: rgba(0, 0, 0, 0);
72  margin-left: 0px;
73  margin-top: 5px;
74  margin-right: 5px;
75  margin-bottom: 5px;
76  border: 1px solid #dbdbdb;
77  border-radius: 3px;
78}
79table {
80  border-collapse: collapse;
81}
82.line-number {
83  text-align: right;
84  color: #aaa;
85}
86.covered-line {
87  text-align: right;
88  color: #0080ff;
89}
90.uncovered-line {
91  text-align: right;
92  color: #ff3300;
93}
94.tooltip {
95  position: relative;
96  display: inline;
97  background-color: #b3e6ff;
98  text-decoration: none;
99}
100.tooltip span.tooltip-content {
101  position: absolute;
102  width: 100px;
103  margin-left: -50px;
104  color: #FFFFFF;
105  background: #000000;
106  height: 30px;
107  line-height: 30px;
108  text-align: center;
109  visibility: hidden;
110  border-radius: 6px;
111}
112.tooltip span.tooltip-content:after {
113  content: '';
114  position: absolute;
115  top: 100%;
116  left: 50%;
117  margin-left: -8px;
118  width: 0; height: 0;
119  border-top: 8px solid #000000;
120  border-right: 8px solid transparent;
121  border-left: 8px solid transparent;
122}
123:hover.tooltip span.tooltip-content {
124  visibility: visible;
125  opacity: 0.8;
126  bottom: 30px;
127  left: 50%;
128  z-index: 999;
129}
130th, td {
131  vertical-align: top;
132  padding: 2px 5px;
133  border-collapse: collapse;
134  border-right: solid 1px #eee;
135  border-left: solid 1px #eee;
136}
137td:first-child {
138  border-left: none;
139}
140td:last-child {
141  border-right: none;
142}
143
144)"
145  "</style>";
146
147const char *EndHeader = "</head>";
148
149const char *BeginCenteredDiv = "<div class='centered'>";
150
151const char *EndCenteredDiv = "</div>";
152
153const char *BeginSourceNameDiv = "<div class='source-name-title'>";
154
155const char *EndSourceNameDiv = "</div>";
156
157const char *BeginCodeTD = "<td class='code'>";
158
159const char *EndCodeTD = "</td>";
160
161const char *BeginPre = "<pre>";
162
163const char *EndPre = "</pre>";
164
165const char *BeginExpansionDiv = "<div class='expansion-view'>";
166
167const char *EndExpansionDiv = "</div>";
168
169const char *BeginTable = "<table>";
170
171const char *EndTable = "</table>";
172
173void emitPrelude(raw_ostream &OS) {
174  OS << "<!doctype html>"
175        "<html>"
176     << BeginHeader << CSSForCoverage << EndHeader << "<body>"
177     << BeginCenteredDiv;
178}
179
180void emitEpilog(raw_ostream &OS) {
181  OS << EndCenteredDiv << "</body>"
182                          "</html>";
183}
184
185// Return a string with the special characters in \p Str escaped.
186std::string escape(StringRef Str) {
187  std::string Result;
188  for (char C : Str) {
189    if (C == '&')
190      Result += "&amp;";
191    else if (C == '<')
192      Result += "&lt;";
193    else if (C == '>')
194      Result += "&gt;";
195    else if (C == '\"')
196      Result += "&quot;";
197    else
198      Result += C;
199  }
200  return Result;
201}
202
203// Create a \p Name tag around \p Str, and optionally set its \p ClassName.
204std::string tag(const std::string &Name, const std::string &Str,
205                const std::string &ClassName = "") {
206  std::string Tag = "<" + Name;
207  if (ClassName != "")
208    Tag += " class='" + ClassName + "'";
209  return Tag + ">" + Str + "</" + Name + ">";
210}
211
212// Create an anchor to \p Link with the label \p Str.
213std::string a(const std::string &Link, const std::string &Str) {
214  return "<a href='" + Link + "'>" + Str + "</a>";
215}
216
217} // anonymous namespace
218
219Expected<CoveragePrinter::OwnedStream>
220CoveragePrinterHTML::createViewFile(StringRef Path, bool InToplevel) {
221  auto OSOrErr = createOutputStream(Path, "html", InToplevel);
222  if (!OSOrErr)
223    return OSOrErr;
224
225  OwnedStream OS = std::move(OSOrErr.get());
226  emitPrelude(*OS.get());
227  return std::move(OS);
228}
229
230void CoveragePrinterHTML::closeViewFile(OwnedStream OS) {
231  emitEpilog(*OS.get());
232}
233
234Error CoveragePrinterHTML::createIndexFile(ArrayRef<StringRef> SourceFiles) {
235  auto OSOrErr = createOutputStream("index", "html", /*InToplevel=*/true);
236  if (Error E = OSOrErr.takeError())
237    return E;
238  auto OS = std::move(OSOrErr.get());
239  raw_ostream &OSRef = *OS.get();
240
241  // Emit a table containing links to reports for each file in the covmapping.
242  emitPrelude(OSRef);
243  OSRef << BeginSourceNameDiv << "Index" << EndSourceNameDiv;
244  OSRef << BeginTable;
245  for (StringRef SF : SourceFiles) {
246    std::string LinkText = escape(sys::path::relative_path(SF));
247    std::string LinkTarget =
248        escape(getOutputPath(SF, "html", /*InToplevel=*/false));
249    OSRef << tag("tr", tag("td", tag("pre", a(LinkTarget, LinkText), "code")));
250  }
251  OSRef << EndTable;
252  emitEpilog(OSRef);
253
254  return Error::success();
255}
256
257void SourceCoverageViewHTML::renderViewHeader(raw_ostream &OS) {
258  OS << BeginTable;
259}
260
261void SourceCoverageViewHTML::renderViewFooter(raw_ostream &OS) {
262  OS << EndTable;
263}
264
265void SourceCoverageViewHTML::renderSourceName(raw_ostream &OS) {
266  OS << BeginSourceNameDiv << tag("pre", escape(getSourceName()))
267     << EndSourceNameDiv;
268}
269
270void SourceCoverageViewHTML::renderLinePrefix(raw_ostream &OS, unsigned) {
271  OS << "<tr>";
272}
273
274void SourceCoverageViewHTML::renderLineSuffix(raw_ostream &OS, unsigned) {
275  // If this view has sub-views, renderLine() cannot close the view's cell.
276  // Take care of it here, after all sub-views have been rendered.
277  if (hasSubViews())
278    OS << EndCodeTD;
279  OS << "</tr>";
280}
281
282void SourceCoverageViewHTML::renderViewDivider(raw_ostream &, unsigned) {
283  // The table-based output makes view dividers unnecessary.
284}
285
286void SourceCoverageViewHTML::renderLine(
287    raw_ostream &OS, LineRef L, const coverage::CoverageSegment *WrappedSegment,
288    CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned) {
289  StringRef Line = L.Line;
290
291  // Steps for handling text-escaping, highlighting, and tooltip creation:
292  //
293  // 1. Split the line into N+1 snippets, where N = |Segments|. The first
294  //    snippet starts from Col=1 and ends at the start of the first segment.
295  //    The last snippet starts at the last mapped column in the line and ends
296  //    at the end of the line. Both are required but may be empty.
297
298  SmallVector<std::string, 8> Snippets;
299
300  unsigned LCol = 1;
301  auto Snip = [&](unsigned Start, unsigned Len) {
302    assert(Start + Len <= Line.size() && "Snippet extends past the EOL");
303    Snippets.push_back(Line.substr(Start, Len));
304    LCol += Len;
305  };
306
307  Snip(LCol - 1, Segments.empty() ? 0 : (Segments.front()->Col - 1));
308
309  for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
310    assert(LCol == Segments[I - 1]->Col && "Snippet start position is wrong");
311    Snip(LCol - 1, Segments[I]->Col - LCol);
312  }
313
314  // |Line| + 1 is needed to avoid underflow when, e.g |Line| = 0 and LCol = 1.
315  Snip(LCol - 1, Line.size() + 1 - LCol);
316  assert(LCol == Line.size() + 1 && "Final snippet doesn't reach the EOL");
317
318  // 2. Escape all of the snippets.
319
320  for (unsigned I = 0, E = Snippets.size(); I < E; ++I)
321    Snippets[I] = escape(Snippets[I]);
322
323  // 3. Use \p WrappedSegment to set the highlight for snippets 0 and 1. Use
324  //    segment 1 to set the highlight for snippet 2, segment 2 to set the
325  //    highlight for snippet 3, and so on.
326
327  Optional<std::string> Color;
328  auto Highlight = [&](const std::string &Snippet) {
329    return tag("span", Snippet, Color.getValue());
330  };
331
332  auto CheckIfUncovered = [](const coverage::CoverageSegment *S) {
333    return S && S->HasCount && S->Count == 0;
334  };
335
336  if (CheckIfUncovered(WrappedSegment) ||
337      CheckIfUncovered(Segments.empty() ? nullptr : Segments.front())) {
338    Color = "red";
339    Snippets[0] = Highlight(Snippets[0]);
340    Snippets[1] = Highlight(Snippets[1]);
341  }
342
343  for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
344    const auto *CurSeg = Segments[I];
345    if (CurSeg->Col == ExpansionCol)
346      Color = "cyan";
347    else if (CheckIfUncovered(CurSeg))
348      Color = "red";
349    else
350      Color = None;
351
352    if (Color.hasValue())
353      Snippets[I + 1] = Highlight(Snippets[I + 1]);
354  }
355
356  // 4. Snippets[1:N+1] correspond to \p Segments[0:N]: use these to generate
357  //    sub-line region count tooltips if needed.
358
359  bool HasMultipleRegions = [&] {
360    unsigned RegionCount = 0;
361    for (const auto *S : Segments)
362      if (S->HasCount && S->IsRegionEntry)
363        if (++RegionCount > 1)
364          return true;
365    return false;
366  }();
367
368  if (shouldRenderRegionMarkers(HasMultipleRegions)) {
369    for (unsigned I = 0, E = Segments.size(); I < E; ++I) {
370      const auto *CurSeg = Segments[I];
371      if (!CurSeg->IsRegionEntry || !CurSeg->HasCount)
372        continue;
373
374      Snippets[I + 1] =
375          tag("div", Snippets[I + 1] + tag("span", formatCount(CurSeg->Count),
376                                          "tooltip-content"),
377              "tooltip");
378    }
379  }
380
381  OS << BeginCodeTD;
382  OS << BeginPre;
383  for (const auto &Snippet : Snippets)
384    OS << Snippet;
385  OS << EndPre;
386
387  // If there are no sub-views left to attach to this cell, end the cell.
388  // Otherwise, end it after the sub-views are rendered (renderLineSuffix()).
389  if (!hasSubViews())
390    OS << EndCodeTD;
391}
392
393void SourceCoverageViewHTML::renderLineCoverageColumn(
394    raw_ostream &OS, const LineCoverageStats &Line) {
395  std::string Count = "";
396  if (Line.isMapped())
397    Count = tag("pre", formatCount(Line.ExecutionCount));
398  std::string CoverageClass =
399      (Line.ExecutionCount > 0) ? "covered-line" : "uncovered-line";
400  OS << tag("td", Count, CoverageClass);
401}
402
403void SourceCoverageViewHTML::renderLineNumberColumn(raw_ostream &OS,
404                                                    unsigned LineNo) {
405  OS << tag("td", tag("pre", utostr(uint64_t(LineNo))), "line-number");
406}
407
408void SourceCoverageViewHTML::renderRegionMarkers(raw_ostream &,
409                                                 CoverageSegmentArray,
410                                                 unsigned) {
411  // Region markers are rendered in-line using tooltips.
412}
413
414void SourceCoverageViewHTML::renderExpansionSite(
415    raw_ostream &OS, LineRef L, const coverage::CoverageSegment *WrappedSegment,
416    CoverageSegmentArray Segments, unsigned ExpansionCol, unsigned ViewDepth) {
417  // Render the line containing the expansion site. No extra formatting needed.
418  renderLine(OS, L, WrappedSegment, Segments, ExpansionCol, ViewDepth);
419}
420
421void SourceCoverageViewHTML::renderExpansionView(raw_ostream &OS,
422                                                 ExpansionView &ESV,
423                                                 unsigned ViewDepth) {
424  OS << BeginExpansionDiv;
425  ESV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/false,
426                  ViewDepth + 1);
427  OS << EndExpansionDiv;
428}
429
430void SourceCoverageViewHTML::renderInstantiationView(raw_ostream &OS,
431                                                     InstantiationView &ISV,
432                                                     unsigned ViewDepth) {
433  OS << BeginExpansionDiv;
434  ISV.View->print(OS, /*WholeFile=*/false, /*ShowSourceName=*/true, ViewDepth);
435  OS << EndExpansionDiv;
436}
437