Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed -fcxx-exceptions -std=c++11 %s
      2 
      3 // TODO: Switch to using macros for the expected warnings.
      4 
      5 #define CALLABLE_WHEN(...)      __attribute__ ((callable_when(__VA_ARGS__)))
      6 #define CONSUMABLE(state)       __attribute__ ((consumable(state)))
      7 #define PARAM_TYPESTATE(state)  __attribute__ ((param_typestate(state)))
      8 #define RETURN_TYPESTATE(state) __attribute__ ((return_typestate(state)))
      9 #define SET_TYPESTATE(state)    __attribute__ ((set_typestate(state)))
     10 #define TEST_TYPESTATE(state)   __attribute__ ((test_typestate(state)))
     11 
     12 typedef decltype(nullptr) nullptr_t;
     13 
     14 template <typename T>
     15 class CONSUMABLE(unconsumed) ConsumableClass {
     16   T var;
     17 
     18 public:
     19   ConsumableClass();
     20   ConsumableClass(nullptr_t p) RETURN_TYPESTATE(consumed);
     21   ConsumableClass(T val) RETURN_TYPESTATE(unconsumed);
     22   ConsumableClass(ConsumableClass<T> &other);
     23   ConsumableClass(ConsumableClass<T> &&other);
     24 
     25   ConsumableClass<T>& operator=(ConsumableClass<T>  &other);
     26   ConsumableClass<T>& operator=(ConsumableClass<T> &&other);
     27   ConsumableClass<T>& operator=(nullptr_t) SET_TYPESTATE(consumed);
     28 
     29   template <typename U>
     30   ConsumableClass<T>& operator=(ConsumableClass<U>  &other);
     31 
     32   template <typename U>
     33   ConsumableClass<T>& operator=(ConsumableClass<U> &&other);
     34 
     35   void operator()(int a) SET_TYPESTATE(consumed);
     36   void operator*() const CALLABLE_WHEN("unconsumed");
     37   void unconsumedCall() const CALLABLE_WHEN("unconsumed");
     38   void callableWhenUnknown() const CALLABLE_WHEN("unconsumed", "unknown");
     39 
     40   bool isValid() const TEST_TYPESTATE(unconsumed);
     41   operator bool() const TEST_TYPESTATE(unconsumed);
     42   bool operator!=(nullptr_t) const TEST_TYPESTATE(unconsumed);
     43   bool operator==(nullptr_t) const TEST_TYPESTATE(consumed);
     44 
     45   void constCall() const;
     46   void nonconstCall();
     47 
     48   void consume() SET_TYPESTATE(consumed);
     49   void unconsume() SET_TYPESTATE(unconsumed);
     50 };
     51 
     52 class CONSUMABLE(unconsumed) DestructorTester {
     53 public:
     54   DestructorTester();
     55   DestructorTester(int);
     56 
     57   void operator*() CALLABLE_WHEN("unconsumed");
     58 
     59   ~DestructorTester() CALLABLE_WHEN("consumed");
     60 };
     61 
     62 void baf0(const ConsumableClass<int>  var);
     63 void baf1(const ConsumableClass<int> &var);
     64 void baf2(const ConsumableClass<int> *var);
     65 
     66 void baf3(ConsumableClass<int>   var);
     67 void baf4(ConsumableClass<int>  &var);
     68 void baf5(ConsumableClass<int>  *var);
     69 void baf6(ConsumableClass<int> &&var);
     70 
     71 ConsumableClass<int> returnsUnconsumed() {
     72   return ConsumableClass<int>(); // expected-warning {{return value not in expected state; expected 'unconsumed', observed 'consumed'}}
     73 }
     74 
     75 ConsumableClass<int> returnsConsumed() RETURN_TYPESTATE(consumed);
     76 ConsumableClass<int> returnsConsumed() {
     77   return ConsumableClass<int>();
     78 }
     79 
     80 ConsumableClass<int> returnsUnknown() RETURN_TYPESTATE(unknown);
     81 
     82 void testInitialization() {
     83   ConsumableClass<int> var0;
     84   ConsumableClass<int> var1 = ConsumableClass<int>();
     85   ConsumableClass<int> var2(42);
     86   ConsumableClass<int> var3(var2);  // copy constructor
     87   ConsumableClass<int> var4(var0);  // copy consumed value
     88 
     89   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
     90   *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
     91   *var2;
     92   *var3;
     93   *var4; // expected-warning {{invalid invocation of method 'operator*' on object 'var4' while it is in the 'consumed' state}}
     94 
     95   var0 = ConsumableClass<int>(42);
     96   *var0;
     97 
     98   var0 = var1;
     99   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    100 
    101   if (var0.isValid()) {
    102     *var0;
    103     *var1;
    104 
    105   } else {
    106     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    107   }
    108 }
    109 
    110 void testDestruction() {
    111   DestructorTester D0(42), D1(42), D2;
    112 
    113   *D0;
    114   *D1;
    115   *D2; // expected-warning {{invalid invocation of method 'operator*' on object 'D2' while it is in the 'consumed' state}}
    116 
    117   D0.~DestructorTester(); // expected-warning {{invalid invocation of method '~DestructorTester' on object 'D0' while it is in the 'unconsumed' state}}
    118 
    119   return; // expected-warning {{invalid invocation of method '~DestructorTester' on object 'D0' while it is in the 'unconsumed' state}} \
    120              expected-warning {{invalid invocation of method '~DestructorTester' on object 'D1' while it is in the 'unconsumed' state}}
    121 }
    122 
    123 void testTempValue() {
    124   *ConsumableClass<int>(); // expected-warning {{invalid invocation of method 'operator*' on a temporary object while it is in the 'consumed' state}}
    125 }
    126 
    127 void testSimpleRValueRefs() {
    128   ConsumableClass<int> var0;
    129   ConsumableClass<int> var1(42);
    130 
    131   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    132   *var1;
    133 
    134   var0 = static_cast<ConsumableClass<int>&&>(var1);
    135 
    136   *var0;
    137   *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    138 }
    139 
    140 void testIfStmt() {
    141   ConsumableClass<int> var;
    142 
    143   if (var.isValid()) {
    144     *var;
    145   } else {
    146     *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    147   }
    148 
    149   if (!var.isValid()) {
    150     *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    151   } else {
    152     *var;
    153   }
    154 
    155   if (var) {
    156     // Empty
    157   } else {
    158     *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    159   }
    160 
    161   if (var != nullptr) {
    162     // Empty
    163   } else {
    164     *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    165   }
    166 
    167   if (var == nullptr) {
    168     *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    169   } else {
    170     // Empty
    171   }
    172 }
    173 
    174 void testComplexConditionals0() {
    175   ConsumableClass<int> var0, var1, var2;
    176 
    177   if (var0 && var1) {
    178     *var0;
    179     *var1;
    180 
    181   } else {
    182     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    183     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    184   }
    185 
    186   if (var0 || var1) {
    187     *var0;
    188     *var1;
    189 
    190   } else {
    191     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    192     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    193   }
    194 
    195   if (var0 && !var1) {
    196     *var0;
    197     *var1;
    198 
    199   } else {
    200     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    201     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    202   }
    203 
    204   if (var0 || !var1) {
    205     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    206     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    207 
    208   } else {
    209     *var0;
    210     *var1;
    211   }
    212 
    213   if (!var0 && !var1) {
    214     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    215     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    216 
    217   } else {
    218     *var0;
    219     *var1;
    220   }
    221 
    222   if (!var0 || !var1) {
    223     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    224     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    225 
    226   } else {
    227     *var0;
    228     *var1;
    229   }
    230 
    231   if (!(var0 && var1)) {
    232     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    233     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    234 
    235   } else {
    236     *var0;
    237     *var1;
    238   }
    239 
    240   if (!(var0 || var1)) {
    241     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    242     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    243 
    244   } else {
    245     *var0;
    246     *var1;
    247   }
    248 
    249   if (var0 && var1 && var2) {
    250     *var0;
    251     *var1;
    252     *var2;
    253 
    254   } else {
    255     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    256     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    257     *var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
    258   }
    259 
    260 #if 0
    261   // FIXME: Get this test to pass.
    262   if (var0 || var1 || var2) {
    263     *var0;
    264     *var1;
    265     *var2;
    266 
    267   } else {
    268     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    269     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    270     *var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
    271   }
    272 #endif
    273 }
    274 
    275 void testComplexConditionals1() {
    276   ConsumableClass<int> var0, var1, var2;
    277 
    278   // Coerce all variables into the unknown state.
    279   baf4(var0);
    280   baf4(var1);
    281   baf4(var2);
    282 
    283   if (var0 && var1) {
    284     *var0;
    285     *var1;
    286 
    287   } else {
    288     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    289     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    290   }
    291 
    292   if (var0 || var1) {
    293     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    294     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    295 
    296   } else {
    297     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    298     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    299   }
    300 
    301   if (var0 && !var1) {
    302     *var0;
    303     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    304 
    305   } else {
    306     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    307     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    308   }
    309 
    310   if (var0 || !var1) {
    311     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    312     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    313 
    314   } else {
    315     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    316     *var1;
    317   }
    318 
    319   if (!var0 && !var1) {
    320     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    321     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    322 
    323   } else {
    324     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    325     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    326   }
    327 
    328   if (!(var0 || var1)) {
    329     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    330     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    331 
    332   } else {
    333     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    334     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    335   }
    336 
    337   if (!var0 || !var1) {
    338     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    339     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    340 
    341   } else {
    342     *var0;
    343     *var1;
    344   }
    345 
    346   if (!(var0 && var1)) {
    347     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    348     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    349 
    350   } else {
    351     *var0;
    352     *var1;
    353   }
    354 
    355   if (var0 && var1 && var2) {
    356     *var0;
    357     *var1;
    358     *var2;
    359 
    360   } else {
    361     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    362     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    363     *var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'unknown' state}}
    364   }
    365 
    366 #if 0
    367   // FIXME: Get this test to pass.
    368   if (var0 || var1 || var2) {
    369     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
    370     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
    371     *var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'unknown' state}}
    372 
    373   } else {
    374     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    375     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    376     *var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
    377   }
    378 #endif
    379 }
    380 
    381 void testStateChangeInBranch() {
    382   ConsumableClass<int> var;
    383 
    384   // Make var enter the 'unknown' state.
    385   baf4(var);
    386 
    387   if (!var) {
    388     var = ConsumableClass<int>(42);
    389   }
    390 
    391   *var;
    392 }
    393 
    394 void testFunctionParam(ConsumableClass<int> param) {
    395 
    396   if (param.isValid()) {
    397     *param;
    398   } else {
    399     *param;
    400   }
    401 
    402   param = nullptr;
    403   *param; // expected-warning {{invocation of method 'operator*' on object 'param' while it is in the 'consumed' state}}
    404 }
    405 
    406 void testParamReturnTypestateCallee(bool cond, ConsumableClass<int> &Param RETURN_TYPESTATE(unconsumed)) { // expected-warning {{parameter 'Param' not in expected state when the function returns: expected 'unconsumed', observed 'consumed'}}
    407 
    408   if (cond) {
    409     Param.consume();
    410     return; // expected-warning {{parameter 'Param' not in expected state when the function returns: expected 'unconsumed', observed 'consumed'}}
    411   }
    412 
    413   Param.consume();
    414 }
    415 
    416 void testParamReturnTypestateCaller() {
    417   ConsumableClass<int> var;
    418 
    419   testParamReturnTypestateCallee(true, var);
    420 
    421   *var;
    422 }
    423 
    424 void testParamTypestateCallee(ConsumableClass<int>  Param0 PARAM_TYPESTATE(consumed),
    425                               ConsumableClass<int> &Param1 PARAM_TYPESTATE(consumed)) {
    426 
    427   *Param0; // expected-warning {{invalid invocation of method 'operator*' on object 'Param0' while it is in the 'consumed' state}}
    428   *Param1; // expected-warning {{invalid invocation of method 'operator*' on object 'Param1' while it is in the 'consumed' state}}
    429 }
    430 
    431 void testParamTypestateCaller() {
    432   ConsumableClass<int> Var0, Var1(42);
    433 
    434   testParamTypestateCallee(Var0, Var1); // expected-warning {{argument not in expected state; expected 'consumed', observed 'unconsumed'}}
    435 }
    436 
    437 
    438 void consumeFunc(ConsumableClass<int> P PARAM_TYPESTATE(unconsumed));
    439 struct ParamTest {
    440   static void consumeFuncStatic(ConsumableClass<int> P PARAM_TYPESTATE(unconsumed));
    441   void consumeFuncMeth(ConsumableClass<int> P PARAM_TYPESTATE(unconsumed));
    442   void operator<<(ConsumableClass<int> P PARAM_TYPESTATE(unconsumed));
    443 };
    444 
    445 void operator>>(ParamTest& pt, ConsumableClass<int> P PARAM_TYPESTATE(unconsumed));
    446 
    447 
    448 void testFunctionParams() {
    449   // Make sure we handle the different kinds of functions.
    450   ConsumableClass<int> P;
    451 
    452   consumeFunc(P);                   // expected-warning {{argument not in expected state; expected 'unconsumed', observed 'consumed'}}
    453   ParamTest::consumeFuncStatic(P);  // expected-warning {{argument not in expected state; expected 'unconsumed', observed 'consumed'}}
    454   ParamTest pt;
    455   pt.consumeFuncMeth(P);            // expected-warning {{argument not in expected state; expected 'unconsumed', observed 'consumed'}}
    456   pt << P;                          // expected-warning {{argument not in expected state; expected 'unconsumed', observed 'consumed'}}
    457   pt >> P;                          // expected-warning {{argument not in expected state; expected 'unconsumed', observed 'consumed'}}
    458 }
    459 
    460 void baf3(ConsumableClass<int> var) {
    461   *var;
    462 }
    463 
    464 void baf4(ConsumableClass<int> &var) {
    465   *var;  // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
    466 }
    467 
    468 void baf6(ConsumableClass<int> &&var) {
    469   *var;
    470 }
    471 
    472 void testCallingConventions() {
    473   ConsumableClass<int> var(42);
    474 
    475   baf0(var);
    476   *var;
    477 
    478   baf1(var);
    479   *var;
    480 
    481   baf2(&var);
    482   *var;
    483 
    484   baf4(var);
    485   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
    486 
    487   var = ConsumableClass<int>(42);
    488   baf5(&var);
    489   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
    490 
    491   var = ConsumableClass<int>(42);
    492   baf6(static_cast<ConsumableClass<int>&&>(var));
    493   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    494 }
    495 
    496 void testConstAndNonConstMemberFunctions() {
    497   ConsumableClass<int> var(42);
    498 
    499   var.constCall();
    500   *var;
    501 
    502   var.nonconstCall();
    503   *var;
    504 }
    505 
    506 void testFunctionParam0(ConsumableClass<int> param) {
    507   *param;
    508 }
    509 
    510 void testFunctionParam1(ConsumableClass<int> &param) {
    511   *param; // expected-warning {{invalid invocation of method 'operator*' on object 'param' while it is in the 'unknown' state}}
    512 }
    513 
    514 void testReturnStates() {
    515   ConsumableClass<int> var;
    516 
    517   var = returnsUnconsumed();
    518   *var;
    519 
    520   var = returnsConsumed();
    521   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    522 }
    523 
    524 void testCallableWhen() {
    525   ConsumableClass<int> var(42);
    526 
    527   *var;
    528 
    529   baf4(var);
    530 
    531   var.callableWhenUnknown();
    532 }
    533 
    534 void testMoveAsignmentish() {
    535   ConsumableClass<int>  var0;
    536   ConsumableClass<long> var1(42);
    537 
    538   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    539   *var1;
    540 
    541   var0 = static_cast<ConsumableClass<long>&&>(var1);
    542 
    543   *var0;
    544   *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    545 
    546   var1 = ConsumableClass<long>(42);
    547   var1 = nullptr;
    548   *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    549 }
    550 
    551 void testConditionalMerge() {
    552   ConsumableClass<int> var;
    553 
    554   if (var.isValid()) {
    555     // Empty
    556   }
    557 
    558   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    559 
    560   if (var.isValid()) {
    561     // Empty
    562   } else {
    563     // Empty
    564   }
    565 
    566   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    567 }
    568 
    569 void testSetTypestate() {
    570   ConsumableClass<int> var(42);
    571 
    572   *var;
    573 
    574   var.consume();
    575 
    576   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    577 
    578   var.unconsume();
    579 
    580   *var;
    581 }
    582 
    583 void testConsumes0() {
    584   ConsumableClass<int> var(nullptr);
    585 
    586   *var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
    587 }
    588 
    589 void testConsumes1() {
    590   ConsumableClass<int> var(42);
    591 
    592   var.unconsumedCall();
    593   var(6);
    594 
    595   var.unconsumedCall(); // expected-warning {{invalid invocation of method 'unconsumedCall' on object 'var' while it is in the 'consumed' state}}
    596 }
    597 
    598 void testUnreachableBlock() {
    599   ConsumableClass<int> var(42);
    600 
    601   if (var) {
    602     *var;
    603   } else {
    604     *var;
    605   }
    606 
    607   *var;
    608 }
    609 
    610 
    611 void testForLoop1() {
    612   ConsumableClass<int> var0, var1(42);
    613 
    614   for (int i = 0; i < 10; ++i) { // expected-warning {{state of variable 'var1' must match at the entry and exit of loop}}
    615     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    616 
    617     *var1;
    618     var1.consume();
    619     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    620   }
    621 
    622   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    623 }
    624 
    625 void testWhileLoop1() {
    626   int i = 10;
    627 
    628   ConsumableClass<int> var0, var1(42);
    629 
    630   while (i-- > 0) { // expected-warning {{state of variable 'var1' must match at the entry and exit of loop}}
    631     *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    632 
    633     *var1;
    634     var1.consume();
    635     *var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
    636   }
    637 
    638   *var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
    639 }
    640 
    641 // Tests if state information is correctly discarded for certain shapes of CFGs.
    642 void testSwitchGOTO(void) {
    643 	int a;
    644 
    645 	LABEL0:
    646 	switch (a)
    647 	case 0:
    648 		goto LABEL0;
    649 
    650 	goto LABEL0;
    651 }
    652 
    653 typedef const int*& IntegerPointerReference;
    654 void testIsRValueRefishAndCanonicalType(IntegerPointerReference a) {}
    655 
    656 namespace ContinueICETest {
    657 
    658 bool cond1();
    659 bool cond2();
    660 
    661 static void foo1() {
    662   while (cond1()) {
    663     if (cond2())
    664       continue;
    665   }
    666 }
    667 
    668 static void foo2() {
    669   while (true) {
    670     if (false)
    671       continue;
    672   }
    673 }
    674 
    675 class runtime_error
    676 {
    677 public:
    678   virtual ~runtime_error();
    679 };
    680 
    681 void read(bool sf) {
    682     while (sf) {
    683         if(sf) throw runtime_error();
    684     }
    685 }
    686 
    687 } // end namespace ContinueICETest
    688 
    689 
    690 namespace StatusUseCaseTests {
    691 
    692 class CONSUMABLE(unconsumed)
    693       __attribute__((consumable_auto_cast_state))
    694       __attribute__((consumable_set_state_on_read))
    695     Status {
    696   int code;
    697 
    698 public:
    699   static Status OK;
    700 
    701   Status() RETURN_TYPESTATE(consumed);
    702   Status(int c) RETURN_TYPESTATE(unconsumed);
    703 
    704   Status(const Status &other);
    705   Status(Status &&other);
    706 
    707   Status& operator=(const Status &other) CALLABLE_WHEN("unknown", "consumed");
    708   Status& operator=(Status &&other) CALLABLE_WHEN("unknown", "consumed");
    709 
    710   bool operator==(const Status &other) const SET_TYPESTATE(consumed);
    711 
    712   bool check()  const SET_TYPESTATE(consumed);
    713   void ignore() const SET_TYPESTATE(consumed);
    714   // Status& markAsChecked() { return *this; }
    715 
    716   void clear() CALLABLE_WHEN("unknown", "consumed") SET_TYPESTATE(consumed);
    717 
    718   ~Status() CALLABLE_WHEN("unknown", "consumed");
    719 
    720   operator bool() const; // Will not consume the object.
    721 };
    722 
    723 
    724 bool   cond();
    725 Status doSomething();
    726 void   handleStatus(const Status& s RETURN_TYPESTATE(consumed));
    727 void   handleStatusRef(Status& s);
    728 void   handleStatusPtr(Status* s);
    729 void   handleStatusUnmarked(const Status& s);
    730 
    731 void   log(const char* msg);
    732 void   fail() __attribute__((noreturn));
    733 void   checkStat(const Status& s);
    734 
    735 
    736 void testSimpleTemporaries0() {
    737   doSomething(); // expected-warning {{invalid invocation of method '~Status' on a temporary object while it is in the 'unconsumed' state}}
    738 }
    739 
    740 void testSimpleTemporaries1() {
    741   doSomething().ignore();
    742 }
    743 
    744 void testSimpleTemporaries2() {
    745   handleStatus(doSomething());
    746 }
    747 
    748 void testSimpleTemporaries3() {
    749   Status s = doSomething();
    750 }  // expected-warning {{invalid invocation of method '~Status' on object 's' while it is in the 'unconsumed' state}}
    751 
    752 void testTemporariesWithControlFlow(bool a) {
    753   bool b = false || doSomething(); // expected-warning {{invalid invocation of method '~Status' on a temporary object while it is in the 'unconsumed' state}}
    754 }
    755 
    756 Status testSimpleTemporariesReturn0() {
    757   return doSomething();
    758 }
    759 
    760 Status testSimpleTemporariesReturn1() {
    761   Status s = doSomething();
    762   return s;
    763 }
    764 
    765 void testSimpleTemporaries4() {
    766   Status s = doSomething();
    767   s.check();
    768 }
    769 
    770 void testSimpleTemporaries5() {
    771   Status s = doSomething();
    772   s.clear(); // expected-warning {{invalid invocation of method 'clear' on object 's' while it is in the 'unconsumed' state}}
    773 }
    774 
    775 void testSimpleTemporaries6() {
    776   Status s1 = doSomething();
    777   handleStatus(s1);
    778 
    779   Status s2 = doSomething();
    780   handleStatusRef(s2);
    781 
    782   Status s3 = doSomething();
    783   handleStatusPtr(&s3);
    784 
    785   Status s4 = doSomething();
    786   handleStatusUnmarked(s4);
    787 }
    788 
    789 void testSimpleTemporaries7() {
    790   Status s;
    791   s = doSomething();
    792 }  // expected-warning {{invalid invocation of method '~Status' on object 's' while it is in the 'unconsumed' state}}
    793 
    794 void testTemporariesWithConditionals0() {
    795   int a;
    796 
    797   Status s = doSomething();
    798   if (cond()) a = 0;
    799   else        a = 1;
    800 } // expected-warning {{invalid invocation of method '~Status' on object 's' while it is in the 'unconsumed' state}}
    801 
    802 void testTemporariesWithConditionals1() {
    803   int a;
    804 
    805   Status s = doSomething();
    806   if (cond()) a = 0;
    807   else        a = 1;
    808   s.ignore();
    809 }
    810 
    811 void testTemporariesWithConditionals2() {
    812   int a;
    813 
    814   Status s = doSomething();
    815   s.ignore();
    816   if (cond()) a = 0;
    817   else        a = 1;
    818 }
    819 
    820 void testTemporariesWithConditionals3() {
    821   Status s = doSomething();
    822   if (cond()) {
    823     s.check();
    824   }
    825 }
    826 
    827 void testTemporariesAndConstructors0() {
    828   Status s(doSomething());    // Test the copy constructor.
    829   s.check();
    830 }
    831 
    832 void testTemporariesAndConstructors1F() {
    833   Status s1 = doSomething();  // Test the copy constructor.
    834   Status s2 = s1;
    835 } // expected-warning {{invalid invocation of method '~Status' on object 's2' while it is in the 'unconsumed' state}}
    836 
    837 void testTemporariesAndConstructors1S() {
    838   Status s1 = doSomething();  // Test the copy constructor.
    839   Status s2(s1);
    840   s2.check();
    841 }
    842 
    843 void testTemporariesAndConstructors2F() {
    844   // Test the move constructor.
    845   Status s1 = doSomething();
    846   Status s2 = static_cast<Status&&>(s1);
    847 } // expected-warning {{invalid invocation of method '~Status' on object 's2' while it is in the 'unconsumed' state}}
    848 
    849 void testTemporariesAndConstructors2S() {
    850   // Test the move constructor.
    851   Status s1 = doSomething();
    852   Status s2 = static_cast<Status&&>(s1);
    853   s2.check();
    854 }
    855 
    856 void testTemporariesAndOperators0F() {
    857   // Test the assignment operator.
    858   Status s1 = doSomething();
    859   Status s2;
    860   s2 = s1;
    861 } // expected-warning {{invalid invocation of method '~Status' on object 's2' while it is in the 'unconsumed' state}}
    862 
    863 void testTemporariesAndOperators0S() {
    864   // Test the assignment operator.
    865   Status s1 = doSomething();
    866   Status s2;
    867   s2 = s1;
    868   s2.check();
    869 }
    870 
    871 void testTemporariesAndOperators1F() {
    872   // Test the move assignment operator.
    873   Status s1 = doSomething();
    874   Status s2;
    875   s2 = static_cast<Status&&>(s1);
    876 } // expected-warning {{invalid invocation of method '~Status' on object 's2' while it is in the 'unconsumed' state}}
    877 
    878 void testTemporariesAndOperators1S() {
    879   // Test the move assignment operator.
    880   Status s1 = doSomething();
    881   Status s2;
    882   s2 = static_cast<Status&&>(s1);
    883   s2.check();
    884 }
    885 
    886 void testTemporariesAndOperators2() {
    887   Status s1 = doSomething();
    888   Status s2 = doSomething();
    889   s1 = s2; // expected-warning {{invalid invocation of method 'operator=' on object 's1' while it is in the 'unconsumed' state}}
    890   s1.check();
    891   s2.check();
    892 }
    893 
    894 Status testReturnAutocast() {
    895   Status s = doSomething();
    896   s.check();  // consume s
    897   return s;   // should autocast back to unconsumed
    898 }
    899 
    900 
    901 namespace TestParens {
    902 
    903 void test3() {
    904   checkStat((doSomething()));
    905 }
    906 
    907 void test4() {
    908   Status s = (doSomething());
    909   s.check();
    910 }
    911 
    912 void test5() {
    913   (doSomething()).check();
    914 }
    915 
    916 void test6() {
    917   if ((doSomething()) == Status::OK)
    918     return;
    919 }
    920 
    921 } // end namespace TestParens
    922 
    923 } // end namespace InitializerAssertionFailTest
    924 
    925 
    926 namespace std {
    927   void move();
    928   template<class T>
    929   void move(T&&);
    930 
    931   namespace __1 {
    932     void move();
    933     template<class T>
    934     void move(T&&);
    935   }
    936 }
    937 
    938 namespace PR18260 {
    939   class X {
    940     public:
    941       void move();
    942   } x;
    943 
    944   void test() {
    945     x.move();
    946     std::move();
    947     std::move(x);
    948     std::__1::move();
    949     std::__1::move(x);
    950   }
    951 } // end namespace PR18260
    952 
    953