[Analyzer] Use note tags to track iterator increments and decrements

[baloghadamsoftware]

Summary

Note tags marking the points where an iterator is incremented or decremented helps finding the root cause of iterator errors, especially out-of-range dereferences and out-of-range increments and decrements. This patch adds such tags.

[baloghadamsoftware]

Minor update: ignore parentheses and casts when taking the name of the expression.

[Szelethus]

See my related comment here: D73720#1901453.

[baloghadamsoftware]

Split into two patches. This is the first one.

[Szelethus]

A few nits, otherwise the patch is great!

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

525–526

Are It1 and It2 used? Why do we default the latter to UndefinedVal?

clang/test/Analysis/iterator-modelling.cpp

1–5

Can we prettify this? :)

clang/test/Analysis/iterator-range.cpp

1–3

And this?

[Szelethus]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

525–526

Ah, okay, we use it in a followup patch. Still, we shouldn't use UndefinedVal, as discussed in D75514.

[baloghadamsoftware]

Updated according to the comments.

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

525–526

I completely removed them from this patch.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

503–504

Can we assert out the ChangeVal == 0 case or make a better message for it ("unchanged" or something like that)?

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

503–504

Another important thing to do here is to track the RHS value via trackExpressionValue(). I.e., why do we think that iterator is incremented by 1 and not by 2?

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

503–504

I agree, that is important, but where should I call it? This is the modeling checker, which models the increments and the decrements, but trackExpressionValue() can only be invoked for bug reports. Should I put it into the NoteTag lambda?

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

503–504

Yup, it should be possible to invoke trackExpressionValue(), and generally attach more visitors, inside a NoteTag.

[baloghadamsoftware]

Rebased and added call for trackExpressionValue().

[baloghadamsoftware]

clang/test/Analysis/iterator-modelling.cpp

227

Strange, that we do not get this note for prev.

[NoQ]

clang/test/Analysis/iterator-modelling.cpp

227

Mmm, why 0-1?

[baloghadamsoftware]

Rebased.

[baloghadamsoftware]

clang/test/Analysis/iterator-modelling.cpp

227

Because it depends whether next() is inlined.

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

class DebugIteratorModeling
   };
 
 public:
   DebugIteratorModeling();
 
   bool evalCall(const CallEvent &Call, CheckerContext &C) const;
 };
 
+bool contains(const SourceManager &SM, const SourceRange Outer,
+              SourceRange Inner);
+
 } //namespace
 
 DebugIteratorModeling::DebugIteratorModeling() {
   DebugMsgBugType.reset(
       new BugType(this, "Checking analyzer assumptions", "debug",
                   /*SuppressOnSink=*/true));
 }
 
void DebugIteratorModeling::analyzerIteratorDataField(const CallExpr *CE,
   auto State = C.getState();
   SVal V = C.getSVal(CE->getArg(0));
   const auto *Pos = getIteratorPosition(State, V);
   if (Pos) {
     State = State->BindExpr(CE, C.getLocationContext(), get(Pos));
   } else {
     State = State->BindExpr(CE, C.getLocationContext(), Default);
   }
-  C.addTransition(State);
+
+  const auto &SM = C.getSourceManager();
+  const NoteTag *InterestingTag =
+    C.getNoteTag([V, CE, &SM](BugReport &BR) -> std::string {
+        auto *PSBR = dyn_cast<PathSensitiveBugReport>(&BR);
+        if (PSBR && contains(SM, PSBR->getRanges()[0], CE->getSourceRange())) {
+          PSBR->markInteresting(V);
+        }
+        return "";
+      });
+
+  C.addTransition(State, InterestingTag);
 }
 
 void DebugIteratorModeling::analyzerIteratorPosition(const CallExpr *CE,
                                                      CheckerContext &C) const {
   auto &BVF = C.getSValBuilder().getBasicValueFactory();
   analyzerIteratorDataField(CE, C, [](const IteratorPosition *P) {
       return nonloc::SymbolVal(P->getOffset());
     }, nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
if (!N)
     return nullptr;
 
   auto &BR = C.getBugReporter();
   BR.emitReport(std::make_unique<PathSensitiveBugReport>(*DebugMsgBugType,
                                                          Msg, N));
   return N;
 }
 
+namespace {
+
+bool contains(const SourceManager &SM, const SourceRange Outer,
+              SourceRange Inner) {
+  SourceLocation OB = Outer.getBegin(), OE = Outer.getEnd(),
+                 IB = Inner.getBegin(), IE = Inner.getEnd();
+  return (OB == IB || SM.isBeforeInTranslationUnit(OB, IB)) &&
+         (IE == OE || SM.isBeforeInTranslationUnit(IE, OE));
+}
+
+} // namespace
+
 void ento::registerDebugIteratorModeling(CheckerManager &mgr) {
   mgr.registerChecker<DebugIteratorModeling>();
 }
 
 bool ento::shouldRegisterDebugIteratorModeling(const LangOptions &LO) {
   return true;
 }

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

class IteratorModeling
 
   void handleComparison(CheckerContext &C, const Expr *CE, SVal RetVal,
                         const SVal &LVal, const SVal &RVal,
                         OverloadedOperatorKind Op) const;
   void processComparison(CheckerContext &C, ProgramStateRef State,
                          SymbolRef Sym1, SymbolRef Sym2, const SVal &RetVal,
                          OverloadedOperatorKind Op) const;
   void handleIncrement(CheckerContext &C, const SVal &RetVal, const SVal &Iter,
-                       bool Postfix) const;
+                       const Expr *ItE, bool Postfix) const;
   void handleDecrement(CheckerContext &C, const SVal &RetVal, const SVal &Iter,
-                       bool Postfix) const;
+                       const Expr *ItE, bool Postfix) const;
   void handleRandomIncrOrDecr(CheckerContext &C, const Expr *CE,
                               OverloadedOperatorKind Op, const SVal &RetVal,
-                              const SVal &LHS, const SVal &RHS) const;
+                              const SVal &LHS, const SVal &RHS,
+                              const Expr *ItE) const;
   void assignToContainer(CheckerContext &C, const Expr *CE, const SVal &RetVal,
                          const MemRegion *Cont) const;
+  const NoteTag *getChangeTag(CheckerContext &C, StringRef Text,
+                              const Expr *ItE, SVal It1, int64_t Amount = 0,
+                              SVal It2 = UndefinedVal()) const;
+  const NoteTag *getInterestingnessPropagationTag(CheckerContext &C, SVal It1,
+                                                  SVal It2) const;
   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
                   const char *Sep) const override;
-
 public:
   IteratorModeling() {}
 
   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
   void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const;
-  void checkPostStmt(const CXXConstructExpr *CCE, CheckerContext &C) const;
-  void checkPostStmt(const DeclStmt *DS, CheckerContext &C) const;
   void checkPostStmt(const MaterializeTemporaryExpr *MTE,
                      CheckerContext &C) const;
   void checkLiveSymbols(ProgramStateRef State, SymbolReaper &SR) const;
   void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
 };
 
 bool isSimpleComparisonOperator(OverloadedOperatorKind OK);
 ProgramStateRef removeIteratorPosition(ProgramStateRef State, const SVal &Val);
