[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

707–708

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

clang/test/Analysis/iterator-modelling.cpp

1–5 ↗

(On Diff #248447)

Can we prettify this? :)

clang/test/Analysis/iterator-range.cpp

0–12

And this?

[Szelethus]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

707–708

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

707–708

I completely removed them from this patch.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

661–662

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

661–662

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

661–662

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

661–662

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

434 ↗

(On Diff #252615)

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

[NoQ]

clang/test/Analysis/iterator-modelling.cpp

434 ↗

(On Diff #252615)

Mmm, why 0-1?

[baloghadamsoftware]

Rebased.

[baloghadamsoftware]

clang/test/Analysis/iterator-modelling.cpp

434 ↗

(On Diff #252615)

Because it depends whether next() is inlined.

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

 namespace {
 
 class IteratorModeling
     : public Checker<check::PostCall, check::PostStmt<UnaryOperator>,
                      check::PostStmt<BinaryOperator>, check::Bind,
                      check::LiveSymbols, check::DeadSymbols> {
 
   using AdvanceFn = void (IteratorModeling::*)(CheckerContext &, const Expr *,
-                                               SVal, SVal, SVal) const;
+                                               SVal, SVal, SVal, const Expr *,
+                                               const Expr *) const;
 
   void handleOverloadedOperator(CheckerContext &C, const CallEvent &Call,
                                 OverloadedOperatorKind Op) const;
   void handleAdvanceLikeFunction(CheckerContext &C, const CallEvent &Call,
                                  const Expr *OrigExpr,
                                  const AdvanceFn *Handler) const;
 
   void handleComparison(CheckerContext &C, const Expr *CE, SVal RetVal,
                         SVal LVal, SVal RVal, OverloadedOperatorKind Op) const;
   void processComparison(CheckerContext &C, ProgramStateRef State,
                          SymbolRef Sym1, SymbolRef Sym2, SVal RetVal,
                          OverloadedOperatorKind Op) const;
-  void handleIncrement(CheckerContext &C, SVal RetVal,
-                       SVal Iter, bool Postfix) const;
-  void handleDecrement(CheckerContext &C, SVal RetVal,
-                       SVal Iter, bool Postfix) const;
+  void handleIncrement(CheckerContext &C, SVal RetVal, SVal Iter,
+                       const Expr *ItEx, bool Postfix) const;
+  void handleDecrement(CheckerContext &C, SVal RetVal, SVal Iter,
+                       const Expr *ItEx, bool Postfix) const;
   void handleRandomIncrOrDecr(CheckerContext &C, const Expr *CE,
-                              OverloadedOperatorKind Op,
-                              SVal RetVal, SVal LHS,
-                              SVal RHS) const;
+                              OverloadedOperatorKind Op, SVal RetVal, SVal LHS,
+                              SVal RHS, const Expr *LHSEx,
+                              const Expr *RHSEx = nullptr) const;
   void handlePtrIncrOrDecr(CheckerContext &C, const Expr *Iterator,
-                           OverloadedOperatorKind OK, SVal Offset) const;
-  void handleAdvance(CheckerContext &C, const Expr *CE, SVal RetVal,
-                     SVal Iter, SVal Amount) const;
-  void handlePrev(CheckerContext &C, const Expr *CE, SVal RetVal,
-                  SVal Iter, SVal Amount) const;
-  void handleNext(CheckerContext &C, const Expr *CE, SVal RetVal,
-                  SVal Iter, SVal Amount) const;
+                           OverloadedOperatorKind Op, SVal Amount,
+                           const Expr *AmEx) const;
+  void handleAdvance(CheckerContext &C, const Expr *CE, SVal RetVal, SVal Iter,
+                     SVal Amount, const Expr *ItEx, const Expr *AmEx) const;
+  void handlePrev(CheckerContext &C, const Expr *CE, SVal RetVal, SVal Iter,
+                  SVal Amount, const Expr *ItEx, const Expr *AmEx) const;
+  void handleNext(CheckerContext &C, const Expr *CE, SVal RetVal, SVal Iter,
+                  SVal Amount, const Expr *ItEx, const Expr *AmEx) const;
   void assignToContainer(CheckerContext &C, const Expr *CE, SVal RetVal,
                          const MemRegion *Cont) const;
+  const NoteTag *getChangeTag(CheckerContext &C, StringRef Text,
+                              const Expr *ItEx, int64_t Amount = 0,
+                              const Expr *AmEx = nullptr) const;
   bool noChangeInAdvance(CheckerContext &C, SVal Iter, const Expr *CE) const;
   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
                   const char *Sep) const override;
 
   // std::advance, std::prev & std::next
   CallDescriptionMap<AdvanceFn> AdvanceLikeFunctions = {
       // template<class InputIt, class Distance>
       // void advance(InputIt& it, Distance n);
void IteratorModeling::checkPostStmt(const UnaryOperator *UO,
                                      CheckerContext &C) const {
   UnaryOperatorKind OK = UO->getOpcode();
   if (!isIncrementOperator(OK) && !isDecrementOperator(OK))
     return;
 
   auto &SVB = C.getSValBuilder();
   handlePtrIncrOrDecr(C, UO->getSubExpr(),
                       isIncrementOperator(OK) ? OO_Plus : OO_Minus,
-                      SVB.makeArrayIndex(1));
+                      SVB.makeArrayIndex(1), nullptr);
 }
 
 void IteratorModeling::checkPostStmt(const BinaryOperator *BO,
                                      CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   BinaryOperatorKind OK = BO->getOpcode();
   SVal RVal = State->getSVal(BO->getRHS(), C.getLocationContext());
 
   if (isSimpleComparisonOperator(BO->getOpcode())) {
     SVal LVal = State->getSVal(BO->getLHS(), C.getLocationContext());
     SVal Result = State->getSVal(BO, C.getLocationContext());
     handleComparison(C, BO, Result, LVal, RVal,
                      BinaryOperator::getOverloadedOperator(OK));
   } else if (isRandomIncrOrDecrOperator(OK)) {
     if (!BO->getRHS()->getType()->isIntegralOrEnumerationType())
       return;
     handlePtrIncrOrDecr(C, BO->getLHS(),
-                        BinaryOperator::getOverloadedOperator(OK), RVal);
+                        BinaryOperator::getOverloadedOperator(OK), RVal,
+                        BO->getRHS());
   }
 }
 
 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) {
if (isSimpleComparisonOperator(Op)) {
     SVal Arg1 = getIteratorArg(Call, 1, C.blockCount());
     handleComparison(C, OrigExpr, Call.getReturnValue(), Arg0, Arg1, Op);
     return;
   } else if (isRandomIncrOrDecrOperator(Op)) {
     if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
       if (Call.getNumArgs() >= 1 &&
           Call.getArgExpr(0)->getType()->isIntegralOrEnumerationType()) {
         handleRandomIncrOrDecr(C, OrigExpr, Op, getReturnIterator(Call),
-                               InstCall->getCXXThisVal(), Call.getArgSVal(0));
+                               InstCall->getCXXThisVal(), Call.getArgSVal(0),
+                               InstCall->getCXXThisExpr(),
+                               Call.getArgExpr(0));
         return;
       }
     } else {
       if (Call.getNumArgs() >= 2 &&
           Call.getArgExpr(1)->getType()->isIntegralOrEnumerationType()) {
         SVal Arg0 = getIteratorArg(Call, 0, C.blockCount());
         handleRandomIncrOrDecr(C, OrigExpr, Op, getReturnIterator(Call), Arg0,
-                               Call.getArgSVal(1));
+                               Call.getArgSVal(1), InstCall->getCXXThisExpr(),
+                               Call.getArgExpr(0));
         return;
       }
     }
   } else if (isIncrementOperator(Op)) {
     if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
       handleIncrement(C, getReturnIterator(Call), InstCall->getCXXThisVal(),
-                      Call.getNumArgs());
+                      InstCall->getCXXThisExpr(), Call.getNumArgs());
       return;
     }
 
     SVal Arg0 = getIteratorArg(Call, 0, C.blockCount());
-    handleIncrement(C, getReturnIterator(Call), Arg0, Call.getNumArgs());
+    handleIncrement(C, getReturnIterator(Call), Arg0, Call.getArgExpr(0),
+                    Call.getNumArgs());
     return;
   } else if (isDecrementOperator(Op)) {
     if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
       handleDecrement(C, getReturnIterator(Call), InstCall->getCXXThisVal(),
-                      Call.getNumArgs());
+                      InstCall->getCXXThisExpr(), Call.getNumArgs());
       return;
     }
 
     SVal Arg0 = getIteratorArg(Call, 0, C.blockCount());
-    handleDecrement(C, getReturnIterator(Call), Arg0, Call.getNumArgs());
+    handleDecrement(C, getReturnIterator(Call), Arg0, Call.getArgExpr(0),
+                    Call.getNumArgs());
     return;
   }
 }
 
 void
 IteratorModeling::handleAdvanceLikeFunction(CheckerContext &C,
                                             const CallEvent &Call,
                                             const Expr *OrigExpr,
                                             const AdvanceFn *Handler) const {
   SVal Arg0 = getIteratorArg(Call, 0, C.blockCount());
    if (!C.wasInlined) {
      (this->**Handler)(C, OrigExpr, getReturnIterator(Call), Arg0,
-                       Call.getArgSVal(1));
+                       Call.getArgSVal(1), Call.getArgExpr(0),
+                       Call.getArgExpr(1));
     return;
   }
 
   // If std::advance() was inlined, but a non-standard function it calls inside
   // was not, then we have to model it explicitly
   const auto *IdInfo = cast<FunctionDecl>(Call.getDecl())->getIdentifier();
   if (IdInfo) {
     if (IdInfo->getName() == "advance") {
       if (noChangeInAdvance(C, Arg0, OrigExpr)) {
         (this->**Handler)(C, OrigExpr, getReturnIterator(Call), Arg0,
-                          Call.getArgSVal(1));
+                          Call.getArgSVal(1), Call.getArgExpr(0),
+                          Call.getArgExpr(1));
       }
     }
   }
 }
 
 void IteratorModeling::handleComparison(CheckerContext &C, const Expr *CE,
                                         SVal RetVal, SVal LVal, SVal RVal,
                                         OverloadedOperatorKind Op) const {
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, SVal RetVal,
-                                       SVal Iter, bool Postfix) const {
+                                       SVal Iter, const Expr *ItEx,
+                                       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", ItEx, 1);
   State = setIteratorPosition(State, Iter, *NewPos);
   State = setIteratorPosition(State, RetVal, Postfix ? *Pos : *NewPos);
-  C.addTransition(State);
+  C.addTransition(State, ChangeTag);
 }
 
 void IteratorModeling::handleDecrement(CheckerContext &C, SVal RetVal,
-                                       SVal Iter, bool Postfix) const {
+                                       SVal Iter, const Expr *ItEx,
+                                       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", ItEx, 1);
   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,
+void IteratorModeling::handleRandomIncrOrDecr(CheckerContext &C, const Expr *CE,
                                               OverloadedOperatorKind Op,
                                               SVal RetVal, SVal Iter,
-                                              SVal Amount) const {
+                                              SVal Amount, const Expr *ItEx,
+                                              const Expr *AmEx) const {
   // Increment or decrement the symbolic expressions which represents the
   // position of the iterator
   auto State = C.getState();
 
   const auto *Pos = getIteratorPosition(State, Iter);
   if (!Pos)
     return;
 
void IteratorModeling::handleRandomIncrOrDecr(CheckerContext &C, const Expr *CE,
   // only need this state to retrieve the new position, but we do not want
   // to change the position of `LHS` (in every case).
   auto AdvancedState = advancePosition(State, Iter, Op, *AmountVal);
   if (AdvancedState) {
     const auto *NewPos = getIteratorPosition(AdvancedState, Iter);
     assert(NewPos &&
            "Iterator should have position after successful advancement");
 
+    auto &SVB = State->getStateManager().getSValBuilder();
+    int64_t ChangeVal = SVB.getKnownValue(State, *AmountVal)->getExtValue();
+    StringRef ChangeText =
+      ((Op == OO_Plus || Op == OO_PlusEqual) != (ChangeVal <= 0)) ?
+      "incremented" : "decremented";
+    if (!ChangeVal)
+      ChangeText = "unchanged";
+    
+    const NoteTag *ChangeTag = getChangeTag(C, ChangeText, ItEx,
+                                            std::abs(ChangeVal), AmEx);
     State = setIteratorPosition(State, TgtVal, *NewPos);
-    C.addTransition(State);
+    C.addTransition(State, ChangeTag);
   } else {
     assignToContainer(C, CE, TgtVal, Pos->getContainer());
   }
 }
 
 void IteratorModeling::handlePtrIncrOrDecr(CheckerContext &C,
                                            const Expr *Iterator,
-                                           OverloadedOperatorKind OK,
-                                           SVal Offset) const {
-  if (!Offset.getAs<DefinedSVal>())
+                                           OverloadedOperatorKind Op,
+                                           SVal Amount,
+                                           const Expr *AmEx) const {
+  if (!Amount.getAs<DefinedSVal>())
     return;
 
   QualType PtrType = Iterator->getType();
   if (!PtrType->isPointerType())
     return;
   QualType ElementType = PtrType->getPointeeType();
 
   ProgramStateRef State = C.getState();
   SVal OldVal = State->getSVal(Iterator, C.getLocationContext());
 
   const IteratorPosition *OldPos = getIteratorPosition(State, OldVal);
   if (!OldPos)
     return;
 
   SVal NewVal;
-  if (OK == OO_Plus || OK == OO_PlusEqual) {
-    NewVal = State->getLValue(ElementType, Offset, OldVal);
+  if (Op == OO_Plus || Op == OO_PlusEqual) {
+    NewVal = State->getLValue(ElementType, Amount, OldVal);
   } else {
     auto &SVB = C.getSValBuilder();
-    SVal NegatedOffset = SVB.evalMinus(Offset.castAs<NonLoc>());
-    NewVal = State->getLValue(ElementType, NegatedOffset, OldVal);
+    SVal NegatedAmount = SVB.evalMinus(Amount.castAs<NonLoc>());
+    NewVal = State->getLValue(ElementType, NegatedAmount, OldVal);
   }
 
   // `AdvancedState` is a state where the position of `Old` is advanced. We
   // only need this state to retrieve the new position, but we do not want
   // ever to change the position of `OldVal`.
-  auto AdvancedState = advancePosition(State, OldVal, OK, Offset);
+  auto AdvancedState = advancePosition(State, OldVal, Op, Amount);
   if (AdvancedState) {
     const IteratorPosition *NewPos = getIteratorPosition(AdvancedState, OldVal);
     assert(NewPos &&
            "Iterator should have position after successful advancement");
 
+    auto &SVB = State->getStateManager().getSValBuilder();
+    int64_t ChangeVal = SVB.getKnownValue(State, Amount)->getExtValue();
+    StringRef ChangeText =
+      ((Op == OO_Plus || Op == OO_PlusEqual) != (ChangeVal <= 0)) ?
+      "incremented" : "decremented";
+    if (!ChangeVal)
+      ChangeText = "unchanged";
+    
+    const NoteTag *ChangeTag = getChangeTag(C, ChangeText, Iterator,
+                                            std::abs(ChangeVal), AmEx);
+
     ProgramStateRef NewState = setIteratorPosition(State, NewVal, *NewPos);
-    C.addTransition(NewState);
+    C.addTransition(NewState, ChangeTag);
   } else {
     assignToContainer(C, Iterator, NewVal, OldPos->getContainer());
   }
 }
 
 void IteratorModeling::handleAdvance(CheckerContext &C, const Expr *CE,
                                      SVal RetVal, SVal Iter,
-                                     SVal Amount) const {
-  handleRandomIncrOrDecr(C, CE, OO_PlusEqual, RetVal, Iter, Amount);
+                                     SVal Amount, const Expr *ItEx,
+                                     const Expr *AmEx) const {
+  handleRandomIncrOrDecr(C, CE, OO_PlusEqual, RetVal, Iter, Amount, ItEx, AmEx);
 }
 
 void IteratorModeling::handlePrev(CheckerContext &C, const Expr *CE,
-                                  SVal RetVal, SVal Iter,
-                                  SVal Amount) const {
-  handleRandomIncrOrDecr(C, CE, OO_Minus, RetVal, Iter, Amount);
+                                  SVal RetVal, SVal Iter, SVal Amount,
+                                  const Expr *ItEx, const Expr *AmEx) const {
+  handleRandomIncrOrDecr(C, CE, OO_Minus, RetVal, Iter, Amount, ItEx, AmEx);
 }
 
 void IteratorModeling::handleNext(CheckerContext &C, const Expr *CE,
-                                  SVal RetVal, SVal Iter,
-                                  SVal Amount) const {
-  handleRandomIncrOrDecr(C, CE, OO_Plus, RetVal, Iter, Amount);
+                                  SVal RetVal, SVal Iter, SVal Amount,
+                                  const Expr *ItEx, const Expr *AmEx) const {
+  handleRandomIncrOrDecr(C, CE, OO_Plus, RetVal, Iter, Amount, ItEx, AmEx);
 }
 
 void IteratorModeling::assignToContainer(CheckerContext &C, const Expr *CE,
                                          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);
 }
 
 bool IteratorModeling::noChangeInAdvance(CheckerContext &C, SVal Iter,
                                          const Expr *CE) const {
   // Compare the iterator position before and after the call. (To be called
   // from `checkPostCall()`.)
   const auto StateAfter = C.getState();
 
   const auto *PosAfter = getIteratorPosition(StateAfter, Iter);
   // If we have no position after the call of `std::advance`, then we are not
   // interested. (Modeling of an inlined `std::advance()` should not remove the
   // position in any case.)
   if (!PosAfter)
bool IteratorModeling::noChangeInAdvance(CheckerContext &C, SVal Iter,
   //        the new position is assigned to the wrong pointer. This causes
   //        crash if we use an assertion here.
   if (!PosBefore)
     return false;
 
   return PosBefore->getOffset() == PosAfter->getOffset();
 }
 
+const NoteTag *IteratorModeling::getChangeTag(CheckerContext &C, StringRef Text,
+                                              const Expr *ItEx, int64_t Amount,
+                                              const Expr *AmEx) const {
+  if (const auto *CCE = dyn_cast<CXXConstructExpr>(ItEx)) {
+    ItEx = CCE->getArg(0);
+  }
+
+  StringRef Name;
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(ItEx->IgnoreParenCasts())) {
+    Name = DRE->getDecl()->getName();
+  }
+
+  return C.getNoteTag(
+      [Text, Name, Amount, AmEx](PathSensitiveBugReport &BR) -> std::string {
+    SmallString<256> Msg;
+    llvm::raw_svector_ostream Out(Msg);
+    Out << "Iterator " << (!Name.empty() ? ("'" + Name.str() + "' ") : "")
+        << Text;
+    if (Amount) {
+      Out << " by " << Amount;
+    }
+    if (AmEx) {
+      bugreporter::trackExpressionValue(BR.getErrorNode(), AmEx, BR);
+    }
+    return std::string(Out.str());
+  });
+}
+
 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>();
   // Use a counter to add newlines before every line except the first one.
   unsigned Count = 0;
 
   if (!SymbolMap.isEmpty() || !RegionMap.isEmpty()) {

clang/test/Analysis/iterator-modeling.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 -analyzer-config display-checker-name=false
-
-// 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 -analyzer-config display-checker-name=false
-
-// 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 -DSTD_ADVANCE_INLINE_LEVEL=0 %s -verify -analyzer-config display-checker-name=false
-
-// 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 -DSTD_ADVANCE_INLINE_LEVEL=1 %s -verify -analyzer-config display-checker-name=false
-
-// 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 -DSTD_ADVANCE_INLINE_LEVEL=2 %s -verify -analyzer-config display-checker-name=false
-
-// 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
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=false -analyzer-output=text %s\
+// RUN: -analyzer-config display-checker-name=false\
+// RUN: -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=true -DINLINE=1\
+// RUN: -analyzer-config display-checker-name=false\
+// RUN: -analyzer-output=text %s -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=true -DINLINE=1\
+// RUN: -analyzer-config display-checker-name=false\
+// RUN: -DSTD_ADVANCE_INLINE_LEVEL=0 -analyzer-output=text %s -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=true -DINLINE=1\
+// RUN: -analyzer-config display-checker-name=false\
+// RUN: -DSTD_ADVANCE_INLINE_LEVEL=1 -analyzer-output=text %s -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=true -DINLINE=1\
+// RUN: -analyzer-config display-checker-name=false\
+// RUN: -DSTD_ADVANCE_INLINE_LEVEL=2 -analyzer-output=text %s -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorModeling,debug.ExprInspection\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true %s\
+// RUN: 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&);
 long clang_analyzer_iterator_position(int*);
 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-re {{$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-re {{$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 2{{Iterator 'i' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}
+                                                               // expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$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 2{{Iterator 'i' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$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 2{{Iterator 'i' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}
+                                                               // expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$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 2{{Iterator 'i' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$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-re {{$v.begin() + 2{{$}}}}
+                                                               // expected-note@-1{{$v.begin() + 2}}
 }
 
 void plus_equal_negative(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-re {{$v.end() - 2{{$}}}}
+                                                               // expected-note@-1{{$v.end() - 2}}
+}
+
+void plus_equal_zero(const std::vector<int> &v) {
+  auto i = v.end();
+
+  clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
+
+  i += 0; // expected-note{{Iterator 'i' unchanged}}
+
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$v.end()}}
+                                                               // expected-note@-1{{$v.end()}}
 }
 
 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-re {{$v.end() - 2{{$}}}}
+                                                               // expected-note@-1{{$v.end() - 2}}
 }
 
 void minus_equal_negative(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-re {{$v.begin() + 2{{$}}}}
+                                                               // expected-note@-1{{$v.begin() + 2}}
+}
+
+void minus_equal_zero(const std::vector<int> &v) {
+  auto i = v.begin();
+
+  clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
+
+  i -= 0; // expected-note{{Iterator 'i' unchanged}}
+
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$v.begin()}}
+                                                               // expected-note@-1{{$v.begin()}}
 }
 
 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(i1));     // expected-warning-re {{$v.end(){{$}}}}
+                                                                    // expected-note@-1{{$v.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning-re {{$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 4{{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(i1));     // expected-warning-re{{$v.begin(){{$}}}}
+                                                                    // expected-note@-1{{$v.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning-re{{$v.begin() + 2{{$}}}}
+                                                                    // expected-note@-1{{$v.begin() + 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning{{$v.begin() + 2}}
+                                                                    // expected-note@-1{{$v.begin() + 2}}
 }
 
 void plus_negative(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 3{{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(i1));     // expected-warning-re {{$v.end(){{$}}}}
+                                                                    // expected-note@-1{{$v.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning-re {{$v.end() - 2{{$}}}}
+                                                                    // expected-note@-1{{$v.end() - 2}}
+}
+
+void plus_zero(const std::vector<int> &v) {
+  auto i1 = v.begin();
+
+  clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
+
+  auto i2 = i1 + 0; // expected-note 2{{Iterator 'i1' unchanged}}
+
+  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-re {{$v.begin(){{$}}}}
+                                                                    // expected-note@-1{{$v.begin()}}
 }
 
 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 3{{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(i1));     // expected-warning-re {{$v.end(){{$}}}}
+                                                                    // expected-note@-1{{$v.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning-re {{$v.end() - 2{{$}}}}
+                                                                    // expected-note@-1{{$v.end() - 2}}
 }
 
 void minus_negative(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 3{{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(i1));     // expected-warning-re {{$v.begin(){{$}}}}
+                                                                    // expected-note@-1{{$v.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2));     // expected-warning-re {{$v.begin() + 2{{$}}}}
+                                                                    // expected-note@-1{{$v.begin() + 2}}
+}
+
+void minus_zero(const std::vector<int> &v) {
+  auto i1 = v.begin();
+
+  clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
+
+  auto i2 = i1 - 0; // expected-note 2{{Iterator 'i1' unchanged}}
+
+  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-re {{$v.begin(){{$}}}}
+                                                                // expected-note@-1{{$v.begin()}}
 }
 
 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 2{{Iterator 'i1' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.begin() + 1{{$}}}}
+                                                                // expected-note@-1{{$v.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 2{{Iterator 'i2' incremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.begin(){{$}}}}
+                                                                // expected-note@-1{{$v.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 2{{Iterator 'i1' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$v.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 2{{Iterator 'i2' decremented by 1}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}
+                                                                // expected-note@-1{{$v.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$v.end() - 1}}
 }
 
 /// std::advance(), std::prev(), std::next()
 
 void std_advance_minus(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  std::advance(i, -1);
+  std::advance(i, -1); // expected-note 0-1{{Iterator 'i' decremented by 1}}
+  // expected-note@-1 0-1{{Calling 'advance}}
+  // expected-note@-2 0-1{{Passing the value -1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value -1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' decremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@-7 0-1{{Returning from 'advance}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$v.end() - 1}}
 }
 
 void std_advance_plus(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  std::advance(i, 1);
+  std::advance(i, 1); // expected-note 0-1{{Iterator 'i' incremented by 1}}
+  // expected-note@-1 0-1{{Calling 'advance}}
+  // expected-note@-2 0-1{{Passing the value 1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value 1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' incremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@-7 0-1{{Returning from 'advance}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$v.begin() + 1}}
+                                                               // expected-note@-1{{$v.begin() + 1}}
 }
 
 void std_prev(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  auto j = std::prev(i);
+  auto j = std::prev(i); // expected-note 0-1{{Iterator 'i' decremented by 1}}
+  // expected-note@-1 0-1{{Calling 'prev}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Iterator 'it' decremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Calling 'advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Passing the value -1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value -1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' decremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Returning from 'advance}}
+  // expected-note@-10 0-1{{Returning from 'prev}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end() - 1{{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$v.end() - 1}}
+                                                               // expected-note@-1{{$v.end() - 1}}
 }
 
 void std_prev2(const std::vector<int> &v) {
   auto i = v.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");
 
-  auto j = std::prev(i, 2);
+  auto j = std::prev(i, 2); // expected-note 0-1{{Iterator 'i' decremented by 2}}
+  // expected-note@-1 0-1{{Calling 'prev}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Iterator 'it' decremented by 2}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Calling 'advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Passing the value -2 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value -2 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' decremented by 2}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:801 0-1{{Returning from 'advance}}
+  // expected-note@-10 0-1{{Returning from 'prev}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end() - 2{{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$v.end() - 2}}
+                                                               // expected-note@-1{{$v.end() - 2}}
 }
 
 void std_next(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  auto j = std::next(i);
+  auto j = std::next(i); // expected-note 0-1{{Iterator 'i' incremented by 1}}
+  // expected-note@-1 0-1{{Calling 'next}}
+  // expected-note@-2 0-1{{Passing the value 1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Iterator 'it' incremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Calling 'advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Passing the value 1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value 1 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' incremented by 1}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Returning from 'advance}}
+  // expected-note@-11 0-1{{Returning from 'next}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin() + 1{{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$v.begin() + 1}}
+                                                               // expected-note@-1{{$v.begin() + 1}}
 }
 
 void std_next2(const std::vector<int> &v) {
   auto i = v.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");
 
-  auto j = std::next(i, 2);
+  auto j = std::next(i, 2); // expected-note 0-1{{Iterator 'i' incremented by 2}}
+  // expected-note@-1 0-1{{Calling 'next}}
+  // expected-note@-2 0-1{{Passing the value 2 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Iterator 'it' incremented by 2}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Calling 'advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Passing the value 2 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Calling '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Passing the value 2 via 2nd parameter 'n'}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:776 0-1{{Iterator 'it' incremented by 2}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:788 0-1{{Returning from '__advance}}
+  // expected-note@Inputs/system-header-simulator-cxx.h:815 0-1{{Returning from 'advance}}
+  // expected-note@-11 0-1{{Returning from 'next}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin() + 2{{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$v.begin() + 2}}
+                                                               // expected-note@-1{{$v.begin() + 2}}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 ///
 /// 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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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 7{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+  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-re {{$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 7{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+  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-re {{$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 7{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}} FIXME: Should be FALSE.
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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}}
+  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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$V.begin(){{$}}}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$L.end()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$V.begin(){{$}}}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin() + 1{{$}}}}
+                                                                // expected-note@-1{{$L.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$D.begin() + 1{{$}}}}
+                                                                // expected-note@-1{{$D.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin() + 1{{$}}}}
+                                                                // expected-note@-1{{$FL.begin() + 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$V.begin(){{$}}}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
+                                                                // expected-note@-1{{$L.end() - 1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$V.begin(){{$}}}}
+                                                                // expected-note@-1{{$V.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 6{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$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-re {{$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 5{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
+  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-re {{$L.begin(){{$}}}}
+                                                                // expected-note@-1{{$L.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 4{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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-re {{$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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 3{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
+  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 7{{Iterator incremented by 1}}
   ++i2;
