//===- HTMLDiagnostics.cpp - HTML Diagnostics for Paths -------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file defines the HTMLDiagnostics object.

//

//===----------------------------------------------------------------------===//

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/Stmt.h"

#include "clang/Analysis/IssueHash.h"

#include "clang/Analysis/MacroExpansionContext.h"

#include "clang/Analysis/PathDiagnostic.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Lex/Lexer.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Lex/Token.h"

#include "clang/Rewrite/Core/HTMLRewrite.h"

#include "clang/Rewrite/Core/Rewriter.h"

#include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/Sequence.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Errc.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>

#include <cassert>

#include <map>

#include <memory>

#include <set>

#include <sstream>

#include <string>

#include <system_error>

#include <utility>

#include <vector>

using namespace clang;

using namespace ento;

//===----------------------------------------------------------------------===//

// Boilerplate.

//===----------------------------------------------------------------------===//

namespace {

class ArrowMap;

class HTMLDiagnostics : public PathDiagnosticConsumer {

  PathDiagnosticConsumerOptions DiagOpts;

  std::string Directory;

  bool createdDir = false;

  bool noDir = false;

  const Preprocessor &PP;

  const bool SupportsCrossFileDiagnostics;

public:

  HTMLDiagnostics(PathDiagnosticConsumerOptions DiagOpts,

                  const std::string &OutputDir, const Preprocessor &pp,

                  bool supportsMultipleFiles)

      : DiagOpts(std::move(DiagOpts)), Directory(OutputDir), PP(pp),

        SupportsCrossFileDiagnostics(supportsMultipleFiles) {}

  ~HTMLDiagnostics() override { FlushDiagnostics(nullptr); }

  void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,

                            FilesMade *filesMade) override;

  StringRef getName() const override { return "HTMLDiagnostics"; }

  bool supportsCrossFileDiagnostics() const override {

    return SupportsCrossFileDiagnostics;

  }

  unsigned ProcessMacroPiece(raw_ostream &os, const PathDiagnosticMacroPiece &P,

                             unsigned num);

  unsigned ProcessControlFlowPiece(Rewriter &R, FileID BugFileID,

                                   const PathDiagnosticControlFlowPiece &P,

                                   unsigned Number);

  void HandlePiece(Rewriter &R, FileID BugFileID, const PathDiagnosticPiece &P,

                   const std::vector<SourceRange> &PopUpRanges, unsigned num,

                   unsigned max);

  void HighlightRange(Rewriter &R, FileID BugFileID, SourceRange Range,

                      const char *HighlightStart = "<span class=\"mrange\">",

                      const char *HighlightEnd = "</span>");

  void ReportDiag(const PathDiagnostic &D, FilesMade *filesMade);

  // Generate the full HTML report

  std::string GenerateHTML(const PathDiagnostic &D, Rewriter &R,

                           const SourceManager &SMgr, const PathPieces &path,

                           const char *declName);

  // Add HTML header/footers to file specified by FID

  void FinalizeHTML(const PathDiagnostic &D, Rewriter &R,

                    const SourceManager &SMgr, const PathPieces &path,

                    FileID FID, FileEntryRef Entry, const char *declName);

  // Rewrite the file specified by FID with HTML formatting.

  void RewriteFile(Rewriter &R, const PathPieces &path, FileID FID);

  PathGenerationScheme getGenerationScheme() const override {

    return Everything;

  }

private:

  void addArrowSVGs(Rewriter &R, FileID BugFileID,

                    const ArrowMap &ArrowIndices);

  /// \return Javascript for displaying shortcuts help;

  StringRef showHelpJavascript();

  /// \return Javascript for navigating the HTML report using j/k keys.

  StringRef generateKeyboardNavigationJavascript();

  /// \return Javascript for drawing control-flow arrows.

  StringRef generateArrowDrawingJavascript();

  /// \return JavaScript for an option to only show relevant lines.

  std::string showRelevantLinesJavascript(const PathDiagnostic &D,

                                          const PathPieces &path);

  /// Write executed lines from \p D in JSON format into \p os.

  void dumpCoverageData(const PathDiagnostic &D, const PathPieces &path,

                        llvm::raw_string_ostream &os);

};

bool isArrowPiece(const PathDiagnosticPiece &P) {

  return isa<PathDiagnosticControlFlowPiece>(P) && 
P.getString().empty()1.42k
;

}

unsigned getPathSizeWithoutArrows(const PathPieces &Path) {

  unsigned TotalPieces = Path.size();

  unsigned TotalArrowPieces = llvm::count_if(

      Path, [](const PathDiagnosticPieceRef &P) { return isArrowPiece(*P); });

  return TotalPieces - TotalArrowPieces;

}

