[Analyzer] Only add iterator note tags to the operations of the affected iterators

[baloghadamsoftware]

Summary

If an error happens which is related to some iterators the Iterator Modeling checker adds note tags to all the iterator operations along the bug path. This may be disturbing if there are other iterators beside the ones which are affected by the bug. This patch restricts the note tags to only the affected iterators and adjust the debug checkers to be able to test this change.

[baloghadamsoftware]

Updated according to the comments to D75514.

[baloghadamsoftware]

Rebased.

[Szelethus]

Its very interesting to see how the idea of interestingness propagation through NoteTags works in practice -- I feel like many other checkers will need to adopt something like this, and its great that we have the first use case presented here. The patch from afar looks good, I only left some nits to ease the readability for the uninitiated.

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

90–115

Now that we have multiple SVals around, can we rename V? Also, I would appreciate some comments. As I understand it, ExprInspectionChecker now marks the arguments as interesting, so if we write this:

clang_analyzer_express(clang_analyzer_iterator_position(i2));

clang_analyzer_iterator_position(i2) will be interesting, and this function propagates this interestingness to i2, correct?

103

We won't need this anymore :)

clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

432 ↗

(On Diff #249320)

Why the need for the Optional stuff here?

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

125–126

The usage of this function is very non-obvious, plenty of comments would be appreciated here as well.

[Szelethus]

clang/test/Analysis/iterator-modelling.cpp

169 ↗

(On Diff #249320)

Interestingness won't be propagated here because clang_analyzer_iterator_container(i2) == &v is interesting, not clang_analyzer_iterator_container(i2), correct?

[baloghadamsoftware]

Updated according to the comments.

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

90–115

Yes.

clang/test/Analysis/iterator-modelling.cpp

169 ↗

(On Diff #249320)

Currently only clang_analyzer_express() marks its argument as interesting. This could be extended in the future, however the argument of clang_analyzer_eval() is usually the result of the comparison, not the symbolic comparison itself so the sides of the comparison are not reachable at that point.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

107–108

What region would it be in the common scenario? Will it be the argument region or the region from which the value was copied into the argument region? Can we say explicitly "let's just take the argument region" because it's clearly the right thing to do?

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

I'm opposed to this code for the same reason that i'm opposed to it in the debug checker. Parent region is an undocumented implementation detail of RegionStore. It is supposed to be immaterial to the user. You should not rely on its exact value.

@baloghadamsoftware Can we eliminate all such code from iterator checkers and instead identify all iterators by regions in which they're stored? Does my improved C++ support help with this anyhow whenever it kicks in?

clang/test/Analysis/iterator-modelling.cpp

69 ↗

(On Diff #250180)

Let's also add a test for a simple copy, i.e. auto j = i;. Does it say Iterator 'i' copied? What about moved?

clang/test/Analysis/iterator-range.cpp

42

This line ultimately needs a note as well, i.e. Iterator points to end of container 'V' or something like that.

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

How to find the region where it is stored? I am open to find better solutions, but it was the only one I could find so far. If we ignore LazyCompoundVal then everything falls apart, we can remove all the iterator-related checkers.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

It's the region from which you loaded it. If you obtained it as Call.getArgSVal() then it's the parameter region for the call. If you obtained it as Call.getReturnValue() then it's the target region can be obtained by looking at the construction context for the call.

[Szelethus]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

LazyCompoundVal and friends seem to be a constantly emerging headache for almost everyone. For how long I've spent in the analyzer, and have religiously studied conversations and your workbook about it, I still feel anxious whenever it comes up.

It would be great to have this documented in the code sometime.

clang/test/Analysis/iterator-modelling.cpp

169 ↗

(On Diff #249320)

Fair enough.

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

Do you mean CallEvent::getParameterLocation() for arguments? What is the construction context for the call? How can it be obtained?

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

I do not know exactly how many place LazyCompoundVal appears, but one place for sure is in MaterializeTemporaryExpr::getSubExpr(). What to use there instead?

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

I also get it in the Val parameter of checkBind().

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

Now I spent a whole day in vain. You probably mean ExprEngine::getObjectUnderConstruction(), (which takes ConstructionContextItem as its argument) but it turned out that there are no objects under construction in checkPostCall(). (Stack dump says constructing_objects as null.) It seems that the only working solution is the current one. I am not opposed to find better working solutions, but we cannot spend months to completely rewrite parts of the analyzer for such a simple patch. And note tags are definitely needed for iterator checkers.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

"A whole day"? "One simple patch"? Give me a break.

We've been discussing this problem since your very first implementation of the iterator checker dozens of patches ago, and i spent six months of my full time work trying to make this part of the analyzer operate in an obvious, principled manner, even made a dev meeting talk about it in order to explain how it works. And all you do is keep insisting that your solution is "working" even though literally nobody understands how, even you.

Out of all the contributors who bring patches to me every day, only @Szelethus is actively addressing the technical debt. This is not "one simple patch". This has to stop at some point, and i expect you, being a fairly senior contributor at this point, to put at least a slight effort into good engineering practices, apply the necessary amount of critical thinking, take basic responsibility for your code.

I don't mind if you address this issue immediately after this patch if you urgently need this patch landed. But i wouldn't like this to go on forever.

dump says constructing_objects as null

You shouldn't be spending the whole day before noticing it. Whenever something isn't working, the first thing you do should be dump the ExplodedGraph and look at it. You would have noticed it right away.

Was the object never there or was it removed too early? If there are no objects under construction tracked but you need them tracked, make them tracked for as long as you need. That's the whole point of the objects-under-construction map.

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

Sorry, @NoQ, I wrote this comment before starting the WIP patch. I agree that we should have clean solutions and I do not like hacking at all. Also at the University I do not accept solutions that just work by chance (i.e. pointers randomly pointing to memory where it luckily does not crash).

However, unfortunately we are a profit-oriented company where our small team has tons of internal customers. Their requests should be top-priority. I already got lots of comments from my teammates and bosses that I spend too much time on a single topic (iterator checkers). If I cannot increase my performance the company may decide that these checkers remain in downstream. I am trying very hard to avoid that. The point of open-source projects is that many are contributing and get other's contributions for free. So, theoretically it should be cheaper than downstream development. However, in this project there are very few contributors. So if I have to spend 20x the time for open-sourcing every single patch than just developing a working solution downstream then open-source development turns out to be much more expensive. There is a risk that our company will not take that. This is the reason I try to balance between fully proper solutions and less proper, but fully tested and working solutions. You must understand that I am in a situation where I must do this for not losing the possibility to open-source my work.

@Szelethus is in somewhat better situation as a student. The company is not so strict with students. The money we spend on students is more of a "research" investment but employees are paid for serving the customers. Unfortunately, I am not allowed to spend years for something that is not directly visible for them. So I am willing to fix this issue properly but I need your help because I must be as fast as possible.

Anyway, constructing_objects is only null because we do not have LocationContext in the dumping function.

[NoQ]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

I wrote this comment before starting the WIP patch

Dang! I almost knew something was wrong :( Sorry, please accept my apologies :(

[baloghadamsoftware]

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

732–733

No problem, I phrased a bit too harsh. Please accept my apologies! I really want to solve this problem now properly, so please follow my comments at that patch. Every day I solve one problem and face two more so the number of problems grows exponentially, just like the virus.

[baloghadamsoftware]

Rebased, no tricks with LazyCompoundVals are used anymore.

clang/lib/StaticAnalyzer/Checkers/DebugIteratorModeling.cpp

void DebugIteratorModeling::analyzerIteratorDataField(const CallExpr *CE,
                                                       CheckerContext &C,
                                                       Getter get,
                                                       SVal Default) const {
   if (CE->getNumArgs() == 0) {
     reportDebugMsg("Missing iterator argument", C);
     return;
   }
 
   auto State = C.getState();
-  SVal V = C.getSVal(CE->getArg(0));
-  const auto *Pos = getIteratorPosition(State, V);
+  SVal Iter = C.getSVal(CE->getArg(0));
+  const auto *Pos = getIteratorPosition(State, Iter);
+  SVal Field = Default;
+
   if (Pos) {
-    State = State->BindExpr(CE, C.getLocationContext(), get(Pos));
-  } else {
-    State = State->BindExpr(CE, C.getLocationContext(), Default);
+    Field = get(Pos);
+  }
+
+  State = State->BindExpr(CE, C.getLocationContext(), Field);
+
+  // Progpagate interestingness from the iterator's position (marked interesting
+  // by an `ExprInspection` debug call to the iterator itself.
+  const NoteTag *InterestingTag =
+      C.getNoteTag([Iter, Field](PathSensitiveBugReport &BR) -> std::string {
+        if (BR.isInteresting(Field)) {
+          BR.markInteresting(Iter);
+          if (const auto &LCV = Iter.getAs<nonloc::LazyCompoundVal>()) {
+            BR.markInteresting(LCV->getRegion());
+          }
         }
-  C.addTransition(State);
+        return "";
+      });
+
+  C.addTransition(State, InterestingTag);
 }
 
 void DebugIteratorModeling::analyzerIteratorPosition(const CallExpr *CE,
                                                      CheckerContext &C) const {
   auto &BVF = C.getSValBuilder().getBasicValueFactory();
   analyzerIteratorDataField(CE, C, [](const IteratorPosition *P) {
       return nonloc::SymbolVal(P->getOffset());
     }, nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(0))));
 }

clang/lib/StaticAnalyzer/Checkers/IteratorModeling.cpp

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;
+                              const Expr *ItE, SVal It1, int64_t Amount = 0,
+                              Optional<SVal> It2 = None) const;
   bool noChangeInAdvance(CheckerContext &C, SVal Iter, const Expr *CE) const;
+  const NoteTag *getInterestingnessPropagationTag(CheckerContext &C, SVal It1,
+                                                  SVal It2) const;
   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
                   const char *Sep) const override;
 
   // std::advance, std::prev & std::next
   CallDescriptionMap<AdvanceFn> AdvanceLikeFunctions = {
       // template<class InputIt, class Distance>
       // void advance(InputIt& it, Distance n);
       {{{"std", "advance"}, 2}, &IteratorModeling::handleAdvance},
void IteratorModeling::checkPostCall(const CallEvent &Call,
   // Copy-like and move constructors
   if (isa<CXXConstructorCall>(&Call) && Call.getNumArgs() == 1) {
     SVal Arg = getIteratorArg(Call, 0, C.blockCount());
     if (const auto *Pos = getIteratorPosition(State, Arg)) {
       State = setIteratorPosition(State, RetVal, *Pos);
       if (cast<CXXConstructorDecl>(Func)->isMoveConstructor()) {
         State = removeIteratorPosition(State, Arg);
       }
-      C.addTransition(State);
+      const NoteTag *InterestingTag =
+        getInterestingnessPropagationTag(C, Arg, RetVal);
+      C.addTransition(State, InterestingTag);
       return;
     }
   }
 
   // Assumption: if return value is an iterator which is not yet bound to a
   //             container, then look for the first iterator argument of the
   //             same type as the return value and bind the return value to
   //             the same container. This approach works for STL algorithms.
void IteratorModeling::checkBind(SVal Loc, SVal Val, const Stmt *S,
                                  CheckerContext &C) const {
   auto State = C.getState();
   if (Val.getAs<nonloc::LazyCompoundVal>())
     return;
 
   const auto *Pos = getIteratorPosition(State, Val);
   if (Pos) {
     State = setIteratorPosition(State, Loc, *Pos);
-    C.addTransition(State);
+    const NoteTag *InterestingTag =
+      getInterestingnessPropagationTag(C, Val, Loc);
+    C.addTransition(State, InterestingTag);
   } else {
     const auto *OldPos = getIteratorPosition(State, Loc);
     if (OldPos) {
       State = removeIteratorPosition(State, Loc);
       C.addTransition(State);
     }
   }
 }
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);
+  const NoteTag *ChangeTag =
+    getChangeTag(C, "incremented", ItEx, Iter, 1,
+                 Postfix ? None : Optional<SVal>(RetVal));
   State = setIteratorPosition(State, Iter, *NewPos);
   State = setIteratorPosition(State, RetVal, Postfix ? *Pos : *NewPos);
   C.addTransition(State, ChangeTag);
 }
 
 void IteratorModeling::handleDecrement(CheckerContext &C, SVal RetVal,
                                        SVal Iter, const Expr *ItEx,
                                        bool Postfix) const {
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);
+  const NoteTag *ChangeTag =
+    getChangeTag(C, "decremented", ItEx, Iter, 1,
+                 Postfix ? None : Optional<SVal>(RetVal));
   State = setIteratorPosition(State, Iter, *NewPos);
   State = setIteratorPosition(State, RetVal, Postfix ? *Pos : *NewPos);
   C.addTransition(State, ChangeTag);
 }
 
 void IteratorModeling::handleRandomIncrOrDecr(CheckerContext &C, const Expr *CE,
                                               OverloadedOperatorKind Op,
                                               SVal RetVal, SVal Iter,
if (AdvancedState) {
     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);
+    const NoteTag *ChangeTag =
+      getChangeTag(C, ChangeText, ItEx, Iter, std::abs(ChangeVal),
+                   (TgtVal == RetVal) ? Optional<SVal>(RetVal) : None);
     State = setIteratorPosition(State, TgtVal, *NewPos);
     C.addTransition(State, ChangeTag);
   } else {
     assignToContainer(C, CE, TgtVal, Pos->getContainer());
   }
 }
 
 void IteratorModeling::handlePtrIncrOrDecr(CheckerContext &C,
if (AdvancedState) {
     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);
+    const NoteTag *ChangeTag =
+      getChangeTag(C, ChangeText, Iterator, OldVal, std::abs(ChangeVal),
+                   NewVal);
 
     ProgramStateRef NewState = setIteratorPosition(State, NewVal, *NewPos);
     C.addTransition(NewState, ChangeTag);
   } else {
     assignToContainer(C, Iterator, NewVal, OldPos->getContainer());
   }
 }
 
