[analyzer] A testing facility for testing relationships between symbols.

[NoQ]

Summary

A test introduced in rC329780 was disabled in rC342317 for the reason explained in https://reviews.llvm.org/D41938?id=130403#inline-371070 - tests shouldn't test dump infrastructure when all they care about is how symbols relate to each other.

Add a new feature to ExprInspection: clang_analyzer_denote() and clang_analyzer_explain(). The former adds a notation to a symbol, the latter expresses another symbol in terms of previously denoted symbols.

It's currently a bit wonky - doesn't print parentheses and only supports denoting atomic symbols. But it's even more readable that way.

I also noticed that an important use case was omitted in these tests. Namely, tests for unsigned integer rearrangement are done with signed-type symbols stored in unsigned variables and we also need to test unsigned symbols stored in unsigned variables (and ideally also unsigned symbols stored in signed variables).

[baloghadamsoftware]

This looks better than using the "raw" dumps.

Should not it we have its own test in expr-inspection.c?

lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

65 ↗

(On Diff #165635)

Why const void *?

[NoQ]

Address comments. Add more sanity checks and test them.

[NoQ]

Should not it we have its own test in expr-inspection.c?

This isn't usually necessary when we're testing all code paths anyway, but i guess it's worth it to test our sanity-check warnings.

lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

65 ↗

(On Diff #165635)

Whoops, i was incorrectly recalling that it doesn't work because the respective type trait structures aren't defined for non-void pointers, but that must have been some other data structure.

[george.karpenkov]

@NoQ Actually I agree with @baloghadamsoftware that it makes sense to have a separate test, as this functionality should be tested regardless of svalbuilder-rearrange-comparisons existence.

[NoQ]

In D52133#1237312, @george.karpenkov wrote:

@NoQ Actually I agree with @baloghadamsoftware that it makes sense to have a separate test, as this functionality should be tested regardless of svalbuilder-rearrange-comparisons existence.

That's why i added a spearate test.

[NoQ]

Mm, i mean, that reason as good as well.

[george.karpenkov]

lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

273 ↗

(On Diff #165810)

Sidenote: this code fragment is so common I wonder whether we should have a helper/facility for that.

cfe/trunk/docs/analyzer/DebugChecks.rst

- ``void clang_analyzer_hashDump(int);``
 
   Example usage::
 
     void foo() {
       int x = 1;
       clang_analyzer_hashDump(x); // expected-warning{{hashed string for x}}
     }
 
+- ``void clang_analyzer_denote(int, const char *);``
+
+  Denotes symbols with strings. A subsequent call to clang_analyzer_express()
+  will expresses another symbol in terms of these string. Useful for testing
+  relationships between different symbols.
+
+  Example usage::
+
+    void foo(int x) {
+      clang_analyzer_denote(x, "$x");
+      clang_analyzer_express(x + 1); // expected-warning{{$x + 1}}
+    }
+
+- ``void clang_analyzer_express(int);``
+
+  See clang_analyzer_denote().
+
 Statistics
 ==========
 
 The debug.Stats checker collects various information about the analysis of each
 function, such as how many blocks were reached and if the analyzer timed out.
 
 There is also an additional -analyzer-stats flag, which enables various
 statistics within the analyzer engine. Note the Stats checker (which produces at
 least one bug report per function) may actually change the values reported by
 -analyzer-stats.

cfe/trunk/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

class ExprInspectionChecker : public Checker<eval::Call, check::DeadSymbols,
   void analyzerNumTimesReached(const CallExpr *CE, CheckerContext &C) const;
   void analyzerCrash(const CallExpr *CE, CheckerContext &C) const;
   void analyzerWarnOnDeadSymbol(const CallExpr *CE, CheckerContext &C) const;
   void analyzerDump(const CallExpr *CE, CheckerContext &C) const;
   void analyzerExplain(const CallExpr *CE, CheckerContext &C) const;
   void analyzerPrintState(const CallExpr *CE, CheckerContext &C) const;
   void analyzerGetExtent(const CallExpr *CE, CheckerContext &C) const;
   void analyzerHashDump(const CallExpr *CE, CheckerContext &C) const;
+  void analyzerDenote(const CallExpr *CE, CheckerContext &C) const;
+  void analyzerExpress(const CallExpr *CE, CheckerContext &C) const;
 
   typedef void (ExprInspectionChecker::*FnCheck)(const CallExpr *,
                                                  CheckerContext &C) const;
 
   ExplodedNode *reportBug(llvm::StringRef Msg, CheckerContext &C) const;
   ExplodedNode *reportBug(llvm::StringRef Msg, BugReporter &BR,
                           ExplodedNode *N) const;
 
 public:
   bool evalCall(const CallExpr *CE, CheckerContext &C) const;
   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
   void checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
                         ExprEngine &Eng) const;
 };
 }
 
 REGISTER_SET_WITH_PROGRAMSTATE(MarkedSymbols, SymbolRef)