class ArrowMap : public std::vector<unsigned> {

  using Base = std::vector<unsigned>;

public:

  ArrowMap(unsigned Size) : Base(Size, 0) {}

  unsigned getTotalNumberOfArrows() const { return at(0); }

};

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const ArrowMap &Indices) {

  OS << "[ ";

  llvm::interleave(Indices, OS, ",");

  return OS << " ]";

}

} // namespace

void ento::createHTMLDiagnosticConsumer(

    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,

    const std::string &OutputDir, const Preprocessor &PP,

    const cross_tu::CrossTranslationUnitContext &CTU,

    const MacroExpansionContext &MacroExpansions) {

  // FIXME: HTML is currently our default output type, but if the output

  // directory isn't specified, it acts like if it was in the minimal text

  // output mode. This doesn't make much sense, we should have the minimal text

  // as our default. In the case of backward compatibility concerns, this could

  // be preserved with -analyzer-config-compatibility-mode=true.

  createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU,

                                          MacroExpansions);

  // TODO: Emit an error here.

  if (OutputDir.empty())

    return;

  C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, true));

}

void ento::createHTMLSingleFileDiagnosticConsumer(

    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,

    const std::string &OutputDir, const Preprocessor &PP,

    const cross_tu::CrossTranslationUnitContext &CTU,

    const clang::MacroExpansionContext &MacroExpansions) {

  createTextMinimalPathDiagnosticConsumer(DiagOpts, C, OutputDir, PP, CTU,

                                          MacroExpansions);

  // TODO: Emit an error here.

  if (OutputDir.empty())

    return;

  C.push_back(new HTMLDiagnostics(std::move(DiagOpts), OutputDir, PP, false));

}

void ento::createPlistHTMLDiagnosticConsumer(

    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,

    const std::string &prefix, const Preprocessor &PP,

    const cross_tu::CrossTranslationUnitContext &CTU,

    const MacroExpansionContext &MacroExpansions) {

  createHTMLDiagnosticConsumer(

      DiagOpts, C, std::string(llvm::sys::path::parent_path(prefix)), PP, CTU,

      MacroExpansions);

  createPlistMultiFileDiagnosticConsumer(DiagOpts, C, prefix, PP, CTU,

                                         MacroExpansions);

  createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, prefix, PP,

                                          CTU, MacroExpansions);

}

void ento::createSarifHTMLDiagnosticConsumer(

    PathDiagnosticConsumerOptions DiagOpts, PathDiagnosticConsumers &C,

    const std::string &sarif_file, const Preprocessor &PP,

    const cross_tu::CrossTranslationUnitContext &CTU,

    const MacroExpansionContext &MacroExpansions) {

  createHTMLDiagnosticConsumer(

      DiagOpts, C, std::string(llvm::sys::path::parent_path(sarif_file)), PP,

      CTU, MacroExpansions);

  createSarifDiagnosticConsumer(DiagOpts, C, sarif_file, PP, CTU,

                                MacroExpansions);

  createTextMinimalPathDiagnosticConsumer(std::move(DiagOpts), C, sarif_file,

                                          PP, CTU, MacroExpansions);

}

//===----------------------------------------------------------------------===//

// Report processing.

//===----------------------------------------------------------------------===//

void HTMLDiagnostics::FlushDiagnosticsImpl(

  std::vector<const PathDiagnostic *> &Diags,

  FilesMade *filesMade) {

  for (const auto Diag : Diags)

    ReportDiag(*Diag, filesMade);

}

static llvm::SmallString<32> getIssueHash(const PathDiagnostic &D,

                                          const Preprocessor &PP) {

  SourceManager &SMgr = PP.getSourceManager();

  PathDiagnosticLocation UPDLoc = D.getUniqueingLoc();

  FullSourceLoc L(SMgr.getExpansionLoc(UPDLoc.isValid()

                                           ? 
UPDLoc.asLocation()4

                                           : 
D.getLocation().asLocation()206
),

                  SMgr);

  return getIssueHash(L, D.getCheckerName(), D.getBugType(),

                      D.getDeclWithIssue(), PP.getLangOpts());

}