bool IteratorModeling::noChangeInAdvance(CheckerContext &C, SVal Iter,
   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)
     return false;
 
   const ExplodedNode *N = findCallEnter(C.getPredecessor(), CE);
   assert(N && "Any call should have a `CallEnter` node.");
 
   const auto StateBefore = N->getState();
   const auto *PosBefore = getIteratorPosition(StateBefore, Iter);
   // FIXME: `std::advance()` should not create a new iterator position but
   //        change existing ones. However, in case of iterators implemented as
   //        pointers the handling of parameters in `std::advance()`-like
   //        functions is still incomplete which may result in cases where
   //        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);
+                                              const Expr *ItE, SVal It1,
+                                              int64_t Amount,
+                                              Optional<SVal> It2) const {
+  if (const auto *CCE = dyn_cast<CXXConstructExpr>(ItE)) {
+    ItE = CCE->getArg(0);
   }
 
   StringRef Name;
-  if (const auto *DRE = dyn_cast<DeclRefExpr>(ItEx->IgnoreParenCasts())) {
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(ItE->IgnoreParenCasts())) {
     Name = DRE->getDecl()->getName();
   }
 
-  return C.getNoteTag(
-      [Text, Name, Amount, AmEx](PathSensitiveBugReport &BR) -> std::string {
+  return C.getNoteTag([Text, Name, Amount, It1,
+                       It2](PathSensitiveBugReport &BR) -> std::string {
+    if (It2 && BR.isInteresting(*It2))
+      BR.markInteresting(It1);
+
+    if (!BR.isInteresting(It1))
+      return "";
+
     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());
   });
 }
 
+// Propagate interestingness between iterators upon their assignments. This
+// is essential for tracking all the changes of an iterator from the beginning
+// to the bug location.
+//
+// Example: i = ++j;
+//
+// If `j` is affected by a bug, then this function ensures that `i` is tracked
+// further up along the path (using `NoteTags`).
+
+const NoteTag *
+IteratorModeling::getInterestingnessPropagationTag(CheckerContext &C,
+                                                   SVal It1, SVal It2) const {
+  return C.getNoteTag([It1, It2](PathSensitiveBugReport &BR) -> std::string {
+    if (BR.isInteresting(It2))
+      BR.markInteresting(It1);
+
+    return "";
+  });
+}
+
 void IteratorModeling::printState(raw_ostream &Out, ProgramStateRef State,
                                   const char *NL, const char *Sep) const {
   auto SymbolMap = State->get<IteratorSymbolMap>();
   auto RegionMap = State->get<IteratorRegionMap>();
   // 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

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++; // expected-note 2{{Iterator 'i' incremented by 1}}
+  auto j = i++; // expected-note{{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--; // expected-note 2{{Iterator 'i' decremented by 1}}
+  auto j = i--; // expected-note{{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) {
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; // expected-note 4{{Iterator 'i1' incremented by 2}}
+  auto i2 = i1 + 2; // expected-note 2{{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); // expected-note 3{{Iterator 'i1' decremented by 2}}
+  auto i2 = i1 + (-2); // expected-note 2{{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}}
+  auto i2 = i1 + 0; // expected-note{{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;  // expected-note 3{{Iterator 'i1' decremented by 2}}
+  auto i2 = i1 - 2; // expected-note 2{{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); // expected-note 3{{Iterator 'i1' incremented by 2}}
+  auto i2 = i1 - (-2); // expected-note 2{{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}}
+  auto i2 = i1 - 0; // expected-note{{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;  // expected-note 2{{Iterator 'i1' incremented by 1}}
+  ++i1;  // expected-note{{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;  // expected-note 2{{Iterator 'i2' incremented by 1}}
+  ++i2;  // expected-note{{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;  // expected-note 2{{Iterator 'i1' decremented by 1}}
+  --i1;  // expected-note{{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;  // expected-note 2{{Iterator 'i2' decremented by 1}}
+  --i2;  // expected-note{{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 forward_list_copy_assignment(std::forward_list<int> &FL1,
   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}}
                                                              // expected-note@-1{{FALSE}}
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}}
                                                              // expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{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}}
                                                              // expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}

 ///   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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.push_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
