[Analyzer] Model return values of container insert and delete operations

[baloghadamsoftware]

Summary

Insert and delete operations of insert(), erase() (plus insert_after() and erase_after() for std::forward_list-like containers were not modeled yet. This patch fixes this issue.

[martong]

It seems like we could model here emplace and emplace_after exactly the same way we do with insert and insert_after, couldn't we? Perhaps that could go into this patch too.

[baloghadamsoftware]

In D77125#1952769, @martong wrote:

It seems like we could model here emplace and emplace_after exactly the same way we do with insert and insert_after, couldn't we? Perhaps that could go into this patch too.

They are already in this patch (see the tests and the CallDescriptionMap), but they share their handing function with insert and insert_after.

[martong]

In D77125#1955245, @baloghadamsoftware wrote:

In D77125#1952769, @martong wrote:

It seems like we could model here emplace and emplace_after exactly the same way we do with insert and insert_after, couldn't we? Perhaps that could go into this patch too.

They are already in this patch (see the tests and the CallDescriptionMap), but they share their handing function with insert and insert_after.

Ok, I missed that.

[baloghadamsoftware]

Rebased.

[baloghadamsoftware]

Protection agains Unknown return values added.

clang/lib/StaticAnalyzer/Checkers/ContainerModeling.cpp

class ContainerModeling
   void handleAssignment(CheckerContext &C, SVal Cont, const Expr *CE = nullptr,
                         SVal OldCont = UndefinedVal()) const;
   void handleAssign(CheckerContext &C, SVal Cont, const Expr *ContE) const;
   void handleClear(CheckerContext &C, SVal Cont, const Expr *ContE) const;
   void handlePushBack(CheckerContext &C, SVal Cont, const Expr *ContE) const;
   void handlePopBack(CheckerContext &C, SVal Cont, const Expr *ContE) const;
   void handlePushFront(CheckerContext &C, SVal Cont, const Expr *ContE) const;
   void handlePopFront(CheckerContext &C, SVal Cont, const Expr *ContE) const;
-  void handleInsert(CheckerContext &C, SVal Cont, SVal Iter) const;
-  void handleErase(CheckerContext &C, SVal Cont, SVal Iter) const;
-  void handleErase(CheckerContext &C, SVal Cont, SVal Iter1, SVal Iter2) const;
-  void handleEraseAfter(CheckerContext &C, SVal Cont, SVal Iter) const;
+  void handleInsert(CheckerContext &C, SVal Cont, SVal Iter,
+                    SVal RetVal) const;
+  void handleInsertAfter(CheckerContext &C, SVal Cont, SVal Iter,
+                         SVal RetVal) const;
+  void handleErase(CheckerContext &C, SVal Cont, SVal Iter,
+                    SVal RetVal) const;
+  void handleErase(CheckerContext &C, SVal Cont, SVal Iter1, SVal Iter2,
+                    SVal RetVal) const;
+  void handleEraseAfter(CheckerContext &C, SVal Cont, SVal Iter,
+                        SVal RetVal) const;
   void handleEraseAfter(CheckerContext &C, SVal Cont, SVal Iter1,
-                        SVal Iter2) const;
+                        SVal Iter2, SVal RetVal) const;
   const NoteTag *getChangeTag(CheckerContext &C, StringRef Text,
                               const MemRegion *ContReg,
                               const Expr *ContE) const;
   void printState(raw_ostream &Out, ProgramStateRef State, const char *NL,
                   const char *Sep) const override;
 
 public:
   ContainerModeling() = default;
 
   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
   void checkLiveSymbols(ProgramStateRef State, SymbolReaper &SR) const;
   void checkDeadSymbols(SymbolReaper &SR, CheckerContext &C) const;
 
   using NoItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal,
                                                   const Expr *) const;
   using OneItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal,