void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,

                                 FilesMade *filesMade) {

  // Create the HTML directory if it is missing.

  if (!createdDir) {

    createdDir = true;

    if (std::error_code ec = llvm::sys::fs::create_directories(Directory)) {

      llvm::errs() << "warning: could not create directory '"

                   << Directory << "': " << ec.message() << '\n';

      noDir = true;

      return;

    }

  }

  if (noDir)

    return;

  // First flatten out the entire path to make it easier to use.

  PathPieces path = D.path.flatten(/*ShouldFlattenMacros=*/false);

  // The path as already been prechecked that the path is non-empty.

  assert(!path.empty());

  const SourceManager &SMgr = path.front()->getLocation().getManager();

  // Create a new rewriter to generate HTML.

  Rewriter R(const_cast<SourceManager&>(SMgr), PP.getLangOpts());

  // Get the function/method name

  SmallString<128> declName("unknown");

  int offsetDecl = 0;

  if (const Decl *DeclWithIssue = D.getDeclWithIssue()) {

      if (const auto *ND = dyn_cast<NamedDecl>(DeclWithIssue))

          declName = ND->getDeclName().getAsString();

      if (const Stmt *Body = DeclWithIssue->getBody()) {

          // Retrieve the relative position of the declaration which will be used

          // for the file name

          FullSourceLoc L(

              SMgr.getExpansionLoc(path.back()->getLocation().asLocation()),

              SMgr);

          FullSourceLoc FunL(SMgr.getExpansionLoc(Body->getBeginLoc()), SMgr);

          offsetDecl = L.getExpansionLineNumber() - FunL.getExpansionLineNumber();

      }

  }

  std::string report = GenerateHTML(D, R, SMgr, path, declName.c_str());

  if (report.empty()) {

    llvm::errs() << "warning: no diagnostics generated for main file.\n";

    return;

  }

  // Create a path for the target HTML file.

  int FD;

  SmallString<128> FileNameStr;

  llvm::raw_svector_ostream FileName(FileNameStr);

  FileName << "report-";

  // Historically, neither the stable report filename nor the unstable report

  // filename were actually stable. That said, the stable report filename

  // was more stable because it was mostly composed of information

  // about the bug report instead of being completely random.

  // Now both stable and unstable report filenames are in fact stable

  // but the stable report filename is still more verbose.

  if (DiagOpts.ShouldWriteVerboseReportFilename) {

    // FIXME: This code relies on knowing what constitutes the issue hash.

    // Otherwise deduplication won't work correctly.

    FileID ReportFile =

        path.back()->getLocation().asLocation().getExpansionLoc().getFileID();

    OptionalFileEntryRef Entry = SMgr.getFileEntryRefForID(ReportFile);

    FileName << llvm::sys::path::filename(Entry->getName()).str() << "-"

             << declName.c_str() << "-" << offsetDecl << "-";

  }

  FileName << StringRef(getIssueHash(D, PP)).substr(0, 6).str() << ".html";

  SmallString<128> ResultPath;

  llvm::sys::path::append(ResultPath, Directory, FileName.str());

  if (std::error_code EC = llvm::sys::fs::make_absolute(ResultPath)) {

    llvm::errs() << "warning: could not make '" << ResultPath

                 << "' absolute: " << EC.message() << '\n';

    return;

  }

  if (std::error_code EC = llvm::sys::fs::openFileForReadWrite(

          ResultPath, FD, llvm::sys::fs::CD_CreateNew,

          llvm::sys::fs::OF_Text)) {

    // Existence of the file corresponds to the situation where a different

    // Clang instance has emitted a bug report with the same issue hash.

    // This is an entirely normal situation that does not deserve a warning,

    // as apart from hash collisions this can happen because the reports

    // are in fact similar enough to be considered duplicates of each other.

    if (EC != llvm::errc::file_exists) {

      llvm::errs() << "warning: could not create file in '" << Directory

                   << "': " << EC.message() << '\n';

    }

    return;

  }

  llvm::raw_fd_ostream os(FD, true);

  if (filesMade)

    filesMade->addDiagnostic(D, getName(),

                             llvm::sys::path::filename(ResultPath));

  // Emit the HTML to disk.

  os << report;

}