+  // expected-note@-1 7{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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-re {{$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 9{{Iterator 'i2' incremented by 1}}
   ++i3;
+  // expected-note@-1 9{{Iterator 'i3' incremented by 1}}
   ++i3;
+  // expected-note@-1 9{{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}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}
-  clang_analyzer_eval(clang_analyzer_iterator_validity(i4)); //expected-warning{{TRUE}}
+  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-re {{$FL.begin(){{$}}}}
+                                                                // expected-note@-1{{$FL.begin()}}
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}
+                                                                // expected-note@-1{{$i1}}
   clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning-re {{$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-re {{$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 2{{Assuming the condition is false}}
+                                                                // expected-note@-4{{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}}
   }
 }
 
 template<typename T>
 struct cont_with_ptr_iterator {
   typedef T* iterator;
   T* begin() const;
   T* end() const;
 };
 
 void begin_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.begin();
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i) == &c); // expected-warning{{TRUE}}
+                                                                   // expected-note@-1{{TRUE}}
   clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.begin(){{$}}}}
+                                                               // expected-note@-1{{$c.begin()}}
 
   if (i != c.begin()) {
     clang_analyzer_warnIfReached();
   }
   }
 
 void prefix_increment_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");
 
-  auto j = ++i;
+  auto j = ++i; // expected-note 2{{Iterator 'i' incremented by 1}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 1}}
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.begin() + 1{{$}}}}
+                                                               // expected-note@-1{{$c.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$c.begin() + 1{{$}}}}
+                                                               // expected-note@-1{{$c.begin() + 1}}
 }
 
 void prefix_decrement_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");
 