+REGISTER_MAP_WITH_PROGRAMSTATE(DenotedSymbols, SymbolRef, const StringLiteral *)
 
 bool ExprInspectionChecker::evalCall(const CallExpr *CE,
                                      CheckerContext &C) const {
   // These checks should have no effect on the surrounding environment
   // (globals should not be invalidated, etc), hence the use of evalCall.
   FnCheck Handler = llvm::StringSwitch<FnCheck>(C.getCalleeName(CE))
     .Case("clang_analyzer_eval", &ExprInspectionChecker::analyzerEval)
     .Case("clang_analyzer_checkInlined",
           &ExprInspectionChecker::analyzerCheckInlined)
     .Case("clang_analyzer_crash", &ExprInspectionChecker::analyzerCrash)
     .Case("clang_analyzer_warnIfReached",
           &ExprInspectionChecker::analyzerWarnIfReached)
     .Case("clang_analyzer_warnOnDeadSymbol",
           &ExprInspectionChecker::analyzerWarnOnDeadSymbol)
     .StartsWith("clang_analyzer_explain", &ExprInspectionChecker::analyzerExplain)
     .StartsWith("clang_analyzer_dump", &ExprInspectionChecker::analyzerDump)
     .Case("clang_analyzer_getExtent", &ExprInspectionChecker::analyzerGetExtent)
     .Case("clang_analyzer_printState",
           &ExprInspectionChecker::analyzerPrintState)
     .Case("clang_analyzer_numTimesReached",
           &ExprInspectionChecker::analyzerNumTimesReached)
     .Case("clang_analyzer_hashDump", &ExprInspectionChecker::analyzerHashDump)
+    .Case("clang_analyzer_denote", &ExprInspectionChecker::analyzerDenote)
+    .Case("clang_analyzer_express", &ExprInspectionChecker::analyzerExpress)
     .Default(nullptr);
 
   if (!Handler)
     return false;
 
   (this->*Handler)(CE, C);
   return true;
 }
for (auto I = Syms.begin(), E = Syms.end(); I != E; ++I) {
     if (!SymReaper.isDead(Sym))
       continue;
 
     // The non-fatal error node should be the same for all reports.
     if (ExplodedNode *BugNode = reportBug("SYMBOL DEAD", C))
       N = BugNode;
     State = State->remove<MarkedSymbols>(Sym);
   }