std::string HTMLDiagnostics::GenerateHTML(const PathDiagnostic& D, Rewriter &R,

    const SourceManager& SMgr, const PathPieces& path, const char *declName) {

  // Rewrite source files as HTML for every new file the path crosses

  std::vector<FileID> FileIDs;

  for (auto I : path) {

    FileID FID = I->getLocation().asLocation().getExpansionLoc().getFileID();

    if (llvm::is_contained(FileIDs, FID))

      continue;

    FileIDs.push_back(FID);

    RewriteFile(R, path, FID);

  }

  if (SupportsCrossFileDiagnostics && 
FileIDs.size() > 1103
) {

    // Prefix file names, anchor tags, and nav cursors to every file

    for (auto I = FileIDs.begin(), E = FileIDs.end(); I != E; 
I++20
) {

      std::string s;

      llvm::raw_string_ostream os(s);

      if (I != FileIDs.begin())

        os << "<hr class=divider>\n";

      os << "<div id=File" << I->getHashValue() << ">\n";

      // Left nav arrow

      if (I != FileIDs.begin())

        os << "<div class=FileNav><a href=\"#File" << (I - 1)->getHashValue()

           << "\">&#x2190;</a></div>";

      os << "<h4 class=FileName>" << SMgr.getFileEntryRefForID(*I)->getName()

         << "</h4>\n";

      // Right nav arrow

      if (I + 1 != E)

        os << "<div class=FileNav><a href=\"#File" << (I + 1)->getHashValue()

           << "\">&#x2192;</a></div>";

      os << "</div>\n";

      R.InsertTextBefore(SMgr.getLocForStartOfFile(*I), os.str());

    }

    // Append files to the main report file in the order they appear in the path

    for (auto I : llvm::drop_begin(FileIDs)) {

      std::string s;

      llvm::raw_string_ostream os(s);

      const RewriteBuffer *Buf = R.getRewriteBufferFor(I);

      for (auto BI : *Buf)

        os << BI;

      R.InsertTextAfter(SMgr.getLocForEndOfFile(FileIDs[0]), os.str());

    }

  }

  const RewriteBuffer *Buf = R.getRewriteBufferFor(FileIDs[0]);

  if (!Buf)

    return {};

  // Add CSS, header, and footer.

  FileID FID =

      path.back()->getLocation().asLocation().getExpansionLoc().getFileID();

  OptionalFileEntryRef Entry = SMgr.getFileEntryRefForID(FID);

  FinalizeHTML(D, R, SMgr, path, FileIDs[0], *Entry, declName);

  std::string file;

  llvm::raw_string_ostream os(file);

  for (auto BI : *Buf)

    os << BI;

  return file;

}

void HTMLDiagnostics::dumpCoverageData(

    const PathDiagnostic &D,

    const PathPieces &path,

    llvm::raw_string_ostream &os) {

  const FilesToLineNumsMap &ExecutedLines = D.getExecutedLines();

  os << "var relevant_lines = {";

  for (auto I = ExecutedLines.begin(),

            E = ExecutedLines.end(); I != E; 
++I115
) {

    if (I != ExecutedLines.begin())

      os << ", ";

    os << "\"" << I->first.getHashValue() << "\": {";

    for (unsigned LineNo : I->second) {

      if (LineNo != *(I->second.begin()))

        os << ", ";

      os << "\"" << LineNo << "\": 1";

    }

    os << "}";

  }

  os << "};";

}

std::string HTMLDiagnostics::showRelevantLinesJavascript(

      const PathDiagnostic &D, const PathPieces &path) {

  std::string s;

  llvm::raw_string_ostream os(s);

  os << "<script type='text/javascript'>\n";

  dumpCoverageData(D, path, os);

  os << R"<<<(

var filterCounterexample = function (hide) {

  var tables = document.getElementsByClassName("code");

  for (var t=0; t<tables.length; t++) {

    var table = tables[t];

    var file_id = table.getAttribute("data-fileid");

    var lines_in_fid = relevant_lines[file_id];

    if (!lines_in_fid) {

      lines_in_fid = {};

    }

    var lines = table.getElementsByClassName("codeline");

    for (var i=0; i<lines.length; i++) {

        var el = lines[i];

        var lineNo = el.getAttribute("data-linenumber");

        if (!lines_in_fid[lineNo]) {

          if (hide) {

            el.setAttribute("hidden", "");

          } else {

            el.removeAttribute("hidden");

          }

        }

    }

  }

}

window.addEventListener("keydown", function (event) {

  if (event.defaultPrevented) {

    return;

  }

  // SHIFT + S

  if (event.shiftKey && event.keyCode == 83) {

    var checked = document.getElementsByName("showCounterexample")[0].checked;

    filterCounterexample(!checked);

    document.getElementsByName("showCounterexample")[0].click();

  } else {

    return;

  }

  event.preventDefault();

}, true);

document.addEventListener("DOMContentLoaded", function() {

    document.querySelector('input[name="showCounterexample"]').onchange=

        function (event) {

      filterCounterexample(this.checked);

    };

});

</script>

<form>

    <input type="checkbox" name="showCounterexample" id="showCounterexample" />

    <label for="showCounterexample">

       Show only relevant lines

    </label>

    <input type="checkbox" name="showArrows"

           id="showArrows" style="margin-left: 10px" />

    <label for="showArrows">

       Show control flow arrows

    </label>

</form>

)<<<";

  return s;

}

