1//===- HTMLDiagnostics.cpp - HTML Diagnostics for Paths -------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the HTMLDiagnostics object.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclBase.h"
15#include "clang/AST/Stmt.h"
16#include "clang/Analysis/IssueHash.h"
17#include "clang/Analysis/MacroExpansionContext.h"
18#include "clang/Analysis/PathDiagnostic.h"
19#include "clang/Basic/FileManager.h"
20#include "clang/Basic/LLVM.h"
21#include "clang/Basic/SourceLocation.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Lex/Lexer.h"
24#include "clang/Lex/Preprocessor.h"
25#include "clang/Lex/Token.h"
26#include "clang/Rewrite/Core/HTMLRewrite.h"
27#include "clang/Rewrite/Core/Rewriter.h"
28#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
29#include "llvm/ADT/ArrayRef.h"
30#include "llvm/ADT/STLExtras.h"
31#include "llvm/ADT/Sequence.h"
32#include "llvm/ADT/SmallString.h"
33#include "llvm/ADT/StringRef.h"
34#include "llvm/ADT/iterator_range.h"
35#include "llvm/Support/Casting.h"
36#include "llvm/Support/Errc.h"
37#include "llvm/Support/ErrorHandling.h"
38#include "llvm/Support/FileSystem.h"
39#include "llvm/Support/MemoryBuffer.h"
40#include "llvm/Support/Path.h"
41#include "llvm/Support/raw_ostream.h"
42#include <algorithm>
43#include <cassert>
44#include <map>
45#include <memory>
46#include <set>
47#include <sstream>
48#include <string>
49#include <system_error>
50#include <utility>
51#include <vector>
52
53using namespace clang;
54using namespace ento;
55
56//===----------------------------------------------------------------------===//
57// Boilerplate.
58//===----------------------------------------------------------------------===//
59
60namespace {
61
62class ArrowMap;
63
64class HTMLDiagnostics : public PathDiagnosticConsumer {
65 PathDiagnosticConsumerOptions DiagOpts;
66 std::string Directory;
67 bool createdDir = false;
68 bool noDir = false;
69 const Preprocessor &PP;
70 const bool SupportsCrossFileDiagnostics;
71
72public:
73 HTMLDiagnostics(PathDiagnosticConsumerOptions DiagOpts,
74 const std::string &OutputDir, const Preprocessor &pp,
75 bool supportsMultipleFiles)
76 : DiagOpts(std::move(DiagOpts)), Directory(OutputDir), PP(pp),
77 SupportsCrossFileDiagnostics(supportsMultipleFiles) {}
78
79 ~HTMLDiagnostics() override { FlushDiagnostics(nullptr); }
80
81 void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
82 FilesMade *filesMade) override;
83
84 StringRef getName() const override { return "HTMLDiagnostics"; }
85
86 bool supportsCrossFileDiagnostics() const override {
87 return SupportsCrossFileDiagnostics;
88 }
89
90 unsigned ProcessMacroPiece(raw_ostream &os, const PathDiagnosticMacroPiece &P,
91 unsigned num);
92
93 unsigned ProcessControlFlowPiece(Rewriter &R, FileID BugFileID,
94 const PathDiagnosticControlFlowPiece &P,
95 unsigned Number);
96
97 void HandlePiece(Rewriter &R, FileID BugFileID, const PathDiagnosticPiece &P,
98 const std::vector<SourceRange> &PopUpRanges, unsigned num,
99 unsigned max);
100
101 void HighlightRange(Rewriter &R, FileID BugFileID, SourceRange Range,
102 const char *HighlightStart = "<span class=\"mrange\">",
103 const char *HighlightEnd = "</span>");
104
105 void ReportDiag(const PathDiagnostic &D, FilesMade *filesMade);
106
107 // Generate the full HTML report
108 std::string GenerateHTML(const PathDiagnostic &D, Rewriter &R,
109 const SourceManager &SMgr, const PathPieces &path,
110 const char *declName);
111
112 // Add HTML header/footers to file specified by FID
113 void FinalizeHTML(const PathDiagnostic &D, Rewriter &R,
114 const SourceManager &SMgr, const PathPieces &path,
115 FileID FID, const FileEntry *Entry, const char *declName);
116
117 // Rewrite the file specified by FID with HTML formatting.
118 void RewriteFile(Rewriter &R, const PathPieces &path, FileID FID);
119
120 PathGenerationScheme getGenerationScheme() const override {
121 return Everything;
122 }
123
124private:
125 void addArrowSVGs(Rewriter &R, FileID BugFileID,
126 const ArrowMap &ArrowIndices);
127
128 /// \return Javascript for displaying shortcuts help;
129 StringRef showHelpJavascript();
130
131 /// \return Javascript for navigating the HTML report using j/k keys.
132 StringRef generateKeyboardNavigationJavascript();
133
134 /// \return Javascript for drawing control-flow arrows.
135 StringRef generateArrowDrawingJavascript();
136
137 /// \return JavaScript for an option to only show relevant lines.
138 std::string showRelevantLinesJavascript(const PathDiagnostic &D,
139 const PathPieces &path);
140
141 /// Write executed lines from \p D in JSON format into \p os.
142 void dumpCoverageData(const PathDiagnostic &D, const PathPieces &path,
143 llvm::raw_string_ostream &os);
144};
145
146bool isArrowPiece(const PathDiagnosticPiece &P) {
147 return isa<PathDiagnosticControlFlowPiece>(P) && P.getString().empty();
148}
149
150unsigned getPathSizeWithoutArrows(const PathPieces &Path) {
151 unsigned TotalPieces = Path.size();
152 unsigned TotalArrowPieces = llvm::count_if(
153 Path, [](const PathDiagnosticPieceRef &P) { return isArrowPiece(*P); });
154 return TotalPieces - TotalArrowPieces;
155}
156
157class ArrowMap : public std::vector<unsigned> {
158 using Base = std::vector<unsigned>;
159
160public:
161 ArrowMap(unsigned Size) : Base(Size, 0) {}
162 unsigned getTotalNumberOfArrows() const { return at(0); }
163};
164
165llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const ArrowMap &Indices) {
166 OS << "[ ";
167 llvm::interleave(Indices, OS, ",");
168 return OS << " ]";
169}
170
171} // namespace
172
173void ento::createHTMLDiagnosticConsumer(
174 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
175 const std::string &OutputDir, const Preprocessor &PP,
176 const cross_tu::CrossTranslationUnitContext &CTU,
177 const MacroExpansionContext &MacroExpansions) {
178
179 // FIXME: HTML is currently our default output type, but if the output
180 // directory isn't specified, it acts like if it was in the minimal text
181 // output mode. This doesn't make much sense, we should have the minimal text
182 // as our default. In the case of backward compatibility concerns, this could
183 // be preserved with -analyzer-config-compatibility-mode=true.
184 createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU,
185 MacroExpansions);
186
187 // TODO: Emit an error here.
188 if (OutputDir.empty())
189 return;
190
191 C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, true));
192}
193
194void ento::createHTMLSingleFileDiagnosticConsumer(
195 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
196 const std::string &OutputDir, const Preprocessor &PP,
197 const cross_tu::CrossTranslationUnitContext &CTU,
198 const clang::MacroExpansionContext &MacroExpansions) {
199 createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU,
200 MacroExpansions);
201
202 // TODO: Emit an error here.
203 if (OutputDir.empty())
204 return;
205
206 C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, false));
207}
208
209void ento::createPlistHTMLDiagnosticConsumer(
210 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
211 const std::string &prefix, const Preprocessor &PP,
212 const cross_tu::CrossTranslationUnitContext &CTU,
213 const MacroExpansionContext &MacroExpansions) {
214 createHTMLDiagnosticConsumer(
215 DiagOpts, C, std::string(llvm::sys::path::parent_path(prefix)), PP, CTU,
216 MacroExpansions);
217 createPlistMultiFileDiagnosticConsumer(DiagOpts, C, prefix, PP, CTU,
218 MacroExpansions);
219 createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, prefix, PP,
220 CTU, MacroExpansions);
221}
222
223void ento::createSarifHTMLDiagnosticConsumer(
224 PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,
225 const std::string &sarif_file, const Preprocessor &PP,
226 const cross_tu::CrossTranslationUnitContext &CTU,
227 const MacroExpansionContext &MacroExpansions) {
228 createHTMLDiagnosticConsumer(
229 DiagOpts, C, std::string(llvm::sys::path::parent_path(sarif_file)), PP,
230 CTU, MacroExpansions);
231 createSarifDiagnosticConsumer(DiagOpts, C, sarif_file, PP, CTU,
232 MacroExpansions);
233 createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, sarif_file,
234 PP, CTU, MacroExpansions);
235}
236
237//===----------------------------------------------------------------------===//
238// Report processing.
239//===----------------------------------------------------------------------===//
240
241void HTMLDiagnostics::FlushDiagnosticsImpl(
242 std::vector<const PathDiagnostic *> &Diags,
243 FilesMade *filesMade) {
244 for (const auto Diag : Diags)
245 ReportDiag(*Diag, filesMade);
246}
247
248static llvm::SmallString<32> getIssueHash(const PathDiagnostic &D,
249 const Preprocessor &PP) {
250 SourceManager &SMgr = PP.getSourceManager();
251 PathDiagnosticLocation UPDLoc = D.getUniqueingLoc();
252 FullSourceLoc L(SMgr.getExpansionLoc(UPDLoc.isValid()
253 ? UPDLoc.asLocation()
254 : D.getLocation().asLocation()),
255 SMgr);
256 return getIssueHash(L, D.getCheckerName(), D.getBugType(),
257 D.getDeclWithIssue(), PP.getLangOpts());
258}
259
260void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
261 FilesMade *filesMade) {
262 // Create the HTML directory if it is missing.
263 if (!createdDir) {
264 createdDir = true;
265 if (std::error_code ec = llvm::sys::fs::create_directories(Directory)) {
266 llvm::errs() << "warning: could not create directory '"
267 << Directory << "': " << ec.message() << '\n';
268 noDir = true;
269 return;
270 }
271 }
272
273 if (noDir)
274 return;
275
276 // First flatten out the entire path to make it easier to use.
277 PathPieces path = D.path.flatten(/*ShouldFlattenMacros=*/false);
278
279 // The path as already been prechecked that the path is non-empty.
280 assert(!path.empty());
281 const SourceManager &SMgr = path.front()->getLocation().getManager();
282
283 // Create a new rewriter to generate HTML.
284 Rewriter R(const_cast<SourceManager&>(SMgr), PP.getLangOpts());
285
286 // Get the function/method name
287 SmallString<128> declName("unknown");
288 int offsetDecl = 0;
289 if (const Decl *DeclWithIssue = D.getDeclWithIssue()) {
290 if (const auto *ND = dyn_cast<NamedDecl>(DeclWithIssue))
291 declName = ND->getDeclName().getAsString();
292
293 if (const Stmt *Body = DeclWithIssue->getBody()) {
294 // Retrieve the relative position of the declaration which will be used
295 // for the file name
296 FullSourceLoc L(
297 SMgr.getExpansionLoc(path.back()->getLocation().asLocation()),
298 SMgr);
299 FullSourceLoc FunL(SMgr.getExpansionLoc(Body->getBeginLoc()), SMgr);
300 offsetDecl = L.getExpansionLineNumber() - FunL.getExpansionLineNumber();
301 }
302 }
303
304 std::string report = GenerateHTML(D, R, SMgr, path, declName.c_str());
305 if (report.empty()) {
306 llvm::errs() << "warning: no diagnostics generated for main file.\n";
307 return;
308 }
309
310 // Create a path for the target HTML file.
311 int FD;
312
313 SmallString<128> FileNameStr;
314 llvm::raw_svector_ostream FileName(FileNameStr);
315 FileName << "report-";
316
317 // Historically, neither the stable report filename nor the unstable report
318 // filename were actually stable. That said, the stable report filename
319 // was more stable because it was mostly composed of information
320 // about the bug report instead of being completely random.
321 // Now both stable and unstable report filenames are in fact stable
322 // but the stable report filename is still more verbose.
323 if (DiagOpts.ShouldWriteVerboseReportFilename) {
324 // FIXME: This code relies on knowing what constitutes the issue hash.
325 // Otherwise deduplication won't work correctly.
326 FileID ReportFile =
327 path.back()->getLocation().asLocation().getExpansionLoc().getFileID();
328
329 const FileEntry *Entry = SMgr.getFileEntryForID(ReportFile);
330
331 FileName << llvm::sys::path::filename(Entry->getName()).str() << "-"
332 << declName.c_str() << "-" << offsetDecl << "-";
333 }
334
335 FileName << StringRef(getIssueHash(D, PP)).substr(0, 6).str() << ".html";
336
337 SmallString<128> ResultPath;
338 llvm::sys::path::append(ResultPath, Directory, FileName.str());
339 if (std::error_code EC = llvm::sys::fs::make_absolute(ResultPath)) {
340 llvm::errs() << "warning: could not make '" << ResultPath
341 << "' absolute: " << EC.message() << '\n';
342 return;
343 }
344
345 if (std::error_code EC = llvm::sys::fs::openFileForReadWrite(
346 ResultPath, FD, llvm::sys::fs::CD_CreateNew,
347 llvm::sys::fs::OF_Text)) {
348 // Existence of the file corresponds to the situation where a different
349 // Clang instance has emitted a bug report with the same issue hash.
350 // This is an entirely normal situation that does not deserve a warning,
351 // as apart from hash collisions this can happen because the reports
352 // are in fact similar enough to be considered duplicates of each other.
353 if (EC != llvm::errc::file_exists) {
354 llvm::errs() << "warning: could not create file in '" << Directory
355 << "': " << EC.message() << '\n';
356 }
357 return;
358 }
359
360 llvm::raw_fd_ostream os(FD, true);
361
362 if (filesMade)
363 filesMade->addDiagnostic(D, getName(),
364 llvm::sys::path::filename(ResultPath));
365
366 // Emit the HTML to disk.
367 os << report;
368}
369
370std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic& D, Rewriter &R,
371 const SourceManager& SMgr, const PathPieces& path, const char *declName) {
372 // Rewrite source files as HTML for every new file the path crosses
373 std::vector<FileID> FileIDs;
374 for (auto I : path) {
375 FileID FID = I->getLocation().asLocation().getExpansionLoc().getFileID();
376 if (llvm::is_contained(FileIDs, FID))
377 continue;
378
379 FileIDs.push_back(FID);
380 RewriteFile(R, path, FID);
381 }
382
383 if (SupportsCrossFileDiagnostics && FileIDs.size() > 1) {
384 // Prefix file names, anchor tags, and nav cursors to every file
385 for (auto I = FileIDs.begin(), E = FileIDs.end(); I != E; I++) {
386 std::string s;
387 llvm::raw_string_ostream os(s);
388
389 if (I != FileIDs.begin())
390 os << "<hr class=divider>\n";
391
392 os << "<div id=File" << I->getHashValue() << ">\n";
393
394 // Left nav arrow
395 if (I != FileIDs.begin())
396 os << "<div class=FileNav><a href=\"#File" << (I - 1)->getHashValue()
397 << "\">&#x2190;</a></div>";
398
399 os << "<h4 class=FileName>" << SMgr.getFileEntryForID(*I)->getName()
400 << "</h4>\n";
401
402 // Right nav arrow
403 if (I + 1 != E)
404 os << "<div class=FileNav><a href=\"#File" << (I + 1)->getHashValue()
405 << "\">&#x2192;</a></div>";
406
407 os << "</div>\n";
408
409 R.InsertTextBefore(SMgr.getLocForStartOfFile(*I), os.str());
410 }
411
412 // Append files to the main report file in the order they appear in the path
413 for (auto I : llvm::drop_begin(FileIDs)) {
414 std::string s;
415 llvm::raw_string_ostream os(s);
416
417 const RewriteBuffer *Buf = R.getRewriteBufferFor(I);
418 for (auto BI : *Buf)
419 os << BI;
420
421 R.InsertTextAfter(SMgr.getLocForEndOfFile(FileIDs[0]), os.str());
422 }
423 }
424
425 const RewriteBuffer *Buf = R.getRewriteBufferFor(FileIDs[0]);
426 if (!Buf)
427 return {};
428
429 // Add CSS, header, and footer.
430 FileID FID =
431 path.back()->getLocation().asLocation().getExpansionLoc().getFileID();
432 const FileEntry* Entry = SMgr.getFileEntryForID(FID);
433 FinalizeHTML(D, R, SMgr, path, FileIDs[0], Entry, declName);
434
435 std::string file;
436 llvm::raw_string_ostream os(file);
437 for (auto BI : *Buf)
438 os << BI;
439
440 return file;
441}
442
443void HTMLDiagnostics::dumpCoverageData(
444 const PathDiagnostic &D,
445 const PathPieces &path,
446 llvm::raw_string_ostream &os) {
447
448 const FilesToLineNumsMap &ExecutedLines = D.getExecutedLines();
449
450 os << "var relevant_lines = {";
451 for (auto I = ExecutedLines.begin(),
452 E = ExecutedLines.end(); I != E; ++I) {
453 if (I != ExecutedLines.begin())
454 os << ", ";
455
456 os << "\"" << I->first.getHashValue() << "\": {";
457 for (unsigned LineNo : I->second) {
458 if (LineNo != *(I->second.begin()))
459 os << ", ";
460
461 os << "\"" << LineNo << "\": 1";
462 }
463 os << "}";
464 }
465
466 os << "};";
467}
468
469std::string HTMLDiagnostics::showRelevantLinesJavascript(
470 const PathDiagnostic &D, const PathPieces &path) {
471 std::string s;
472 llvm::raw_string_ostream os(s);
473 os << "<script type='text/javascript'>\n";
474 dumpCoverageData(D, path, os);
475 os << R"<<<(
476
477var filterCounterexample = function (hide) {
478 var tables = document.getElementsByClassName("code");
479 for (var t=0; t<tables.length; t++) {
480 var table = tables[t];
481 var file_id = table.getAttribute("data-fileid");
482 var lines_in_fid = relevant_lines[file_id];
483 if (!lines_in_fid) {
484 lines_in_fid = {};
485 }
486 var lines = table.getElementsByClassName("codeline");
487 for (var i=0; i<lines.length; i++) {
488 var el = lines[i];
489 var lineNo = el.getAttribute("data-linenumber");
490 if (!lines_in_fid[lineNo]) {
491 if (hide) {
492 el.setAttribute("hidden", "");
493 } else {
494 el.removeAttribute("hidden");
495 }
496 }
497 }
498 }
499}
500
501window.addEventListener("keydown", function (event) {
502 if (event.defaultPrevented) {
503 return;
504 }
505 // SHIFT + S
506 if (event.shiftKey && event.keyCode == 83) {
507 var checked = document.getElementsByName("showCounterexample")[0].checked;
508 filterCounterexample(!checked);
509 document.getElementsByName("showCounterexample")[0].click();
510 } else {
511 return;
512 }
513 event.preventDefault();
514}, true);
515
516document.addEventListener("DOMContentLoaded", function() {
517 document.querySelector('input[name="showCounterexample"]').onchange=
518 function (event) {
519 filterCounterexample(this.checked);
520 };
521});
522</script>
523
524<form>
525 <input type="checkbox" name="showCounterexample" id="showCounterexample" />
526 <label for="showCounterexample">
527 Show only relevant lines
528 </label>
529 <input type="checkbox" name="showArrows"
530 id="showArrows" style="margin-left: 10px" />
531 <label for="showArrows">
532 Show control flow arrows
533 </label>
534</form>
535)<<<";
536
537 return s;
538}
539
540void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic& D, Rewriter &R,
541 const SourceManager& SMgr, const PathPieces& path, FileID FID,
542 const FileEntry *Entry, const char *declName) {
543 // This is a cludge; basically we want to append either the full
544 // working directory if we have no directory information. This is
545 // a work in progress.
546
547 llvm::SmallString<0> DirName;
548
549 if (llvm::sys::path::is_relative(Entry->getName())) {
550 llvm::sys::fs::current_path(DirName);
551 DirName += '/';
552 }
553
554 int LineNumber = path.back()->getLocation().asLocation().getExpansionLineNumber();
555 int ColumnNumber = path.back()->getLocation().asLocation().getExpansionColumnNumber();
556
557 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), showHelpJavascript());
558
559 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),
560 generateKeyboardNavigationJavascript());
561
562 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),
563 generateArrowDrawingJavascript());
564
565 // Checkbox and javascript for filtering the output to the counterexample.
566 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),
567 showRelevantLinesJavascript(D, path));
568
569 // Add the name of the file as an <h1> tag.
570 {
571 std::string s;
572 llvm::raw_string_ostream os(s);
573
574 os << "<!-- REPORTHEADER -->\n"
575 << "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n"
576 "<tr><td class=\"rowname\">File:</td><td>"
577 << html::EscapeText(DirName)
578 << html::EscapeText(Entry->getName())
579 << "</td></tr>\n<tr><td class=\"rowname\">Warning:</td><td>"
580 "<a href=\"#EndPath\">line "
581 << LineNumber
582 << ", column "
583 << ColumnNumber
584 << "</a><br />"
585 << D.getVerboseDescription() << "</td></tr>\n";
586
587 // The navigation across the extra notes pieces.
588 unsigned NumExtraPieces = 0;
589 for (const auto &Piece : path) {
590 if (const auto *P = dyn_cast<PathDiagnosticNotePiece>(Piece.get())) {
591 int LineNumber =
592 P->getLocation().asLocation().getExpansionLineNumber();
593 int ColumnNumber =
594 P->getLocation().asLocation().getExpansionColumnNumber();
595 os << "<tr><td class=\"rowname\">Note:</td><td>"
596 << "<a href=\"#Note" << NumExtraPieces << "\">line "
597 << LineNumber << ", column " << ColumnNumber << "</a><br />"
598 << P->getString() << "</td></tr>";
599 ++NumExtraPieces;
600 }
601 }
602
603 // Output any other meta data.
604
605 for (PathDiagnostic::meta_iterator I = D.meta_begin(), E = D.meta_end();
606 I != E; ++I) {
607 os << "<tr><td></td><td>" << html::EscapeText(*I) << "</td></tr>\n";
608 }
609
610 os << R"<<<(
611</table>
612<!-- REPORTSUMMARYEXTRA -->
613<h3>Annotated Source Code</h3>
614<p>Press <a href="#" onclick="toggleHelp(); return false;">'?'</a>
615 to see keyboard shortcuts</p>
616<input type="checkbox" class="spoilerhider" id="showinvocation" />
617<label for="showinvocation" >Show analyzer invocation</label>
618<div class="spoiler">clang -cc1 )<<<";
619 os << html::EscapeText(DiagOpts.ToolInvocation);
620 os << R"<<<(
621</div>
622<div id='tooltiphint' hidden="true">
623 <p>Keyboard shortcuts: </p>
624 <ul>
625 <li>Use 'j/k' keys for keyboard navigation</li>
626 <li>Use 'Shift+S' to show/hide relevant lines</li>
627 <li>Use '?' to toggle this window</li>
628 </ul>
629 <a href="#" onclick="toggleHelp(); return false;">Close</a>
630</div>
631)<<<";
632
633 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
634 }
635
636 // Embed meta-data tags.
637 {
638 std::string s;
639 llvm::raw_string_ostream os(s);
640
641 StringRef BugDesc = D.getVerboseDescription();
642 if (!BugDesc.empty())
643 os << "\n<!-- BUGDESC " << BugDesc << " -->\n";
644
645 StringRef BugType = D.getBugType();
646 if (!BugType.empty())
647 os << "\n<!-- BUGTYPE " << BugType << " -->\n";
648
649 PathDiagnosticLocation UPDLoc = D.getUniqueingLoc();
650 FullSourceLoc L(SMgr.getExpansionLoc(UPDLoc.isValid()
651 ? UPDLoc.asLocation()
652 : D.getLocation().asLocation()),
653 SMgr);
654
655 StringRef BugCategory = D.getCategory();
656 if (!BugCategory.empty())
657 os << "\n<!-- BUGCATEGORY " << BugCategory << " -->\n";
658
659 os << "\n<!-- BUGFILE " << DirName << Entry->getName() << " -->\n";
660
661 os << "\n<!-- FILENAME " << llvm::sys::path::filename(Entry->getName()) << " -->\n";
662
663 os << "\n<!-- FUNCTIONNAME " << declName << " -->\n";
664
665 os << "\n<!-- ISSUEHASHCONTENTOFLINEINCONTEXT " << getIssueHash(D, PP)
666 << " -->\n";
667
668 os << "\n<!-- BUGLINE "
669 << LineNumber
670 << " -->\n";
671
672 os << "\n<!-- BUGCOLUMN "
673 << ColumnNumber
674 << " -->\n";
675
676 os << "\n<!-- BUGPATHLENGTH " << getPathSizeWithoutArrows(path) << " -->\n";
677
678 // Mark the end of the tags.
679 os << "\n<!-- BUGMETAEND -->\n";
680
681 // Insert the text.
682 R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
683 }
684
685 html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry->getName());
686}
687
688StringRef HTMLDiagnostics::showHelpJavascript() {
689 return R"<<<(
690<script type='text/javascript'>
691
692var toggleHelp = function() {
693 var hint = document.querySelector("#tooltiphint");
694 var attributeName = "hidden";
695 if (hint.hasAttribute(attributeName)) {
696 hint.removeAttribute(attributeName);
697 } else {
698 hint.setAttribute("hidden", "true");
699 }
700};
701window.addEventListener("keydown", function (event) {
702 if (event.defaultPrevented) {
703 return;
704 }
705 if (event.key == "?") {
706 toggleHelp();
707 } else {
708 return;
709 }
710 event.preventDefault();
711});
712</script>
713)<<<";
714}
715
716static bool shouldDisplayPopUpRange(const SourceRange &Range) {
717 return !(Range.getBegin().isMacroID() || Range.getEnd().isMacroID());
718}
719
720static void
721HandlePopUpPieceStartTag(Rewriter &R,
722 const std::vector<SourceRange> &PopUpRanges) {
723 for (const auto &Range : PopUpRanges) {
724 if (!shouldDisplayPopUpRange(Range))
725 continue;
726
727 html::HighlightRange(R, Range.getBegin(), Range.getEnd(), "",
728 "<table class='variable_popup'><tbody>",
729 /*IsTokenRange=*/true);
730 }
731}
732
733static void HandlePopUpPieceEndTag(Rewriter &R,
734 const PathDiagnosticPopUpPiece &Piece,
735 std::vector<SourceRange> &PopUpRanges,
736 unsigned int LastReportedPieceIndex,
737 unsigned int PopUpPieceIndex) {
738 SmallString<256> Buf;
739 llvm::raw_svector_ostream Out(Buf);
740
741 SourceRange Range(Piece.getLocation().asRange());
742 if (!shouldDisplayPopUpRange(Range))
743 return;
744
745 // Write out the path indices with a right arrow and the message as a row.
746 Out << "<tr><td valign='top'><div class='PathIndex PathIndexPopUp'>"
747 << LastReportedPieceIndex;
748
749 // Also annotate the state transition with extra indices.
750 Out << '.' << PopUpPieceIndex;
751
752 Out << "</div></td><td>" << Piece.getString() << "</td></tr>";
753
754 // If no report made at this range mark the variable and add the end tags.
755 if (!llvm::is_contained(PopUpRanges, Range)) {
756 // Store that we create a report at this range.
757 PopUpRanges.push_back(Range);
758
759 Out << "</tbody></table></span>";
760 html::HighlightRange(R, Range.getBegin(), Range.getEnd(),
761 "<span class='variable'>", Buf.c_str(),
762 /*IsTokenRange=*/true);
763 } else {
764 // Otherwise inject just the new row at the end of the range.
765 html::HighlightRange(R, Range.getBegin(), Range.getEnd(), "", Buf.c_str(),
766 /*IsTokenRange=*/true);
767 }
768}
769
770void HTMLDiagnostics::RewriteFile(Rewriter &R, const PathPieces &path,
771 FileID FID) {
772
773 // Process the path.
774 // Maintain the counts of extra note pieces separately.
775 unsigned TotalPieces = getPathSizeWithoutArrows(path);
776 unsigned TotalNotePieces =
777 llvm::count_if(path, [](const PathDiagnosticPieceRef &p) {
778 return isa<PathDiagnosticNotePiece>(*p);
779 });
780 unsigned PopUpPieceCount =
781 llvm::count_if(path, [](const PathDiagnosticPieceRef &p) {
782 return isa<PathDiagnosticPopUpPiece>(*p);
783 });
784
785 unsigned TotalRegularPieces = TotalPieces - TotalNotePieces - PopUpPieceCount;
786 unsigned NumRegularPieces = TotalRegularPieces;
787 unsigned NumNotePieces = TotalNotePieces;
788 unsigned NumberOfArrows = 0;
789 // Stores the count of the regular piece indices.
790 std::map<int, int> IndexMap;
791 ArrowMap ArrowIndices(TotalRegularPieces + 1);
792
793 // Stores the different ranges where we have reported something.
794 std::vector<SourceRange> PopUpRanges;
795 for (const PathDiagnosticPieceRef &I : llvm::reverse(path)) {
796 const auto &Piece = *I.get();
797
798 if (isa<PathDiagnosticPopUpPiece>(Piece)) {
799 ++IndexMap[NumRegularPieces];
800 } else if (isa<PathDiagnosticNotePiece>(Piece)) {
801 // This adds diagnostic bubbles, but not navigation.
802 // Navigation through note pieces would be added later,
803 // as a separate pass through the piece list.
804 HandlePiece(R, FID, Piece, PopUpRanges, NumNotePieces, TotalNotePieces);
805 --NumNotePieces;
806
807 } else if (isArrowPiece(Piece)) {
808 NumberOfArrows = ProcessControlFlowPiece(
809 R, FID, cast<PathDiagnosticControlFlowPiece>(Piece), NumberOfArrows);
810 ArrowIndices[NumRegularPieces] = NumberOfArrows;
811
812 } else {
813 HandlePiece(R, FID, Piece, PopUpRanges, NumRegularPieces,
814 TotalRegularPieces);
815 --NumRegularPieces;
816 ArrowIndices[NumRegularPieces] = ArrowIndices[NumRegularPieces + 1];
817 }
818 }
819 ArrowIndices[0] = NumberOfArrows;
820
821 // At this point ArrowIndices represent the following data structure:
822 // [a_0, a_1, ..., a_N]
823 // where N is the number of events in the path.
824 //
825 // Then for every event with index i \in [0, N - 1], we can say that
826 // arrows with indices \in [a_(i+1), a_i) correspond to that event.
827 // We can say that because arrows with these indices appeared in the
828 // path in between the i-th and the (i+1)-th events.
829 assert(ArrowIndices.back() == 0 &&
830 "No arrows should be after the last event");
831 // This assertion also guarantees that all indices in are <= NumberOfArrows.
832 assert(llvm::is_sorted(ArrowIndices, std::greater<unsigned>()) &&
833 "Incorrect arrow indices map");
834
835 // Secondary indexing if we are having multiple pop-ups between two notes.
836 // (e.g. [(13) 'a' is 'true']; [(13.1) 'b' is 'false']; [(13.2) 'c' is...)
837 NumRegularPieces = TotalRegularPieces;
838 for (const PathDiagnosticPieceRef &I : llvm::reverse(path)) {
839 const auto &Piece = *I.get();
840
841 if (const auto *PopUpP = dyn_cast<PathDiagnosticPopUpPiece>(&Piece)) {
842 int PopUpPieceIndex = IndexMap[NumRegularPieces];
843
844 // Pop-up pieces needs the index of the last reported piece and its count
845 // how many times we report to handle multiple reports on the same range.
846 // This marks the variable, adds the </table> end tag and the message
847 // (list element) as a row. The <table> start tag will be added after the
848 // rows has been written out. Note: It stores every different range.
849 HandlePopUpPieceEndTag(R, *PopUpP, PopUpRanges, NumRegularPieces,
850 PopUpPieceIndex);
851
852 if (PopUpPieceIndex > 0)
853 --IndexMap[NumRegularPieces];
854
855 } else if (!isa<PathDiagnosticNotePiece>(Piece) && !isArrowPiece(Piece)) {
856 --NumRegularPieces;
857 }
858 }
859
860 // Add the <table> start tag of pop-up pieces based on the stored ranges.
861 HandlePopUpPieceStartTag(R, PopUpRanges);
862
863 // Add line numbers, header, footer, etc.
864 html::EscapeText(R, FID);
865 html::AddLineNumbers(R, FID);
866
867 addArrowSVGs(R, FID, ArrowIndices);
868
869 // If we have a preprocessor, relex the file and syntax highlight.
870 // We might not have a preprocessor if we come from a deserialized AST file,
871 // for example.
872 html::SyntaxHighlight(R, FID, PP);
873 html::HighlightMacros(R, FID, PP);
874}
875
876void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,
877 const PathDiagnosticPiece &P,
878 const std::vector<SourceRange> &PopUpRanges,
879 unsigned num, unsigned max) {
880 // For now, just draw a box above the line in question, and emit the
881 // warning.
882 FullSourceLoc Pos = P.getLocation().asLocation();
883
884 if (!Pos.isValid())
885 return;
886
887 SourceManager &SM = R.getSourceMgr();
888 assert(&Pos.getManager() == &SM && "SourceManagers are different!");
889 std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);
890
891 if (LPosInfo.first != BugFileID)
892 return;
893
894 llvm::MemoryBufferRef Buf = SM.getBufferOrFake(LPosInfo.first);
895 const char *FileStart = Buf.getBufferStart();
896
897 // Compute the column number. Rewind from the current position to the start
898 // of the line.
899 unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
900 const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
901 const char *LineStart = TokInstantiationPtr-ColNo;
902
903 // Compute LineEnd.
904 const char *LineEnd = TokInstantiationPtr;
905 const char *FileEnd = Buf.getBufferEnd();
906 while (*LineEnd != '\n' && LineEnd != FileEnd)
907 ++LineEnd;
908
909 // Compute the margin offset by counting tabs and non-tabs.
910 unsigned PosNo = 0;
911 for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
912 PosNo += *c == '\t' ? 8 : 1;
913
914 // Create the html for the message.
915
916 const char *Kind = nullptr;
917 bool IsNote = false;
918 bool SuppressIndex = (max == 1);
919 switch (P.getKind()) {
920 case PathDiagnosticPiece::Event: Kind = "Event"; break;
921 case PathDiagnosticPiece::ControlFlow: Kind = "Control"; break;
922 // Setting Kind to "Control" is intentional.
923 case PathDiagnosticPiece::Macro: Kind = "Control"; break;
924 case PathDiagnosticPiece::Note:
925 Kind = "Note";
926 IsNote = true;
927 SuppressIndex = true;
928 break;
929 case PathDiagnosticPiece::Call:
930 case PathDiagnosticPiece::PopUp:
931 llvm_unreachable("Calls and extra notes should already be handled");
932 }
933
934 std::string sbuf;
935 llvm::raw_string_ostream os(sbuf);
936
937 os << "\n<tr><td class=\"num\"></td><td class=\"line\"><div id=\"";
938
939 if (IsNote)
940 os << "Note" << num;
941 else if (num == max)
942 os << "EndPath";
943 else
944 os << "Path" << num;
945
946 os << "\" class=\"msg";
947 if (Kind)
948 os << " msg" << Kind;
949 os << "\" style=\"margin-left:" << PosNo << "ex";
950
951 // Output a maximum size.
952 if (!isa<PathDiagnosticMacroPiece>(P)) {
953 // Get the string and determining its maximum substring.
954 const auto &Msg = P.getString();
955 unsigned max_token = 0;
956 unsigned cnt = 0;
957 unsigned len = Msg.size();
958
959 for (char C : Msg)
960 switch (C) {
961 default:
962 ++cnt;
963 continue;
964 case ' ':
965 case '\t':
966 case '\n':
967 if (cnt > max_token) max_token = cnt;
968 cnt = 0;
969 }
970
971 if (cnt > max_token)
972 max_token = cnt;
973
974 // Determine the approximate size of the message bubble in em.
975 unsigned em;
976 const unsigned max_line = 120;
977
978 if (max_token >= max_line)
979 em = max_token / 2;
980 else {
981 unsigned characters = max_line;
982 unsigned lines = len / max_line;
983
984 if (lines > 0) {
985 for (; characters > max_token; --characters)
986 if (len / characters > lines) {
987 ++characters;
988 break;
989 }
990 }
991
992 em = characters / 2;
993 }
994
995 if (em < max_line/2)
996 os << "; max-width:" << em << "em";
997 }
998 else
999 os << "; max-width:100em";
1000
1001 os << "\">";
1002
1003 if (!SuppressIndex) {
1004 os << "<table class=\"msgT\"><tr><td valign=\"top\">";
1005 os << "<div class=\"PathIndex";
1006 if (Kind) os << " PathIndex" << Kind;
1007 os << "\">" << num << "</div>";
1008
1009 if (num > 1) {
1010 os << "</td><td><div class=\"PathNav\"><a href=\"#Path"
1011 << (num - 1)
1012 << "\" title=\"Previous event ("
1013 << (num - 1)
1014 << ")\">&#x2190;</a></div>";
1015 }
1016
1017 os << "</td><td>";
1018 }
1019
1020 if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(&P)) {
1021 os << "Within the expansion of the macro '";
1022
1023 // Get the name of the macro by relexing it.
1024 {
1025 FullSourceLoc L = MP->getLocation().asLocation().getExpansionLoc();
1026 assert(L.isFileID());
1027 StringRef BufferInfo = L.getBufferData();
1028 std::pair<FileID, unsigned> LocInfo = L.getDecomposedLoc();
1029 const char* MacroName = LocInfo.second + BufferInfo.data();
1030 Lexer rawLexer(SM.getLocForStartOfFile(LocInfo.first), PP.getLangOpts(),
1031 BufferInfo.begin(), MacroName, BufferInfo.end());
1032
1033 Token TheTok;
1034 rawLexer.LexFromRawLexer(TheTok);
1035 for (unsigned i = 0, n = TheTok.getLength(); i < n; ++i)
1036 os << MacroName[i];
1037 }
1038
1039 os << "':\n";
1040
1041 if (!SuppressIndex) {
1042 os << "</td>";
1043 if (num < max) {
1044 os << "<td><div class=\"PathNav\"><a href=\"#";
1045 if (num == max - 1)
1046 os << "EndPath";
1047 else
1048 os << "Path" << (num + 1);
1049 os << "\" title=\"Next event ("
1050 << (num + 1)
1051 << ")\">&#x2192;</a></div></td>";
1052 }
1053
1054 os << "</tr></table>";
1055 }
1056
1057 // Within a macro piece. Write out each event.
1058 ProcessMacroPiece(os, *MP, 0);
1059 }
1060 else {
1061 os << html::EscapeText(P.getString());
1062
1063 if (!SuppressIndex) {
1064 os << "</td>";
1065 if (num < max) {
1066 os << "<td><div class=\"PathNav\"><a href=\"#";
1067 if (num == max - 1)
1068 os << "EndPath";
1069 else
1070 os << "Path" << (num + 1);
1071 os << "\" title=\"Next event ("
1072 << (num + 1)
1073 << ")\">&#x2192;</a></div></td>";
1074 }
1075
1076 os << "</tr></table>";
1077 }
1078 }
1079
1080 os << "</div></td></tr>";
1081
1082 // Insert the new html.
1083 unsigned DisplayPos = LineEnd - FileStart;
1084 SourceLocation Loc =
1085 SM.getLocForStartOfFile(LPosInfo.first).getLocWithOffset(DisplayPos);
1086
1087 R.InsertTextBefore(Loc, os.str());
1088
1089 // Now highlight the ranges.
1090 ArrayRef<SourceRange> Ranges = P.getRanges();
1091 for (const auto &Range : Ranges) {
1092 // If we have already highlighted the range as a pop-up there is no work.
1093 if (llvm::is_contained(PopUpRanges, Range))
1094 continue;
1095
1096 HighlightRange(R, LPosInfo.first, Range);
1097 }
1098}
1099
1100static void EmitAlphaCounter(raw_ostream &os, unsigned n) {
1101 unsigned x = n % ('z' - 'a');
1102 n /= 'z' - 'a';
1103
1104 if (n > 0)
1105 EmitAlphaCounter(os, n);
1106
1107 os << char('a' + x);
1108}
1109
1110unsigned HTMLDiagnostics::ProcessMacroPiece(raw_ostream &os,
1111 const PathDiagnosticMacroPiece& P,
1112 unsigned num) {
1113 for (const auto &subPiece : P.subPieces) {
1114 if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(subPiece.get())) {
1115 num = ProcessMacroPiece(os, *MP, num);
1116 continue;
1117 }
1118
1119 if (const auto *EP = dyn_cast<PathDiagnosticEventPiece>(subPiece.get())) {
1120 os << "<div class=\"msg msgEvent\" style=\"width:94%; "
1121 "margin-left:5px\">"
1122 "<table class=\"msgT\"><tr>"
1123 "<td valign=\"top\"><div class=\"PathIndex PathIndexEvent\">";
1124 EmitAlphaCounter(os, num++);
1125 os << "</div></td><td valign=\"top\">"
1126 << html::EscapeText(EP->getString())
1127 << "</td></tr></table></div>\n";
1128 }
1129 }
1130
1131 return num;
1132}
1133
1134void HTMLDiagnostics::addArrowSVGs(Rewriter &R, FileID BugFileID,
1135 const ArrowMap &ArrowIndices) {
1136 std::string S;
1137 llvm::raw_string_ostream OS(S);
1138
1139 OS << R"<<<(
1140<style type="text/css">
1141 svg {
1142 position:absolute;
1143 top:0;
1144 left:0;
1145 height:100%;
1146 width:100%;
1147 pointer-events: none;
1148 overflow: visible
1149 }
1150 .arrow {
1151 stroke-opacity: 0.2;
1152 stroke-width: 1;
1153 marker-end: url(#arrowhead);
1154 }
1155
1156 .arrow.selected {
1157 stroke-opacity: 0.6;
1158 stroke-width: 2;
1159 marker-end: url(#arrowheadSelected);
1160 }
1161
1162 .arrowhead {
1163 orient: auto;
1164 stroke: none;
1165 opacity: 0.6;
1166 fill: blue;
1167 }
1168</style>
1169<svg xmlns="http://www.w3.org/2000/svg">
1170 <defs>
1171 <marker id="arrowheadSelected" class="arrowhead" opacity="0.6"
1172 viewBox="0 0 10 10" refX="3" refY="5"
1173 markerWidth="4" markerHeight="4">
1174 <path d="M 0 0 L 10 5 L 0 10 z" />
1175 </marker>
1176 <marker id="arrowhead" class="arrowhead" opacity="0.2"
1177 viewBox="0 0 10 10" refX="3" refY="5"
1178 markerWidth="4" markerHeight="4">
1179 <path d="M 0 0 L 10 5 L 0 10 z" />
1180 </marker>
1181 </defs>
1182 <g id="arrows" fill="none" stroke="blue" visibility="hidden">
1183)<<<";
1184
1185 for (unsigned Index : llvm::seq(0u, ArrowIndices.getTotalNumberOfArrows())) {
1186 OS << " <path class=\"arrow\" id=\"arrow" << Index << "\"/>\n";
1187 }
1188
1189 OS << R"<<<(
1190 </g>
1191</svg>
1192<script type='text/javascript'>
1193const arrowIndices = )<<<";
1194
1195 OS << ArrowIndices << "\n</script>\n";
1196
1197 R.InsertTextBefore(R.getSourceMgr().getLocForStartOfFile(BugFileID),
1198 OS.str());
1199}
1200
1201std::string getSpanBeginForControl(const char *ClassName, unsigned Index) {
1202 std::string Result;
1203 llvm::raw_string_ostream OS(Result);
1204 OS << "<span id=\"" << ClassName << Index << "\">";
1205 return Result;
1206}
1207
1208std::string getSpanBeginForControlStart(unsigned Index) {
1209 return getSpanBeginForControl("start", Index);
1210}
1211
1212std::string getSpanBeginForControlEnd(unsigned Index) {
1213 return getSpanBeginForControl("end", Index);
1214}
1215
1216unsigned HTMLDiagnostics::ProcessControlFlowPiece(
1217 Rewriter &R, FileID BugFileID, const PathDiagnosticControlFlowPiece &P,
1218 unsigned Number) {
1219 for (const PathDiagnosticLocationPair &LPair : P) {
1220 std::string Start = getSpanBeginForControlStart(Number),
1221 End = getSpanBeginForControlEnd(Number++);
1222
1223 HighlightRange(R, BugFileID, LPair.getStart().asRange().getBegin(),
1224 Start.c_str());
1225 HighlightRange(R, BugFileID, LPair.getEnd().asRange().getBegin(),
1226 End.c_str());
1227 }
1228
1229 return Number;
1230}
1231
1232void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID,
1233 SourceRange Range,
1234 const char *HighlightStart,
1235 const char *HighlightEnd) {
1236 SourceManager &SM = R.getSourceMgr();
1237 const LangOptions &LangOpts = R.getLangOpts();
1238
1239 SourceLocation InstantiationStart = SM.getExpansionLoc(Range.getBegin());
1240 unsigned StartLineNo = SM.getExpansionLineNumber(InstantiationStart);
1241
1242 SourceLocation InstantiationEnd = SM.getExpansionLoc(Range.getEnd());
1243 unsigned EndLineNo = SM.getExpansionLineNumber(InstantiationEnd);
1244
1245 if (EndLineNo < StartLineNo)
1246 return;
1247
1248 if (SM.getFileID(InstantiationStart) != BugFileID ||
1249 SM.getFileID(InstantiationEnd) != BugFileID)
1250 return;
1251
1252 // Compute the column number of the end.
1253 unsigned EndColNo = SM.getExpansionColumnNumber(InstantiationEnd);
1254 unsigned OldEndColNo = EndColNo;
1255
1256 if (EndColNo) {
1257 // Add in the length of the token, so that we cover multi-char tokens.
1258 EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts)-1;
1259 }
1260
1261 // Highlight the range. Make the span tag the outermost tag for the
1262 // selected range.
1263
1264 SourceLocation E =
1265 InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
1266
1267 html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
1268}
1269
1270StringRef HTMLDiagnostics::generateKeyboardNavigationJavascript() {
1271 return R"<<<(
1272<script type='text/javascript'>
1273var digitMatcher = new RegExp("[0-9]+");
1274
1275var querySelectorAllArray = function(selector) {
1276 return Array.prototype.slice.call(
1277 document.querySelectorAll(selector));
1278}
1279
1280document.addEventListener("DOMContentLoaded", function() {
1281 querySelectorAllArray(".PathNav > a").forEach(
1282 function(currentValue, currentIndex) {
1283 var hrefValue = currentValue.getAttribute("href");
1284 currentValue.onclick = function() {
1285 scrollTo(document.querySelector(hrefValue));
1286 return false;
1287 };
1288 });
1289});
1290
1291var findNum = function() {
1292 var s = document.querySelector(".msg.selected");
1293 if (!s || s.id == "EndPath") {
1294 return 0;
1295 }
1296 var out = parseInt(digitMatcher.exec(s.id)[0]);
1297 return out;
1298};
1299
1300var classListAdd = function(el, theClass) {
1301 if(!el.className.baseVal)
1302 el.className += " " + theClass;
1303 else
1304 el.className.baseVal += " " + theClass;
1305};
1306
1307var classListRemove = function(el, theClass) {
1308 var className = (!el.className.baseVal) ?
1309 el.className : el.className.baseVal;
1310 className = className.replace(" " + theClass, "");
1311 if(!el.className.baseVal)
1312 el.className = className;
1313 else
1314 el.className.baseVal = className;
1315};
1316
1317var scrollTo = function(el) {
1318 querySelectorAllArray(".selected").forEach(function(s) {
1319 classListRemove(s, "selected");
1320 });
1321 classListAdd(el, "selected");
1322 window.scrollBy(0, el.getBoundingClientRect().top -
1323 (window.innerHeight / 2));
1324 highlightArrowsForSelectedEvent();
1325};
1326
1327var move = function(num, up, numItems) {
1328 if (num == 1 && up || num == numItems - 1 && !up) {
1329 return 0;
1330 } else if (num == 0 && up) {
1331 return numItems - 1;
1332 } else if (num == 0 && !up) {
1333 return 1 % numItems;
1334 }
1335 return up ? num - 1 : num + 1;
1336}
1337
1338var numToId = function(num) {
1339 if (num == 0) {
1340 return document.getElementById("EndPath")
1341 }
1342 return document.getElementById("Path" + num);
1343};
1344
1345var navigateTo = function(up) {
1346 var numItems = document.querySelectorAll(
1347 ".line > .msgEvent, .line > .msgControl").length;
1348 var currentSelected = findNum();
1349 var newSelected = move(currentSelected, up, numItems);
1350 var newEl = numToId(newSelected, numItems);
1351
1352 // Scroll element into center.
1353 scrollTo(newEl);
1354};
1355
1356window.addEventListener("keydown", function (event) {
1357 if (event.defaultPrevented) {
1358 return;
1359 }
1360 // key 'j'
1361 if (event.keyCode == 74) {
1362 navigateTo(/*up=*/false);
1363 // key 'k'
1364 } else if (event.keyCode == 75) {
1365 navigateTo(/*up=*/true);
1366 } else {
1367 return;
1368 }
1369 event.preventDefault();
1370}, true);
1371</script>
1372 )<<<";
1373}
1374
1375StringRef HTMLDiagnostics::generateArrowDrawingJavascript() {
1376 return R"<<<(
1377<script type='text/javascript'>
1378// Return range of numbers from a range [lower, upper).
1379function range(lower, upper) {
1380 var array = [];
1381 for (var i = lower; i <= upper; ++i) {
1382 array.push(i);
1383 }
1384 return array;
1385}
1386
1387var getRelatedArrowIndices = function(pathId) {
1388 // HTML numeration of events is a bit different than it is in the path.
1389 // Everything is rotated one step to the right, so the last element
1390 // (error diagnostic) has index 0.
1391 if (pathId == 0) {
1392 // arrowIndices has at least 2 elements
1393 pathId = arrowIndices.length - 1;
1394 }
1395
1396 return range(arrowIndices[pathId], arrowIndices[pathId - 1]);
1397}
1398
1399var highlightArrowsForSelectedEvent = function() {
1400 const selectedNum = findNum();
1401 const arrowIndicesToHighlight = getRelatedArrowIndices(selectedNum);
1402 arrowIndicesToHighlight.forEach((index) => {
1403 var arrow = document.querySelector("#arrow" + index);
1404 if(arrow) {
1405 classListAdd(arrow, "selected")
1406 }
1407 });
1408}
1409
1410var getAbsoluteBoundingRect = function(element) {
1411 const relative = element.getBoundingClientRect();
1412 return {
1413 left: relative.left + window.pageXOffset,
1414 right: relative.right + window.pageXOffset,
1415 top: relative.top + window.pageYOffset,
1416 bottom: relative.bottom + window.pageYOffset,
1417 height: relative.height,
1418 width: relative.width
1419 };
1420}
1421
1422var drawArrow = function(index) {
1423 // This function is based on the great answer from SO:
1424 // https://stackoverflow.com/a/39575674/11582326
1425 var start = document.querySelector("#start" + index);
1426 var end = document.querySelector("#end" + index);
1427 var arrow = document.querySelector("#arrow" + index);
1428
1429 var startRect = getAbsoluteBoundingRect(start);
1430 var endRect = getAbsoluteBoundingRect(end);
1431
1432 // It is an arrow from a token to itself, no need to visualize it.
1433 if (startRect.top == endRect.top &&
1434 startRect.left == endRect.left)
1435 return;
1436
1437 // Each arrow is a very simple B├ęzier curve, with two nodes and
1438 // two handles. So, we need to calculate four points in the window:
1439 // * start node
1440 var posStart = { x: 0, y: 0 };
1441 // * end node
1442 var posEnd = { x: 0, y: 0 };
1443 // * handle for the start node
1444 var startHandle = { x: 0, y: 0 };
1445 // * handle for the end node
1446 var endHandle = { x: 0, y: 0 };
1447 // One can visualize it as follows:
1448 //
1449 // start handle
1450 // /
1451 // X"""_.-""""X
1452 // .' \
1453 // / start node
1454 // |
1455 // |
1456 // | end node
1457 // \ /
1458 // `->X
1459 // X-'
1460 // \
1461 // end handle
1462 //
1463 // NOTE: (0, 0) is the top left corner of the window.
1464
1465 // We have 3 similar, but still different scenarios to cover:
1466 //
1467 // 1. Two tokens on different lines.
1468 // -xxx
1469 // /
1470 // \
1471 // -> xxx
1472 // In this situation, we draw arrow on the left curving to the left.
1473 // 2. Two tokens on the same line, and the destination is on the right.
1474 // ____
1475 // / \
1476 // / V
1477 // xxx xxx
1478 // In this situation, we draw arrow above curving upwards.
1479 // 3. Two tokens on the same line, and the destination is on the left.
1480 // xxx xxx
1481 // ^ /
1482 // \____/
1483 // In this situation, we draw arrow below curving downwards.
1484 const onDifferentLines = startRect.top <= endRect.top - 5 ||
1485 startRect.top >= endRect.top + 5;
1486 const leftToRight = startRect.left < endRect.left;
1487
1488 // NOTE: various magic constants are chosen empirically for
1489 // better positioning and look
1490 if (onDifferentLines) {
1491 // Case #1
1492 const topToBottom = startRect.top < endRect.top;
1493 posStart.x = startRect.left - 1;
1494 // We don't want to start it at the top left corner of the token,
1495 // it doesn't feel like this is where the arrow comes from.
1496 // For this reason, we start it in the middle of the left side
1497 // of the token.
1498 posStart.y = startRect.top + startRect.height / 2;
1499
1500 // End node has arrow head and we give it a bit more space.
1501 posEnd.x = endRect.left - 4;
1502 posEnd.y = endRect.top;
1503
1504 // Utility object with x and y offsets for handles.
1505 var curvature = {
1506 // We want bottom-to-top arrow to curve a bit more, so it doesn't
1507 // overlap much with top-to-bottom curves (much more frequent).
1508 x: topToBottom ? 15 : 25,
1509 y: Math.min((posEnd.y - posStart.y) / 3, 10)
1510 }
1511
1512 // When destination is on the different line, we can make a
1513 // curvier arrow because we have space for it.
1514 // So, instead of using
1515 //
1516 // startHandle.x = posStart.x - curvature.x
1517 // endHandle.x = posEnd.x - curvature.x
1518 //
1519 // We use the leftmost of these two values for both handles.
1520 startHandle.x = Math.min(posStart.x, posEnd.x) - curvature.x;
1521 endHandle.x = startHandle.x;
1522
1523 // Curving downwards from the start node...
1524 startHandle.y = posStart.y + curvature.y;
1525 // ... and upwards from the end node.
1526 endHandle.y = posEnd.y - curvature.y;
1527
1528 } else if (leftToRight) {
1529 // Case #2
1530 // Starting from the top right corner...
1531 posStart.x = startRect.right - 1;
1532 posStart.y = startRect.top;
1533
1534 // ...and ending at the top left corner of the end token.
1535 posEnd.x = endRect.left + 1;
1536 posEnd.y = endRect.top - 1;
1537
1538 // Utility object with x and y offsets for handles.
1539 var curvature = {
1540 x: Math.min((posEnd.x - posStart.x) / 3, 15),
1541 y: 5
1542 }
1543
1544 // Curving to the right...
1545 startHandle.x = posStart.x + curvature.x;
1546 // ... and upwards from the start node.
1547 startHandle.y = posStart.y - curvature.y;
1548
1549 // And to the left...
1550 endHandle.x = posEnd.x - curvature.x;
1551 // ... and upwards from the end node.
1552 endHandle.y = posEnd.y - curvature.y;
1553
1554 } else {
1555 // Case #3
1556 // Starting from the bottom right corner...
1557 posStart.x = startRect.right;
1558 posStart.y = startRect.bottom;
1559
1560 // ...and ending also at the bottom right corner, but of the end token.
1561 posEnd.x = endRect.right - 1;
1562 posEnd.y = endRect.bottom + 1;
1563
1564 // Utility object with x and y offsets for handles.
1565 var curvature = {
1566 x: Math.min((posStart.x - posEnd.x) / 3, 15),
1567 y: 5
1568 }
1569
1570 // Curving to the left...
1571 startHandle.x = posStart.x - curvature.x;
1572 // ... and downwards from the start node.
1573 startHandle.y = posStart.y + curvature.y;
1574
1575 // And to the right...
1576 endHandle.x = posEnd.x + curvature.x;
1577 // ... and downwards from the end node.
1578 endHandle.y = posEnd.y + curvature.y;
1579 }
1580
1581 // Put it all together into a path.
1582 // More information on the format:
1583 // https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths
1584 var pathStr = "M" + posStart.x + "," + posStart.y + " " +
1585 "C" + startHandle.x + "," + startHandle.y + " " +
1586 endHandle.x + "," + endHandle.y + " " +
1587 posEnd.x + "," + posEnd.y;
1588
1589 arrow.setAttribute("d", pathStr);
1590};
1591
1592var drawArrows = function() {
1593 const numOfArrows = document.querySelectorAll("path[id^=arrow]").length;
1594 for (var i = 0; i < numOfArrows; ++i) {
1595 drawArrow(i);
1596 }
1597}
1598
1599var toggleArrows = function(event) {
1600 const arrows = document.querySelector("#arrows");
1601 if (event.target.checked) {
1602 arrows.setAttribute("visibility", "visible");
1603 } else {
1604 arrows.setAttribute("visibility", "hidden");
1605 }
1606}
1607
1608window.addEventListener("resize", drawArrows);
1609document.addEventListener("DOMContentLoaded", function() {
1610 // Whenever we show invocation, locations change, i.e. we
1611 // need to redraw arrows.
1612 document
1613 .querySelector('input[id="showinvocation"]')
1614 .addEventListener("click", drawArrows);
1615 // Hiding irrelevant lines also should cause arrow rerender.
1616 document
1617 .querySelector('input[name="showCounterexample"]')
1618 .addEventListener("change", drawArrows);
1619 document
1620 .querySelector('input[name="showArrows"]')
1621 .addEventListener("change", toggleArrows);
1622 drawArrows();
1623 // Default highlighting for the last event.
1624 highlightArrowsForSelectedEvent();
1625});
1626</script>
1627 )<<<";
1628}
1629

source code of clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp