maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/SemaCXX/warn-consumed-analysis.cpp

688 lines
22 KiB
C++
Raw Normal View History

Consumed analysis: update to previous test case. llvm-svn: 192926
2013-10-18 06:21:03 +08:00
// RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed -fcxx-exceptions -std=c++11 %s
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
// TODO: Switch to using macros for the expected warnings.
#define CALLABLE_WHEN(...) __attribute__ ((callable_when(__VA_ARGS__)))
#define CONSUMABLE(state) __attribute__ ((consumable(state)))
Consumed analysis: Add param_typestate attribute, which specifies that function parameters must be in a particular state. Patch by chris.wailes@gmail.com. Reviewed by delesley@google.com. llvm-svn: 192934
2013-10-18 07:23:53 +08:00
#define PARAM_TYPESTATE(state) __attribute__ ((param_typestate(state)))
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
#define RETURN_TYPESTATE(state) __attribute__ ((return_typestate(state)))
Consumed analysis: Add param_typestate attribute, which specifies that function parameters must be in a particular state. Patch by chris.wailes@gmail.com. Reviewed by delesley@google.com. llvm-svn: 192934
2013-10-18 07:23:53 +08:00
#define SET_TYPESTATE(state) __attribute__ ((set_typestate(state)))
Changed tests_typestate to test_typestate for consistency. llvm-svn: 193648
2013-10-30 04:28:41 +08:00
#define TEST_TYPESTATE(state) __attribute__ ((test_typestate(state)))
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
typedef decltype(nullptr) nullptr_t;
template <typename T>
Consumed Analysis: The 'consumable' attribute now takes a identifier specifying the default assumed state for objects of this class This information is used for return states and pass-by-value parameter states. Patch by Chris Wailes. Review by DeLesley Hutchins and Aaron Ballman. llvm-svn: 190116
2013-09-06 09:28:43 +08:00
class CONSUMABLE(unconsumed) ConsumableClass {
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
T var;
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
public:
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
ConsumableClass();
Consumed analysis: add return_typestate attribute. Patch by chris.wailes@gmail.com Functions can now declare what state the consumable type the are returning will be in. This is then used on the caller side and checked on the callee side. Constructors now use this attribute instead of the 'consumes' attribute. llvm-svn: 189843
2013-09-04 04:11:38 +08:00
ConsumableClass(nullptr_t p) RETURN_TYPESTATE(consumed);
ConsumableClass(T val) RETURN_TYPESTATE(unconsumed);
Consumed Analysis: The 'consumable' attribute now takes a identifier specifying the default assumed state for objects of this class This information is used for return states and pass-by-value parameter states. Patch by Chris Wailes. Review by DeLesley Hutchins and Aaron Ballman. llvm-svn: 190116
2013-09-06 09:28:43 +08:00
ConsumableClass(ConsumableClass<T> &other);
ConsumableClass(ConsumableClass<T> &&other);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<T>& operator=(ConsumableClass<T> &other);
ConsumableClass<T>& operator=(ConsumableClass<T> &&other);
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
ConsumableClass<T>& operator=(nullptr_t) SET_TYPESTATE(consumed);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
template <typename U>
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<T>& operator=(ConsumableClass<U> &other);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
template <typename U>
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<T>& operator=(ConsumableClass<U> &&other);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
void operator()(int a) SET_TYPESTATE(consumed);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
void operator*() const CALLABLE_WHEN("unconsumed");
void unconsumedCall() const CALLABLE_WHEN("unconsumed");
void callableWhenUnknown() const CALLABLE_WHEN("unconsumed", "unknown");
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Changed tests_typestate to test_typestate for consistency. llvm-svn: 193648
2013-10-30 04:28:41 +08:00
bool isValid() const TEST_TYPESTATE(unconsumed);
operator bool() const TEST_TYPESTATE(unconsumed);
bool operator!=(nullptr_t) const TEST_TYPESTATE(unconsumed);
bool operator==(nullptr_t) const TEST_TYPESTATE(consumed);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void constCall() const;
void nonconstCall();
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
void consume() SET_TYPESTATE(consumed);
void unconsume() SET_TYPESTATE(unconsumed);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
};
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
class CONSUMABLE(unconsumed) DestructorTester {
public:
Consumed analysis: All the return_typestate parameter to be attached to the default constructor. Patch by chris.wailes@gmail.com, reviewed by delesley. llvm-svn: 192991
2013-10-19 02:36:21 +08:00
DestructorTester() RETURN_TYPESTATE(unconsumed);
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
DestructorTester(int);
Consumed analysis: All the return_typestate parameter to be attached to the default constructor. Patch by chris.wailes@gmail.com, reviewed by delesley. llvm-svn: 192991
2013-10-19 02:36:21 +08:00
void operator*() CALLABLE_WHEN("unconsumed");
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
~DestructorTester() CALLABLE_WHEN("consumed");
};
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
void baf0(const ConsumableClass<int> var);
void baf1(const ConsumableClass<int> &var);
void baf2(const ConsumableClass<int> *var);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
void baf3(ConsumableClass<int> var);
void baf4(ConsumableClass<int> &var);
void baf5(ConsumableClass<int> *var);
void baf6(ConsumableClass<int> &&var);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: add return_typestate attribute. Patch by chris.wailes@gmail.com Functions can now declare what state the consumable type the are returning will be in. This is then used on the caller side and checked on the callee side. Constructors now use this attribute instead of the 'consumes' attribute. llvm-svn: 189843
2013-09-04 04:11:38 +08:00
ConsumableClass<int> returnsUnconsumed() {
return ConsumableClass<int>(); // expected-warning {{return value not in expected state; expected 'unconsumed', observed 'consumed'}}
}
ConsumableClass<int> returnsConsumed() RETURN_TYPESTATE(consumed);
ConsumableClass<int> returnsConsumed() {
return ConsumableClass<int>();
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
ConsumableClass<int> returnsUnknown() RETURN_TYPESTATE(unknown);
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testInitialization() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var0;
ConsumableClass<int> var1 = ConsumableClass<int>();
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
var0 = ConsumableClass<int>();
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
if (var0.isValid()) {
*var0;
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
*var1;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
}
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
void testDestruction() {
DestructorTester D0(42), D1(42);
*D0;
*D1;
Consumed analysis: All the return_typestate parameter to be attached to the default constructor. Patch by chris.wailes@gmail.com, reviewed by delesley. llvm-svn: 192991
2013-10-19 02:36:21 +08:00
DestructorTester D2;
*D2;
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
D0.~DestructorTester(); // expected-warning {{invalid invocation of method '~DestructorTester' on object 'D0' while it is in the 'unconsumed' state}}
Consumed analysis: All the return_typestate parameter to be attached to the default constructor. Patch by chris.wailes@gmail.com, reviewed by delesley. llvm-svn: 192991
2013-10-19 02:36:21 +08:00
return; // expected-warning {{invalid invocation of method '~DestructorTester' on object 'D0' while it is in the 'unconsumed' state}} \
expected-warning {{invalid invocation of method '~DestructorTester' on object 'D1' while it is in the 'unconsumed' state}} \
expected-warning {{invalid invocation of method '~DestructorTester' on object 'D2' while it is in the 'unconsumed' state}}
Consumed analysis: check destructor calls. This allows the callable_when attribute to be attached to destructors. Original patch by chris.wailes@gmail.com, reviewed and edited by delesley. llvm-svn: 192508
2013-10-12 05:55:33 +08:00
}
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
void testTempValue() {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*ConsumableClass<int>(); // expected-warning {{invalid invocation of method 'operator*' on a temporary object while it is in the 'consumed' state}}
Update to consumed analysis. Patch by chris.wailes@gmail.com. The following functionality was added: * The same functionality is now supported for both CXXOperatorCallExprs and CXXMemberCallExprs. * Factored out some code in StmtVisitor. * Removed variables from the state map when their destructors are encountered. * Started adding documentation for the consumed analysis attributes. llvm-svn: 189059
2013-08-23 04:44:47 +08:00
}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testSimpleRValueRefs() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var0;
ConsumableClass<int> var1(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
*var1;
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
var0 = static_cast<ConsumableClass<int>&&>(var1);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
*var0;
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testIfStmt() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
if (var.isValid()) {
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
*var;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
if (!var.isValid()) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
} else {
*var;
}
if (var) {
// Empty
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Update to consumed analysis. Patch by chris.wailes@gmail.com. The following functionality was added: * The same functionality is now supported for both CXXOperatorCallExprs and CXXMemberCallExprs. * Factored out some code in StmtVisitor. * Removed variables from the state map when their destructors are encountered. * Started adding documentation for the consumed analysis attributes. llvm-svn: 189059
2013-08-23 04:44:47 +08:00
if (var != nullptr) {
// Empty
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Update to consumed analysis. Patch by chris.wailes@gmail.com. The following functionality was added: * The same functionality is now supported for both CXXOperatorCallExprs and CXXMemberCallExprs. * Factored out some code in StmtVisitor. * Removed variables from the state map when their destructors are encountered. * Started adding documentation for the consumed analysis attributes. llvm-svn: 189059
2013-08-23 04:44:47 +08:00
}
Consumed analysis: switch from tests_consumed/unconsumed to a general tests_typestate attribute. Patch by chris.wailes@gmail.com. llvm-svn: 192513
2013-10-12 06:30:48 +08:00
if (var == nullptr) {
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
} else {
// Empty
}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
void testComplexConditionals0() {
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
ConsumableClass<int> var0, var1, var2;
if (var0 && var1) {
*var0;
*var1;
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
}
if (var0 || var1) {
*var0;
*var1;
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
}
if (var0 && !var1) {
*var0;
*var1;
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
}
if (var0 || !var1) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
} else {
*var0;
*var1;
}
if (!var0 && !var1) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
} else {
*var0;
*var1;
}
if (!var0 || !var1) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
} else {
*var0;
*var1;
}
if (!(var0 && var1)) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
} else {
*var0;
*var1;
}
if (!(var0 || var1)) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
} else {
*var0;
*var1;
}
if (var0 && var1 && var2) {
*var0;
*var1;
*var2;
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
*var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
}
#if 0
// FIXME: Get this test to pass.
if (var0 || var1 || var2) {
*var0;
*var1;
*var2;
} else {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
*var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
}
#endif
}
void testComplexConditionals1() {
ConsumableClass<int> var0, var1, var2;
// Coerce all variables into the unknown state.
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf4(var0);
baf4(var1);
baf4(var2);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
if (var0 && var1) {
*var0;
*var1;
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
}
if (var0 || var1) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
}
if (var0 && !var1) {
*var0;
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
}
if (var0 || !var1) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1;
}
if (!var0 && !var1) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
}
if (!(var0 || var1)) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
}
if (!var0 || !var1) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
} else {
*var0;
*var1;
}
if (!(var0 && var1)) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
} else {
*var0;
*var1;
}
if (var0 && var1 && var2) {
*var0;
*var1;
*var2;
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
*var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'unknown' state}}
}
#if 0
// FIXME: Get this test to pass.
if (var0 || var1 || var2) {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'unknown' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'unknown' state}}
*var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'unknown' state}}
} else {
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
*var2; // expected-warning {{invalid invocation of method 'operator*' on object 'var2' while it is in the 'consumed' state}}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
}
#endif
}
void testStateChangeInBranch() {
ConsumableClass<int> var;
// Make var enter the 'unknown' state.
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf4(var);
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
if (!var) {
var = ConsumableClass<int>(42);
}
*var;
}
Consumed analysis: track function parameters. Patch by chris.wailes@gmail.com. llvm-svn: 189616
2013-08-30 06:36:05 +08:00
void testFunctionParam(ConsumableClass<int> param) {
if (param.isValid()) {
*param;
} else {
Consumed Analysis: The 'consumable' attribute now takes a identifier specifying the default assumed state for objects of this class This information is used for return states and pass-by-value parameter states. Patch by Chris Wailes. Review by DeLesley Hutchins and Aaron Ballman. llvm-svn: 190116
2013-09-06 09:28:43 +08:00
*param;
Consumed analysis: track function parameters. Patch by chris.wailes@gmail.com. llvm-svn: 189616
2013-08-30 06:36:05 +08:00
}
param = nullptr;
*param; // expected-warning {{invocation of method 'operator*' on object 'param' while it is in the 'consumed' state}}
}
Consumed Analysis: Allow parameters that are passed by non-const reference to be treated as return values, and marked with the "returned_typestate" attribute. Patch by chris.wailes@gmail.com; reviewed by delesley@google.com. llvm-svn: 192932
2013-10-18 06:53:04 +08:00
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'}}
if (cond) {
Param.consume();
return; // expected-warning {{parameter 'Param' not in expected state when the function returns: expected 'unconsumed', observed 'consumed'}}
}
Param.consume();
}
void testParamReturnTypestateCaller() {
ConsumableClass<int> var;
testParamReturnTypestateCallee(true, var);
*var;
}
Consumed analysis: Add param_typestate attribute, which specifies that function parameters must be in a particular state. Patch by chris.wailes@gmail.com. Reviewed by delesley@google.com. llvm-svn: 192934
2013-10-18 07:23:53 +08:00
void testParamTypestateCallee(ConsumableClass<int> Param0 PARAM_TYPESTATE(consumed),
ConsumableClass<int> &Param1 PARAM_TYPESTATE(consumed)) {
*Param0; // expected-warning {{invalid invocation of method 'operator*' on object 'Param0' while it is in the 'consumed' state}}
*Param1; // expected-warning {{invalid invocation of method 'operator*' on object 'Param1' while it is in the 'consumed' state}}
}
void testParamTypestateCaller() {
ConsumableClass<int> Var0, Var1(42);
testParamTypestateCallee(Var0, Var1); // expected-warning {{argument not in expected state; expected 'consumed', observed 'unconsumed'}}
}
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
void baf3(ConsumableClass<int> var) {
*var;
}
void baf4(ConsumableClass<int> &var) {
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
}
void baf6(ConsumableClass<int> &&var) {
*var;
}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testCallingConventions() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
baf0(var);
*var;
baf1(var);
*var;
baf2(&var);
*var;
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf4(var);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
var = ConsumableClass<int>(42);
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf5(&var);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'unknown' state}}
var = ConsumableClass<int>(42);
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf6(static_cast<ConsumableClass<int>&&>(var));
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
}
void testConstAndNonConstMemberFunctions() {
ConsumableClass<int> var(42);
var.constCall();
*var;
var.nonconstCall();
*var;
}
void testFunctionParam0(ConsumableClass<int> param) {
*param;
}
void testFunctionParam1(ConsumableClass<int> &param) {
*param; // expected-warning {{invalid invocation of method 'operator*' on object 'param' while it is in the 'unknown' state}}
Consumed analysis: add return_typestate attribute. Patch by chris.wailes@gmail.com Functions can now declare what state the consumable type the are returning will be in. This is then used on the caller side and checked on the callee side. Constructors now use this attribute instead of the 'consumes' attribute. llvm-svn: 189843
2013-09-04 04:11:38 +08:00
}
void testReturnStates() {
ConsumableClass<int> var;
var = returnsUnconsumed();
*var;
var = returnsConsumed();
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
}
void testCallableWhen() {
ConsumableClass<int> var(42);
*var;
Consumed analysis: assume that non-const reference parameters are initially in the "uknown" state. Patch by chris.wailes@gmail.com. Reviewed by delesley. llvm-svn: 192995
2013-10-19 03:25:18 +08:00
baf4(var);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
var.callableWhenUnknown();
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testMoveAsignmentish() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var0;
ConsumableClass<long> var1(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
*var1;
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
var0 = static_cast<ConsumableClass<long>&&>(var1);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
*var0;
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Consumed analysis: non-const methods no longer transfer an object into an unknown state. Patch by chris.wailes@gmail.com. llvm-svn: 189612
2013-08-30 05:17:25 +08:00
var1 = ConsumableClass<long>(42);
var1 = nullptr;
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
void testConditionalMerge() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
if (var.isValid()) {
// Empty
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
if (var.isValid()) {
// Empty
} else {
// Empty
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
void testSetTypestate() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
*var;
var.consume();
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
var.unconsume();
*var;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
void testConsumes0() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var(nullptr);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
*var; // expected-warning {{invalid invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: replace the consumes attribute with a set_typestate attribute. Patch by chris.wailes@gmail.com; reviewed and edited by delesley. llvm-svn: 192515
2013-10-12 07:03:26 +08:00
void testConsumes1() {
Consumed analysis: change class name in test cases. The name of a class used in the testing files was updated to actually be descriptive. Patch by chris.wailes@gmail.com. llvm-svn: 189132
2013-08-24 02:40:39 +08:00
ConsumableClass<int> var(42);
Update to consumed analysis. Patch by chris.wailes@gmail.com. The following functionality was added: * The same functionality is now supported for both CXXOperatorCallExprs and CXXMemberCallExprs. * Factored out some code in StmtVisitor. * Removed variables from the state map when their destructors are encountered. * Started adding documentation for the consumed analysis attributes. llvm-svn: 189059
2013-08-23 04:44:47 +08:00
var.unconsumedCall();
var(6);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
var.unconsumedCall(); // expected-warning {{invalid invocation of method 'unconsumedCall' on object 'var' while it is in the 'consumed' state}}
Update to consumed analysis. Patch by chris.wailes@gmail.com. The following functionality was added: * The same functionality is now supported for both CXXOperatorCallExprs and CXXMemberCallExprs. * Factored out some code in StmtVisitor. * Removed variables from the state map when their destructors are encountered. * Started adding documentation for the consumed analysis attributes. llvm-svn: 189059
2013-08-23 04:44:47 +08:00
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
void testUnreachableBlock() {
Consumed analysis: improve handling of conditionals. Patch by chris.wailes@gmail.com. * The TestedVarsVisitor was folded into the ConsumedStmtVisitor. * The VarTestResult class was updated to allow these changes. * The PropagationInfo class was updated for the same reasons. * Correctly handle short-circuiting of Boolean operations. * Blocks are now marked as unreachable when we can statically prove we will never branch to them. * Unreachable blocks are skipped by the analysis. llvm-svn: 189594
2013-08-30 01:26:57 +08:00
ConsumableClass<int> var(42);
if (var) {
*var;
} else {
*var;
}
*var;
}
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
void testForLoop1() {
ConsumableClass<int> var0, var1(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
for (int i = 0; i < 10; ++i) { // expected-warning {{state of variable 'var1' must match at the entry and exit of loop}}
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1;
var1.consume();
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
void testWhileLoop1() {
int i = 10;
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
ConsumableClass<int> var0, var1(42);
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
Consumed analysis: fix ICE in handling of loop source locations. llvm-svn: 192911
2013-10-18 02:19:31 +08:00
while (i-- > 0) { // expected-warning {{state of variable 'var1' must match at the entry and exit of loop}}
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
*var1;
var1.consume();
Consumed analysis: fix ICE in handling of loop source locations. llvm-svn: 192911
2013-10-18 02:19:31 +08:00
*var1; // expected-warning {{invalid invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: improve loop handling. The prior version of the analysis marked all variables as "unknown" at the start of a loop. The new version keeps the initial state of variables unchanged, but issues a warning if the state at the end of the loop is different from the state at the beginning. This patch will eventually be replaced with a more precise analysis. Initial patch by chris.wailes@gmail.com. Reviewed and edited by delesley@google.com. llvm-svn: 192314
2013-10-10 02:30:24 +08:00
*var0; // expected-warning {{invalid invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206
2013-08-13 05:20:55 +08:00
}
Consumed analysis: fix ICE in handling of loop source locations. llvm-svn: 192911
2013-10-18 02:19:31 +08:00
namespace ContinueICETest {
bool cond1();
bool cond2();
static void foo1() {
while (cond1()) {
if (cond2())
continue;
}
}
static void foo2() {
while (true) {
if (false)
continue;
}
}
Consumed analysis: update to previous test case. llvm-svn: 192926
2013-10-18 06:21:03 +08:00
class runtime_error
{
public:
virtual ~runtime_error();
};
void read(bool sf) {
while (sf) {
if(sf) throw runtime_error();
}
}
Consumed analysis: fix ICE in handling of loop source locations. llvm-svn: 192911
2013-10-18 02:19:31 +08:00
} // end namespace ContinueICETest
Consumed analysis: fix assert failure. llvm-svn: 193010
2013-10-19 07:11:49 +08:00
namespace InitializerAssertionFailTest {
class CONSUMABLE(unconsumed) Status {
int code;
public:
Status() RETURN_TYPESTATE(consumed);
Status(int c) RETURN_TYPESTATE(unconsumed);
Status(const Status &other);
//Status(Status &&other);
Status& operator=(const Status &other) CALLABLE_WHEN("unknown", "consumed");
//Status& operator=(Status &&other) CALLABLE_WHEN("unknown", "consumed");
bool check() const SET_TYPESTATE(consumed);
void ignore() const SET_TYPESTATE(consumed);
// Status& markAsChecked() { return *this; }
void clear() CALLABLE_WHEN("unknown", "consumed") SET_TYPESTATE(consumed);
~Status() CALLABLE_WHEN("unknown", "consumed");
};
bool cond();
Status doSomething();
void handleStatus(const Status& s);
void handleStatusPtr(const Status* s);
int a;
void test() {
if (cond()) {
Status s = doSomething();
return; // Warning: Store it, but don't check.
}
}
} // end namespace InitializerAssertionFailTest