-                                                   SVal) const;
+                                                   SVal, SVal) const;
   using TwoItParamFn = void (ContainerModeling::*)(CheckerContext &, SVal, SVal,
-                                                   SVal) const;
+                                                   SVal, SVal) const;
 
   CallDescriptionMap<NoItParamFn> NoIterParamFunctions = {
     {{0, "clear", 0},
      &ContainerModeling::handleClear},
     {{0, "assign", 2},
      &ContainerModeling::handleAssign},
     {{0, "push_back", 1},
      &ContainerModeling::handlePushBack},
     {{0, "emplace_back", 1},
      &ContainerModeling::handlePushBack},
     {{0, "pop_back", 0},
      &ContainerModeling::handlePopBack},
     {{0, "push_front", 1},
      &ContainerModeling::handlePushFront},
     {{0, "emplace_front", 1},
      &ContainerModeling::handlePushFront},
     {{0, "pop_front", 0},
      &ContainerModeling::handlePopFront},
   };
                                                           
   CallDescriptionMap<OneItParamFn> OneIterParamFunctions = {
     {{0, "insert", 2},
      &ContainerModeling::handleInsert},
+    {{0, "insert_after", 2},
+     &ContainerModeling::handleInsertAfter},
     {{0, "emplace", 2},
      &ContainerModeling::handleInsert},
+    {{0, "emplace_after", 2},
+     &ContainerModeling::handleInsertAfter},
     {{0, "erase", 1},
      &ContainerModeling::handleErase},
     {{0, "erase_after", 1},
      &ContainerModeling::handleEraseAfter},
   };
                                                           
   CallDescriptionMap<TwoItParamFn> TwoIterParamFunctions = {
     {{0, "erase", 2},
if (Op == OO_Equal) {
         return;
       }
 
       handleAssignment(C, InstCall->getCXXThisVal());
       return;
     }
   } else {
     if (const auto *InstCall = dyn_cast<CXXInstanceCall>(&Call)) {
+      const auto *OrigExpr = Call.getOriginExpr();
+      if (!OrigExpr)
+        return;
+
+      QualType RetType = Call.getResultType();
+      SVal RetVal = Call.getReturnValue();
+      if (isIteratorType(RetType) && RetVal.isUnknown()) {
+        ProgramStateRef State = C.getState();
+        auto &SymMgr = C.getSymbolManager();
+        auto *LCtx = C.getLocationContext();
+        SymbolRef RetSym = SymMgr.conjureSymbol(OrigExpr, LCtx, RetType,
+                                                C.blockCount());
+        if (RetType->getUnqualifiedDesugaredType()->isPointerType()) {
+          auto &RegMgr = C.getStoreManager().getRegionManager();
+          const MemRegion *RetReg = RegMgr.getSymbolicRegion(RetSym);
+          RetVal = loc::MemRegionVal(RetReg);
+        } else {
+          RetVal = nonloc::SymbolVal(RetSym);
+        }
+        State = State->BindExpr(OrigExpr, LCtx, RetVal);
+        C.addTransition(State);
+      }
+
       const NoItParamFn *Handler0 = NoIterParamFunctions.lookup(Call);
       if (Handler0) {
         (this->**Handler0)(C, InstCall->getCXXThisVal(),
                            InstCall->getCXXThisExpr());
         return;
       }
 
       const OneItParamFn *Handler1 = OneIterParamFunctions.lookup(Call);
       if (Handler1) {
-        (this->**Handler1)(C, InstCall->getCXXThisVal(), Call.getArgSVal(0));
+        (this->**Handler1)(C, InstCall->getCXXThisVal(), Call.getArgSVal(0),
+                           RetVal);
         return;
       }
 
       const TwoItParamFn *Handler2 = TwoIterParamFunctions.lookup(Call);
       if (Handler2) {
         (this->**Handler2)(C, InstCall->getCXXThisVal(), Call.getArgSVal(0),
-                           Call.getArgSVal(1));
+                           Call.getArgSVal(1), RetVal);
         return;
       }
 
-      const auto *OrigExpr = Call.getOriginExpr();
-      if (!OrigExpr)
-        return;
-
       if (isBeginCall(Func)) {
-        handleBegin(C, OrigExpr, Call.getReturnValue(),
-                    InstCall->getCXXThisVal());
+        handleBegin(C, OrigExpr, RetVal, InstCall->getCXXThisVal());
         return;
       }
 
       if (isEndCall(Func)) {
-        handleEnd(C, OrigExpr, Call.getReturnValue(),
-                  InstCall->getCXXThisVal());
+        handleEnd(C, OrigExpr, RetVal, InstCall->getCXXThisVal());
         return;
       }
     }
   }
 }
 
 void ContainerModeling::checkLiveSymbols(ProgramStateRef State,
                                          SymbolReaper &SR) const {
if (!CData)
     return;
 
   // For vector-like containers invalidate the past-end iterator positions
   if (const auto EndSym = CData->getEnd()) {
     if (hasSubscriptOperator(State, ContReg)) {
       State = invalidateIteratorPositions(State, EndSym, BO_GE);
     }
     auto &SymMgr = C.getSymbolManager();
-    auto &BVF = SymMgr.getBasicVals();
     auto &SVB = C.getSValBuilder();
     const auto newEndSym =
-      SVB.evalBinOp(State, BO_Add,
-                    nonloc::SymbolVal(EndSym),
-                    nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+      SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(EndSym),
+                    SVB.makeIntVal(1, false),
                     SymMgr.getType(EndSym)).getAsSymbol();
     const NoteTag *ChangeTag =
       getChangeTag(C, "extended to the back by 1 position", ContReg, ContE);
     State = setContainerData(State, ContReg, CData->newEnd(newEndSym));
     C.addTransition(State, ChangeTag);
   }
 }
 
 void ContainerModeling::handlePopBack(CheckerContext &C, SVal Cont,
                                       const Expr *ContE) const {
   const auto *ContReg = Cont.getAsRegion();
   if (!ContReg)
     return;
 
   ContReg = ContReg->getMostDerivedObjectRegion();
 
   auto State = C.getState();
   const auto CData = getContainerData(State, ContReg);
   if (!CData)
     return;
 
   if (const auto EndSym = CData->getEnd()) {
     auto &SymMgr = C.getSymbolManager();
-    auto &BVF = SymMgr.getBasicVals();
     auto &SVB = C.getSValBuilder();
     const auto BackSym =
-      SVB.evalBinOp(State, BO_Sub,
-                    nonloc::SymbolVal(EndSym),
-                    nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+      SVB.evalBinOp(State, BO_Sub, nonloc::SymbolVal(EndSym),
+                    SVB.makeIntVal(1, false),
                     SymMgr.getType(EndSym)).getAsSymbol();
     const NoteTag *ChangeTag =
       getChangeTag(C, "shrank from the back by 1 position", ContReg, ContE);
     // For vector-like and deque-like containers invalidate the last and the
     // past-end iterator positions. For list-like containers only invalidate
     // the last position
     if (hasSubscriptOperator(State, ContReg) &&
         backModifiable(State, ContReg)) {
if (hasSubscriptOperator(State, ContReg)) {
     C.addTransition(State);
   } else {
     const auto CData = getContainerData(State, ContReg);
     if (!CData)
       return;
 
     if (const auto BeginSym = CData->getBegin()) {
       auto &SymMgr = C.getSymbolManager();
-      auto &BVF = SymMgr.getBasicVals();
       auto &SVB = C.getSValBuilder();
       const auto newBeginSym =
-        SVB.evalBinOp(State, BO_Sub,
-                      nonloc::SymbolVal(BeginSym),
-                      nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+        SVB.evalBinOp(State, BO_Sub, nonloc::SymbolVal(BeginSym),
+                      SVB.makeIntVal(1, false),
                       SymMgr.getType(BeginSym)).getAsSymbol();
       const NoteTag *ChangeTag =
         getChangeTag(C, "extended to the front by 1 position", ContReg, ContE);
       State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
       C.addTransition(State, ChangeTag);
     }
   }
 }
void ContainerModeling::handlePopFront(CheckerContext &C, SVal Cont,
   // iterators only invalidate the first position
   if (const auto BeginSym = CData->getBegin()) {
     if (hasSubscriptOperator(State, ContReg)) {
       State = invalidateIteratorPositions(State, BeginSym, BO_LE);
     } else {
       State = invalidateIteratorPositions(State, BeginSym, BO_EQ);
     }
     auto &SymMgr = C.getSymbolManager();
-    auto &BVF = SymMgr.getBasicVals();
     auto &SVB = C.getSValBuilder();
     const auto newBeginSym =
-      SVB.evalBinOp(State, BO_Add,
-                    nonloc::SymbolVal(BeginSym),
-                    nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+      SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(BeginSym),
+                    SVB.makeIntVal(1, false),
                     SymMgr.getType(BeginSym)).getAsSymbol();
     const NoteTag *ChangeTag =
       getChangeTag(C, "shrank from the front by 1 position", ContReg, ContE);
     State = setContainerData(State, ContReg, CData->newBegin(newBeginSym));
     C.addTransition(State, ChangeTag);
   }
 }
 
 void ContainerModeling::handleInsert(CheckerContext &C, SVal Cont,
-                                     SVal Iter) const {
+                                     SVal Iter, SVal RetVal) const {
   const auto *ContReg = Cont.getAsRegion();
   if (!ContReg)
     return;
 
   ContReg = ContReg->getMostDerivedObjectRegion();
 
   auto State = C.getState();
   const auto *Pos = getIteratorPosition(State, Iter);
if (frontModifiable(State, ContReg)) {
       State = invalidateIteratorPositions(State, Pos->getOffset(), BO_GE);
     }
     if (const auto *CData = getContainerData(State, ContReg)) {
       if (const auto EndSym = CData->getEnd()) {
         State = invalidateIteratorPositions(State, EndSym, BO_GE);
         State = setContainerData(State, ContReg, CData->newEnd(nullptr));
       }
     }
-    C.addTransition(State);
-  }
+  }
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    auto RetPos =
+      IteratorPosition::getPosition(Pos->getContainer(), Pos->getOffset());
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
+
+void ContainerModeling::handleInsertAfter(CheckerContext &C, SVal Cont,
+                                     SVal Iter, SVal RetVal) const {
+  const auto *ContReg = Cont.getAsRegion();
+  if (!ContReg)
+    return;
+
+  ContReg = ContReg->getMostDerivedObjectRegion();
+
+  auto State = C.getState();
+  const auto *Pos = getIteratorPosition(State, Iter);
+  if (!Pos)
+    return;
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    auto &SymMgr = C.getSymbolManager();
+    auto &SVB = C.getSValBuilder();
+    const auto RetOffset =
+      SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(Pos->getOffset()),
+                    SVB.makeIntVal(1, false),
+                    SymMgr.getType(Pos->getOffset())).getAsSymbol();
+    auto RetPos = IteratorPosition::getPosition(Pos->getContainer(), RetOffset);
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
+  C.addTransition(State);
 }
 
 void ContainerModeling::handleErase(CheckerContext &C, SVal Cont,
-                                    SVal Iter) const {
+                                    SVal Iter, SVal RetVal) const {
   const auto *ContReg = Cont.getAsRegion();
   if (!ContReg)
     return;
 
   ContReg = ContReg->getMostDerivedObjectRegion();
 
   auto State = C.getState();
   const auto *Pos = getIteratorPosition(State, Iter);
if (const auto *CData = getContainerData(State, ContReg)) {
       if (const auto EndSym = CData->getEnd()) {
         State = invalidateIteratorPositions(State, EndSym, BO_GE);
         State = setContainerData(State, ContReg, CData->newEnd(nullptr));
       }
     }
   } else {
     State = invalidateIteratorPositions(State, Pos->getOffset(), BO_EQ);
   }
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    auto &SymMgr = C.getSymbolManager();
+    auto &SVB = C.getSValBuilder();
+    const auto RetOffset =
+      SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(Pos->getOffset()),
+                    SVB.makeIntVal(1, false),
+                    SymMgr.getType(Pos->getOffset())).getAsSymbol();
+    auto RetPos = IteratorPosition::getPosition(Pos->getContainer(), RetOffset);
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
   C.addTransition(State);
 }
 
 void ContainerModeling::handleErase(CheckerContext &C, SVal Cont, SVal Iter1,
-                                    SVal Iter2) const {
+                                    SVal Iter2, SVal RetVal) const {
   const auto *ContReg = Cont.getAsRegion();
   if (!ContReg)
     return;
 
   ContReg = ContReg->getMostDerivedObjectRegion();
   auto State = C.getState();
   const auto *Pos1 = getIteratorPosition(State, Iter1);
   const auto *Pos2 = getIteratorPosition(State, Iter2);
if (const auto *CData = getContainerData(State, ContReg)) {
         State = invalidateIteratorPositions(State, EndSym, BO_GE);
         State = setContainerData(State, ContReg, CData->newEnd(nullptr));
       }
     }
   } else {
     State = invalidateIteratorPositions(State, Pos1->getOffset(), BO_GE,
                                         Pos2->getOffset(), BO_LT);
   }
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    auto RetPos =
+      IteratorPosition::getPosition(Pos2->getContainer(), Pos2->getOffset());
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
   C.addTransition(State);
 }
 
 void ContainerModeling::handleEraseAfter(CheckerContext &C, SVal Cont,
-                                        SVal Iter) const {
+                                         SVal Iter, SVal RetVal) const {
   auto State = C.getState();
   const auto *Pos = getIteratorPosition(State, Iter);
   if (!Pos)
     return;
 
   // Invalidate the deleted iterator position, which is the position of the
   // parameter plus one.
   auto &SymMgr = C.getSymbolManager();
-  auto &BVF = SymMgr.getBasicVals();
   auto &SVB = C.getSValBuilder();
   const auto NextSym =
-    SVB.evalBinOp(State, BO_Add,
-                  nonloc::SymbolVal(Pos->getOffset()),
-                  nonloc::ConcreteInt(BVF.getValue(llvm::APSInt::get(1))),
+    SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(Pos->getOffset()),
+                  SVB.makeIntVal(1, false),
                   SymMgr.getType(Pos->getOffset())).getAsSymbol();
   State = invalidateIteratorPositions(State, NextSym, BO_EQ);
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    const auto RetOffset =
+      SVB.evalBinOp(State, BO_Add, nonloc::SymbolVal(NextSym),
+                    SVB.makeIntVal(1, false),
+                    SymMgr.getType(NextSym)).getAsSymbol();
+    auto RetPos = IteratorPosition::getPosition(Pos->getContainer(), RetOffset);
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
   C.addTransition(State);
 }
 
 void ContainerModeling::handleEraseAfter(CheckerContext &C, SVal Cont,
-                                         SVal Iter1, SVal Iter2) const {
+                                         SVal Iter1, SVal Iter2,
+                                         SVal RetVal) const {
   auto State = C.getState();
   const auto *Pos1 = getIteratorPosition(State, Iter1);
   const auto *Pos2 = getIteratorPosition(State, Iter2);
   if (!Pos1 || !Pos2)
     return;
 
   // Invalidate the deleted iterator position range (first..last)
   State = invalidateIteratorPositions(State, Pos1->getOffset(), BO_GT,
                                       Pos2->getOffset(), BO_LT);
+
+  // Set the return value
+  if (!RetVal.isUnknown()) {
+    auto RetPos =
+      IteratorPosition::getPosition(Pos2->getContainer(), Pos2->getOffset());
+    State = setIteratorPosition(State, RetVal, RetPos);
+  }
   C.addTransition(State);
 }
 
 const NoteTag *ContainerModeling::getChangeTag(CheckerContext &C,
                                                StringRef Text,
                                                const MemRegion *ContReg,
                                                const Expr *ContE) const {
   StringRef Name;

clang/lib/StaticAnalyzer/Checkers/Iterator.cpp

 
 #include "Iterator.h"
 
 namespace clang {
 namespace ento {
 namespace iterator {
 
 bool isIteratorType(const QualType &Type) {
-  if (Type->isPointerType())
+  if (Type->getUnqualifiedDesugaredType()->isPointerType())
     return true;
 
   const auto *CRD = Type->getUnqualifiedDesugaredType()->getAsCXXRecordDecl();
   return isIterator(CRD);
 }
 
 bool isIterator(const CXXRecordDecl *CRD) {
   if (!CRD)

clang/test/Analysis/Inputs/system-header-simulator-cxx.h

template <typename T, typename Ptr, typename Ref> struct __vector_iterator {
   bool operator==(const iterator &rhs) const { return ptr == rhs.ptr; }
   bool operator==(const const_iterator &rhs) const { return ptr == rhs.ptr; }
 
   bool operator!=(const iterator &rhs) const { return ptr != rhs.ptr; }
   bool operator!=(const const_iterator &rhs) const { return ptr != rhs.ptr; }
 
   const Ptr& base() const { return ptr; }
 
+  template <typename UT, typename UPtr, typename URef>
+  friend struct __vector_iterator;
+
 private:
   Ptr ptr;
 };
 
 template <typename T, typename Ptr, typename Ref> struct __deque_iterator {
   typedef __deque_iterator<T, T *, T &> iterator;
   typedef __deque_iterator<T, const T *, const T &> const_iterator;
 
template <typename T, typename Ptr, typename Ref> struct __deque_iterator {
   bool operator==(const iterator &rhs) const { return ptr == rhs.ptr; }
   bool operator==(const const_iterator &rhs) const { return ptr == rhs.ptr; }
 
   bool operator!=(const iterator &rhs) const { return ptr != rhs.ptr; }
   bool operator!=(const const_iterator &rhs) const { return ptr != rhs.ptr; }
 
   const Ptr& base() const { return ptr; }
 
+  template <typename UT, typename UPtr, typename URef>
+  friend struct __deque_iterator;
+
 private:
   Ptr ptr;
 };
 
 template <typename T, typename Ptr, typename Ref> struct __list_iterator {
   typedef __list_iterator<T, __typeof__(T::data) *, __typeof__(T::data) &> iterator;
   typedef __list_iterator<T, const __typeof__(T::data) *, const __typeof__(T::data) &> const_iterator;
 
__list_iterator<T, Ptr, Ref> operator--(int) {
     auto tmp = *this;
     item = item->prev;
     return tmp;
   }
 
   Ref operator*() const { return item->data; }
   Ptr operator->() const { return &item->data; }
 
-  bool operator==(const iterator &rhs) const { return item == rhs->item; }
-  bool operator==(const const_iterator &rhs) const { return item == rhs->item; }
+  bool operator==(const iterator &rhs) const { return item == rhs.item; }
+  bool operator==(const const_iterator &rhs) const { return item == rhs.item; }
 
-  bool operator!=(const iterator &rhs) const { return item != rhs->item; }
-  bool operator!=(const const_iterator &rhs) const { return item != rhs->item; }
+  bool operator!=(const iterator &rhs) const { return item != rhs.item; }
+  bool operator!=(const const_iterator &rhs) const { return item != rhs.item; }
 
   const T* &base() const { return item; }
 
   template <typename UT, typename UPtr, typename URef>
   friend struct __list_iterator;
 
 private:
   T* item;
template <typename T, typename Ptr, typename Ref> struct __fwdl_iterator {
   __fwdl_iterator<T, Ptr, Ref> operator++(int) {
     auto tmp = *this;
     item = item->next;
     return tmp;
   }
   Ref operator*() const { return item->data; }
   Ptr operator->() const { return &item->data; }
 
-  bool operator==(const iterator &rhs) const { return item == rhs->item; }
-  bool operator==(const const_iterator &rhs) const { return item == rhs->item; }
+  bool operator==(const iterator &rhs) const { return item == rhs.item; }
+  bool operator==(const const_iterator &rhs) const { return item == rhs.item; }
 
-  bool operator!=(const iterator &rhs) const { return item != rhs->item; }
-  bool operator!=(const const_iterator &rhs) const { return item != rhs->item; }
+  bool operator!=(const iterator &rhs) const { return item != rhs.item; }
+  bool operator!=(const const_iterator &rhs) const { return item != rhs.item; }
 
   const T* &base() const { return item; }
 
   template <typename UT, typename UPtr, typename URef>
   friend struct __fwdl_iterator;
 
 private:
   T* item;

clang/test/Analysis/diagnostics/explicit-suppression.cpp

class C {
   // The virtual function is to make C not trivially copy assignable so that we call the
   // variant of std::copy() that does not defer to memmove().
   virtual int f();
 };
 
 void testCopyNull(C *I, C *E) {
   std::copy(I, E, (C *)0);
 #ifndef SUPPRESSED
-  // expected-warning@../Inputs/system-header-simulator-cxx.h:699 {{Called C++ object pointer is null}}
+  // expected-warning@../Inputs/system-header-simulator-cxx.h:705 {{Called C++ object pointer is null}}
 #endif
 }

clang/test/Analysis/iterator-modeling.cpp

void list_insert_begin(std::list<int> &L, int n) {
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.begin()}}
 }
 
 void list_insert_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}} FIXME: Should be $L.begin() - 1
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.begin()}}
 }
 
 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1}}
 }
 
 void list_insert_ahead_of_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.end() - 1}}
 }
 
 void list_insert_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}} FIXME: should be $L.end() - 2
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$V.begin()}}
 }
 
 void vector_insert_behind_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() - 1
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); //expected-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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1}}
 }
 
 void vector_insert_ahead_of_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$V.end() - 1}}
 }
 
 void vector_insert_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}} FIXME: Should be $V.end() - 2
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$V.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$D.begin()}}
 }
 
 void deque_insert_behind_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1}}
 }
 
 void deque_insert_ahead_of_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$D.end() - 1}}
 }
 
 void deque_insert_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$D.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.begin() + 1}}
 }
 
 void forward_list_insert_after_behind_begin(std::forward_list<int> &FL, int n) {
   auto i0 = FL.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$FL.begin() + 2}}
 }
 
 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 1}}
 }
 
 /// 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