void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic &D, Rewriter &R,

                                   const SourceManager &SMgr,

                                   const PathPieces &path, FileID FID,

                                   FileEntryRef Entry, const char *declName) {

  // This is a cludge; basically we want to append either the full

  // working directory if we have no directory information.  This is

  // a work in progress.

  llvm::SmallString<0> DirName;

  if (llvm::sys::path::is_relative(Entry.getName())) {

    llvm::sys::fs::current_path(DirName);

    DirName += '/';

  }

  int LineNumber = path.back()->getLocation().asLocation().getExpansionLineNumber();

  int ColumnNumber = path.back()->getLocation().asLocation().getExpansionColumnNumber();

  R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), showHelpJavascript());

  R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),

                     generateKeyboardNavigationJavascript());

  R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),

                     generateArrowDrawingJavascript());

  // Checkbox and javascript for filtering the output to the counterexample.

  R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),

                     showRelevantLinesJavascript(D, path));

  // Add the name of the file as an <h1> tag.

  {

    std::string s;

    llvm::raw_string_ostream os(s);

    os << "<!-- REPORTHEADER -->\n"

       << "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n"

          "<tr><td class=\"rowname\">File:</td><td>"

       << html::EscapeText(DirName)

       << html::EscapeText(Entry.getName())

       << "</td></tr>\n<tr><td class=\"rowname\">Warning:</td><td>"

          "<a href=\"#EndPath\">line "

       << LineNumber

       << ", column "

       << ColumnNumber

       << "</a><br />"

       << D.getVerboseDescription() << "</td></tr>\n";

    // The navigation across the extra notes pieces.

    unsigned NumExtraPieces = 0;

    for (const auto &Piece : path) {

      if (const auto *P = dyn_cast<PathDiagnosticNotePiece>(Piece.get())) {

        int LineNumber =

            P->getLocation().asLocation().getExpansionLineNumber();

        int ColumnNumber =

            P->getLocation().asLocation().getExpansionColumnNumber();

        ++NumExtraPieces;

        os << "<tr><td class=\"rowname\">Note:</td><td>"

           << "<a href=\"#Note" << NumExtraPieces << "\">line "

           << LineNumber << ", column " << ColumnNumber << "</a><br />"

           << P->getString() << "</td></tr>";

      }

    }

    // Output any other meta data.

    for (const std::string &Metadata :

         llvm::make_range(D.meta_begin(), D.meta_end())) {

      os << "<tr><td></td><td>" << html::EscapeText(Metadata) << "</td></tr>\n";

    }

    os << R"<<<(

</table>

<!-- REPORTSUMMARYEXTRA -->

<h3>Annotated Source Code</h3>

<p>Press <a href="#" onclick="toggleHelp(); return false;">'?'</a>

   to see keyboard shortcuts</p>

<input type="checkbox" class="spoilerhider" id="showinvocation" />

<label for="showinvocation" >Show analyzer invocation</label>

<div class="spoiler">clang -cc1 )<<<";

    os << html::EscapeText(DiagOpts.ToolInvocation);

    os << R"<<<(

</div>

<div id='tooltiphint' hidden="true">

  <p>Keyboard shortcuts: </p>

  <ul>

    <li>Use 'j/k' keys for keyboard navigation</li>

    <li>Use 'Shift+S' to show/hide relevant lines</li>

    <li>Use '?' to toggle this window</li>

  </ul>

  <a href="#" onclick="toggleHelp(); return false;">Close</a>

</div>

)<<<";

    R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());

  }

  // Embed meta-data tags.

  {

    std::string s;

    llvm::raw_string_ostream os(s);

    StringRef BugDesc = D.getVerboseDescription();

    if (!BugDesc.empty())

      os << "\n<!-- BUGDESC " << BugDesc << " -->\n";

    StringRef BugType = D.getBugType();

    if (!BugType.empty())

      os << "\n<!-- BUGTYPE " << BugType << " -->\n";

    PathDiagnosticLocation UPDLoc = D.getUniqueingLoc();

    FullSourceLoc L(SMgr.getExpansionLoc(UPDLoc.isValid()

                                             ? 
UPDLoc.asLocation()2

                                             : 
D.getLocation().asLocation()103
),

                    SMgr);

    StringRef BugCategory = D.getCategory();

    if (!BugCategory.empty())

      os << "\n<!-- BUGCATEGORY " << BugCategory << " -->\n";

    os << "\n<!-- BUGFILE " << DirName << Entry.getName() << " -->\n";

    os << "\n<!-- FILENAME " << llvm::sys::path::filename(Entry.getName()) << " -->\n";

    os  << "\n<!-- FUNCTIONNAME " <<  declName << " -->\n";

    os << "\n<!-- ISSUEHASHCONTENTOFLINEINCONTEXT " << getIssueHash(D, PP)

       << " -->\n";

    os << "\n<!-- BUGLINE "

       << LineNumber

       << " -->\n";

    os << "\n<!-- BUGCOLUMN "

      << ColumnNumber

      << " -->\n";

    os << "\n<!-- BUGPATHLENGTH " << getPathSizeWithoutArrows(path) << " -->\n";

    // Mark the end of the tags.

    os << "\n<!-- BUGMETAEND -->\n";

    // Insert the text.

    R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());

  }

  html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry.getName());

}