if (isSimpleComparisonOperator(Op)) {
       if (!OrigExpr)
         return;
 
       if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
         if (Call.getNumArgs() >= 1 &&
               Call.getArgExpr(0)->getType()->isIntegralOrEnumerationType()) {
           handleRandomIncrOrDecr(C, OrigExpr, Func->getOverloadedOperator(),
                                  Call.getReturnValue(),
-                                 InstCall->getCXXThisVal(), Call.getArgSVal(0));
+                                 InstCall->getCXXThisVal(), Call.getArgSVal(0),
+                                 InstCall->getCXXThisExpr());
           return;
         }
       } else {
         if (Call.getNumArgs() >= 2 &&
               Call.getArgExpr(1)->getType()->isIntegralOrEnumerationType()) {
           handleRandomIncrOrDecr(C, OrigExpr, Func->getOverloadedOperator(),
                                  Call.getReturnValue(), Call.getArgSVal(0),
-                                 Call.getArgSVal(1));
+                                 Call.getArgSVal(1), Call.getArgExpr(0));
           return;
         }
       }
     } else if (isIncrementOperator(Func->getOverloadedOperator())) {
       if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
         handleIncrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
-                        Call.getNumArgs());
+                        InstCall->getCXXThisExpr(), Call.getNumArgs());
         return;
       }
 
       handleIncrement(C, Call.getReturnValue(), Call.getArgSVal(0),
-                      Call.getNumArgs());
+                      Call.getArgExpr(0), Call.getNumArgs());
       return;
     } else if (isDecrementOperator(Func->getOverloadedOperator())) {
       if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
         handleDecrement(C, Call.getReturnValue(), InstCall->getCXXThisVal(),
-                        Call.getNumArgs());
+                        InstCall->getCXXThisExpr(), Call.getNumArgs());
         return;
       }
 
       handleDecrement(C, Call.getReturnValue(), Call.getArgSVal(0),
-                        Call.getNumArgs());
+                      Call.getArgExpr(0), Call.getNumArgs());
       return;
     }
   } else {
     if (!isIteratorType(Call.getResultType()))
       return;
 
     const auto *OrigExpr = Call.getOriginExpr();
     if (!OrigExpr)
       return;
 
     auto State = C.getState();
 
     // Already bound to container?
     if (getIteratorPosition(State, Call.getReturnValue()))
       return;
 
     // Copy-like and move constructors
     if (isa<CXXConstructorCall>(&Call) && Call.getNumArgs() == 1) {
       if (const auto *Pos = getIteratorPosition(State, Call.getArgSVal(0))) {
         State = setIteratorPosition(State, Call.getReturnValue(), *Pos);
         if (cast<CXXConstructorDecl>(Func)->isMoveConstructor()) {
           State = removeIteratorPosition(State, Call.getArgSVal(0));
         }
-        C.addTransition(State);
+        const NoteTag *InterestingTag =
+          getInterestingnessPropagationTag(C, Call.getArgSVal(0),
+                                           Call.getReturnValue());
+        C.addTransition(State, InterestingTag);
         return;
       }
     }
 
     // Assumption: if return value is an iterator which is not yet bound to a
     //             container, then look for the first iterator argument, and
     //             bind the return value to the same container. This approach
     //             works for STL algorithms.

 }
 
 void IteratorModeling::checkBind(SVal Loc, SVal Val, const Stmt *S,
                                  CheckerContext &C) const {
   auto State = C.getState();
   const auto *Pos = getIteratorPosition(State, Val);
   if (Pos) {
     State = setIteratorPosition(State, Loc, *Pos);
-    C.addTransition(State);
+    const NoteTag *InterestingTag =
+      getInterestingnessPropagationTag(C, Val, Loc);
+    C.addTransition(State, InterestingTag);
   } else {
     const auto *OldPos = getIteratorPosition(State, Loc);
     if (OldPos) {
       State = removeIteratorPosition(State, Loc);
       C.addTransition(State);
     }
   }
 }
 
 void IteratorModeling::checkPostStmt(const MaterializeTemporaryExpr *MTE,
                                      CheckerContext &C) const {
   /* Transfer iterator state to temporary objects */
   auto State = C.getState();
-  const auto *Pos = getIteratorPosition(State, C.getSVal(MTE->getSubExpr()));
+  SVal OldVal = C.getSVal(MTE->getSubExpr());
+  SVal NewVal = C.getSVal(MTE);
+  const auto *Pos = getIteratorPosition(State, OldVal);
   if (!Pos)
     return;
-  State = setIteratorPosition(State, C.getSVal(MTE), *Pos);
-  C.addTransition(State);
+  State = setIteratorPosition(State, NewVal, *Pos);
+  const NoteTag *InterestingTag =
+    getInterestingnessPropagationTag(C, OldVal, NewVal);
+  C.addTransition(State, InterestingTag);
 }
 
 void IteratorModeling::checkLiveSymbols(ProgramStateRef State,
                                         SymbolReaper &SR) const {
   // Keep symbolic expressions of iterator positions alive
   auto RegionMap = State->get<IteratorRegionMap>();
   for (const auto &Reg : RegionMap) {
     const auto Offset = Reg.second.getOffset();
void IteratorModeling::processComparison(CheckerContext &C,
   
   if (auto StateFalse = relateSymbols(State, Sym1, Sym2, Op != OO_EqualEqual)) {
     StateFalse = StateFalse->assume(*ConditionVal, false);
     C.addTransition(StateFalse);
   }
 }
 
 void IteratorModeling::handleIncrement(CheckerContext &C, const SVal &RetVal,
-                                       const SVal &Iter, bool Postfix) const {
+                                       const SVal &Iter, const Expr *ItE,
+                                       bool Postfix) const {
   // Increment the symbolic expressions which represents the position of the
   // iterator
   auto State = C.getState();
   auto &BVF = C.getSymbolManager().getBasicVals();
 
   const auto *Pos = getIteratorPosition(State, Iter);
   if (!Pos)
     return;
 
   auto NewState =
     advancePosition(State, Iter, OO_Plus,
                     nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
   assert(NewState &&
          "Advancing position by concrete int should always be successful");
 
   const auto *NewPos = getIteratorPosition(NewState, Iter);
   assert(NewPos &&
          "Iterator should have position after successful advancement");
 
+  const NoteTag *ChangeTag =
+    getChangeTag(C, "incremented", ItE, Iter, 1,
+                 Postfix ? UndefinedVal() : RetVal);
   State = setIteratorPosition(State, Iter, *NewPos);
   State = setIteratorPosition(State, RetVal, Postfix ? *Pos : *NewPos);
-  C.addTransition(State);
+  C.addTransition(State, ChangeTag);
 }
 
 void IteratorModeling::handleDecrement(CheckerContext &C, const SVal &RetVal,
-                                       const SVal &Iter, bool Postfix) const {
+                                       const SVal &Iter, const Expr *ItE,
+                                       bool Postfix) const {
   // Decrement the symbolic expressions which represents the position of the
   // iterator
   auto State = C.getState();
   auto &BVF = C.getSymbolManager().getBasicVals();
 
   const auto *Pos = getIteratorPosition(State, Iter);
   if (!Pos)
     return;
 
   auto NewState =
     advancePosition(State, Iter, OO_Minus,
                     nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))));
   assert(NewState &&
          "Advancing position by concrete int should always be successful");
 
   const auto *NewPos = getIteratorPosition(NewState, Iter);
   assert(NewPos &&
          "Iterator should have position after successful advancement");
 
+  const NoteTag *ChangeTag =
+    getChangeTag(C, "decremented", ItE, Iter, 1,
+                 Postfix ? UndefinedVal() : RetVal);
   State = setIteratorPosition(State, Iter, *NewPos);
   State = setIteratorPosition(State, RetVal, Postfix ? *Pos : *NewPos);
-  C.addTransition(State);
+  C.addTransition(State, ChangeTag);
 }
 
 void IteratorModeling::handleRandomIncrOrDecr(CheckerContext &C,
                                               const Expr *CE,
                                               OverloadedOperatorKind Op,
                                               const SVal &RetVal,
                                               const SVal &LHS,
-                                              const SVal &RHS) const {
+                                              const SVal &RHS,
+                                              const Expr *ItE) const {
   // Increment or decrement the symbolic expressions which represents the
   // position of the iterator
   auto State = C.getState();
 
   const auto *Pos = getIteratorPosition(State, LHS);
   if (!Pos)
     return;
 
   const auto *value = &RHS;
   if (auto loc = RHS.getAs<Loc>()) {
     const auto val = State->getRawSVal(*loc);
     value = &val;
   }
 
   auto &TgtVal = (Op == OO_PlusEqual || Op == OO_MinusEqual) ? LHS : RetVal;
 
   auto NewState =
     advancePosition(State, LHS, Op, *value);
   if (NewState) {
     const auto *NewPos = getIteratorPosition(NewState, LHS);
     assert(NewPos &&
            "Iterator should have position after successful advancement");
 
+    auto &SVB = State->getStateManager().getSValBuilder();
+    const NoteTag *ChangeTag =
+      getChangeTag(C, ((Op == OO_Plus || Op == OO_PlusEqual) ?
+                       "incremented" : "decremented"), ItE, LHS,
+                   SVB.getKnownValue(State, *value)->getExtValue(),
+                   (TgtVal == RetVal) ? RetVal : UndefinedVal());
     State = setIteratorPosition(NewState, TgtVal, *NewPos);
-    C.addTransition(State);
+    C.addTransition(State, ChangeTag);
   } else {
     assignToContainer(C, CE, TgtVal, Pos->getContainer());
   }
 }
 
 void IteratorModeling::assignToContainer(CheckerContext &C, const Expr *CE,
                                          const SVal &RetVal,
                                          const MemRegion *Cont) const {
   Cont = Cont->getMostDerivedObjectRegion();
 
   auto State = C.getState();
   const auto *LCtx = C.getLocationContext();
   State = createIteratorPosition(State, RetVal, Cont, CE, LCtx, C.blockCount());
 
   C.addTransition(State);
 }
 