-  auto j = --i;
+  auto j = --i; // expected-note 2{{Iterator 'i' decremented by 1}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 1}}
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$c.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$c.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$c.end() - 1}}
 }
 
 void postfix_increment_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");
 
-  auto j = i++;
+  auto j = i++; // expected-note 2{{Iterator 'i' incremented by 1}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 1}}
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.begin() + 1{{$}}}}
+                                                               // expected-note@-1{{$c.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$c.begin(){{$}}}}
+                                                               // expected-note@-1{{$c.begin()}}
 }
 
 void postfix_decrement_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");
 
-  auto j = i--;
+  auto j = i--; // expected-note 2{{Iterator 'i' decremented by 1}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 1}}
-  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.end() - 1{{$}}}}
+                                                               // expected-note@-1{{$c.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$c.end(){{$}}}}
+                                                               // expected-note@-1{{$c.end()}}
 }
 
 void plus_equal_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");
 
-  i += 2;
+  i += 2; // expected-note {{Iterator 'i' incremented by 2}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.begin() + 2{{$}}}}
+                                                               // expected-note@-1{{$c.begin() + 2}}
 }
 
 void minus_equal_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i = c.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");
 
-  i -= 2;
+  i -= 2; // expected-note {{Iterator 'i' decremented by 2}}
 