StringRef HTMLDiagnostics::showHelpJavascript() {

  return R"<<<(

<script type='text/javascript'>

var toggleHelp = function() {

    var hint = document.querySelector("#tooltiphint");

    var attributeName = "hidden";

    if (hint.hasAttribute(attributeName)) {

      hint.removeAttribute(attributeName);

    } else {

      hint.setAttribute("hidden", "true");

    }

};

window.addEventListener("keydown", function (event) {

  if (event.defaultPrevented) {

    return;

  }

  if (event.key == "?") {

    toggleHelp();

  } else {

    return;

  }

  event.preventDefault();

});

</script>

)<<<";

}

static bool shouldDisplayPopUpRange(const SourceRange &Range) {

  return !(Range.getBegin().isMacroID() || 
Range.getEnd().isMacroID()9
);

}

static void

HandlePopUpPieceStartTag(Rewriter &R,

                         const std::vector<SourceRange> &PopUpRanges) {

  for (const auto &Range : PopUpRanges) {

    if (!shouldDisplayPopUpRange(Range))

      continue;

    html::HighlightRange(R, Range.getBegin(), Range.getEnd(), "",

                         "<table class='variable_popup'><tbody>",

                         /*IsTokenRange=*/true);

  }

}

static void HandlePopUpPieceEndTag(Rewriter &R,

                                   const PathDiagnosticPopUpPiece &Piece,

                                   std::vector<SourceRange> &PopUpRanges,

                                   unsigned int LastReportedPieceIndex,

                                   unsigned int PopUpPieceIndex) {

  SmallString<256> Buf;

  llvm::raw_svector_ostream Out(Buf);

  SourceRange Range(Piece.getLocation().asRange());

  if (!shouldDisplayPopUpRange(Range))

    return;

  // Write out the path indices with a right arrow and the message as a row.

  Out << "<tr><td valign='top'><div class='PathIndex PathIndexPopUp'>"

      << LastReportedPieceIndex;

  // Also annotate the state transition with extra indices.

  Out << '.' << PopUpPieceIndex;

  Out << "</div></td><td>" << Piece.getString() << "</td></tr>";

  // If no report made at this range mark the variable and add the end tags.

  if (!llvm::is_contained(PopUpRanges, Range)) {

    // Store that we create a report at this range.

    PopUpRanges.push_back(Range);

    Out << "</tbody></table></span>";

    html::HighlightRange(R, Range.getBegin(), Range.getEnd(),

                         "<span class='variable'>", Buf.c_str(),

                         /*IsTokenRange=*/true);

  } else {

    // Otherwise inject just the new row at the end of the range.

    html::HighlightRange(R, Range.getBegin(), Range.getEnd(), "", Buf.c_str(),

                         /*IsTokenRange=*/true);

  }

}

