[analyzer] support a mode to only show relevant lines in HTML diagnostics

[george.karpenkov]

Summary

HTML diagnostics can be an overwhelming blob of pages of code.
This patch adds a checkbox which filters this list down to only the lines *relevant* to the counterexample by
e.g. skipping branches which analyzer has assumed to be infeasible at a time.

The resulting amount of output is much smaller, and often fits on one screen, and also provides a much more readable diagnostics.

[george.karpenkov]

Applying clang-format.

[george.karpenkov]

Bugfixes, shortcut, always showing function prototype.

[george.karpenkov]

Proper macro handling.

[george.karpenkov]

Added tests. It is bad to match against HTML output directly, but we can match against provided JSON.

[george.karpenkov]

@dcoughlin @NoQ Any comments?

[NoQ]

I'm liking how it works!

include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

112–114

It might be a good moment to figure out which of these are actually used. Do we use Extensive and AlternateExtensive at all anywhere?

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1910–1912 ↗

(On Diff #127772)

Note that neither BlockDecl nor ObjCMethodDecl is a FunctionDecl.

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

51

The order in which lines are listed would not be deterministic (right?), but i don't particularly care (@xazax.hun, is it important for your stuff?).

[george.karpenkov]

include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

112–114

PlistDiagnosticuses Extensive (strange, since I've expected the output to be conceptually the same as what we get in HTML), and enabling path-diagnostics-alternate option gets AlternateExtensive

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1910–1912 ↗

(On Diff #127772)

I don't think we should care about blocks at this point.
Added ObjcMethodDecl support.

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

51

There is a bunch of non-deterministic outputs in HTML report already, but since we are trying to reduce non-determinism I think we might as well just use map/set here.

[NoQ]

I think this should land. Hope nobody minds some interactivity.

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1905–1908 ↗

(On Diff #128581)

Even though this works, i guess you could simply see if the current program point is CallEnter or CallExit or something like that, and extract all the info you wanted, instead of doing this every time you don't have a statement.

1930 ↗

(On Diff #128581)

Maybe getOpaqueValue() would express what you intend (i.e. lack of collisions) better, even though i'd be shocked if it ever mattered.

[dcoughlin]

At a high level it seems pretty weird that the relevant lines for a diagnostic is represented a path diagnostic piece. This information is not a piece of the path; rather it is metadata about the entire path. It seems to me like this would be better represented as part of the path diagnostic itself and not pieces.

test/Analysis/relevant_lines/header.h

1 ↗

(On Diff #127772)

Can you put in "relevant_lines" directory into a sub directory of test/Analysis called "html_diagnostics" or something like that? This will make it clear that people shouldn't look into "relevant_lines" to try to understand the analysis parts for the analyzer.

test/Analysis/relevant_lines/macros_same_file.c

13 ↗

(On Diff #127772)

It is not clear to me why you can't use FileCheck for this. I think that would be greatly preferable to adding and maintaining a new test helper executable.

[george.karpenkov]

@dcoughlin your high-level comment makes sense, I wanted a least intrusive change.
What about just adding a metadata field to PathDiagnostic?

[dcoughlin]

In D41378#970606, @george.karpenkov wrote:

@dcoughlin your high-level comment makes sense, I wanted a least intrusive change.
What about just adding a metadata field to PathDiagnostic?

That seems reasonable to me (although note that we already have an *unstructured* text collection (sigh) of metadata (see meta_begin()). If you took this approach you could add a "relevantLines" (or whatever) field to PathDiagnostic and populate that field when traversing the path. Then it would be up to the path diagnostic consumer to turn relevant lines into the a visualization (for the HTML consumer it would be your JavaScript; for the plist consumer we could just emit the dictionary in plist form and let clients visualize it, etc.).

[george.karpenkov]

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1930 ↗

(On Diff #128581)

I'm not sure what do you mean here.

[NoQ]

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1930 ↗

(On Diff #128581)

Like, FID.getHashValue() kinda sounds to me like "compute a small hash of the large FID object, which may potentially collide with other FID objects", while FID.getOpaqueValue() sounds like "give me the whole sequence of bytes in FID that uniquely identifies it".

[george.karpenkov]

Changed: now ExecutedLines field belongs to PathDiagnostic and is always calculated. As a result, the change is much smaller.

[george.karpenkov]

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1930 ↗

(On Diff #128581)

Makes sense, but getOpaqueValue is private.
Could we expose it?

[NoQ]

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

1930 ↗

(On Diff #128581)

Whoooops. Never mind then.

[george.karpenkov]

@dcoughlin @NoQ further thoughts? Good to go?

[NoQ]

Looks great.

lib/StaticAnalyzer/Core/BugReporter.cpp

3520–3528

Signature->getBody()?

[dcoughlin]

Thanks! This is quite nice.

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

523

Please move the shortcut documentation to the keyboard navigation help hover that you added in r321320 before committing. Most users won't use the shortcut, so it would be good not to clutter up the main user interface with documentation for it.

It would also be good to not reuse the macro expansion CSS class and instead create new CSS classes for the help hover. This way changes to the macro expansion visualization won't accidentally affect the help visualization and vice versa.

545

Should this be ": 1" or some other truthy value? Doesn't using 0 mean we'll never see the relevant lines when the box is checked?

[NoQ]

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

545

Hmm, indeed, it might be possible to turn this into a list, and also later iterate over that list rather than over all line elements. Performance can be easily evaluated on any html report for a preprocessed sqlite3.c file (:

[george.karpenkov]

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

523

OK would that change require a separate review?

545

:0 just emulates a set from a map. E.g. Java does it with :null.
Iterating over list might be faster, but then we would still need to look up the DOM element from the line number.

[dcoughlin]

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

523

No.

[george.karpenkov]

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

545

actually iterating over a list would not be any better as we would still run in time proportional to the overall number of lines. Committing as it is, with the shortcut documentation (re)moved.

include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h

 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
 #include <deque>
 #include <iterator>
 #include <list>
+#include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 class ConditionalOperator;
 class AnalysisDeclContext;
 class BinaryOperator;
 class CompoundStmt;
public:
   void HandlePathDiagnostic(std::unique_ptr<PathDiagnostic> D);
 
   enum PathGenerationScheme { None, Minimal, Extensive, AlternateExtensive };
   virtual PathGenerationScheme getGenerationScheme() const { return Minimal; }
   virtual bool supportsLogicalOpControlFlow() const { return false; }
   
   /// Return true if the PathDiagnosticConsumer supports individual
   /// PathDiagnostics that span multiple files.
   virtual bool supportsCrossFileDiagnostics() const { return false; }
 
 protected:
   bool flushed;
   llvm::FoldingSet<PathDiagnostic> Diags;
 };
 
 //===----------------------------------------------------------------------===//
 // Path-sensitive diagnostics.
 //===----------------------------------------------------------------------===//
 
static inline bool classof(const PathDiagnosticPiece *P) {
     return P->getKind() == Note;
   }
 
   void dump() const override;
 
   void Profile(llvm::FoldingSetNodeID &ID) const override;
 };
 
+/// File IDs mapped to sets of line numbers.
+typedef std::map<unsigned, std::set<unsigned>> FilesToLineNumsMap;
+
 /// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive
 ///  diagnostic.  It represents an ordered-collection of PathDiagnosticPieces,
 ///  each which represent the pieces of the path.
 class PathDiagnostic : public llvm::FoldingSetNode {
   std::string CheckName;
   const Decl *DeclWithIssue;
   std::string BugType;
   std::string VerboseDesc;
   std::string ShortDesc;
   std::string Category;
   std::deque<std::string> OtherDesc;
 
   /// \brief Loc The location of the path diagnostic report.
   PathDiagnosticLocation Loc;
 
   PathPieces pathImpl;
   SmallVector<PathPieces *, 3> pathStack;
   
   /// \brief Important bug uniqueing location.
   /// The location info is useful to differentiate between bugs.
   PathDiagnosticLocation UniqueingLoc;
   const Decl *UniqueingDecl;
 
+  /// Lines executed in the path.
+  std::unique_ptr<FilesToLineNumsMap> ExecutedLines;
+
   PathDiagnostic() = delete;
 public:
   PathDiagnostic(StringRef CheckName, const Decl *DeclWithIssue,
                  StringRef bugtype, StringRef verboseDesc, StringRef shortDesc,
                  StringRef category, PathDiagnosticLocation LocationToUnique,
-                 const Decl *DeclToUnique);
+                 const Decl *DeclToUnique,
+                 std::unique_ptr<FilesToLineNumsMap> ExecutedLines);
 
   ~PathDiagnostic();
   
   const PathPieces &path;
 
   /// Return the path currently used by builders for constructing the 
   /// PathDiagnostic.
   PathPieces &getActivePath() {
public:
   /// where the bug manifests.
   const Decl *getDeclWithIssue() const { return DeclWithIssue; }
 
   typedef std::deque<std::string>::const_iterator meta_iterator;
   meta_iterator meta_begin() const { return OtherDesc.begin(); }
   meta_iterator meta_end() const { return OtherDesc.end(); }
   void addMeta(StringRef s) { OtherDesc.push_back(s); }
 
+  typedef FilesToLineNumsMap::const_iterator filesmap_iterator;
+  filesmap_iterator executedLines_begin() const {
+    return ExecutedLines->begin();
+  }
+  filesmap_iterator executedLines_end() const { return ExecutedLines->end(); }
+
   PathDiagnosticLocation getLocation() const {
     assert(Loc.isValid() && "No report location set yet!");
     return Loc;
   }
 
   /// \brief Get the location on which the report should be uniqued.
   PathDiagnosticLocation getUniqueingLoc() const {
     return UniqueingLoc;

lib/Rewrite/HTMLRewrite.cpp

std::string html::EscapeText(StringRef s, bool EscapeSpaces, bool ReplaceTabs) {
   return os.str();
 }
 
 static void AddLineNumber(RewriteBuffer &RB, unsigned LineNo,
                           unsigned B, unsigned E) {
   SmallString<256> Str;
   llvm::raw_svector_ostream OS(Str);
 
-  OS << "<tr><td class=\"num\" id=\"LN"
-     << LineNo << "\">"
-     << LineNo << "</td><td class=\"line\">";
+  OS << "<tr class=\"codeline\" data-linenumber=\"" << LineNo << "\">"
+     << "<td class=\"num\" id=\"LN" << LineNo << "\">" << LineNo
+     << "</td><td class=\"line\">";
 
   if (B == E) { // Handle empty lines.
     OS << " </td></tr>";
     RB.InsertTextBefore(B, OS.str());
   } else {
     RB.InsertTextBefore(B, OS.str());
     RB.InsertTextBefore(E, "</td></tr>");
   }
while (C != FileEnd) {
 
       ++FilePos;
     }
 
     AddLineNumber(RB, LineNo, LineStartPos, LineEndPos);
   }
 
   // Add one big table tag that surrounds all of the code.
-  RB.InsertTextBefore(0, "<table class=\"code\">\n");
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  os << "<table class=\"code\" data-fileid=\"" << FID.getHashValue() << "\">\n";
+  RB.InsertTextBefore(0, os.str());
   RB.InsertTextAfter(FileEnd - FileBeg, "</table>");
 }
 
 void html::AddHeaderFooterInternalBuiltinCSS(Rewriter &R, FileID FID,
                                              StringRef title) {
 
   const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
   const char* FileStart = Buf->getBufferStart();

lib/StaticAnalyzer/Core/BugReporter.cpp

void BugReporter::FlushReport(BugReportEquivClass& EQ) {
   BugReport *exampleReport = FindReportInEquivalenceClass(EQ, bugReports);
   if (exampleReport) {
     for (PathDiagnosticConsumer *PDC : getPathDiagnosticConsumers()) {
       FlushReport(exampleReport, *PDC, bugReports);
     }
   }
 }
 
+/// Insert all lines participating in the function signature \p Signature
+/// into \p ExecutedLines.
+static void populateExecutedLinesWithFunctionSignature(
+    const Decl *Signature, SourceManager &SM,
+    std::unique_ptr<FilesToLineNumsMap> &ExecutedLines) {
+
+  SourceRange SignatureSourceRange;
+  const Stmt* Body = Signature->getBody();
+  if (auto FD = dyn_cast<FunctionDecl>(Signature)) {
+    SignatureSourceRange = FD->getSourceRange();
+  } else if (auto OD = dyn_cast<ObjCMethodDecl>(Signature)) {
+    SignatureSourceRange = OD->getSourceRange();
+  } else {
+    return;
+  }
+  SourceLocation Start = SignatureSourceRange.getBegin();
+  SourceLocation End = Body ? Body->getSourceRange().getBegin()
+    : SignatureSourceRange.getEnd();
+  unsigned StartLine = SM.getExpansionLineNumber(Start);
+  unsigned EndLine = SM.getExpansionLineNumber(End);
+
+  FileID FID = SM.getFileID(SM.getExpansionLoc(Start));
+  for (unsigned Line = StartLine; Line <= EndLine; Line++)
+    ExecutedLines->operator[](FID.getHashValue()).insert(Line);
+}
+
+/// \return all executed lines including function signatures on the path
+/// starting from \p N.
+static std::unique_ptr<FilesToLineNumsMap>
+findExecutedLines(SourceManager &SM, const ExplodedNode *N) {
+  auto ExecutedLines = llvm::make_unique<FilesToLineNumsMap>();
+
+  while (N) {
+    if (N->getFirstPred() == nullptr) {
+
+      // First node: show signature of the entrance point.
+      const Decl *D = N->getLocationContext()->getDecl();
+      populateExecutedLinesWithFunctionSignature(D, SM, ExecutedLines);
+
+    } else if (auto CE = N->getLocationAs<CallEnter>()) {
+
+      // Inlined function: show signature.
+      const Decl* D = CE->getCalleeContext()->getDecl();
+      populateExecutedLinesWithFunctionSignature(D, SM, ExecutedLines);
+
+    } else if (const Stmt *S = PathDiagnosticLocation::getStmt(N)) {
+
+      // Otherwise: show lines associated with the processed statement.
+      SourceLocation Loc = S->getSourceRange().getBegin();
+      SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc);
+      FileID FID = SM.getFileID(ExpansionLoc);
+      unsigned LineNo = SM.getExpansionLineNumber(ExpansionLoc);
+      ExecutedLines->operator[](FID.getHashValue()).insert(LineNo);
+    }
+
+    N = N->getFirstPred();
+  }
+  return ExecutedLines;
+}
+
 void BugReporter::FlushReport(BugReport *exampleReport,
                               PathDiagnosticConsumer &PD,
                               ArrayRef<BugReport*> bugReports) {
 
   // FIXME: Make sure we use the 'R' for the path that was actually used.
   // Probably doesn't make a difference in practice.
   BugType& BT = exampleReport->getBugType();
 
-  std::unique_ptr<PathDiagnostic> D(new PathDiagnostic(
+  auto D = llvm::make_unique<PathDiagnostic>(
       exampleReport->getBugType().getCheckName(),
       exampleReport->getDeclWithIssue(), exampleReport->getBugType().getName(),
       exampleReport->getDescription(),
       exampleReport->getShortDescription(/*Fallback=*/false), BT.getCategory(),
-      exampleReport->getUniqueingLocation(),
-      exampleReport->getUniqueingDecl()));
+      exampleReport->getUniqueingLocation(), exampleReport->getUniqueingDecl(),
+      findExecutedLines(getSourceManager(), exampleReport->getErrorNode()));
 
   if (exampleReport->isPathSensitive()) {
     // Generate the full path diagnostic, using the generation scheme
     // specified by the PathDiagnosticConsumer. Note that we have to generate
     // path diagnostics even for consumers which do not support paths, because
     // the BugReporterVisitors may mark this bug as a false positive.
     assert(!bugReports.empty());
 

lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

class HTMLDiagnostics : public PathDiagnosticConsumer {
   std::string Directory;
   bool createdDir, noDir;
   const Preprocessor &PP;
   AnalyzerOptions &AnalyzerOpts;
   const bool SupportsCrossFileDiagnostics;
 public:
   HTMLDiagnostics(AnalyzerOptions &AnalyzerOpts,
                   const std::string& prefix,
                   const Preprocessor &pp,
                   bool supportsMultipleFiles);
 
   ~HTMLDiagnostics() override { FlushDiagnostics(nullptr); }
 
   void FlushDiagnosticsImpl(std::vector<const PathDiagnostic *> &Diags,
                             FilesMade *filesMade) override;
 
   StringRef getName() const override {
void FinalizeHTML(const PathDiagnostic& D, Rewriter &R,
                     FileID FID, const FileEntry *Entry, const char *declName);
 
   // Rewrite the file specified by FID with HTML formatting.
   void RewriteFile(Rewriter &R, const SourceManager& SMgr,
                    const PathPieces& path, FileID FID);
 
   /// \return Javascript for navigating the HTML report using j/k keys.
   std::string generateKeyboardNavigationJavascript();
+
+private:
+  /// \return JavaScript for an option to only show relevant lines.
+  std::string showRelevantLinesJavascript(const PathDiagnostic &D);
+
+  /// \return Executed lines from \p D in JSON format.
+  std::string serializeExecutedLines(const PathDiagnostic &D);
 };
 
 } // end anonymous namespace
 
 HTMLDiagnostics::HTMLDiagnostics(AnalyzerOptions &AnalyzerOpts,
                                  const std::string& prefix,
                                  const Preprocessor &pp,
                                  bool supportsMultipleFiles)
void HTMLDiagnostics::FinalizeHTML(const PathDiagnostic& D, Rewriter &R,
   }
 
   int LineNumber = path.back()->getLocation().asLocation().getExpansionLineNumber();
   int ColumnNumber = path.back()->getLocation().asLocation().getExpansionColumnNumber();
 
   R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),
                      generateKeyboardNavigationJavascript());
 
+  // Checkbox and javascript for filtering the output to the counterexample.
+  R.InsertTextBefore(SMgr.getLocForStartOfFile(FID),
+                     showRelevantLinesJavascript(D));
+
   // 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>"
// Embed meta-data tags.
 
     // Insert the text.
     R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
   }
 
   html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry->getName());
 }
 
+std::string
+HTMLDiagnostics::showRelevantLinesJavascript(const PathDiagnostic &D) {
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  os << "<script type='text/javascript'>\n";
+  os << serializeExecutedLines(D);
+  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;
+  }
+  if (event.key == "S") {
+    var checked = document.getElementsByName("showCounterexample")[0].checked;
+    filterCounterexample(!checked);
+    document.getElementsByName("showCounterexample")[0].checked = !checked;
+  } 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" />
+    <label for="showCounterexample">
+       Show only relevant lines
+    </label>
+</form>
+)<<<";
+
+  return os.str();
+}
+
+std::string HTMLDiagnostics::serializeExecutedLines(const PathDiagnostic &D) {
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  os << "var relevant_lines = {";
+  for (auto I = D.executedLines_begin(),
+            E = D.executedLines_end(); I != E; ++I) {
+    if (I != D.executedLines_begin())
+      os << ", ";
+
+    os << "\"" << I->first << "\": {";
+    for (unsigned LineNo : I->second) {
+      if (LineNo != *(I->second.begin()))
+        os << ", ";
+
+      os << "\"" << LineNo << "\": 1";
+    }
+    os << "}";
+  }
+
+  os << "};";
+  return os.str();
+}
+
 void HTMLDiagnostics::RewriteFile(Rewriter &R, const SourceManager& SMgr,
     const PathPieces& path, FileID FID) {
   // Process the path.
   // Maintain the counts of extra note pieces separately.
   unsigned TotalPieces = path.size();
   unsigned TotalNotePieces =
       std::count_if(path.begin(), path.end(),
                     [](const std::shared_ptr<PathDiagnosticPiece> &p) {

lib/StaticAnalyzer/Core/PathDiagnostic.cpp

case PathDiagnosticPiece::Note:
       Current.push_back(Piece);
       break;
     }
   }
 }
 
 PathDiagnostic::~PathDiagnostic() {}
 
-PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue,
-                               StringRef bugtype, StringRef verboseDesc,
-                               StringRef shortDesc, StringRef category,
-                               PathDiagnosticLocation LocationToUnique,
-                               const Decl *DeclToUnique)
-  : CheckName(CheckName),
-    DeclWithIssue(declWithIssue),
+PathDiagnostic::PathDiagnostic(
+    StringRef CheckName, const Decl *declWithIssue, StringRef bugtype,
+    StringRef verboseDesc, StringRef shortDesc, StringRef category,
+    PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique,
+    std::unique_ptr<FilesToLineNumsMap> ExecutedLines)
+    : CheckName(CheckName), DeclWithIssue(declWithIssue),
       BugType(StripTrailingDots(bugtype)),
       VerboseDesc(StripTrailingDots(verboseDesc)),
       ShortDesc(StripTrailingDots(shortDesc)),
-    Category(StripTrailingDots(category)),
-    UniqueingLoc(LocationToUnique),
-    UniqueingDecl(DeclToUnique),
+      Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique),
+      UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)),
       path(pathImpl) {}
 
 static PathDiagnosticCallPiece *
 getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP,
                                 const SourceManager &SMgr) {
   SourceLocation CallLoc = CP->callEnter.asLocation();
 
   // If the call is within a macro, don't do anything (for now).
   if (CallLoc.isMacroID())

test/Analysis/html_diagnostics/relevant_lines/header.h

+#define deref(X) (*X)
+
+char helper(
+    char *out,
+    int doDereference) {
+  if (doDereference) {
+    return deref(out);
+  } else {
+    return 'x';
+  }
+  return 'c';
+}

test/Analysis/html_diagnostics/relevant_lines/macros_same_file.c

+#define deref(X) (*X)
+
+int f(int coin) {
+  if (coin) {
+    int *x = 0;
+    return deref(x);
+  } else {
+    return 0;
+  }
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s
+// RUN: cat %t.output/* | FileCheck %s --match-full-lines
+// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}};

test/Analysis/html_diagnostics/relevant_lines/multifile.c

+#include "header.h"
+
+int f(int coin) {
+  char *p = 0;
+  if (coin) {
+    return helper(p, coin);
+  }
+  return 0;
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s
+// RUN: cat %t.output/* | FileCheck %s --match-full-lines
+// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}, "3": {"3": 1, "4": 1, "5": 1, "6": 1, "7": 1}};

test/Analysis/html_diagnostics/relevant_lines/multiline_func_def.c

+int f(
+    int coin,
+    int paramA,
+    int paramB) {
+  if (coin) {
+    int *x = 0;
+    return *x;
+  } else {
+    return 0;
+  }
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s
+// RUN: cat %t.output/* | FileCheck %s --match-full-lines
+// CHECK: var relevant_lines = {"1": {"1": 1, "2": 1, "3": 1, "4": 1, "5": 1, "6": 1, "7": 1}};

test/Analysis/html_diagnostics/relevant_lines/objcmethods.m

+@interface I
+- (int)func;
+@end
+
+@implementation I
+- (int)func:(int *)param {
+  return *param;
+}
+@end
+
+void foo(I *i) {
+  int *x = 0;
+  [i func:x];
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output -Wno-objc-root-class %s
+// RUN: cat %t.output/* | FileCheck %s
+// CHECK: var relevant_lines = {"1": {"6": 1, "7": 1, "11": 1, "12": 1, "13": 1}};

test/Analysis/html_diagnostics/relevant_lines/simple_conditional.c

+int f(int coin) {
+  if (coin) {
+    int *x = 0;
+    return *x;
+  } else {
+    return 0;
+  }
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s
+// RUN: cat %t.output/* | FileCheck %s --match-full-lines
+// CHECK: var relevant_lines = {"1": {"1": 1, "2": 1, "3": 1, "4": 1}};

test/Analysis/html_diagnostics/relevant_lines/unused_header.c

+#include "header.h"
+
+int f(int coin) {
+  if (coin) {
+    int *x = 0;
+    return *x;
+  } else {
+    return 0;
+  }
+}
+
+int v(int coin) {
+  return coin;
+}
+
+// RUN: rm -rf %t.output
+// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core -analyzer-output html -o %t.output %s
+// RUN: cat %t.output/* | FileCheck %s --match-full-lines
+// CHECK: var relevant_lines = {"1": {"3": 1, "4": 1, "5": 1, "6": 1}};