2053 lines · cpp
1// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify -analyzer-config display-checker-name=false2 3// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify -analyzer-config display-checker-name=false4 5// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 -DSTD_ADVANCE_INLINE_LEVEL=0 %s -verify -analyzer-config display-checker-name=false6 7// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 -DSTD_ADVANCE_INLINE_LEVEL=1 %s -verify -analyzer-config display-checker-name=false8 9// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,debug.DebugIteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 -DSTD_ADVANCE_INLINE_LEVEL=2 %s -verify -analyzer-config display-checker-name=false10 11// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorModeling,debug.ExprInspection -analyzer-config aggressive-binary-operation-simplification=true %s 2>&1 | FileCheck %s12 13#include "Inputs/system-header-simulator-cxx.h"14 15template <typename Container>16long clang_analyzer_container_begin(const Container&);17template <typename Container>18long clang_analyzer_container_end(const Container&);19template <typename Iterator>20long clang_analyzer_iterator_position(const Iterator&);21long clang_analyzer_iterator_position(int*);22template <typename Iterator>23void* clang_analyzer_iterator_container(const Iterator&);24template <typename Iterator>25bool clang_analyzer_iterator_validity(const Iterator&);26 27void clang_analyzer_denote(long, const char*);28void clang_analyzer_express(long);29void clang_analyzer_eval(bool);30void clang_analyzer_warnIfReached();31 32void begin(const std::vector<int> &v) {33 auto i = v.begin();34 35 clang_analyzer_eval(clang_analyzer_iterator_container(i) == &v); // expected-warning{{TRUE}}36 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");37 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin(){{$}}}}38 39 if (i != v.begin()) {40 clang_analyzer_warnIfReached();41 }42}43 44void end(const std::vector<int> &v) {45 auto i = v.end();46 47 clang_analyzer_eval(clang_analyzer_iterator_container(i) == &v); // expected-warning{{TRUE}}48 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");49 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end(){{$}}}}50 51 if (i != v.end()) {52 clang_analyzer_warnIfReached();53 }54}55 56void prefix_increment(const std::vector<int> &v) {57 auto i = v.begin();58 59 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");60 61 auto j = ++i;62 63 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}64 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin() + 1{{$}}}}65}66 67void prefix_decrement(const std::vector<int> &v) {68 auto i = v.end();69 70 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");71 72 auto j = --i;73 74 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}75 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end() - 1{{$}}}}76}77 78void postfix_increment(const std::vector<int> &v) {79 auto i = v.begin();80 81 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");82 83 auto j = i++;84 85 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}86 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin(){{$}}}}87}88 89void postfix_decrement(const std::vector<int> &v) {90 auto i = v.end();91 92 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");93 94 auto j = i--;95 96 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}97 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end(){{$}}}}98}99 100void plus_equal(const std::vector<int> &v) {101 auto i = v.begin();102 103 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");104 105 i += 2;106 107 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 2{{$}}}}108}109 110void plus_equal_negative(const std::vector<int> &v) {111 auto i = v.end();112 113 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");114 115 i += -2;116 117 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 2{{$}}}}118}119 120void minus_equal(const std::vector<int> &v) {121 auto i = v.end();122 123 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");124 125 i -= 2;126 127 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 2{{$}}}}128}129 130void minus_equal_negative(const std::vector<int> &v) {131 auto i = v.begin();132 133 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");134 135 i -= -2;136 137 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 2{{$}}}}138}139 140void copy(const std::vector<int> &v) {141 auto i1 = v.end();142 143 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");144 145 auto i2 = i1;146 147 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}148 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}149 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end(){{$}}}}150}151 152void plus_lhs(const std::vector<int> &v) {153 auto i1 = v.begin();154 155 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");156 157 auto i2 = i1 + 2;158 159 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}160 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re{{$v.begin(){{$}}}}161 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re{{$v.begin() + 2{{$}}}}162}163 164void plus_rhs(const std::vector<int> &v) {165 auto i1 = v.begin();166 167 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");168 169 auto i2 = 2 + i1;170 171 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}172 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re{{$v.begin(){{$}}}}173 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re{{$v.begin() + 2{{$}}}}174}175 176void plus_lhs_negative(const std::vector<int> &v) {177 auto i1 = v.end();178 179 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");180 181 auto i2 = i1 + (-2);182 183 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}184 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}185 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end() - 2{{$}}}}186}187 188void plus_rhs_negative(const std::vector<int> &v) {189 auto i1 = v.end();190 191 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");192 193 auto i2 = (-2) + i1;194 195 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}196 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}197 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end() - 2{{$}}}}198}199 200void minus(const std::vector<int> &v) {201 auto i1 = v.end();202 203 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");204 205 auto i2 = i1 - 2;206 207 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}208 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}209 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end() - 2{{$}}}}210}211 212void minus_negative(const std::vector<int> &v) {213 auto i1 = v.begin();214 215 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");216 217 auto i2 = i1 - (-2);218 219 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &v); // expected-warning{{TRUE}}220 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.begin(){{$}}}}221 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.begin() + 2{{$}}}}222}223 224void copy_and_increment1(const std::vector<int> &v) {225 auto i1 = v.begin();226 227 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");228 229 auto i2 = i1;230 ++i1;231 232 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.begin() + 1{{$}}}}233 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.begin(){{$}}}}234}235 236void copy_and_increment2(const std::vector<int> &v) {237 auto i1 = v.begin();238 239 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");240 241 auto i2 = i1;242 ++i2;243 244 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.begin(){{$}}}}245 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.begin() + 1{{$}}}}246}247 248void copy_and_decrement1(const std::vector<int> &v) {249 auto i1 = v.end();250 251 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");252 253 auto i2 = i1;254 --i1;255 256 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end() - 1{{$}}}}257 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end(){{$}}}}258}259 260void copy_and_decrement2(const std::vector<int> &v) {261 auto i1 = v.end();262 263 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");264 265 auto i2 = i1;266 --i2;267 268 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$v.end(){{$}}}}269 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$v.end() - 1{{$}}}}270}271 272/// std::advance(), std::prev(), std::next()273 274void std_advance_minus(const std::vector<int> &v) {275 auto i = v.end();276 277 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");278 279 std::advance(i, -1);280 281 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.end() - 1{{$}}}}282}283 284void std_advance_plus(const std::vector<int> &v) {285 auto i = v.begin();286 287 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");288 289 std::advance(i, 1);290 291 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning-re {{$v.begin() + 1{{$}}}}292}293 294void std_prev(const std::vector<int> &v) {295 auto i = v.end();296 297 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");298 299 auto j = std::prev(i);300 301 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end() - 1{{$}}}}302}303 304void std_prev2(const std::vector<int> &v) {305 auto i = v.end();306 307 clang_analyzer_denote(clang_analyzer_container_end(v), "$v.end()");308 309 auto j = std::prev(i, 2);310 311 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.end() - 2{{$}}}}312}313 314void std_next(const std::vector<int> &v) {315 auto i = v.begin();316 317 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");318 319 auto j = std::next(i);320 321 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin() + 1{{$}}}}322}323 324void std_next2(const std::vector<int> &v) {325 auto i = v.begin();326 327 clang_analyzer_denote(clang_analyzer_container_begin(v), "$v.begin()");328 329 auto j = std::next(i, 2);330 331 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning-re {{$v.begin() + 2{{$}}}}332}333 334////////////////////////////////////////////////////////////////////////////////335///336/// C O N T A I N E R A S S I G N M E N T S337///338////////////////////////////////////////////////////////////////////////////////339 340// Copy341 342void list_copy_assignment(std::list<int> &L1, const std::list<int> &L2) {343 auto i0 = L1.cbegin();344 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}345 L1 = L2;346 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}347}348 349void vector_copy_assignment(std::vector<int> &V1, const std::vector<int> &V2) {350 auto i0 = V1.cbegin();351 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}352 V1 = V2;353 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}354}355 356void deque_copy_assignment(std::deque<int> &D1, const std::deque<int> &D2) {357 auto i0 = D1.cbegin();358 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}359 D1 = D2;360 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}361}362 363void forward_list_copy_assignment(std::forward_list<int> &FL1,364 const std::forward_list<int> &FL2) {365 auto i0 = FL1.cbegin();366 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}367 FL1 = FL2;368 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}369}370 371// Move372 373void list_move_assignment(std::list<int> &L1, std::list<int> &L2) {374 auto i0 = L1.cbegin(), i1 = L2.cbegin(), i2 = --L2.cend(), i3 = L2.cend();375 376 clang_analyzer_denote(clang_analyzer_container_begin(L2), "$L2.begin()");377 clang_analyzer_denote(clang_analyzer_container_end(L2), "$L2.end()");378 379 L1 = std::move(L2);380 381 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}382 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}383 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}384 clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.385 386 clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &L1); // expected-warning{{TRUE}}387 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &L1); // expected-warning{{TRUE}}388 389 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L2.begin(){{$}}}}390}391 392void vector_move_assignment(std::vector<int> &V1, std::vector<int> &V2) {393 auto i0 = V1.cbegin(), i1 = V2.cbegin(), i2 = --V2.cend(), i3 = V2.cend();394 395 clang_analyzer_denote(clang_analyzer_container_begin(V2), "$V2.begin()");396 397 V1 = std::move(V2);398 399 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}400 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}401 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}402 clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.403 404 clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &V1); // expected-warning{{TRUE}}405 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &V1); // expected-warning{{TRUE}}406 407 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V2.begin(){{$}}}}408}409 410void deque_move_assignment(std::deque<int> &D1, std::deque<int> &D2) {411 auto i0 = D1.cbegin(), i1 = D2.cbegin(), i2 = --D2.cend(), i3 = D2.cend();412 413 clang_analyzer_denote(clang_analyzer_container_begin(D2), "$D2.begin()");414 415 D1 = std::move(D2);416 417 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}418 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}419 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}420 clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}} FIXME: Should be FALSE.421 422 clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &D1); // expected-warning{{TRUE}}423 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &D1); // expected-warning{{TRUE}}424 425 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$D2.begin(){{$}}}}426}427 428void forward_list_move_assignment(std::forward_list<int> &FL1,429 std::forward_list<int> &FL2) {430 auto i0 = FL1.cbegin(), i1 = FL2.cbegin(), i2 = FL2.cend();431 432 clang_analyzer_denote(clang_analyzer_container_begin(FL2), "$FL2.begin()");433 434 FL1 = std::move(FL2);435 436 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}437 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}438 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}} FIXME: Should be FALSE.439 440 clang_analyzer_eval(clang_analyzer_iterator_container(i1) == &FL1); // expected-warning{{TRUE}}441 442 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL2.begin(){{$}}}}443}444 445 446////////////////////////////////////////////////////////////////////////////////447///448/// C O N T A I N E R M O D I F I E R S449///450////////////////////////////////////////////////////////////////////////////////451 452/// assign()453///454/// - Invalidates all iterators, including the past-the-end iterator for all455/// container types.456 457void list_assign(std::list<int> &L, int n) {458 auto i0 = L.cbegin(), i1 = L.cend();459 L.assign(10, n);460 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}461 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}462}463 464void vector_assign(std::vector<int> &V, int n) {465 auto i0 = V.cbegin(), i1 = V.cend();466 V.assign(10, n);467 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}468 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}469}470 471void deque_assign(std::deque<int> &D, int n) {472 auto i0 = D.cbegin(), i1 = D.cend();473 D.assign(10, n);474 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}475 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}476}477 478void forward_list_assign(std::forward_list<int> &FL, int n) {479 auto i0 = FL.cbegin(), i1 = FL.cend();480 FL.assign(10, n);481 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}482 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}483}484 485/// clear()486///487/// - Invalidates all iterators, including the past-the-end iterator for all488/// container types.489 490void list_clear(std::list<int> &L) {491 auto i0 = L.cbegin(), i1 = L.cend();492 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}493 L.clear();494 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}495}496 497void vector_clear(std::vector<int> &V) {498 auto i0 = V.cbegin(), i1 = V.cend();499 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}500 V.clear();501 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}502}503 504void deque_clear(std::deque<int> &D) {505 auto i0 = D.cbegin(), i1 = D.cend();506 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}507 D.clear();508 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}509}510 511void forward_list_clear(std::forward_list<int> &FL) {512 auto i0 = FL.cbegin(), i1 = FL.cend();513 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}514 FL.clear();515 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}516}517 518/// push_back()519///520/// - Design decision: extends containers to the ->RIGHT-> (i.e. the521/// past-the-end position of the container is incremented).522///523/// - Iterator invalidation rules depend the container type.524 525/// std::list-like containers: No iterators are invalidated.526 527void list_push_back(std::list<int> &L, int n) {528 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();529 530 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");531 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");532 533 L.push_back(n);534 535 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}536 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}537 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}538 539 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}540 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}541 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}} FIXME: Should be $L.end() + 1542}543 544/// std::vector-like containers: The past-the-end iterator is invalidated.545 546void vector_push_back(std::vector<int> &V, int n) {547 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();548 549 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");550 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");551 552 V.push_back(n);553 554 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}555 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}556 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}557 558 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}559 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}}560}561 562/// std::deque-like containers: All iterators, including the past-the-end563/// iterator, are invalidated.564 565void deque_push_back(std::deque<int> &D, int n) {566 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();567 568 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");569 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");570 571 D.push_back(n);572 573 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}574 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}575 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}576}577 578/// emplace_back()579///580/// - Design decision: extends containers to the ->RIGHT-> (i.e. the581/// past-the-end position of the container is incremented).582///583/// - Iterator invalidation rules depend the container type.584 585/// std::list-like containers: No iterators are invalidated.586 587void list_emplace_back(std::list<int> &L, int n) {588 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();589 590 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");591 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");592 593 L.emplace_back(n);594 595 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}596 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}597 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}598 599 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}600 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}601 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}} FIXME: Should be $L.end() + 1602}603 604/// std::vector-like containers: The past-the-end iterator is invalidated.605 606void vector_emplace_back(std::vector<int> &V, int n) {607 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();608 609 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");610 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");611 612 V.emplace_back(n);613 614 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}615 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}616 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}617 618 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}619 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}}620}621 622/// std::deque-like containers: All iterators, including the past-the-end623/// iterator, are invalidated.624 625void deque_emplace_back(std::deque<int> &D, int n) {626 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();627 628 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");629 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");630 631 D.emplace_back(n);632 633 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}634 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}635 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}636}637 638/// pop_back()639///640/// - Design decision: shrinks containers to the <-LEFT<- (i.e. the641/// past-the-end position of the container is decremented).642///643/// - Iterator invalidation rules depend the container type.644 645/// std::list-like containers: Iterators to the last element are invalidated.646 647void list_pop_back(std::list<int> &L, int n) {648 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();649 650 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");651 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");652 653 L.pop_back();654 655 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}656 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}657 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}658 659 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}660 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}} FIXME: Should be $L.end() - 1661}662 663/// std::vector-like containers: Iterators to the last element, as well as the664/// past-the-end iterator, are invalidated.665 666void vector_pop_back(std::vector<int> &V, int n) {667 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();668 669 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");670 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");671 672 V.pop_back();673 674 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}675 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}676 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}677 678 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}679}680 681/// std::deque-like containers: Iterators to the last element are invalidated.682/// The past-the-end iterator is also invalidated.683/// Other iterators are not affected.684 685void deque_pop_back(std::deque<int> &D, int n) {686 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();687 688 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");689 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");690 691 D.pop_back();692 693 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}694 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}695 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}696 697 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$D.begin(){{$}}}}698}699 700/// push_front()701///702/// - Design decision: extends containers to the <-LEFT<- (i.e. the first703/// position of the container is decremented).704///705/// - Iterator invalidation rules depend the container type.706 707/// std::list-like containers: No iterators are invalidated.708 709void list_push_front(std::list<int> &L, int n) {710 auto i0 = L.cbegin(), i1 = L.cend();711 712 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");713 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");714 715 L.push_front(n);716 717 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}718 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}719 720 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}721 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end(){{$}}}}722}723 724/// std::deque-like containers: All iterators, including the past-the-end725/// iterator, are invalidated.726 727void deque_push_front(std::deque<int> &D, int n) {728 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();729 730 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");731 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");732 733 D.push_front(n);734 735 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}736 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}737 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}738}739 740/// std::forward_list-like containers: No iterators are invalidated.741 742void forward_list_push_front(std::forward_list<int> &FL, int n) {743 auto i0 = FL.cbegin(), i1 = FL.cend();744 745 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");746 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");747 748 FL.push_front(n);749 750 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}751 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}752 753 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}754 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.end(){{$}}}}755}756 757/// emplace_front()758///759/// - Design decision: extends containers to the <-LEFT<- (i.e. the first760/// position of the container is decremented).761///762/// - Iterator invalidation rules depend the container type.763 764/// std::list-like containers: No iterators are invalidated.765 766void list_emplace_front(std::list<int> &L, int n) {767 auto i0 = L.cbegin(), i1 = L.cend();768 769 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");770 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");771 772 L.emplace_front(n);773 774 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}775 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}776 777 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}778 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end(){{$}}}}779}780 781/// std::deque-like containers: All iterators, including the past-the-end782/// iterator, are invalidated.783 784void deque_emplace_front(std::deque<int> &D, int n) {785 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();786 787 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");788 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");789 790 D.emplace_front(n);791 792 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}793 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}794 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}795}796 797/// std::forward_list-like containers: No iterators are invalidated.798 799void forward_list_emplace_front(std::forward_list<int> &FL, int n) {800 auto i0 = FL.cbegin(), i1 = FL.cend();801 802 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");803 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");804 805 FL.emplace_front(n);806 807 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}808 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}809 810 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}811 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.end(){{$}}}}812}813 814/// pop_front()815///816/// - Design decision: shrinks containers to the ->RIGHT-> (i.e. the first817/// position of the container is incremented).818///819/// - Iterator invalidation rules depend the container type.820 821/// std::list-like containers: Iterators to the first element are invalidated.822 823void list_pop_front(std::list<int> &L, int n) {824 auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();825 826 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");827 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");828 829 L.pop_front();830 831 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}832 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}833 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}834 835 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.begin() + 1{{$}}}}836 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}837}838 839/// std::deque-like containers: Iterators to the first element are invalidated.840/// Other iterators are not affected.841 842void deque_pop_front(std::deque<int> &D, int n) {843 auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();844 845 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");846 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");847 848 D.pop_front();849 850 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}851 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}852 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}853 854 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$D.begin() + 1{{$}}}}855 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$D.end(){{$}}}}856}857 858/// std::forward_list-like containers: Iterators to the first element are859/// invalidated.860 861void forward_list_pop_front(std::list<int> &FL, int n) {862 auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();863 864 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");865 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");866 867 FL.pop_front();868 869 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}870 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}871 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}872 873 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.begin() + 1{{$}}}}874 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.end(){{$}}}}875}876 877/// insert()878///879/// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator880/// ahead of the insertion point are decremented; if the881/// relation between the insertion point and the first882/// position of the container is known, the first position883/// of the container is also decremented).884///885/// - Iterator invalidation rules depend the container type.886 887/// std::list-like containers: No iterators are invalidated.888 889void list_insert_begin(std::list<int> &L, int n) {890 auto i0 = L.cbegin(), i1 = L.cend();891 892 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");893 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");894 895 auto i2 = L.insert(i0, n);896 897 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}898 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}899 900 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}901 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $L.begin() - 1902 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end(){{$}}}}903}904 905void list_insert_behind_begin(std::list<int> &L, int n) {906 auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();907 908 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");909 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");910 911 auto i3 = L.insert(i1, n);912 913 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}914 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}915 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}916 917 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}} FIXME: Should be $L.begin() - 1918 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.begin() + 1{{$}}}}919 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin()920 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}921}922 923template <typename Iter> Iter return_any_iterator(const Iter &It);924 925void list_insert_unknown(std::list<int> &L, int n) {926 auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();927 928 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");929 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");930 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");931 932 auto i3 = L.insert(i1, n);933 934 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}935 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}936 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}937 938 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}939 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}940 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i - 1941 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}942}943 944void list_insert_ahead_of_end(std::list<int> &L, int n) {945 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();946 947 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");948 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");949 950 auto i3 = L.insert(i1, n);951 952 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}953 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}954 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}955 956 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}957 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}958 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}959 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 2960}961 962void list_insert_end(std::list<int> &L, int n) {963 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();964 965 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");966 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");967 968 auto i3 = L.insert(i2, n);969 970 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}971 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}972 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}973 974 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}975 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}} FIXME: should be $L.end() - 2976 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}977 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 1978}979 980/// std::vector-like containers: Only the iterators before the insertion point981/// remain valid. The past-the-end iterator is also982/// invalidated.983 984void vector_insert_begin(std::vector<int> &V, int n) {985 auto i0 = V.cbegin(), i1 = V.cend();986 987 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");988 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");989 990 auto i2 = V.insert(i0, n);991 992 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}993 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}994 995 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 1996}997 998void vector_insert_behind_begin(std::vector<int> &V, int n) {999 auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();1000 1001 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1002 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1003 1004 auto i3 = V.insert(i1, n);1005 1006 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1007 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1008 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1009 1010 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() - 11011 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()1012}1013 1014void vector_insert_unknown(std::vector<int> &V, int n) {1015 auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();1016 1017 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1018 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1019 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1020 1021 auto i3 = V.insert(i1, n);1022 1023 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1024 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1025 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1026 1027 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1028 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 11029}1030 1031void vector_insert_ahead_of_end(std::vector<int> &V, int n) {1032 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();1033 1034 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1035 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1036 1037 auto i3 = V.insert(i1, n);1038 1039 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1040 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1041 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1042 1043 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1044 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 21045}1046 1047void vector_insert_end(std::vector<int> &V, int n) {1048 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();1049 1050 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1051 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1052 1053 auto i3 = V.insert(i2, n);1054 1055 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1056 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1057 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1058 1059 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1060 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}} FIXME: Should be $V.end() - 21061 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 11062}1063 1064/// std::deque-like containers: All iterators, including the past-the-end1065/// iterator, are invalidated.1066 1067void deque_insert_begin(std::deque<int> &D, int n) {1068 auto i0 = D.cbegin(), i1 = D.cend();1069 1070 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1071 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1072 1073 auto i2 = D.insert(i0, n);1074 1075 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1076 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1077 1078 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 11079}1080 1081void deque_insert_behind_begin(std::deque<int> &D, int n) {1082 auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();1083 1084 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1085 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1086 1087 auto i3 = D.insert(i1, n);1088 1089 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1090 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1091 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1092 1093 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 11094}1095 1096void deque_insert_unknown(std::deque<int> &D, int n) {1097 auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();1098 1099 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1100 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1101 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1102 1103 auto i3 = D.insert(i1, n);1104 1105 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1106 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1107 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1108 1109 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 11110}1111 1112void deque_insert_ahead_of_end(std::deque<int> &D, int n) {1113 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();1114 1115 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1116 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1117 1118 auto i3 = D.insert(i1, n);1119 1120 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1121 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1122 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1123 1124 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 21125}1126 1127void deque_insert_end(std::deque<int> &D, int n) {1128 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();1129 1130 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1131 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1132 1133 auto i3 = D.insert(i2, n);1134 1135 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1136 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1137 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1138 1139 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 11140}1141 1142/// insert_after() [std::forward_list-like containers]1143///1144/// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator1145/// ahead of the insertion point are incremented; if the1146/// relation between the insertion point and the past-the-end1147/// position of the container is known, the first position of1148/// the container is also incremented).1149///1150/// - No iterators are invalidated.1151 1152void forward_list_insert_after_begin(std::forward_list<int> &FL, int n) {1153 auto i0 = FL.cbegin(), i1 = FL.cend();1154 1155 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1156 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1157 1158 auto i2 = FL.insert_after(i0, n);1159 1160 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1161 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1162 1163 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1164 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $FL.begin() + 11165 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.end(){{$}}}}1166}1167 1168void forward_list_insert_after_behind_begin(std::forward_list<int> &FL, int n) {1169 auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();1170 1171 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1172 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1173 1174 auto i3 = FL.insert_after(i1, n);1175 1176 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1177 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1178 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1179 1180 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1181 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.begin() + 1{{$}}}}1182 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $FL.begin() + 21183 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.end(){{$}}}}1184}1185 1186void forward_list_insert_after_unknown(std::forward_list<int> &FL, int n) {1187 auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = FL.cend();1188 1189 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1190 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1191 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1192 1193 auto i3 = FL.insert_after(i1, n);1194 1195 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1196 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1197 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1198 1199 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1200 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}1201 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 11202 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.end(){{$}}}}1203}1204 1205/// emplace()1206///1207/// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator1208/// ahead of the emplacement point are decremented; if the1209/// relation between the emplacement point and the first1210/// position of the container is known, the first position1211/// of the container is also decremented).1212///1213/// - Iterator invalidation rules depend the container type.1214 1215/// std::list-like containers: No iterators are invalidated.1216 1217void list_emplace_begin(std::list<int> &L, int n) {1218 auto i0 = L.cbegin(), i1 = L.cend();1219 1220 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1221 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1222 1223 auto i2 = L.emplace(i0, n);1224 1225 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1226 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1227 1228 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1229 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $L.begin() - 11230 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end(){{$}}}}1231}1232 1233void list_emplace_behind_begin(std::list<int> &L, int n) {1234 auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();1235 1236 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1237 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1238 1239 auto i3 = L.emplace(i1, n);1240 1241 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1242 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1243 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1244 1245 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}} FIXME: Should be $L.begin() - 11246 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.begin() + 1{{$}}}}1247 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin()1248 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1249}1250 1251template <typename Iter> Iter return_any_iterator(const Iter &It);1252 1253void list_emplace_unknown(std::list<int> &L, int n) {1254 auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();1255 1256 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1257 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1258 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1259 1260 auto i3 = L.emplace(i1, n);1261 1262 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1263 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1264 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1265 1266 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1267 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}1268 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i - 11269 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1270}1271 1272void list_emplace_ahead_of_end(std::list<int> &L, int n) {1273 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();1274 1275 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1276 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1277 1278 auto i3 = L.emplace(i1, n);1279 1280 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1281 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1282 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1283 1284 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1285 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}}1286 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1287 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 21288}1289 1290void list_emplace_end(std::list<int> &L, int n) {1291 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();1292 1293 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1294 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1295 1296 auto i3 = L.emplace(i2, n);1297 1298 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1299 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1300 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1301 1302 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1303 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.end() - 1{{$}}}} FIXME: should be $L.end() - 21304 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1305 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end() - 11306}1307 1308/// std::vector-like containers: Only the iterators before the emplacement point1309/// remain valid. The past-the-end iterator is also1310/// invalidated.1311 1312void vector_emplace_begin(std::vector<int> &V, int n) {1313 auto i0 = V.cbegin(), i1 = V.cend();1314 1315 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1316 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1317 1318 auto i2 = V.emplace(i0, n);1319 1320 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1321 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1322 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $V.begin() - 11323}1324 1325void vector_emplace_behind_begin(std::vector<int> &V, int n) {1326 auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();1327 1328 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1329 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1330 1331 auto i3 = V.emplace(i1, n);1332 1333 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1334 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1335 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1336 1337 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() - 11338 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); // FIXME: expect -warning $V.begin()1339}1340 1341void vector_emplace_unknown(std::vector<int> &V, int n) {1342 auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();1343 1344 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1345 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1346 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1347 1348 auto i3 = V.emplace(i1, n);1349 1350 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1351 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1352 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1353 1354 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1355 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expecte warning $i1 - 11356}1357 1358void vector_emplace_ahead_of_end(std::vector<int> &V, int n) {1359 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();1360 1361 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1362 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1363 1364 auto i3 = V.emplace(i1, n);1365 1366 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1367 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1368 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1369 1370 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1371 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 21372}1373 1374void vector_emplace_end(std::vector<int> &V, int n) {1375 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();1376 1377 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1378 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1379 1380 auto i3 = V.emplace(i2, n);1381 1382 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1383 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1384 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1385 1386 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1387 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$V.end() - 1{{$}}}} FIXME: Should be $V.end() - 21388 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end() - 11389}1390 1391/// std::deque-like containers: All iterators, including the past-the-end1392/// iterator, are invalidated.1393 1394void deque_emplace_begin(std::deque<int> &D, int n) {1395 auto i0 = D.cbegin(), i1 = D.cend();1396 1397 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1398 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1399 1400 auto i2 = D.emplace(i0, n);1401 1402 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1403 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1404 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $D.begin() - 11405}1406 1407void deque_emplace_behind_begin(std::deque<int> &D, int n) {1408 auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();1409 1410 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1411 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1412 1413 auto i3 = D.emplace(i1, n);1414 1415 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1416 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1417 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1418 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() - 11419}1420 1421void deque_emplace_unknown(std::deque<int> &D, int n) {1422 auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();1423 1424 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1425 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1426 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1427 1428 auto i3 = D.emplace(i1, n);1429 1430 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1431 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1432 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1433 1434 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 - 11435}1436 1437void deque_emplace_ahead_of_end(std::deque<int> &D, int n) {1438 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();1439 1440 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1441 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1442 1443 auto i3 = D.emplace(i1, n);1444 1445 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1446 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1447 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1448 1449 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 21450}1451 1452void deque_emplace_end(std::deque<int> &D, int n) {1453 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();1454 1455 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1456 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1457 1458 auto i3 = D.emplace(i2, n);1459 1460 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1461 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1462 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1463 1464 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end() - 11465}1466 1467/// emplace_after() [std::forward_list-like containers]1468///1469/// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator1470/// ahead of the emplacement point are incremented; if the1471/// relation between the emplacement point and the1472/// past-the-end position of the container is known, the1473/// first position of the container is also incremented).1474///1475/// - No iterators are invalidated.1476 1477void forward_list_emplace_after_begin(std::forward_list<int> &FL, int n) {1478 auto i0 = FL.cbegin(), i1 = FL.cend();1479 1480 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1481 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1482 1483 auto i2 = FL.emplace_after(i0, n);1484 1485 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1486 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1487 1488 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1489 // clang_analyzer_express(clang_analyzer_iterator_position(i2)); FIXME: expect warning $FL.begin() + 11490 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.end(){{$}}}}1491}1492 1493void forward_list_emplace_after_behind_begin(std::forward_list<int> &FL,1494 int n) {1495 auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = FL.cend();1496 1497 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1498 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1499 1500 auto i3 = FL.emplace_after(i1, n);1501 1502 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1503 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1504 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1505 1506 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1507 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$FL.begin() + 1{{$}}}}1508 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $FL.begin() + 21509 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.end(){{$}}}}1510}1511 1512void forward_list_emplace_after_unknown(std::forward_list<int> &FL, int n) {1513 auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = FL.cend();1514 1515 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1516 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1517 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1518 1519 auto i3 = FL.emplace_after(i1, n);1520 1521 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1522 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1523 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1524 1525 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1526 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}1527 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 11528 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.end(){{$}}}}1529}1530 1531/// erase()1532///1533/// - Design decision: shifts positions to the ->RIGHT-> (i.e. all iterator1534/// ahead of the ereased element are incremented; if the1535/// relation between the position of the erased element1536/// and the first position of the container is known, the1537/// first position of the container is also incremented).1538///1539/// - Iterator invalidation rules depend the container type.1540 1541/// std::list-like containers: Iterators to the erased element are invalidated.1542/// Other iterators are not affected.1543 1544void list_erase_begin(std::list<int> &L) {1545 auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();1546 1547 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1548 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1549 1550 auto i3 = L.erase(i0);1551 1552 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1553 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1554 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1555 1556 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$L.begin() + 1{{$}}}}1557 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin() + 11558 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1559}1560 1561void list_erase_behind_begin(std::list<int> &L, int n) {1562 auto i0 = L.cbegin(), i1 = ++L.cbegin(), i2 = L.cend();1563 1564 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1565 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1566 1567 auto i3 = L.erase(i1);1568 1569 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1570 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1571 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1572 1573 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}} FIXME: Should be $L.begin() + 11574 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.begin() + 21575 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1576}1577 1578void list_erase_unknown(std::list<int> &L) {1579 auto i0 = L.cbegin(), i1 = return_any_iterator(L.cbegin()), i2 = L.cend();1580 1581 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1582 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1583 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1584 1585 auto i3 = L.erase(i1);1586 1587 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1588 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1589 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1590 1591 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1592 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 11593 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1594}1595 1596void list_erase_ahead_of_end(std::list<int> &L) {1597 auto i0 = L.cbegin(), i1 = --L.cend(), i2 = L.cend();1598 1599 clang_analyzer_denote(clang_analyzer_container_begin(L), "$L.begin()");1600 clang_analyzer_denote(clang_analyzer_container_end(L), "$L.end()");1601 1602 auto i3 = L.erase(i1);1603 1604 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1605 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1606 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1607 1608 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$L.begin(){{$}}}}1609 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$L.end(){{$}}}}1610 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $L.end()1611}1612 1613/// std::vector-like containers: Invalidates iterators at or after the point of1614/// the erase, including the past-the-end iterator.1615 1616void vector_erase_begin(std::vector<int> &V) {1617 auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();1618 1619 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1620 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1621 1622 auto i3 = V.erase(i0);1623 1624 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1625 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1626 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1627 1628 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 11629}1630 1631void vector_erase_behind_begin(std::vector<int> &V, int n) {1632 auto i0 = V.cbegin(), i1 = ++V.cbegin(), i2 = V.cend();1633 1634 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1635 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1636 1637 auto i3 = V.erase(i1);1638 1639 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1640 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1641 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1642 1643 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}} FIXME: Should be $V.begin() + 11644 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.begin() + 21645}1646 1647void vector_erase_unknown(std::vector<int> &V) {1648 auto i0 = V.cbegin(), i1 = return_any_iterator(V.cbegin()), i2 = V.cend();1649 1650 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1651 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1652 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1653 1654 auto i3 = V.erase(i1);1655 1656 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1657 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1658 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1659 1660 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1661 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 11662}1663 1664void vector_erase_ahead_of_end(std::vector<int> &V) {1665 auto i0 = V.cbegin(), i1 = --V.cend(), i2 = V.cend();1666 1667 clang_analyzer_denote(clang_analyzer_container_begin(V), "$V.begin()");1668 clang_analyzer_denote(clang_analyzer_container_end(V), "$V.end()");1669 1670 auto i3 = V.erase(i1);1671 1672 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1673 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1674 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1675 1676 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$V.begin(){{$}}}}1677 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $V.end()1678}1679 1680/// std::deque-like containers: All iterators are invalidated, unless the erased1681/// element is at the end or the beginning of the1682/// container, in which case only the iterators to1683/// the erased element are invalidated. The1684/// past-the-end iterator is also invalidated unless1685/// the erased element is at the beginning of the1686/// container and the last element is not erased.1687 1688void deque_erase_begin(std::deque<int> &D) {1689 auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();1690 1691 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1692 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1693 1694 auto i3 = D.erase(i0);1695 1696 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1697 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1698 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1699 1700 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 11701}1702 1703void deque_erase_behind_begin(std::deque<int> &D, int n) {1704 auto i0 = D.cbegin(), i1 = ++D.cbegin(), i2 = D.cend();1705 1706 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1707 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1708 1709 auto i3 = D.erase(i1);1710 1711 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1712 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1713 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1714 1715 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.begin() + 21716}1717 1718void deque_erase_unknown(std::deque<int> &D) {1719 auto i0 = D.cbegin(), i1 = return_any_iterator(D.cbegin()), i2 = D.cend();1720 1721 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1722 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1723 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1724 1725 auto i3 = D.erase(i1);1726 1727 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1728 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1729 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1730 1731 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $i1 + 11732}1733 1734void deque_erase_ahead_of_end(std::deque<int> &D) {1735 auto i0 = D.cbegin(), i1 = --D.cend(), i2 = D.cend();1736 1737 clang_analyzer_denote(clang_analyzer_container_begin(D), "$D.begin()");1738 clang_analyzer_denote(clang_analyzer_container_end(D), "$D.end()");1739 1740 auto i3 = D.erase(i1);1741 1742 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{FALSE}}1743 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1744 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1745 1746 // clang_analyzer_express(clang_analyzer_iterator_position(i3)); FIXME: expect warning $D.end()1747}1748 1749/// erase_after() [std::forward_list-like containers]1750///1751/// - Design decision: shifts positions to the <-LEFT<- (i.e. all iterator1752/// begind of the ereased element are decremented; if the1753/// relation between the position of the erased element1754/// and the past-the-end position of the container is known,1755/// the past-the-end position of the container is also1756/// decremented).1757///1758/// - Iterators to the erased element are invalidated. Other iterators are not1759/// affected.1760 1761 1762void forward_list_erase_after_begin(std::forward_list<int> &FL) {1763 auto i0 = FL.cbegin(), i1 = ++FL.cbegin(), i2 = i1, i3 = FL.cend();1764 ++i2;1765 1766 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1767 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1768 1769 auto i4 = FL.erase_after(i0);1770 1771 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1772 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{FALSE}}1773 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{TRUE}}1774 clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}1775 1776 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1777 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning-re {{$FL.begin() + 2{{$}}}} FIXME: Should be $FL.begin() + 11778 // clang_analyzer_express(clang_analyzer_iterator_position(i4)); FIXME: expect warning $FL.begin() + 11779 clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning-re {{$FL.end(){{$}}}}1780}1781 1782void forward_list_erase_after_unknown(std::forward_list<int> &FL) {1783 auto i0 = FL.cbegin(), i1 = return_any_iterator(FL.cbegin()), i2 = i1,1784 i3 = i1, i4 = FL.cend();1785 ++i2;1786 ++i3;1787 ++i3;1788 1789 clang_analyzer_denote(clang_analyzer_container_begin(FL), "$FL.begin()");1790 clang_analyzer_denote(clang_analyzer_container_end(FL), "$FL.end()");1791 clang_analyzer_denote(clang_analyzer_iterator_position(i1), "$i1");1792 1793 auto i5 = FL.erase_after(i1);1794 1795 clang_analyzer_eval(clang_analyzer_iterator_validity(i0)); //expected-warning{{TRUE}}1796 clang_analyzer_eval(clang_analyzer_iterator_validity(i1)); //expected-warning{{TRUE}}1797 clang_analyzer_eval(clang_analyzer_iterator_validity(i2)); //expected-warning{{FALSE}}1798 clang_analyzer_eval(clang_analyzer_iterator_validity(i3)); //expected-warning{{TRUE}}1799 clang_analyzer_eval(clang_analyzer_iterator_validity(i4)); //expected-warning{{TRUE}}1800 1801 clang_analyzer_express(clang_analyzer_iterator_position(i0)); // expected-warning-re {{$FL.begin(){{$}}}}1802 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning-re {{$i1{{$}}}}1803 clang_analyzer_express(clang_analyzer_iterator_position(i3)); // expected-warning-re {{$i1 + 2{{$}}}} FIXME: Should be $i1 + 11804 // clang_analyzer_express(clang_analyzer_iterator_position(i5)); FIXME: expect warning $i1 + 11805 clang_analyzer_express(clang_analyzer_iterator_position(i4)); // expected-warning-re {{$FL.end(){{$}}}}1806}1807 1808struct simple_iterator_base {1809 simple_iterator_base();1810 simple_iterator_base(const simple_iterator_base& rhs);1811 simple_iterator_base &operator=(const simple_iterator_base& rhs);1812 virtual ~simple_iterator_base();1813 bool friend operator==(const simple_iterator_base &lhs,1814 const simple_iterator_base &rhs);1815 bool friend operator!=(const simple_iterator_base &lhs,1816 const simple_iterator_base &rhs);1817private:1818 int *ptr;1819};1820 1821struct simple_derived_iterator: public simple_iterator_base {1822 int& operator*();1823 int* operator->();1824 simple_iterator_base &operator++();1825 simple_iterator_base operator++(int);1826 simple_iterator_base &operator--();1827 simple_iterator_base operator--(int);1828};1829 1830struct simple_container {1831 typedef simple_derived_iterator iterator;1832 1833 iterator begin();1834 iterator end();1835};1836 1837void good_derived(simple_container c) {1838 auto i0 = c.end();1839 1840 if (i0 != c.end()) {1841 clang_analyzer_warnIfReached();1842 }1843}1844 1845void iter_diff(std::vector<int> &V) {1846 auto i0 = V.begin(), i1 = V.end();1847 ptrdiff_t len = i1 - i0; // no-crash1848}1849 1850void deferred_assumption(std::vector<int> &V, int e) {1851 const auto first = V.begin();1852 const auto comp1 = (first != V.end()), comp2 = (first == V.end());1853 if (comp1) {1854 clang_analyzer_eval(clang_analyzer_container_end(V) ==1855 clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}}1856 }1857}1858 1859void loop(std::vector<int> &V, int e) {1860 auto start = V.begin();1861 while (true) {1862 auto item = std::find(start, V.end(), e);1863 if (item == V.end())1864 break;1865 1866 clang_analyzer_eval(clang_analyzer_container_end(V) ==1867 clang_analyzer_iterator_position(item)); // expected-warning@-1{{FALSE}}1868 }1869}1870 1871template <typename InputIterator, typename T>1872InputIterator nonStdFind(InputIterator first, InputIterator last,1873 const T &val) {1874 for (auto i = first; i != last; ++i) {1875 if (*i == val) {1876 return i;1877 }1878 }1879 return last;1880}1881 1882void non_std_find(std::vector<int> &V, int e) {1883 auto first = nonStdFind(V.begin(), V.end(), e);1884 clang_analyzer_eval(clang_analyzer_container_end(V) ==1885 clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}} expected-warning@-1{{TRUE}}1886 if (V.end() != first) {1887 clang_analyzer_eval(clang_analyzer_container_end(V) ==1888 clang_analyzer_iterator_position(first)); // expected-warning@-1{{FALSE}}1889 }1890}1891 1892template<typename T>1893struct cont_with_ptr_iterator {1894 typedef T* iterator;1895 T* begin() const;1896 T* end() const;1897};1898 1899void begin_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1900 auto i = c.begin();1901 1902 clang_analyzer_eval(clang_analyzer_iterator_container(i) == &c); // expected-warning{{TRUE}}1903 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1904 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin()}}1905 1906 if (i != c.begin()) {1907 clang_analyzer_warnIfReached();1908 }1909 }1910 1911void prefix_increment_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1912 auto i = c.begin();1913 1914 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1915 1916 auto j = ++i;1917 1918 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 1}}1919 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.begin() + 1}}1920}1921 1922void prefix_decrement_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1923 auto i = c.end();1924 1925 clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");1926 1927 auto j = --i;1928 1929 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 1}}1930 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.end() - 1}}1931}1932 1933void postfix_increment_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1934 auto i = c.begin();1935 1936 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1937 1938 auto j = i++;1939 1940 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 1}}1941 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.begin()}}1942}1943 1944void postfix_decrement_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1945 auto i = c.end();1946 1947 clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");1948 1949 auto j = i--;1950 1951 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 1}}1952 clang_analyzer_express(clang_analyzer_iterator_position(j)); // expected-warning{{$c.end()}}1953}1954 1955void plus_equal_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1956 auto i = c.begin();1957 1958 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1959 1960 i += 2;1961 1962 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.begin() + 2}}1963}1964 1965void minus_equal_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1966 auto i = c.end();1967 1968 clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");1969 1970 i -= 2;1971 1972 clang_analyzer_express(clang_analyzer_iterator_position(i)); // expected-warning{{$c.end() - 2}}1973}1974 1975void minus_equal_ptr_iterator_variable(const cont_with_ptr_iterator<int> &c,1976 int n) {1977 auto i = c.end();1978 1979 i -= n; // no-crash1980}1981 1982void plus_lhs_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1983 auto i1 = c.begin();1984 1985 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1986 1987 auto i2 = i1 + 2;1988 1989 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}1990 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$c.begin()}}1991 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$c.begin() + 2}}1992}1993 1994void plus_rhs_ptr_iterator(const cont_with_ptr_iterator<int> &c) {1995 auto i1 = c.begin();1996 1997 clang_analyzer_denote(clang_analyzer_container_begin(c), "$c.begin()");1998 1999 auto i2 = 2 + i1;2000 2001 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}2002 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$c.begin()}}2003 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$c.begin() + 2}}2004}2005 2006void minus_ptr_iterator(const cont_with_ptr_iterator<int> &c) {2007 auto i1 = c.end();2008 2009 clang_analyzer_denote(clang_analyzer_container_end(c), "$c.end()");2010 2011 auto i2 = i1 - 2;2012 2013 clang_analyzer_eval(clang_analyzer_iterator_container(i2) == &c); // expected-warning{{TRUE}}2014 clang_analyzer_express(clang_analyzer_iterator_position(i1)); // expected-warning{{$c.end()}}2015 clang_analyzer_express(clang_analyzer_iterator_position(i2)); // expected-warning{{$c.end() - 2}}2016}2017 2018void ptr_iter_diff(cont_with_ptr_iterator<int> &c) {2019 auto i0 = c.begin(), i1 = c.end();2020 ptrdiff_t len = i1 - i0; // no-crash2021}2022 2023void ptr_iter_cmp_nullptr(cont_with_ptr_iterator<int> &c) {2024 auto i0 = c.begin();2025 if (i0 != nullptr) // no-crash2026 ++i0;2027}2028 2029void clang_analyzer_printState();2030 2031void print_state(std::vector<int> &V) {2032 const auto i0 = V.cbegin();2033 clang_analyzer_printState();2034 2035 // CHECK: "checker_messages": [2036 // CHECK: { "checker": "alpha.cplusplus.IteratorModeling", "messages": [2037 // CHECK-NEXT: "Iterator Positions :",2038 // CHECK-NEXT: "i0 : Valid ; Container == SymRegion{reg_$[[#]]<std::vector<int> & V>} ; Offset == conj_$[[#]]{long, LC[[#]], S[[#]], #[[#]]}"2039 // CHECK-NEXT: ]}2040 2041 *i0;2042 const auto i1 = V.cend();2043 clang_analyzer_printState();2044 2045 // CHECK: "checker_messages": [2046 // CHECK: { "checker": "alpha.cplusplus.IteratorModeling", "messages": [2047 // CHECK-NEXT: "Iterator Positions :",2048 // CHECK-NEXT: "i1 : Valid ; Container == SymRegion{reg_$[[#]]<std::vector<int> & V>} ; Offset == conj_$[[#]]{long, LC[[#]], S[[#]], #[[#]]}"2049 // CHECK-NEXT: ]}2050 2051 *i1;2052}2053