void list_push_back(std::list<int> &L, int n) {
   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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   V.push_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-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}}
                                                              // expected-note@-1{{FALSE}}

 ///   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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.emplace_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
void list_emplace_back(std::list<int> &L, int n) {
   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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   V.emplace_back(n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-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}}
                                                              // expected-note@-1{{FALSE}}

 ///   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}}
                                                              // 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}}
                                                              // 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}}
                                                              // expected-note@-1{{TRUE}}
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}}
                                                              // expected-note@-1{{FALSE}}
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}}
                                                              // expected-note@-1{{FALSE}}

 ///   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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   L.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");
 
   D.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   FL.pop_front();
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
clang_analyzer_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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.insert(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
void vector_insert_begin(std::vector<int> &V, int n) {
   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}}
                                                              // expected-note@-1{{TRUE}}
void vector_insert_unknown(std::vector<int> &V, int n) {
 
   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}}
                                                              // 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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.insert(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
void deque_insert_begin(std::deque<int> &D, int n) {
   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}}
                                                              // expected-note@-1{{FALSE}}
void deque_insert_unknown(std::deque<int> &D, int n) {
   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}}
                                                              // 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}}
                                                              // expected-note@-1{{FALSE}}
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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i3 = FL.insert_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
clang_analyzer_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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.emplace(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
clang_analyzer_eval(clang_analyzer_iterator_validity(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}}
                                                              // expected-note@-1{{TRUE}}
void vector_emplace_unknown(std::vector<int> &V, int n) {
 
   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}}
                                                              // 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}}