void list_emplace_begin(std::list<int> &L, int n) {
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.begin()}}
 }
 
 void list_emplace_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}} FIXME: Should be $L.begin() - 1
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.begin() + 1}}
 }
 
 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i}}
 }
 
 void list_emplace_ahead_of_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.end() - 1}}
 }
 
 void list_emplace_end(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}} FIXME: should be $L.end() - 2
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$V.begin()}}
 }
 
 void vector_emplace_behind_begin(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() - 1
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // // expected-warning{{$V.begin() + 1}}
 }
 
 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1}}
 }
 
 void vector_emplace_ahead_of_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$V.end() - 1}}
 }
 
 void vector_emplace_end(std::vector<int> &V, int n) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}} FIXME: Should be $V.end() - 2
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$V.end() - 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$V.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$D.begin()}}
 }
 
 void deque_emplace_behind_begin(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1}}
 }
 
 void deque_emplace_ahead_of_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$D.end() - 1}}
 }
 
 void deque_emplace_end(std::deque<int> &D, int n) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$D.end()}}
 }
 
 /// 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.begin() + 1}}
 }
 
 void forward_list_emplace_after_behind_begin(std::forward_list<int> &FL,
                                              int n) {
   auto i0 = FL.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$FL.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$FL.begin() + 2}}
 }
 
 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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 1}}
 }
 
 /// 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