-  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$c.end() - 2{{$}}}}
+                                                               // expected-note@-1{{$c.end() - 2}}
 }
 
 void minus_equal_ptr_iterator_variable(const cont_with_ptr_iterator<int> &c,
                                        int n) {
   auto i = c.end();
 
   i -= n; // no-crash
 }
 
 void plus_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i1 = c.begin();
 
   clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");
 
-  auto i2 = i1 + 2;
+  auto i2 = i1 + 2; // expected-note 3{{Iterator 'i1' incremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$c.begin()}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$c.begin() + 2}}
+                                                                    // expected-note@-1{{TRUE}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$c.begin(){{$}}}}
+                                                                // expected-note@-1{{$c.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$c.begin() + 2{{$}}}}
+                                                                // expected-note@-1{{$c.begin() + 2}}
 }
 
 void minus_ptr_iterator(const cont_with_ptr_iterator<int> &c) {
   auto i1 = c.end();
 
   clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");
 
-  auto i2 = i1 - 2;
+  auto i2 = i1 - 2; // expected-note 3{{Iterator 'i1' decremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$c.end()}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$c.end() - 2}}
+                                                                    // expected-note@-1{{TRUE}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$c.end(){{$}}}}
+                                                                // expected-note@-1{{$c.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$c.end() - 2{{$}}}}
+                                                                // expected-note@-1{{$c.end() - 2}}
 }
 
 void ptr_iter_diff(cont_with_ptr_iterator<int> &c) {
   auto i0 = c.begin(), i1 = c.end();
   ptrdiff_t len = i1 - i0; // no-crash
 }
 
 void ptr_iter_cmp_nullptr(cont_with_ptr_iterator<int> &c) {
   auto i0 = c.begin();
   if (i0 != nullptr) // no-crash
     ++i0;
 }
 
