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