[analyzer] exploded-graph-rewriter: Improve source location dumps.

[NoQ]

Summary

• Correctly display macro expansion and spelling locations.
• Use the same procedure to display location context call site locations.
• Display statement IDs for program points.

[Charusso]

Much better! Thanks!

[NoQ]

Whoops, forgot the phabricator link.
Committed as rC365861.

clang/include/clang/Basic/JsonSupport.h

 //===- JsonSupport.h - JSON Output Utilities --------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_JSONSUPPORT_H
 #define LLVM_CLANG_BASIC_JSONSUPPORT_H
 
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 
 namespace clang {
 
 inline raw_ostream &Indent(raw_ostream &Out, const unsigned int Space,
                            bool IsDot) {
inline std::string JsonFormat(StringRef RawSR, bool AddQuotes) {
   Str.erase(std::remove(Str.begin(), Str.end(), '\n'), Str.end());
 
   if (!AddQuotes)
     return Str;
 
   return '\"' + Str + '\"';
 }
 
+inline void printSourceLocationAsJson(raw_ostream &Out, SourceLocation Loc,
+                                      const SourceManager &SM,
+                                      bool AddBraces = true) {
+  // Mostly copy-pasted from SourceLocation::print.
+  if (!Loc.isValid()) {
+    Out << "null";
+    return;
+  }
+
+  if (Loc.isFileID()) {
+    PresumedLoc PLoc = SM.getPresumedLoc(Loc);
+
+    if (PLoc.isInvalid()) {
+      Out << "null";
+      return;
+    }
+    // The macro expansion and spelling pos is identical for file locs.
+    if (AddBraces)
+      Out << "{ ";
+    Out << "\"line\": " << PLoc.getLine()
+        << ", \"column\": " << PLoc.getColumn()
+        << ", \"file\": \"" << PLoc.getFilename() << "\"";
+    if (AddBraces)
+      Out << " }";
+    return;
+  }
+
+  // We want 'location: { ..., spelling: { ... }}' but not
+  // 'location: { ... }, spelling: { ... }', hence the dance
+  // with braces.
+  Out << "{ ";
+  printSourceLocationAsJson(Out, SM.getExpansionLoc(Loc), SM, false);
+  Out << ", \"spelling\": ";
+  printSourceLocationAsJson(Out, SM.getSpellingLoc(Loc), SM, true);
+  Out << " }";
+}
 } // namespace clang
 
 #endif // LLVM_CLANG_BASIC_JSONSUPPORT_H

clang/lib/Analysis/AnalysisDeclContext.cpp

for (const LocationContext *LCtx = this; LCtx; LCtx = LCtx->getParent()) {
     case StackFrame:
       Out << '#' << Frame << " Call\", \"calling\": \"";
       ++Frame;
       if (const auto *D = dyn_cast<NamedDecl>(LCtx->getDecl()))
         Out << D->getQualifiedNameAsString();
       else
         Out << "anonymous code";
 
-      Out << "\", \"call_line\": ";
+      Out << "\", \"location\": ";
       if (const Stmt *S = cast<StackFrameContext>(LCtx)->getCallSite()) {
-        Out << '\"';
-        printLocation(Out, SM, S->getBeginLoc());
-        Out << '\"';
+        printSourceLocationAsJson(Out, S->getBeginLoc(), SM);
       } else {
         Out << "null";
       }
 
       Out << ", \"items\": ";
       break;
     case Scope:
       Out << "Entering scope\" ";
       break;
     case Block:
       Out << "Invoking block\" ";
       if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) {
-        Out << ", \"decl_line\": ";
-        printLocation(Out, SM, D->getBeginLoc());
+        Out << ", \"location\": ";
+        printSourceLocationAsJson(Out, D->getBeginLoc(), SM);
         Out << ' ';
       }
       break;
     }
 
     printMoreInfoPerContext(LCtx);
 
     Out << '}';

clang/lib/Analysis/ProgramPoint.cpp

 //==- ProgramPoint.cpp - Program Points for Path-Sensitive Analysis -*- C++ -*-/
 //
 // 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 interface ProgramPoint, which identifies a
 //  distinct location in a function.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/ProgramPoint.h"