void HTMLDiagnostics::RewriteFile(Rewriter &R, const PathPieces &path,

                                  FileID FID) {

  // Process the path.

  // Maintain the counts of extra note pieces separately.

  unsigned TotalPieces = getPathSizeWithoutArrows(path);

  unsigned TotalNotePieces =

      llvm::count_if(path, [](const PathDiagnosticPieceRef &p) {

        return isa<PathDiagnosticNotePiece>(*p);

      });

  unsigned PopUpPieceCount =

      llvm::count_if(path, [](const PathDiagnosticPieceRef &p) {

        return isa<PathDiagnosticPopUpPiece>(*p);

      });

  unsigned TotalRegularPieces = TotalPieces - TotalNotePieces - PopUpPieceCount;

  unsigned NumRegularPieces = TotalRegularPieces;

  unsigned NumNotePieces = TotalNotePieces;

  unsigned NumberOfArrows = 0;

  // Stores the count of the regular piece indices.

  std::map<int, int> IndexMap;

  ArrowMap ArrowIndices(TotalRegularPieces + 1);

  // Stores the different ranges where we have reported something.

  std::vector<SourceRange> PopUpRanges;

  for (const PathDiagnosticPieceRef &I : llvm::reverse(path)) {

    const auto &Piece = *I.get();

    if (isa<PathDiagnosticPopUpPiece>(Piece)) {

      ++IndexMap[NumRegularPieces];

    } else if (isa<PathDiagnosticNotePiece>(Piece)) {

      // This adds diagnostic bubbles, but not navigation.

      // Navigation through note pieces would be added later,

      // as a separate pass through the piece list.

      HandlePiece(R, FID, Piece, PopUpRanges, NumNotePieces, TotalNotePieces);

      --NumNotePieces;

    } else if (isArrowPiece(Piece)) {

      NumberOfArrows = ProcessControlFlowPiece(

          R, FID, cast<PathDiagnosticControlFlowPiece>(Piece), NumberOfArrows);

      ArrowIndices[NumRegularPieces] = NumberOfArrows;

    } else {

      HandlePiece(R, FID, Piece, PopUpRanges, NumRegularPieces,

                  TotalRegularPieces);

      --NumRegularPieces;

      ArrowIndices[NumRegularPieces] = ArrowIndices[NumRegularPieces + 1];

    }

  }

  ArrowIndices[0] = NumberOfArrows;

  // At this point ArrowIndices represent the following data structure:

  //   [a_0, a_1, ..., a_N]

  // where N is the number of events in the path.

  //

  // Then for every event with index i \in [0, N - 1], we can say that

  // arrows with indices \in [a_(i+1), a_i) correspond to that event.

  // We can say that because arrows with these indices appeared in the

  // path in between the i-th and the (i+1)-th events.

  assert(ArrowIndices.back() == 0 &&

         "No arrows should be after the last event");

  // This assertion also guarantees that all indices in are <= NumberOfArrows.

  assert(llvm::is_sorted(ArrowIndices, std::greater<unsigned>()) &&

         "Incorrect arrow indices map");

  // Secondary indexing if we are having multiple pop-ups between two notes.

  // (e.g. [(13) 'a' is 'true'];  [(13.1) 'b' is 'false'];  [(13.2) 'c' is...)

  NumRegularPieces = TotalRegularPieces;

  for (const PathDiagnosticPieceRef &I : llvm::reverse(path)) {

    const auto &Piece = *I.get();

    if (const auto *PopUpP = dyn_cast<PathDiagnosticPopUpPiece>(&Piece)) {

      int PopUpPieceIndex = IndexMap[NumRegularPieces];

      // Pop-up pieces needs the index of the last reported piece and its count

      // how many times we report to handle multiple reports on the same range.

      // This marks the variable, adds the </table> end tag and the message

      // (list element) as a row. The <table> start tag will be added after the

      // rows has been written out. Note: It stores every different range.

      HandlePopUpPieceEndTag(R, *PopUpP, PopUpRanges, NumRegularPieces,

                             PopUpPieceIndex);

      if (PopUpPieceIndex > 0)

        --IndexMap[NumRegularPieces];

    } else if (!isa<PathDiagnosticNotePiece>(Piece) && 
!isArrowPiece(Piece)631
) {

      --NumRegularPieces;

    }

  }

  // Add the <table> start tag of pop-up pieces based on the stored ranges.

  HandlePopUpPieceStartTag(R, PopUpRanges);

  // Add line numbers, header, footer, etc.

  html::EscapeText(R, FID);

  html::AddLineNumbers(R, FID);

  addArrowSVGs(R, FID, ArrowIndices);

  // If we have a preprocessor, relex the file and syntax highlight.

  // We might not have a preprocessor if we come from a deserialized AST file,

  // for example.

  html::SyntaxHighlight(R, FID, PP);

  html::HighlightMacros(R, FID, PP);

}