+
+  for (auto I : State->get<DenotedSymbols>()) {
+    SymbolRef Sym = I.first;
+    if (!SymReaper.isLive(Sym))
+      State = State->remove<DenotedSymbols>(Sym);
+  }
+
   C.addTransition(State, N);
 }
 
 void ExprInspectionChecker::checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
                                              ExprEngine &Eng) const {
   for (auto Item: ReachedStats) {
     unsigned NumTimesReached = Item.second.NumTimesReached;
     ExplodedNode *N = Item.second.ExampleNode;
void ExprInspectionChecker::analyzerHashDump(const CallExpr *CE,
   FullSourceLoc FL(CE->getArg(0)->getBeginLoc(), SM);
   std::string HashContent =
       GetIssueString(SM, FL, getCheckName().getName(), "Category",
                      C.getLocationContext()->getDecl(), Opts);
 
   reportBug(HashContent, C);
 }
 
+void ExprInspectionChecker::analyzerDenote(const CallExpr *CE,
+                                           CheckerContext &C) const {
+  if (CE->getNumArgs() < 2) {
+    reportBug("clang_analyzer_denote() requires a symbol and a string literal",
+              C);
+    return;
+  }
+
+  SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();
+  if (!Sym) {
+    reportBug("Not a symbol", C);
+    return;
+  }
+
+  if (!isa<SymbolData>(Sym)) {
+    reportBug("Not an atomic symbol", C);
+    return;
+  }
+
+  const auto *E = dyn_cast<StringLiteral>(CE->getArg(1)->IgnoreParenCasts());
+  if (!E) {
+    reportBug("Not a string literal", C);
+    return;
+  }
+
+  ProgramStateRef State = C.getState();
+
+  C.addTransition(C.getState()->set<DenotedSymbols>(Sym, E));
+}
+
+class SymbolExpressor
+    : public SymExprVisitor<SymbolExpressor, Optional<std::string>> {
+  ProgramStateRef State;
+
+public:
+  SymbolExpressor(ProgramStateRef State) : State(State) {}
+
+  Optional<std::string> VisitSymExpr(const SymExpr *S) {
+    if (const StringLiteral *const *SLPtr = State->get<DenotedSymbols>(S)) {
+      const StringLiteral *SL = *SLPtr;
+      return std::string(SL->getBytes());
+    }
+    return None;
+  }
+
+  Optional<std::string> VisitSymIntExpr(const SymIntExpr *S) {
+    if (auto Str = Visit(S->getLHS()))
+      return (*Str + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) + " " +
+              std::to_string(S->getRHS().getLimitedValue()) +
+              (S->getRHS().isUnsigned() ? "U" : ""))
+          .str();
+    return None;
+  }
+
+  Optional<std::string> VisitSymSymExpr(const SymSymExpr *S) {
+    if (auto Str1 = Visit(S->getLHS()))
+      if (auto Str2 = Visit(S->getRHS()))
+        return (*Str1 + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) +
+                " " + *Str2).str();
+    return None;
+  }
+};
+
+void ExprInspectionChecker::analyzerExpress(const CallExpr *CE,
+                                            CheckerContext &C) const {
+  if (CE->getNumArgs() == 0) {
+    reportBug("clang_analyzer_express() requires a symbol", C);
+    return;
+  }
+
+  SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();
+  if (!Sym) {
+    reportBug("Not a symbol", C);
+    return;
+  }
+
+  SymbolExpressor V(C.getState());
+  auto Str = V.Visit(Sym);
+  if (!Str) {
+    reportBug("Unable to express", C);
+    return;
+  }
+
+  reportBug(*Str, C);
+}
+
 void ento::registerExprInspectionChecker(CheckerManager &Mgr) {
   Mgr.registerChecker<ExprInspectionChecker>();
 }

cfe/trunk/test/Analysis/expr-inspection.cpp

+// RUN: %clang_analyze_cc1 -x c++ -analyzer-checker=debug.ExprInspection -verify %s
+
+// Self-tests for the debug.ExprInspection checker.
+
+void clang_analyzer_denote(int x, const char *str);
+void clang_analyzer_express(int x);
+
+// Invalid declarations to test sanity checks.
+void clang_analyzer_denote();
+void clang_analyzer_denote(int x);
+void clang_analyzer_express();
+
+void foo(int x, unsigned y) {
+  clang_analyzer_denote(); // expected-warning{{clang_analyzer_denote() requires a symbol and a string literal}}
+  clang_analyzer_express(); // expected-warning{{clang_analyzer_express() requires a symbol}}
+
+  clang_analyzer_denote(x); // expected-warning{{clang_analyzer_denote() requires a symbol and a string literal}}
+  clang_analyzer_express(x); // expected-warning{{Unable to express}}
+
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x + y); // expected-warning{{$x + $y}}
+
+  clang_analyzer_denote(1, "$z");     // expected-warning{{Not a symbol}}
+  clang_analyzer_express(1);     // expected-warning{{Not a symbol}}
+
+  clang_analyzer_denote(x + 1, "$w"); // expected-warning{{Not an atomic symbol}}
+  clang_analyzer_express(x + 1); // expected-warning{{$x + 1}}
+  clang_analyzer_express(y + 1); // expected-warning{{$y + 1U}}
+}