+const NoteTag *IteratorModeling::getChangeTag(CheckerContext &C, StringRef Text,
+                                              const Expr *ItE, SVal It1,
+                                              int64_t Amount, SVal It2) const {
+  StringRef Name;
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(ItE->IgnoreParenCasts()))) {
+    Name = DRE->getDecl()->getName();
+  }
+
+  return C.getNoteTag([Text, Name, Amount, It1, It2](BugReport &BR)
+                      -> std::string {
+      auto *PSBR = dyn_cast<PathSensitiveBugReport>(&BR);
+      if (!PSBR)
+        return "";
+
+      if (PSBR->isInteresting(It2)) {
+        PSBR->markInteresting(It1);
+        if (const auto &LCV1 = It1.getAs<nonloc::LazyCompoundVal>()) {
+          PSBR->markInteresting(LCV1->getRegion());
+        }
+      } else if (const auto &LCV2 = It2.getAs<nonloc::LazyCompoundVal>()) {
+        if (PSBR->isInteresting(LCV2->getRegion())) {
+          PSBR->markInteresting(It1);
+          if (const auto &LCV1 = It1.getAs<nonloc::LazyCompoundVal>()) {
+            PSBR->markInteresting(LCV1->getRegion());
+          }
+        }
+      }
+      
+      if (!PSBR->isInteresting(It1)) {
+        const auto &LCV1 = It1.getAs<nonloc::LazyCompoundVal>();
+        if (!LCV1)
+          return "";
+        if (!PSBR->isInteresting(LCV1->getRegion()))
+          return "";
+      }
+
+      SmallString<256> Msg;
+      llvm::raw_svector_ostream Out(Msg);
+      Out << "Iterator " << (!Name.empty() ? ("'" + Name.str() + "' ") : "" )
+          << Text;
+      if (Amount) {
+        Out << " by " << Amount;
+      }
+      return std::string(Out.str());
+    });
+}
+
+const NoteTag *
+IteratorModeling::getInterestingnessPropagationTag(CheckerContext &C,
+                                                   SVal It1, SVal It2) const {
+  return C.getNoteTag([It1, It2](BugReport &BR)
+                      -> std::string {
+      auto *PSBR = dyn_cast<PathSensitiveBugReport>(&BR);
+      if (!PSBR)
+        return "";
+
+      if (PSBR->isInteresting(It2)) {
+        PSBR->markInteresting(It1);
+        if (const auto &LCV1 = It1.getAs<nonloc::LazyCompoundVal>()) {
+          PSBR->markInteresting(LCV1->getRegion());
+        }
+      } else if (const auto &LCV2 = It2.getAs<nonloc::LazyCompoundVal>()) {
+        if (PSBR->isInteresting(LCV2->getRegion())) {
+          PSBR->markInteresting(It1);
+          if (const auto &LCV1 = It1.getAs<nonloc::LazyCompoundVal>()) {
+            PSBR->markInteresting(LCV1->getRegion());
+          }
+        }
+      }
+      
+      return "";
+    });
+}
+
 void IteratorModeling::printState(raw_ostream &Out, ProgramStateRef State,
                                   const char *NL, const char *Sep) const {
   auto SymbolMap = State->get<IteratorSymbolMap>();
   auto RegionMap = State->get<IteratorRegionMap>();
 
   if (!SymbolMap.isEmpty() || !RegionMap.isEmpty()) {
     Out << Sep << "Iterator Positions :" << NL;
     for (const auto &Sym : SymbolMap) {

clang/test/Analysis/iterator-modelling.cpp

-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false -analyzer-output=text %s -verify
 
-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 -analyzer-output=text %s -verify
 
 // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true %s 2>&1 | FileCheck %s
 
 #include "Inputs/system-header-simulator-cxx.h"
 
 template <typename Container>
 long clang_analyzer_container_begin(const Container&);
 template <typename Container>
 long clang_analyzer_container_end(const Container&);
 template <typename Iterator>
 long clang_analyzer_iterator_position(const Iterator&);
 template <typename Iterator>
 void* clang_analyzer_iterator_container(const Iterator&);
 template <typename Iterator>
 bool clang_analyzer_iterator_validity(const Iterator&);
 
 void clang_analyzer_denote(long, const char*);
 void clang_analyzer_express(long);
 void clang_analyzer_eval(bool);
 void clang_analyzer_warnIfReached();
 
 void begin(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i) == &v); // expected-warning{{TRUE}}
+                                                                   // expected-note@-1{{TRUE}}
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin()}}
+                                                               //expected-note@-1{{$v.begin()}}
 
   if (i != v.begin()) {
     clang_analyzer_warnIfReached();
   }
 }
 
 void end(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i) == &v); // expected-warning{{TRUE}}