void HTMLDiagnostics::HandlePiece(Rewriter &R, FileID BugFileID,

                                  const PathDiagnosticPiece &P,

                                  const std::vector<SourceRange> &PopUpRanges,

                                  unsigned num, unsigned max) {

  // For now, just draw a box above the line in question, and emit the

  // warning.

  FullSourceLoc Pos = P.getLocation().asLocation();

  if (!Pos.isValid())

    return;

  SourceManager &SM = R.getSourceMgr();

  assert(&Pos.getManager() == &SM && "SourceManagers are different!");

  std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);

  if (LPosInfo.first != BugFileID)

    return;

  llvm::MemoryBufferRef Buf = SM.getBufferOrFake(LPosInfo.first);

  const char *FileStart = Buf.getBufferStart();

  // Compute the column number.  Rewind from the current position to the start

  // of the line.

  unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);

  const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();

  const char *LineStart = TokInstantiationPtr-ColNo;

  // Compute LineEnd.

  const char *LineEnd = TokInstantiationPtr;

  const char *FileEnd = Buf.getBufferEnd();

  while (*LineEnd != '\n' && 
LineEnd != FileEnd8.55k
)

    ++LineEnd;

  // Compute the margin offset by counting tabs and non-tabs.

  unsigned PosNo = 0;

  for (const char* c = LineStart; c != TokInstantiationPtr; 
++c1.68k
)

    PosNo += *c == '\t' ? 
85
 : 
11.68k
;

  // Create the html for the message.

  const char *Kind = nullptr;

  bool IsNote = false;

  bool SuppressIndex = (max == 1);

  switch (P.getKind()) {

  case PathDiagnosticPiece::Event: Kind = "Event"; break;

  case PathDiagnosticPiece::ControlFlow: Kind = "Control"; break;

    // Setting Kind to "Control" is intentional.

  case PathDiagnosticPiece::Macro: Kind = "Control"; break;

  case PathDiagnosticPiece::Note:

    Kind = "Note";

    IsNote = true;

    SuppressIndex = true;

    break;

  case PathDiagnosticPiece::Call:

  case PathDiagnosticPiece::PopUp:

    llvm_unreachable("Calls and extra notes should already be handled");

  }

  std::string sbuf;

  llvm::raw_string_ostream os(sbuf);

  os << "\n<tr><td class=\"num\"></td><td class=\"line\"><div id=\"";

  if (IsNote)

    os << "Note" << num;

  else if (num == max)

    os << "EndPath";

  else

    os << "Path" << num;

  os << "\" class=\"msg";

  if (Kind)

    os << " msg" << Kind;

  os << "\" style=\"margin-left:" << PosNo << "ex";

  // Output a maximum size.

  if (!isa<PathDiagnosticMacroPiece>(P)) {

    // Get the string and determining its maximum substring.

    const auto &Msg = P.getString();

    unsigned max_token = 0;

    unsigned cnt = 0;

    unsigned len = Msg.size();

    for (char C : Msg)

      switch (C) {

      default:

        ++cnt;

        continue;

      case ' ':

      case '\t':

      case '\n':

        if (cnt > max_token) 
max_token = cnt357
;

        cnt = 0;

      }

    if (cnt > max_token)

      max_token = cnt;

    // Determine the approximate size of the message bubble in em.

    unsigned em;

    const unsigned max_line = 120;

    if (max_token >= max_line)

      em = max_token / 2;

    else {

      unsigned characters = max_line;

      unsigned lines = len / max_line;

      if (lines > 0) {

        for (; characters > max_token; 
--characters283
)

          if (len / characters > lines) {

            ++characters;

            break;

          }

      }

      em = characters / 2;

    }

    if (em < max_line/2)

      os << "; max-width:" << em << "em";

  }

  else

    os << "; max-width:100em";

  os << "\">";

  if (!SuppressIndex) {

    os << "<table class=\"msgT\"><tr><td valign=\"top\">";

    os << "<div class=\"PathIndex";

    if (Kind) os << " PathIndex" << Kind;

    os << "\">" << num << "</div>";

    if (num > 1) {

      os << "</td><td><div class=\"PathNav\"><a href=\"#Path"

         << (num - 1)

         << "\" title=\"Previous event ("

         << (num - 1)

         << ")\">&#x2190;</a></div>";

    }

    os << "</td><td>";

  }

  if (const auto *MP = dyn_cast<PathDiagnosticMacroPiece>(&P)) {

    os << "Within the expansion of the macro '";

    // Get the name of the macro by relexing it.

    {

      FullSourceLoc L = MP->getLocation().asLocation().getExpansionLoc();

      assert(L.isFileID());

      StringRef BufferInfo = L.getBufferData();

      std::pair<FileID, unsigned> LocInfo = L.getDecomposedLoc();

      const char* MacroName = LocInfo.second + BufferInfo.data();

      Lexer rawLexer(SM.getLocForStartOfFile(LocInfo.first), PP.getLangOpts(),

                     BufferInfo.begin(), MacroName, BufferInfo.end());

      Token TheTok;

      rawLexer.LexFromRawLexer(TheTok);

      for (unsigned i = 0, n = TheTok.getLength(); i < n; ++i)

        os << MacroName[i];