+  // expected-note@-1{{Iterator decremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");
 
   auto i3 = V.emplace(i2, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{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{{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}}
                                                              // expected-note@-1{{FALSE}}
void deque_emplace_unknown(std::deque<int> &D, int n) {
   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}}
                                                              // 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}}
                                                              // expected-note@-1{{FALSE}}
void forward_list_emplace_after_begin(std::forward_list<int> &FL, int n) {
   // 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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i3 = FL.emplace_after(i1, n);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}

 ///
 /// - 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}}
+  // expected-note@-1{{Iterator incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");
 
   auto i3 = L.erase(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{FALSE}}
                                                              // expected-note@-1{{FALSE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
   clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
 
   clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-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}}
                                                              // 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}}
                                                              // expected-note@-1{{TRUE}}
void list_erase_ahead_of_end(std::list<int> &L) {
   // 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}}
                                                              // 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}}
                                                              // expected-note@-1{{TRUE}}
void vector_erase_unknown(std::vector<int> &V) {
 
   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}}
                                                              // expected-note@-1{{TRUE}}

 ///                             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}}
                                                              // 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}}
                                                              // expected-note@-1{{FALSE}}
void deque_erase_unknown(std::deque<int> &D) {
   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}}
                                                              // expected-note@-1{{FALSE}}

 ///                    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}}