+                                                                   // expected-note@-1{{TRUE}}
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.end()}}
+                                                               //expected-note@-1{{$v.end()}}
 
   if (i != v.end()) {
     clang_analyzer_warnIfReached();
   }
 }
 
 void prefix_increment(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  auto j = ++i;
+  auto j = ++i; // expected-note{{Iterator 'i' incremented by 1}}
+                // expected-note@-1{{Iterator 'i' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin() + 1}}
+                                                               //expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); //expected-warning{{$v.begin() + 1}}
+                                                               //expected-note@-1{{$v.begin() + 1}}
 }
 
 void prefix_decrement(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  auto j = --i;
+  auto j = --i; // expected-note{{Iterator 'i' decremented by 1}}
+                // expected-note@-1{{Iterator 'i' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.end() - 1}}
+                                                               //expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); //expected-warning{{$v.end() - 1}}
+                                                               //expected-note@-1{{$v.end() - 1}}
 }
 
 void postfix_increment(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  auto j = i++;
+  auto j = i++; // expected-note{{Iterator 'i' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin() + 1}}
+                                                               //expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); //expected-warning{{$v.begin()}}
+                                                               //expected-note@-1{{$v.begin()}}
 }
 
 void postfix_decrement(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  auto j = i--;
+  auto j = i--; // expected-note{{Iterator 'i' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.end() - 1}}
+                                                               //expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); //expected-warning{{$v.end()}}
+                                                               //expected-note@-1{{$v.end()}}
 }
 
 void plus_equal(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  i += 2;
+  i += 2; // expected-note{{Iterator 'i' incremented by 2}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin() + 2}}
+                                                               //expected-note@-1{{$v.begin() + 2}}
 }
 
 void minus_equal(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  i -= 2;
+  i -= 2; // expected-note{{Iterator 'i' decremented by 2}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.end() - 2}}
+                                                               //expected-note@-1{{$v.end() - 2}}
 }
 
 void copy(const std::vector<int> &v) {
   auto i1 = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
   auto i2 = i1;
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}
+                                                                    // expected-note@-1{{TRUE}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.end()}}
+                                                                //expected-note@-1{{$v.end()}}
 }
 
 void plus(const std::vector<int> &v) {
   auto i1 = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  auto i2 = i1 + 2;
+  auto i2 = i1 + 2; // expected-note{{Iterator 'i1' incremented by 2}}
+                    // expected-note@-1{{Iterator 'i1' incremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}
+                                                                    // expected-note@-1{{TRUE}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.begin() + 2}}
+                                                                //expected-note@-1{{$v.begin() + 2}}
 }
 
 void minus(const std::vector<int> &v) {
   auto i1 = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  auto i2 = i1 - 2;
+  auto i2 = i1 - 2;  // expected-note{{Iterator 'i1' decremented by 2}}
+                     // expected-note@-1{{Iterator 'i1' decremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}
+                                                                    // expected-note@-1{{TRUE}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.end() - 2}}
+                                                                //expected-note@-1{{$v.end() - 2}}
 }
 
 void copy_and_increment1(const std::vector<int> &v) {
   auto i1 = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
   auto i2 = i1;
-  ++i1;
+  ++i1;  // expected-note{{Iterator 'i1' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); //expected-warning{{$v.begin() + 1}}
+                                                                //expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.begin()}}
+                                                                //expected-note@-1{{$v.begin()}}
 }
 
 void copy_and_increment2(const std::vector<int> &v) {
   auto i1 = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
   auto i2 = i1;
-  ++i2;
+  ++i2;  // expected-note{{Iterator 'i2' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); //expected-warning{{$v.begin()}}
+                                                                //expected-note@-1{{$v.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.begin() + 1}}
+                                                                //expected-note@-1{{$v.begin() + 1}}
 }
 
 void copy_and_decrement1(const std::vector<int> &v) {
   auto i1 = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
   auto i2 = i1;
-  --i1;
+  --i1;  // expected-note{{Iterator 'i1' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); //expected-warning{{$v.end() - 1}}
+                                                                //expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.end()}}
+                                                                //expected-note@-1{{$v.end()}}
 }
 
 void copy_and_decrement2(const std::vector<int> &v) {
   auto i1 = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
   auto i2 = i1;
-  --i2;
+  --i2;  // expected-note{{Iterator 'i2' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); //expected-warning{{$v.end()}}
+                                                                //expected-note@-1{{$v.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); //expected-warning{{$v.end() - 1}}
+                                                                //expected-note@-1{{$v.end() - 1}}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 ///
 /// C O N T A I N E R   A S S I G N M E N T S
 ///
 ////////////////////////////////////////////////////////////////////////////////
 
 // Copy
 
 void list_copy_assignment(std::list<int> &L1, const std::list<int> &L2) {
   auto i0 = L1.cbegin();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   L1 = L2;
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void vector_copy_assignment(std::vector<int> &V1, const std::vector<int> &V2) {
   auto i0 = V1.cbegin();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   V1 = V2;
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void deque_copy_assignment(std::deque<int> &D1, const std::deque<int> &D2) {
   auto i0 = D1.cbegin();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   D1 = D2;
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void forward_list_copy_assignment(std::forward_list<int> &FL1,
                                   const std::forward_list<int> &FL2) {
   auto i0 = FL1.cbegin();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   FL1 = FL2;
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 // Move
 
 void list_move_assignment(std::list<int> &L1, std::list<int> &L2) {
   auto i0 = L1.cbegin(), i1 = L2.cbegin(), i2 = --L2.cend(), i3 = L2.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L2), "$L2.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L2), "$L2.end()");
 
   L1 = std::move(L2);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+                                                             //expected-note@-1{{TRUE}} FIXME: Should be FALSE.
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &L1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &L1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L2.begin()}}
+                                                                // expected-note@-1{{$L2.begin()}}
 }
 
 void vector_move_assignment(std::vector<int> &V1, std::vector<int> &V2) {
   auto i0 = V1.cbegin(), i1 = V2.cbegin(), i2 = --V2.cend(), i3 = V2.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V2), "$V2.begin()");
 
   V1 = std::move(V2);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+                                                             //expected-note@-1{{TRUE}} FIXME: Should be FALSE.
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &V1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &V1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V2.begin()}}
+                                                                // expected-note@-1{{$V2.begin()}}
 }
 
 void deque_move_assignment(std::deque<int> &D1, std::deque<int> &D2) {
   auto i0 = D1.cbegin(), i1 = D2.cbegin(), i2 = --D2.cend(), i3 = D2.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D2), "$D2.begin()");
 
   D1 = std::move(D2);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+                                                             //expected-note@-1{{TRUE}} FIXME: Should be FALSE.
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &D1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &D1); // expected-warning{{TRUE}}
+                                                                     // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$D2.begin()}}
+                                                                // expected-note@-1{{$D2.begin()}}
 }
 
 void forward_list_move_assignment(std::forward_list<int> &FL1,
                                   std::forward_list<int> &FL2) {
   auto i0 = FL1.cbegin(), i1 = FL2.cbegin(), i2 = FL2.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL2), "$FL2.begin()");
 
   FL1 = std::move(FL2);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+                                                             //expected-note@-1{{TRUE}} FIXME: Should be FALSE.
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &FL1); // expected-warning{{TRUE}}
+                                                                      // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL2.begin()}}
+                                                                // expected-note@-1{{$FL2.begin()}}
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 ///
 /// C O N T A I N E R   M O D I F I E R S
 ///
 ////////////////////////////////////////////////////////////////////////////////
 
 /// assign()
 ///
 /// - Invalidates all iterators, including the past-the-end iterator for all
 ///   container types.
 
 void list_assign(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = L.cend();
   L.assign(10, n);
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void vector_assign(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = V.cend();
   V.assign(10, n);
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void deque_assign(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = D.cend();
   D.assign(10, n);
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void forward_list_assign(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
   FL.assign(10, n);
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// clear()
 ///
 /// - Invalidates all iterators, including the past-the-end iterator for all
 ///   container types.
 
 void list_clear(std::list<int> &L) {
   auto i0 = L.cbegin(), i1 = L.cend();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   L.clear();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void vector_clear(std::vector<int> &V) {
   auto i0 = V.cbegin(), i1 = V.cend();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   V.clear();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void deque_clear(std::deque<int> &D) {
   auto i0 = D.cbegin(), i1 = D.cend();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   D.clear();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 void forward_list_clear(std::forward_list<int> &FL) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   FL.clear();
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// push_back()
 ///
 /// - Design decision: extends containers to the ->RIGHT-> (i.e. the
 ///   past-the-end position of the container is incremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_push_back(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.push_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}} FIXME: Should be $L.end() + 1
+                                                                // expected-note@-1{{$L.end()}} FIXME: Should be $L.end() + 1
 }
 
 /// std::vector-like containers: The past-the-end iterator is invalidated.
 
 void vector_push_back(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   V.push_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}}
+                                                                // expected-note@-1{{$V.end() - 1}}
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_push_back(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.push_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// emplace_back()
 ///
 /// - Design decision: extends containers to the ->RIGHT-> (i.e. the
 ///   past-the-end position of the container is incremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_emplace_back(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.emplace_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}  FIXME: Should be $L.end() + 1
+                                                                // expected-note@-1{{$L.end()}}  FIXME: Should be $L.end() + 1
 }
 
 /// std::vector-like containers: The past-the-end iterator is invalidated.
 
 void vector_emplace_back(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   V.emplace_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}}
+                                                                // expected-note@-1{{$V.end() - 1}}
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_emplace_back(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.emplace_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// pop_back()
 ///
 /// - Design decision: shrinks containers to the <-LEFT<- (i.e. the
 ///   past-the-end position of the container is decremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: Iterators to the last element are invalidated.
 
 void list_pop_back(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.pop_back();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}  FIXME: Should be $L.end() - 1
+                                                                // expected-note@-1{{$L.end()}}  FIXME: Should be $L.end() - 1
 }
 
 /// std::vector-like containers: Iterators to the last element, as well as the
 ///                              past-the-end iterator, are invalidated.
 
 void vector_pop_back(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   V.pop_back();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
 }
 
 /// std::deque-like containers: Iterators to the last element are invalidated.
 ///                             The past-the-end iterator is also invalidated.
 ///                             Other iterators are not affected.
 
 void deque_pop_back(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.pop_back();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$D.begin()}}
+                                                                // expected-note@-1{{$D.begin()}}
 }
 
 /// push_front()
 ///
 /// - Design decision: extends containers to the <-LEFT<- (i.e. the first
 ///                    position of the container is decremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_push_front(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.push_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_push_front(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.push_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// std::forward_list-like containers: No iterators are invalidated.
 
 void forward_list_push_front(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   FL.push_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 /// emplace_front()
 ///
 /// - Design decision: extends containers to the <-LEFT<- (i.e. the first
 ///                    position of the container is decremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_emplace_front(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.emplace_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_emplace_front(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.emplace_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 }
 
 /// std::forward_list-like containers: No iterators are invalidated.
 
 void forward_list_emplace_front(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   FL.emplace_front(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 /// pop_front()
 ///
 /// - Design decision: shrinks containers to the ->RIGHT-> (i.e. the first
 ///   position of the container is incremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: Iterators to the first element are invalidated.
 
 void list_pop_front(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+                                                                // expected-note@-1{{$L.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 /// std::deque-like containers: Iterators to the first element are invalidated.
 ///                             Other iterators are not affected.
 
 void deque_pop_front(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$D.begin() + 1}}
+                                                                // expected-note@-1{{$D.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$D.end()}}
+                                                                // expected-note@-1{{$D.end()}}
 }
 
 /// std::forward_list-like containers: Iterators to the first element are
 ///                                    invalidated.
 
 void forward_list_pop_front(std::list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   FL.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.begin() + 1}}
+                                                                // expected-note@-1{{$FL.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 /// insert()
 ///
 /// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator
 ///                    ahead of the insertion point are decremented; if the
 ///                    relation between the insertion point and the first
 ///                    position of the container is known, the first position
 ///                    of the container is also decremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_insert_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i2 = L.insert(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $L.begin() - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_insert_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}} FIXME: Should be $L.begin() - 1
+                                                                // expected-note@-1{{$L.begin()}} FIXME: Should be $L.begin() - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+                                                                // expected-note@-1{{$L.begin() + 1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin()
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 template <typename Iter> Iter return_any_iterator(const Iter &It);
 
 void list_insert_unknown(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = L.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+                                                                // expected-note@-1{{$i1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_insert_ahead_of_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 2
 }
 
 void list_insert_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}} FIXME: should be $L.end() - 2
+                                                                // expected-note@-1{{$L.end() - 1}} FIXME: should be $L.end() - 2
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 1
 }
 
 /// std::vector-like containers: Only the iterators before the insertion point
 ///                              remain valid. The past-the-end iterator is also
 ///                              invalidated.
 
 void vector_insert_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = V.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i2 = V.insert(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 1
 }
 
 void vector_insert_behind_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}} FIXME: Should be $V.begin() - 1