void list_erase_begin(std::list<int> &L) {
   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_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$L.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.begin() + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
 }
 
 void list_erase_behind_begin(std::list<int> &L, int n) {
   auto i0 = L.cbegin(), i1 = ++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()");
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}} FIXME: Should be $L.begin() + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$L.begin() + 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
 }
 
 void list_erase_ahead_of_end(std::list<int> &L) {
   auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end()
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$L.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$L.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() + 1
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}} FIXME: Should be $V.begin() + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 1}}
 }
 
 void vector_erase_ahead_of_end(std::vector<int> &V) {
   auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}
-  // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end()
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$V.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 2
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 1
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 1}}
 }
 
 void deque_erase_ahead_of_end(std::deque<int> &D) {
   auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();
 
   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_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end()
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-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,
void forward_list_erase_after_begin(std::forward_list<int> &FL) {
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$FL.begin() + 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i4)); // expected-warning{{$FL.begin() + 2}}
 }
 
 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;
   ++i3;
   ++i3;
 
   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_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}
-  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning-re {{$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(){{$}}}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning{{$FL.begin()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$i1}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning{{$i1 + 2}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i4)); // expected-warning{{$FL.end()}}
+  clang_analyzer_express(clang_analyzer_iterator_position(i5)); // expected-warning{{$i1 + 2}}
 }
 
 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,