+#include "clang/Basic/JsonSupport.h"
 
 using namespace clang;
 
 ProgramPointTag::~ProgramPointTag() {}
 
 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
                                            const LocationContext *LC,
                                            const ProgramPointTag *tag){
case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
       return PreStmtPurgeDeadSymbols(S, LC, tag);
   }
 }
 
 LLVM_DUMP_METHOD void ProgramPoint::dump() const {
   return printJson(llvm::errs());
 }
 
-static void printLocJson(raw_ostream &Out, SourceLocation Loc,
-                         const SourceManager &SM) {
-  Out << "\"location\": ";
-  if (!Loc.isFileID()) {
-    Out << "null";
-    return;
-  }
-
-  Out << "{ \"line\": " << SM.getExpansionLineNumber(Loc)
-      << ", \"column\": " << SM.getExpansionColumnNumber(Loc)
-      << ", \"file\": \"" << SM.getFilename(Loc) << "\" }";
-}
-
 void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
   const ASTContext &Context =
       getLocationContext()->getAnalysisDeclContext()->getASTContext();
   const SourceManager &SM = Context.getSourceManager();
   const PrintingPolicy &PP = Context.getPrintingPolicy();
   const bool AddQuotes = true;
 
   Out << "\"kind\": \"";
void ProgramPoint::printJson(llvm::raw_ostream &Out, const char *NL) const {
   case ProgramPoint::LoopExitKind:
     Out << "LoopExit\", \"stmt\": \""
         << castAs<LoopExit>().getLoopStmt()->getStmtClassName() << '\"';
     break;
 
   case ProgramPoint::PreImplicitCallKind: {
     ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
     Out << "PreCall\", \"decl\": \""
-        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString() << "\", ";
-    printLocJson(Out, PC.getLocation(), SM);
+        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
+        << "\", \"location\": ";
+    printSourceLocationAsJson(Out, PC.getLocation(), SM);
     break;
   }
 
   case ProgramPoint::PostImplicitCallKind: {
     ImplicitCallPoint PC = castAs<ImplicitCallPoint>();
     Out << "PostCall\", \"decl\": \""
-        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString() << "\", ";
-    printLocJson(Out, PC.getLocation(), SM);
+        << PC.getDecl()->getAsFunction()->getQualifiedNameAsString()
+        << "\", \"location\": ";
+    printSourceLocationAsJson(Out, PC.getLocation(), SM);
     break;
   }
 
   case ProgramPoint::PostInitializerKind: {
     Out << "PostInitializer\", ";
     const CXXCtorInitializer *Init = castAs<PostInitializer>().getInitializer();
     if (const FieldDecl *FD = Init->getAnyMember()) {
       Out << "\"field_decl\": \"" << *FD << '\"';
case ProgramPoint::BlockEdgeKind: {
 
     if (!T) {
       Out << "null, \"term_kind\": null";
       break;
     }
 
     E.getSrc()->printTerminatorJson(Out, Context.getLangOpts(),
                                     /*AddQuotes=*/true);
-    Out << ", ";
-    printLocJson(Out, T->getBeginLoc(), SM);
+    Out << ", \"location\": ";
+    printSourceLocationAsJson(Out, T->getBeginLoc(), SM);
 
     Out << ", \"term_kind\": \"";
     if (isa<SwitchStmt>(T)) {
       Out << "SwitchStmt\", \"case\": ";
       if (const Stmt *Label = E.getDst()->getLabel()) {
         if (const auto *C = dyn_cast<CaseStmt>(Label)) {
           Out << "{ \"lhs\": ";
           if (const Stmt *LHS = C->getLHS()) {
default: {
     assert(S != nullptr && "Expecting non-null Stmt");
 
     Out << "Statement\", \"stmt_kind\": \"" << S->getStmtClassName()
         << "\", \"stmt_id\": " << S->getID(Context)
         << ", \"pointer\": \"" << (const void *)S << "\", \"pretty\": ";
 
     S->printJson(Out, nullptr, PP, AddQuotes);
 
-    Out << ", ";
-    printLocJson(Out, S->getBeginLoc(), SM);
+    Out << ", \"location\": ";
+    printSourceLocationAsJson(Out, S->getBeginLoc(), SM);
 
     Out << ", \"stmt_point_kind\": \"";
     if (getAs<PreLoad>())
       Out << "PreLoad";
     else if (getAs<PreStore>())
       Out << "PreStore";
     else if (getAs<PostAllocatorCall>())
       Out << "PostAllocatorCall";

clang/test/Analysis/dump_egraph.cpp

 
 void foo() {
   // Test that dumping symbols conjured on null statements doesn't crash.
   T t;
 
   new S;
 }
 
-// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"foo\", \"call_line\": null, \"items\": [\l        \{ \"stmt_id\": {{[0-9]+}}, \"kind\": \"construct into local variable\", \"argument_index\": null, \"pretty\": \"T t;\", \"value\": \"&t\"
+// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"foo\", \"location\": null, \"items\": [\l        \{ \"stmt_id\": {{[0-9]+}}, \"kind\": \"construct into local variable\", \"argument_index\": null, \"pretty\": \"T t;\", \"value\": \"&t\"
 
-// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"T::T\", \"call_line\": \"16\", \"items\": [\l        \{ \"init_id\": {{[0-9]+}}, \"kind\": \"construct into member variable\", \"argument_index\": null, \"pretty\": \"s\", \"value\": \"&t-\>s\"
+// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"T::T\", \"location\": \{ \"line\": 16, \"column\": 5, \"file\": \"{{.*}}dump_egraph.cpp\" \}, \"items\": [\l        \{ \"init_id\": {{[0-9]+}}, \"kind\": \"construct into member variable\", \"argument_index\": null, \"pretty\": \"s\", \"value\": \"&t-\>s\"
 
 // CHECK: \"cluster\": \"t\", \"pointer\": \"{{0x[0-9a-f]+}}\", \"items\": [\l        \{ \"kind\": \"Default\", \"offset\": 0, \"value\": \"conj_$2\{int, LC5, no stmt, #1\}\"
 
 // CHECK: \"dynamic_types\": [\l\{ \"region\": \"HeapSymRegion\{conj_$1\{struct S *, LC1, S{{[0-9]+}}, #1\}\}\", \"dyn_type\": \"struct S\", \"sub_classable\": false\}\l

clang/test/Analysis/exploded-graph-rewriter/environment.dot

 // RUN: %exploded_graph_rewriter %s | FileCheck %s
 
 // FIXME: Substitution doesn't seem to work on Windows.
 // UNSUPPORTED: system-windows
 
 // CHECK: <b>Environment: </b>
 // CHECK-SAME: <table border="0">
 // CHECK-SAME:   <tr>
 // CHECK-SAME:     <td align="left">
 // CHECK-SAME:       <b>#0 Call</b>
 // CHECK-SAME:     </td>
 // CHECK-SAME:     <td align="left" colspan="2">
-// CHECK-SAME:       <font color="gray60">foo </font>(line 4)
+// CHECK-SAME:       <font color="gray60">foo </font>
+// CHECK-SAME:       (environment.cpp:<b>4</b>:<b>6</b> 
+// CHECK-SAME:       <font color="royalblue1">
+// CHECK-SAME:         (<i>spelling at </i> environment.h:<b>7</b>:<b>8</b>)
+// CHECK-SAME:       </font>)
 // CHECK-SAME:     </td>
 // CHECK-SAME:   </tr>
 // CHECK-SAME:   <tr>
 // CHECK-SAME:     <td align="left">
 // CHECK-SAME:       <i>S5</i>
 // CHECK-SAME:     </td>
 // CHECK-SAME:     <td align="left">
 // CHECK-SAME:       bar()
"{
         "checker_messages": null,
         "environment": {
           "pointer": "0x2",
           "items": [
             {
               "location_context": "#0 Call",
               "lctx_id": 3,
               "calling": "foo",
-              "call_line": 4,
+              "location": {
+                "file": "environment.cpp",
+                "line": 4,
+                "column": 6,
+                "spelling": {
+                  "file": "environment.h",
+                  "line": 7,
+                  "column": 8
+                }
+              },
               "items": [
                 {
                   "stmt_id": 5,
                   "pretty": "bar()",
                   "value": "Unknown"
                 }
               ]
             }
           ]
         }
       }
     }
 \l}"];

clang/test/Analysis/exploded-graph-rewriter/environment_diff.dot

"{
         "checker_messages": null,
         "environment": {
           "pointer": "0x2",
           "items": [
             {
               "location_context": "#0 Call",
               "lctx_id": 3,
               "calling": "foo",
-              "call_line": 4,
+              "location": null,
               "items": [
                 {
                   "stmt_id": 5,
                   "pretty": "bar()",
                   "value": "Unknown"
                 }
               ]
             }
"{
         "checker_messages": null,
         "environment": {
           "pointer": "0x2",
           "items": [
             {
               "location_context": "#0 Call",
               "lctx_id": 3,
               "calling": "foo",
-              "call_line": 4,
+              "location": null,
               "items": [
                 {
                   "stmt_id": 9,
                   "pretty": "baz()",
                   "value": "Undefined"
                 }
               ]
             }
"{
         "checker_messages": null,
         "environment": {
           "pointer": "0x2",
           "items": [
             {
               "location_context": "#0 Call",
               "lctx_id": 3,
               "calling": "foo",
-              "call_line": 4,
+              "location": null,
               "items": [
                 {
                   "stmt_id": 9,
                   "pretty": "baz()",
                   "value": "Undefined"
                 }
               ]
             }
           ]
         }
       }
     }
 \l}"];

clang/test/Analysis/exploded-graph-rewriter/macros.c

+// FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
+// RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
+// RUN:                     -analyzer-checker=core \
+// RUN:                     -analyzer-dump-egraph=%t.dot %s
+// RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
+// REQUIRES: asserts
+
+// FIXME: Substitution doesn't seem to work on Windows.
+// UNSUPPORTED: system-windows
+
+// CHECK: macros.c:<b>17</b>:<b>10</b>
+// CHECK-SAME: <font color="royalblue1">
+// CHECK-SAME:   (<i>spelling at </i> macros.c:<b>15</b>:<b>14</b>)
+// CHECK-SAME: </font>
+#define NULL 0
+void *foo() {
+  return NULL;
+}

clang/test/Analysis/exploded-graph-rewriter/program_points.dot

 // CHECK-SAME: <table border="0" align="left" width="0">
 // CHECK-SAME:   <tr>
 // CHECK-SAME:     <td align="left" width="0">
 // CHECK-SAME:       main.cpp:<b>4</b>:<b>5</b>:
 // CHECK-SAME:     </td>
 // CHECK-SAME:     <td align="left" width="0">
 // CHECK-SAME:       <font color="cyan4">DeclRefExpr</font>
 // CHECK-SAME:     </td>
+// CHECK-SAME:     <td align="left"><i>S3</i></td>
 // CHECK-SAME:     <td align="left">
 // CHECK-SAME:       <font color="cyan3">PreStmt</font>
 // CHECK-SAME:     </td>
-// CHECK-SAME:     <td>x</td>
+// CHECK-SAME:     <td align="left">x</td>
 // CHECK-SAME:   </tr>
 // CHECK-SAME:   <tr>
 // CHECK-SAME:     <td width="0">
 // CHECK-SAME:     </td>
 // CHECK-SAME:     <td colspan="3" align="left">
 // CHECK-SAME:       <b>Tag: </b>
 // CHECK-SAME:       <font color="crimson">ExprEngine : Clean Node</font>
 // CHECK-SAME:     </td>
 // CHECK-SAME:   </tr>
 // CHECK-SAME: </table>
 Node0x2 [shape=record,label=
  "{
     { "node_id": 2, "pointer": "0x2", "has_report": false, "is_sink": false,
       "program_state": null, "program_points": [
       {
         "kind": "Statement",
         "stmt_kind": "DeclRefExpr",
         "stmt_point_kind": "PreStmt",
-        "stmd_id": 3,
+        "stmt_id": 3,
         "pointer": "0x3",
         "pretty": "x",
         "location": {
           "file": "main.cpp",
           "line": 4,
           "column": 5
         },
         "tag": "ExprEngine : Clean Node"
       }
     ]}
 \l}"];
 
 // Test collapsing large pretty prints with braces.
 
 // CHECK-NEXT: <b>Program point:</b>
-// CHECK-SAME: <td>\{ ... \}</td>
+// CHECK-SAME: <td align="left">\{ ... \}</td>
 Node0x3 [shape=record,label=
  "{
     { "node_id": 3, "pointer": "0x3", "has_report": false, "is_sink": false,
       "program_state": null, "program_points": [
       {
         "kind": "Statement",
         "stmt_kind": "CompoundStmt",
         "stmt_point_kind": "PostStmt",
-        "stmd_id": 6,
+        "stmt_id": 6,
         "pointer": "0x6",
         "pretty": "{ very very very very very very long pretty print }",
         "location": {
           "line": 7,
           "column": 8
         },
         "tag": "ExprEngine : Clean Node"
       }
     ]}
 \l}"];

clang/test/Analysis/expr-inspection.c

 
 // CHECK:      "program_state": {
 // CHECK-NEXT:   "store": { "pointer": "{{0x[0-9a-f]+}}", "items": [
 // CHECK-NEXT:     { "cluster": "y", "pointer": "{{0x[0-9a-f]+}}", "items": [
 // CHECK-NEXT:       { "kind": "Direct", "offset": 0, "value": "2 S32b" }
 // CHECK-NEXT:     ]}
 // CHECK-NEXT:   ]},
 // CHECK-NEXT:   "environment": { "pointer": "{{0x[0-9a-f]+}}", "items": [
-// CHECK-NEXT:     { "lctx_id": 1, "location_context": "#0 Call", "calling": "foo", "call_line": null, "items": [
+// CHECK-NEXT:     { "lctx_id": 1, "location_context": "#0 Call", "calling": "foo", "location": null, "items": [
 // CHECK-NEXT:       { "stmt_id": {{[0-9]+}}, "pretty": "clang_analyzer_printState", "value": "&code{clang_analyzer_printState}" }
 // CHECK-NEXT:     ]}
 // CHECK-NEXT:   ]},
 // CHECK-NEXT:   "constraints": [
 // CHECK-NEXT:     { "symbol": "reg_$0<int x>", "range": "{ [-2147483648, 13] }" }
 // CHECK-NEXT:   ],
 // CHECK-NEXT:   "dynamic_types": null,
 // CHECK-NEXT:   "constructing_objects": null,
 // CHECK-NEXT:   "checker_messages": null
 // CHECK-NEXT: }
 

clang/utils/analyzer/exploded-graph-rewriter.py

def is_different(self, prev):
         removed, added = self.diff(prev)
         return len(removed) != 0 or len(added) != 0
 
 
 # A deserialized source location.
 class SourceLocation(object):
     def __init__(self, json_loc):
         super(SourceLocation, self).__init__()
+        logging.debug('json: %s' % json_loc)
         self.line = json_loc['line']
         self.col = json_loc['column']
         self.filename = os.path.basename(json_loc['file']) \
             if 'file' in json_loc else '(main file)'
+        self.spelling = SourceLocation(json_loc['spelling']) \
+            if 'spelling' in json_loc else None
+
+    def is_macro(self):
+        return self.spelling is not None
 
 
 # A deserialized program point.
 class ProgramPoint(object):
     def __init__(self, json_pp):
         super(ProgramPoint, self).__init__()
         self.kind = json_pp['kind']
         self.tag = json_pp['tag']
         if self.kind == 'Edge':
             self.src_id = json_pp['src_id']
             self.dst_id = json_pp['dst_id']
         elif self.kind == 'Statement':
+            logging.debug(json_pp)
             self.stmt_kind = json_pp['stmt_kind']
             self.stmt_point_kind = json_pp['stmt_point_kind']
+            self.stmt_id = json_pp['stmt_id']
             self.pointer = json_pp['pointer']
             self.pretty = json_pp['pretty']
             self.loc = SourceLocation(json_pp['location']) \
                 if json_pp['location'] is not None else None
         elif self.kind == 'BlockEntrance':
             self.block_id = json_pp['block_id']
 
 

 
 # Deserialized description of a location context.
 class LocationContext(object):
     def __init__(self, json_frame):
         super(LocationContext, self).__init__()
         self.lctx_id = json_frame['lctx_id']
         self.caption = json_frame['location_context']
         self.decl = json_frame['calling']
-        self.line = json_frame['call_line']
+        self.loc = SourceLocation(json_frame['location']) \
+            if json_frame['location'] is not None else None
 
     def _key(self):
         return self.lctx_id
 
     def __eq__(self, other):
         return self._key() == other._key()
 
     def __hash__(self):
def _short_pretty(s):
         right = s.rfind('}')
         if left == -1 or right == -1 or left >= right:
             return s
         candidate = s[0:left + 1] + ' ... ' + s[right:]
         if len(candidate) >= len(s):
             return s
         return candidate
 
+    @staticmethod
+    def _make_sloc(loc):
+        if loc is None:
+            return '<i>Invalid Source Location</i>'
+
+        def make_plain_loc(loc):
+            return '%s:<b>%s</b>:<b>%s</b>' \
+                % (loc.filename, loc.line, loc.col)
+
+        if loc.is_macro():
+            return '%s <font color="royalblue1">' \
+                   '(<i>spelling at </i> %s)</font>' \
+                % (make_plain_loc(loc), make_plain_loc(loc.spelling))
+
+        return make_plain_loc(loc)
+
     def visit_begin_graph(self, graph):
         self._graph = graph
         self._dump_raw('digraph "ExplodedGraph" {\n')
         if self._dark_mode:
             self._dump_raw('bgcolor="gray10";\n')
         self._dump_raw('label="";\n')
 
     def visit_program_point(self, p):
def visit_program_point(self, p):
         else:
             color = 'forestgreen'
 
         if p.kind == 'Statement':
             # This avoids pretty-printing huge statements such as CompoundStmt.
             # Such statements show up only at [Pre|Post]StmtPurgeDeadSymbols
             skip_pretty = 'PurgeDeadSymbols' in p.stmt_point_kind
             stmt_color = 'cyan3'
-            if p.loc is not None:
-                self._dump('<tr><td align="left" width="0">'
-                           '%s:<b>%s</b>:<b>%s</b>:</td>'
-                           '<td align="left" width="0"><font color="%s">'
-                           '%s</font></td>'
-                           '<td align="left"><font color="%s">%s</font></td>'
-                           '<td>%s</td></tr>'
-                           % (p.loc.filename, p.loc.line,
-                              p.loc.col, color, p.stmt_kind,
-                              stmt_color, p.stmt_point_kind,
-                              self._short_pretty(p.pretty)
-                              if not skip_pretty else ''))
-            else:
-                self._dump('<tr><td align="left" width="0">'
-                           '<i>Invalid Source Location</i>:</td>'
-                           '<td align="left" width="0">'
-                           '<font color="%s">%s</font></td>'
-                           '<td align="left"><font color="%s">%s</font></td>'
-                           '<td>%s</td></tr>'
-                           % (color, p.stmt_kind,
-                              stmt_color, p.stmt_point_kind,
-                              self._short_pretty(p.pretty)
-                              if not skip_pretty else ''))
+            self._dump('<tr><td align="left" width="0">%s:</td>'
+                       '%s</font> </td>'
+                       '<td align="left"><i>S%s</i></td>'
+                       '<td align="left">%s</td></tr>'
+                       % (self._make_sloc(p.loc), color, p.stmt_kind,
+                          p.stmt_id, stmt_color, p.stmt_point_kind,
         elif p.kind == 'Edge':
             self._dump('<tr><td width="0"></td>'
                        '<td align="left" width="0">'
                        '<font color="%s">%s</font></td><td align="left">'
                        '[B%d] -\\> [B%d]</td></tr>'
                        % (color, 'BlockEdge', p.src_id, p.dst_id))
         elif p.kind == 'BlockEntrance':
             self._dump('<tr><td width="0"></td>'
def visit_environment(self, e, prev_e=None):
         def dump_location_context(lc, is_added=None):
             self._dump('<tr><td>%s</td>'
                        '<td align="left"><b>%s</b></td>'
                        '<td align="left" colspan="2">'
                        '<font color="gray60">%s </font>'
                        '%s</td></tr>'
                        % (self._diff_plus_minus(is_added),
                           lc.caption, lc.decl,
-                          ('(line %s)' % lc.line) if lc.line is not None
-                          else ''))
+                          ('(%s)' % self._make_sloc(lc.loc))
+                          if lc.loc is not None else ''))
 
         def dump_binding(f, b, is_added=None):
             self._dump('<tr><td>%s</td>'
                        '<td align="left"><i>S%s</i></td>'
                        '%s'
                        '<td align="left">%s</td>'
                        '<td align="left">%s</td></tr>'
                        % (self._diff_plus_minus(is_added),