+                                                                // expected-note@-1{{$V.begin()}} FIXME: Should be $V.begin() - 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()
 }
 
 void vector_insert_unknown(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = V.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 1
 }
 
 void vector_insert_ahead_of_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 2
 }
 
 void vector_insert_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.insert(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}} FIXME: Should be $V.end() - 2
+                                                                // expected-note@-1{{$V.end() - 1}} FIXME: Should be $V.end() - 2
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 1
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_insert_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = D.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i2 = D.insert(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 1
 }
 
 void deque_insert_behind_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 1
 }
 
 void deque_insert_unknown(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = D.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 1
 }
 
 void deque_insert_ahead_of_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 2
 }
 
 void deque_insert_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.insert(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 1
 }
 
 /// insert_after()   [std::forward_list-like containers]
 ///
 /// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator
 ///                    ahead of the insertion point are incremented; if the
 ///                    relation between the insertion point and the past-the-end
 ///                    position of the container is known, the first position of
 ///                    the container is also incremented).
 ///
 /// - No iterators are invalidated.
 
 void forward_list_insert_after_begin(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i2 = FL.insert_after(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $FL.begin() + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 void forward_list_insert_after_behind_begin(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i3 = FL.insert_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.begin() + 1}}
+                                                                // expected-note@-1{{$FL.begin() + 1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $FL.begin() + 2
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 void forward_list_insert_after_unknown(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = FL.insert_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+                                                                // expected-note@-1{{$i1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 /// emplace()
 ///
 /// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator
 ///                    ahead of the emplacement point are decremented; if the
 ///                    relation between the emplacement point and the first
 ///                    position of the container is known, the first position
 ///                    of the container is also decremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: No iterators are invalidated.
 
 void list_emplace_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i2 = L.emplace(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $L.begin() - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_emplace_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}} FIXME: Should be $L.begin() - 1
+                                                                // expected-note@-1{{$L.begin()}} FIXME: Should be $L.begin() - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+                                                                // expected-note@-1{{$L.begin() + 1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin()
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 template <typename Iter> Iter return_any_iterator(const Iter &It);
 
 void list_emplace_unknown(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = L.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+                                                                // expected-note@-1{{$i1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i - 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_emplace_ahead_of_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 2
 }
 
 void list_emplace_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}} FIXME: should be $L.end() - 2