cfe/trunk/test/Analysis/svalbuilder-rearrange-comparisons.c

 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify -analyzer-config eagerly-assume=false %s
 
-// Temporary xfailing, as debug printing functionality has changed.
-// XFAIL: *
-
-void clang_analyzer_dump(int x);
 void clang_analyzer_eval(int x);
+void clang_analyzer_denote(int x, const char *literal);
+void clang_analyzer_express(int x);
 
 void exit(int);
 
 #define UINT_MAX (~0U)
 #define INT_MAX (UINT_MAX & (UINT_MAX >> 1))
 
 extern void __assert_fail (__const char *__assertion, __const char *__file,
     unsigned int __line, __const char *__function)
      __attribute__ ((__noreturn__));
 #define assert(expr) \
   ((expr)  ? (void)(0)  : __assert_fail (#expr, __FILE__, __LINE__, __func__))
 
 int g();
 int f() {
   int x = g();
   // Assert that no overflows occur in this test file.
   // Assuming that concrete integers are also within that range.
   assert(x <= ((int)INT_MAX / 4));
   assert(x >= -((int)INT_MAX / 4));
   return x;
 }
 
 void compare_different_symbol_equal() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 0}}
 }
 
 void compare_different_symbol_plus_left_int_equal() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_minus_left_int_equal() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_different_symbol_plus_right_int_equal() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 2}}
 }
 
 void compare_different_symbol_minus_right_int_equal() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_equal() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_equal() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_equal() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_equal() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_same_symbol_equal() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_right_int_equal() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_right_int_equal() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_or_equal() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_or_equal() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_or_equal() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_or_equal() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_or_equal() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_or_equal() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_or_equal() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_or_equal() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_or_equal() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_same_symbol_less_or_equal() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_less_or_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_less_or_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 0}}
 }
 
 void compare_different_symbol_plus_left_int_less() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_minus_left_int_less() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_different_symbol_plus_right_int_less() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 2}}
 }
 
 void compare_different_symbol_minus_right_int_less() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_same_symbol_less() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_int_less() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_less() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_right_int_less() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_right_int_less() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_different_symbol_equal_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 0}}
 }
 
 void compare_different_symbol_plus_left_int_equal_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_minus_left_int_equal_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_different_symbol_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 2}}
 }
 
 void compare_different_symbol_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_same_symbol_equal_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) == (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x == y); // expected-warning {{$x + 1U == $x}}
 }
 
 void compare_same_symbol_minus_left_int_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) == (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - 1U == $x}}
 }
 
 void compare_same_symbol_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x == $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x == $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) == ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x + 1U == $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) == ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - 1U == $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_or_equal_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_or_equal_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_or_equal_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_same_symbol_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) <= (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x + 1U <= $x}}
 }
 
 void compare_same_symbol_minus_left_int_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) <= (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - 1U <= $x}}
 }
 
 void compare_same_symbol_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x <= $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x <= $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) <= ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x + 1U <= $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) <= ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - 1U <= $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_same_symbol_less_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_int_less_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) < (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x < y); // expected-warning {{$x + 1U < $x}}
 }
 
 void compare_same_symbol_minus_left_int_less_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) < (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - 1U < $x}}
 }
 
 void compare_same_symbol_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x < $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x < $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) < ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x + 1U < $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) < ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - 1U < $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void overflow(signed char n, signed char m) {
   if (n + 0 > m + 0) {
-    clang_analyzer_eval(n - 126 == m + 3); // expected-warning{{UNKNOWN}}
+    clang_analyzer_eval(n - 126 == m + 3); // expected-warning {{UNKNOWN}}
   }
 }
 
 int mixed_integer_types(int x, int y) {
   short a = x - 1U;
   return a - y;
 }