+  // expected-note@-1{{Iterator incremented by 1}}
   ++i2;
-  // expected-note@-1 7{{Iterator 'i2' incremented by 1}}
+  // expected-note@-1{{Iterator 'i2' incremented by 1}}
 
   clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");
   clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");
 
   auto i4 = FL.erase_after(i0);
 
   clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); // expected-warning{{TRUE}}
                                                              // expected-note@-1{{TRUE}}
void forward_list_erase_after_begin(std::forward_list<int> &FL) {
   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}}
+  // expected-note@-1{{Iterator 'i3' incremented by 1}}
   ++i3;
-  // expected-note@-1 9{{Iterator 'i3' incremented by 1}}
+  // expected-note@-1{{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}}
void minus_equal_ptr_iterator_variable(const cont_with_ptr_iterator<int> &c,
   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; // expected-note 3{{Iterator 'i1' incremented by 2}}
+  auto i2 = i1 + 2; // expected-note 2{{Iterator 'i1' incremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}
                                                                     // 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; // expected-note 3{{Iterator 'i1' decremented by 2}}
+  auto i2 = i1 - 2; // expected-note 2{{Iterator 'i1' decremented by 2}}
 
   clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}
                                                                     // 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}}
 }

 
 /// 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.
+  auto k = ++j; // expected-note{{Iterator 'j' incremented by 1}}
+                // Only once!
 
   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.
+  auto k = ++j; // 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();

clang/test/Analysis/iterator-range.cpp

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

 // 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}}
 }
+