+                                                                // expected-note@-1{{$L.end() - 1}} FIXME: should be $L.end() - 2
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 1
 }
 
 /// std::vector-like containers: Only the iterators before the emplacement point
 ///                              remain valid. The past-the-end iterator is also
 ///                              invalidated.
 
 void vector_emplace_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = V.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i2 = V.emplace(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 1
 }
 
 void vector_emplace_behind_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}} FIXME: Should be $V.begin() - 1
+                                                                // expected-note@-1{{$V.begin()}} FIXME: Should be $V.begin() - 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()
 }
 
 void vector_emplace_unknown(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = V.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 1
 }
 
 void vector_emplace_ahead_of_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 2
 }
 
 void vector_emplace_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
+  // expected-note@-2{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.emplace(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}} FIXME: Should be $V.end() - 2
+                                                                // expected-note@-1{{$V.end() - 1}} FIXME: Should be $V.end() - 2
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 1
 }
 
 /// std::deque-like containers: All iterators, including the past-the-end
 ///                             iterator, are invalidated.
 
 void deque_emplace_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = D.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i2 = D.emplace(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 1
 }
 
 void deque_emplace_behind_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 1
 }
 
 void deque_emplace_unknown(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = D.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 1
 }
 
 void deque_emplace_ahead_of_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 2
 }
 
 void deque_emplace_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.emplace(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 1
 }
 
 /// emplace_after()   [std::forward_list-like containers]
 ///
 /// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator
 ///                    ahead of the emplacement point are incremented; if the
 ///                    relation between the emplacement point and the
 ///                    past-the-end position of the container is known, the
 ///                    first position of the container is also incremented).
 ///
 /// - No iterators are invalidated.
 
 void forward_list_emplace_after_begin(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i2 = FL.emplace_after(i0, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $FL.begin() + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 void forward_list_emplace_after_behind_begin(std::forward_list<int> &FL,
                                              int n) {
   auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i3 = FL.emplace_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.begin() + 1}}
+                                                                // expected-note@-1{{$FL.begin() + 1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $FL.begin() + 2
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 void forward_list_emplace_after_unknown(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = FL.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = FL.emplace_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+                                                                // expected-note@-1{{$i1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 /// erase()
 ///
 /// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator
 ///                    ahead of the ereased element are incremented; if the
 ///                    relation between the position of the erased element
 ///                    and the first position of the container is known, the
 ///                    first position of the container is also incremented).
 ///
 /// - Iterator invalidation rules depend the container type.
 
 /// std::list-like containers: Iterators to the erased element are invalidated.
 ///                            Other iterators are not affected.
 
 void list_erase_begin(std::list<int> &L) {
   auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.erase(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+                                                                // expected-note@-1{{$L.begin() + 1}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin() + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_erase_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}} FIXME: Should be $L.begin() + 1
+                                                                // expected-note@-1{{$L.begin()}} FIXME: Should be $L.begin() + 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin() + 2
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_erase_unknown(std::list<int> &L) {
   auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = L.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
 }
 
 void list_erase_ahead_of_end(std::list<int> &L) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+                                                                // expected-note@-1{{$L.end()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end()
 }
 
 /// std::vector-like containers: Invalidates iterators at or after the point of
 ///                              the erase, including the past-the-end iterator.
 
 void vector_erase_begin(std::vector<int> &V) {
   auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.erase(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 1
 }
 
 void vector_erase_behind_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}} FIXME: Should be $V.begin() + 1
+                                                                // expected-note@-1{{$V.begin()}} FIXME: Should be $V.begin() + 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 2
 }
 
 void vector_erase_unknown(std::vector<int> &V) {
   auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = V.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
 }
 
 void vector_erase_ahead_of_end(std::vector<int> &V) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+                                                                // expected-note@-1{{$V.begin()}}
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end()
 }
 
 /// std::deque-like containers: All iterators are invalidated, unless the erased
 ///                             element is at the end or the beginning of the
 ///                             container, in which case only the iterators to
 ///                             the erased element are invalidated. The
 ///                             past-the-end iterator is also invalidated unless
 ///                             the erased element is at the beginning of the
 ///                             container and the last element is not erased.
 
 void deque_erase_begin(std::deque<int> &D) {
   auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.erase(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 1
 }
 
 void deque_erase_behind_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 2
 }
 
 void deque_erase_unknown(std::deque<int> &D) {
   auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i3 = D.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
 }
 
 void deque_erase_ahead_of_end(std::deque<int> &D) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   auto i3 = D.erase(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
 
   // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end()
 }
 
 /// erase_after()   [std::forward_list-like containers]
 ///
 /// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator
 ///                    begind of the ereased element are decremented; if the
 ///                    relation between the position of the erased element
 ///                    and the past-the-end position of the container is known,
 ///                    the past-the-end position of the container is also
 ///                    decremented).
 ///
 /// - Iterators to the erased element are invalidated. Other iterators are not
 ///   affected.
 
 
 void forward_list_erase_after_begin(std::forward_list<int> &FL) {
   auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = i1, i3 = FL.cend();
+  // expected-note@-1{{Iterator incremented by 1}}
+  // expected-note@-2{{Iterator incremented by 1}}
+  // expected-note@-3{{Iterator incremented by 1}}
   ++i2;
+  // expected-note@-1{{Iterator 'i2' incremented by 1}}
+  // expected-note@-2{{Iterator 'i2' incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i4 = FL.erase_after(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.begin() + 2}} FIXME: Should be $FL.begin() + 1
+                                                                // expected-note@-1{{$FL.begin() + 2}} FIXME: Should be $FL.begin() + 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i4)); FIXME: expect warning $FL.begin() + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 void forward_list_erase_after_unknown(std::forward_list<int> &FL) {
   auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = i1,
     i3 = i1, i4 = FL.cend();
   ++i2;
+  // expected-note@-1{{Iterator 'i2' incremented by 1}}
   ++i3;
+  // expected-note@-1{{Iterator 'i3' incremented by 1}}
+  // expected-note@-2{{Iterator 'i3' incremented by 1}}
   ++i3;
+  // expected-note@-1{{Iterator 'i3' incremented by 1}}
+  // expected-note@-2{{Iterator 'i3' incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
   clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");
 
   auto i5 = FL.erase_after(i1);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+                                                             //expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i4)); //expected-warning{{TRUE}}
+                                                             //expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+                                                                // expected-note@-1{{$i1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 2}} FIXME: Should be $i1 + 1
+                                                                // expected-note@-1{{$i1 + 2}} FIXME: Should be $i1 + 1
   // clang_analyzer_express(clang_analyzer_iterator_position(i5)); FIXME: expect warning $i1 + 1
   clang_analyzer_express(clang_analyzer_iterator_position(i4)); // expected-warning{{$FL.end()}}
+                                                                // expected-note@-1{{$FL.end()}}
 }
 
 struct simple_iterator_base {
   simple_iterator_base();
   simple_iterator_base(const simple_iterator_base& rhs);
   simple_iterator_base &operator=(const simple_iterator_base& rhs);
   virtual ~simple_iterator_base();
   bool friend operator==(const simple_iterator_base &lhs,

 void iter_diff(std::vector<int> &V) {
   auto i0 = V.begin(), i1 = V.end();
   ptrdiff_t len = i1 - i0; // no-crash
 }
 
 void deferred_assumption(std::vector<int> &V, int e) {
   const auto first = V.begin();
   const auto comp1 = (first != V.end()), comp2 = (first == V.end());
-  if (comp1) {
+  if (comp1) { // expected-note{{'comp1' is true}}
+               // expected-note@-1{{Taking true branch}}
     clang_analyzer_eval(clang_analyzer_container_end(V) ==
                         clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}}
+                                                                  // expected-note@-2{{FALSE}}
   }
 }
 
 void loop(std::vector<int> &V, int e) {
   auto start = V.begin();
-  while (true) {
+  while (true) { // expected-note{{Loop condition is true.  Entering loop body}}
     auto item = std::find(start, V.end(), e);
-    if (item == V.end())
+    if (item == V.end()) // expected-note{{Taking false branch}}
       break;
 
     clang_analyzer_eval(clang_analyzer_container_end(V) ==
                         clang_analyzer_iterator_position(item)); // expected-warning@-1{{FALSE}}
+                                                                 // expected-note@-2{{FALSE}}
   }
 }
 
 template <typename InputIterator, typename T>
 InputIterator nonStdFind(InputIterator first, InputIterator last,
                          const T &val) {
   for (auto i = first; i != last; ++i) {
     if (*i == val) {
       return i;
     }
   }
   return last;
 }
 
 void non_std_find(std::vector<int> &V, int e) {
   auto first = nonStdFind(V.begin(), V.end(), e);
   clang_analyzer_eval(clang_analyzer_container_end(V) ==
                       clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}} expected-warning@-1{{TRUE}}
-  if (V.end() != first) {
+                                                                // expected-note@-2{{FALSE}} expected-note@-2{{TRUE}}
+                                                                // expected-note@-3{{Assuming the condition is false}}
+                                                                // expected-note@-4{{Assuming the condition is false}}
+                                                                // expected-note@-5{{Assuming the condition is true}}
+  if (V.end() != first) { // expected-note{{Taking true branch}}
+
     clang_analyzer_eval(clang_analyzer_container_end(V) ==
                         clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}}
+                                                                  // expected-note@-2{{FALSE}}
   }
 }
 
+/// Track the right iterators only
+
+void prefix_increment2(const std::vector<int> &v) {
+  auto i = v.begin(), j = v.begin();
+
+  clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
+
+  auto k = ++j; // expected-note{{Iterator 'j' incremented by 1}}
+
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin()}}
+                                                               //expected-note@-1{{$v.begin()}}
+
+  clang_analyzer_express(clang_analyzer_iterator_position(k)); //expected-warning{{$v.begin() + 1}}
+                                                               //expected-note@-1{{$v.begin() + 1}}
+}
+
+void prefix_increment3(const std::vector<int> &v) {
+  auto i = v.begin(), j = v.begin();
+
+  clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
+
+  auto k = ++j; // no note expected
+
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); //expected-warning{{$v.begin()}}
+                                                               //expected-note@-1{{$v.begin()}}
+}
+
+/// Print State
+
 void clang_analyzer_printState();
 
 void print_state(std::vector<int> &V) {
   const auto i0 = V.cbegin();
   clang_analyzer_printState();
 
 // CHECK:      "checker_messages": [
 // CHECK:   { "checker": "alpha.cplusplus.IteratorModeling", "messages": [

clang/test/Analysis/iterator-range.cpp

-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify
-// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false -analyzer-output=text %s -verify
+// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 -analyzer-output=text %s -verify
 
 #include "Inputs/system-header-simulator-cxx.h"
 
 void clang_analyzer_warnIfReached();
 
 // Dereference - operator*()
 
 void deref_begin(const std::vector<int> &V) {
   auto i = V.begin();

 void deref_ahead_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   *i; // no-warning
 }
 
 void deref_end(const std::vector<int> &V) {
   auto i = V.end();
   *i; // expected-warning{{Past-the-end iterator dereferenced}}
+      // expected-note@-1{{Past-the-end iterator dereferenced}}
 }
 
 // Prefix increment - operator++()
 
 void incr_begin(const std::vector<int> &V) {
   auto i = V.begin();
   ++i; // no-warning
 }

 void incr_ahead_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   ++i; // no-warning
 }
 
 void incr_end(const std::vector<int> &V) {
   auto i = V.end();
   ++i; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+       // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // Postfix increment - operator++(int)
 
 void begin_incr(const std::vector<int> &V) {
   auto i = V.begin();
   i++; // no-warning
 }

 void ahead_of_end_incr(const std::vector<int> &V) {
   auto i = --V.end();
   i++; // no-warning
 }
 
 void end_incr(const std::vector<int> &V) {
   auto i = V.end();
   i++; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+       // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // Prefix decrement - operator--()
 
 void decr_begin(const std::vector<int> &V) {
   auto i = V.begin();
   --i; // expected-warning{{Iterator decremented ahead of its valid range}}
+       // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void decr_behind_begin(const std::vector<int> &V) {
   auto i = ++V.begin();
   --i; // no-warning
 }
 
 void decr_unknown(const std::vector<int> &V) {
void decr_end(const std::vector<int> &V) {
   --i; // no-warning
 }
 
 // Postfix decrement - operator--(int)
 
 void begin_decr(const std::vector<int> &V) {
   auto i = V.begin();
   i--; // expected-warning{{Iterator decremented ahead of its valid range}}
+       // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void behind_begin_decr(const std::vector<int> &V) {
   auto i = ++V.begin();
   i--; // no-warning
 }
 
 void unknown_decr(const std::vector<int> &V) {

 
 void incr_by_2_ahead_by_2_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   --i;
   i += 2; // no-warning
 }
 
 void incr_by_2_ahead_of_end(const std::vector<int> &V) {
-  auto i = --V.end();
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
   i += 2; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+          // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 void incr_by_2_end(const std::vector<int> &V) {
   auto i = V.end();
   i += 2; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+          // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // Addition - operator+(int)
 
 void incr_by_2_copy_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = i + 2; // no-warning
 }

 
 void incr_by_2_copy_ahead_by_2_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   --i;
   auto j = i + 2; // no-warning
 }
 
 void incr_by_2_copy_ahead_of_end(const std::vector<int> &V) {
-  auto i = --V.end();
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
   auto j = i + 2; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+                  // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 void incr_by_2_copy_end(const std::vector<int> &V) {
   auto i = V.end();
   auto j = i + 2; // expected-warning{{Iterator incremented behind the past-the-end iterator}}
+                  // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // Subtraction assignment - operator-=(int)
 
 void decr_by_2_begin(const std::vector<int> &V) {
   auto i = V.begin();
   i -= 2; // expected-warning{{Iterator decremented ahead of its valid range}}
+          // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void decr_by_2_behind_begin(const std::vector<int> &V) {
-  auto i = ++V.begin();
+  auto i = ++V.begin(); // expected-note{{Iterator incremented by 1}}
   i -= 2; // expected-warning{{Iterator decremented ahead of its valid range}}
+          // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void decr_by_2_behind_begin_by_2(const std::vector<int> &V) {
   auto i = ++V.begin();
   ++i;
   i -= 2; // no-warning
 }
 
void decr_by_2_end(const std::vector<int> &V) {
   i -= 2; // no-warning
 }
 
 // Subtraction - operator-(int)
 
 void decr_by_2_copy_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = i - 2; // expected-warning{{Iterator decremented ahead of its valid range}}
+                  // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void decr_by_2_copy_behind_begin(const std::vector<int> &V) {
-  auto i = ++V.begin();
+  auto i = ++V.begin(); // expected-note{{Iterator incremented by 1}}
   auto j = i - 2; // expected-warning{{Iterator decremented ahead of its valid range}}
+                  // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void decr_by_2_copy_behind_begin_by_2(const std::vector<int> &V) {
   auto i = ++V.begin();
   ++i;
   auto j = i - 2; // no-warning
 }
 

 void subscript_zero_ahead_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   auto j = i[0]; // no-warning
 }
 
 void subscript_zero_end(const std::vector<int> &V) {
   auto i = V.end();
   auto j = i[0]; // expected-warning{{Past-the-end iterator dereferenced}}
+                 // expected-note@-1{{Past-the-end iterator dereferenced}}
 }
 
 // By negative number
 
 void subscript_negative_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = i[-1]; // no-warning FIXME: expect warning Iterator decremented ahead of its valid range
 }

 
 void subscript_negative_ahead_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   auto j = i[-1]; // no-warning
 }
 
 void subscript_negative_end(const std::vector<int> &V) {
   auto i = V.end();
-  auto j = i[-1]; // // expected-warning{{Past-the-end iterator dereferenced}} FIXME: expect no warning
+  auto j = i[-1]; // expected-warning{{Past-the-end iterator dereferenced}} FIXME: expect no warning
+                  // expected-note@-1{{Past-the-end iterator dereferenced}}
 }
 
 // By positive number
 
 void subscript_positive_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = i[1]; // no-warning
 }

 void subscript_positive_ahead_of_end(const std::vector<int> &V) {
   auto i = --V.end();
   auto j = i[1]; // no-warning FIXME: expected warning Past-the-end iterator dereferenced
 }
 
 void subscript_positive_end(const std::vector<int> &V) {
   auto i = V.end();
   auto j = i[1]; // expected-warning{{Past-the-end iterator dereferenced}} FIXME: expect warning Iterator incremented behind the past-the-end iterator
+                 // expected-note@-1{{Past-the-end iterator dereferenced}} FIXME: expect note@-1 Iterator incremented behind the past-the-end iterator
 }
 
 //
 // Structure member dereference operators
 //
 
 struct S {
   int n;
 };
 
 // Member dereference - operator->()
 
 void arrow_deref_begin(const std::vector<S> &V) {
   auto i = V.begin();
   int n = i->n; // no-warning
 }
 
 void arrow_deref_end(const std::vector<S> &V) {
   auto i = V.end();
-  int n = i->n; //  expected-warning{{Past-the-end iterator dereferenced}}
+  int n = i->n; // expected-warning{{Past-the-end iterator dereferenced}}
+                // expected-note@-1{{Past-the-end iterator dereferenced}}
+}
+
+// Path notes
+
+void deref_end2(const std::vector<int> &V) {
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
+  ++i; // expected-note{{Iterator 'i' incremented by 1}}
+  *i; // expected-warning{{Past-the-end iterator dereferenced}}
+      // expected-note@-1{{Past-the-end iterator dereferenced}}
 }