+/// 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 2{{Iterator 'j' incremented by 1}}
+                // FIXME: Expect only one note.
+
+  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; // expected-note{{Iterator 'j' incremented by 1}}
+                // FIXME: expect no note.
+
+  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 -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
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=false -analyzer-output=text %s\
+// RUN: -verify
+
+// RUN: %clang_analyze_cc1 -std=c++11\
+// RUN: -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange\
+// RUN: -analyzer-config aggressive-binary-operation-simplification=true\
+// RUN: -analyzer-config c++-container-inlining=true -DINLINE=1\
+// RUN: -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 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}}

 
 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_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 advance_plus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   std::advance(i, 2); // no-warning
 }
 
 void advance_plus_2_ahead_of_end(const std::vector<int> &V) {
-  auto i = --V.end();
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
   std::advance(i, 2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                       // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 void advance_plus_2_end(const std::vector<int> &V) {
   auto i = V.end();
   std::advance(i, 2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                       // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // std::advance() by -2
 
 void advance_minus_2_begin(const std::vector<int> &V) {
   auto i = V.begin();
   std::advance(i, -2); // expected-warning{{Iterator decremented ahead of its valid range}}
                        // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void advance_minus_2_behind_begin(const std::vector<int> &V) {
-  auto i = ++V.begin();
+  auto i = ++V.begin(); // expected-note{{Iterator incremented by 1}}
   std::advance(i, -2); // expected-warning{{Iterator decremented ahead of its valid range}}
                        // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void advance_minus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   std::advance(i, -2); // no-warning
 }

 }
 
 void next_plus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   auto j = std::next(i, 2); // no-warning
 }
 
 void next_plus_2_ahead_of_end(const std::vector<int> &V) {
-  auto i = --V.end();
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
   auto j = std::next(i, 2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                             // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 void next_plus_2_end(const std::vector<int> &V) {
   auto i = V.end();
   auto j = std::next(i, 2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                             // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 // std::next() by -2
 
 void next_minus_2_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = std::next(i, -2); // expected-warning{{Iterator decremented ahead of its valid range}}
                              // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void next_minus_2_behind_begin(const std::vector<int> &V) {
-  auto i = ++V.begin();
+  auto i = ++V.begin(); // expected-note{{Iterator incremented by 1}}
   auto j = std::next(i, -2); // expected-warning{{Iterator decremented ahead of its valid range}}
                              // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void next_minus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   auto j = std::next(i, -2); // no-warning
 }

 
 void prev_plus_2_begin(const std::vector<int> &V) {
   auto i = V.begin();
   auto j = std::prev(i, 2); // expected-warning{{Iterator decremented ahead of its valid range}}
                             // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void prev_plus_2_behind_begin(const std::vector<int> &V) {
-  auto i = ++V.begin();
+  auto i = ++V.begin(); // expected-note{{Iterator incremented by 1}}
   auto j = std::prev(i, 2); // expected-warning{{Iterator decremented ahead of its valid range}}
                             // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void prev_plus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   auto j = std::prev(i, 2); // no-warning
 }

 }
 
 void prev_minus_2_unknown(const std::vector<int> &V) {
   auto i = return_any_iterator(V.begin());
   auto j = std::prev(i, -2); // no-warning
 }
 
 void prev_minus_2_ahead_of_end(const std::vector<int> &V) {
-  auto i = --V.end();
+  auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
   auto j = std::prev(i, -2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                              // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
 }
 
 void prev_minus_2_end(const std::vector<int> &V) {
   auto i = V.end();
   auto j = std::prev(i, -2); // expected-warning{{Iterator incremented behind the past-the-end iterator}}
                              // expected-note@-1{{Iterator incremented behind the past-the-end iterator}}
void arrow_deref_end(const std::vector<S> &V) {
   auto i = V.end();
   int n = i->n; // expected-warning{{Past-the-end iterator dereferenced}}
                 // expected-note@-1{{Past-the-end iterator dereferenced}}
 }
 
 // Container modification - test path notes
 
 void deref_end_after_pop_back(std::vector<int> &V) {
-  const auto i = --V.end();
+  const auto i = --V.end(); // expected-note{{Iterator decremented by 1}}
 
   V.pop_back(); // expected-note{{Container 'V' shrank from the back by 1 position}}
 
   *i; // expected-warning{{Past-the-end iterator dereferenced}}
       // expected-note@-1{{Past-the-end iterator dereferenced}}
 }
 
 template<typename T>
void postfix_minus_assign_2_begin_ptr_iterator(
   i -= 2; // expected-warning{{Iterator decremented ahead of its valid range}}
           // expected-note@-1{{Iterator decremented ahead of its valid range}}
 }
 
 void ptr_iter_diff(cont_with_ptr_iterator<S> &c) {
   auto i0 = c.begin(), i1 = c.end();
   ptrdiff_t len = i1 - i0; // no-crash
 }
+
+// Iterator modification - test 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}}
+}