This is an archive of the discontinued LLVM Phabricator instance.

Differential D52687

[clang-tidy] NFC use CHECK-NOTES in tests for cppcoreguidelines-owning-memory
ClosedPublic

Authored by JonasToth on Sep 29 2018, 6:41 AM.

Details

Reviewers
alexfh
aaron.ballman
hokein
Commits
rG46619229acd5: [clang-tidy] NFC use CHECK-NOTES in tests for cppcoreguidelines-owning-memory
rCTE343564: [clang-tidy] NFC use CHECK-NOTES in tests for cppcoreguidelines-owning-memory
rL343564: [clang-tidy] NFC use CHECK-NOTES in tests for cppcoreguidelines-owning-memory

Diff Detail

Repository
rL LLVM

Event Timeline

JonasToth created this revision.Sep 29 2018, 6:41 AM
Herald added subscribers: cfe-commits, kbarton, xazax.hun, nemanjai. · View Herald TranscriptSep 29 2018, 6:41 AM
Harbormaster completed remote builds in B23274: Diff 167599.Sep 29 2018, 6:41 AM
alexfh accepted this revision.Oct 1 2018, 5:27 AM

LG

This revision is now accepted and ready to land.Oct 1 2018, 5:27 AM
Closed by commit rL343564: [clang-tidy] NFC use CHECK-NOTES in tests for cppcoreguidelines-owning-memory (authored by JonasToth). · Explain WhyOct 2 2018, 2:40 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptOct 2 2018, 2:40 AM

Revision Contents

PathSize
clang-tools-extra/
trunk/
test/
clang-tidy/
11 lines
88 lines

Diff 167898

clang-tools-extra/trunk/test/clang-tidy/cppcoreguidelines-owning-memory-containers.cpp

Show All 31 Lines
// All of the following codesnippets should be valid with appropriate 'owner<>' anaylsis, // All of the following codesnippets should be valid with appropriate 'owner<>' anaylsis,
// but currently the type information of 'gsl::owner<>' gets lost in typededuction. // but currently the type information of 'gsl::owner<>' gets lost in typededuction.
int main() { int main() {
std::vector<gsl::owner<int *>> OwnerStdVector(100, nullptr); std::vector<gsl::owner<int *>> OwnerStdVector(100, nullptr);
// Rangebased looping in resource vector. // Rangebased looping in resource vector.
for (auto *Element : OwnerStdVector) { for (auto *Element : OwnerStdVector) {
Element = new int(42); Element = new int(42);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *' // CHECK-NOTES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
} }
for (auto *Element : OwnerStdVector) { for (auto *Element : OwnerStdVector) {
delete Element; delete Element;
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead // CHECK-NOTES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
// CHECK-MESSAGES: [[@LINE-3]]:8: note: variable declared here // CHECK-NOTES: [[@LINE-3]]:8: note: variable declared here
} }
// Indexbased looping in resource vector. // Indexbased looping in resource vector.
for (int i = 0; i < 100; ++i) { for (int i = 0; i < 100; ++i) {
OwnerStdVector[i] = new int(42); OwnerStdVector[i] = new int(42);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *' // CHECK-NOTES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
} }
for (int i = 0; i < 100; ++i) { for (int i = 0; i < 100; ++i) {
delete OwnerStdVector[i]; delete OwnerStdVector[i];
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead // CHECK-NOTES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
// CHECK-NOTES: [[@LINE-21]]:3: note: variable declared here
// A note gets emitted here pointing to the return value of the operator[] from the // A note gets emitted here pointing to the return value of the operator[] from the
// vector implementation. Maybe this is considered misleading. // vector implementation. Maybe this is considered misleading.
} }
return 0; return 0;
} }

clang-tools-extra/trunk/test/clang-tidy/cppcoreguidelines-owning-memory.cpp

Show All 30 Lines
} }
gsl::owner<int *> returns_owner1() { return gsl::owner<int *>(new int(42)); } // Ok gsl::owner<int *> returns_owner1() { return gsl::owner<int *>(new int(42)); } // Ok
gsl::owner<int *> returns_owner2() { return new int(42); } // Ok gsl::owner<int *> returns_owner2() { return new int(42); } // Ok
int *returns_no_owner1() { return nullptr; } int *returns_no_owner1() { return nullptr; }
int *returns_no_owner2() { int *returns_no_owner2() {
return new int(42); return new int(42);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: returning a newly created resource of type 'int *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: returning a newly created resource of type 'int *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
} }
int *returns_no_owner3() { int *returns_no_owner3() {
int *should_be_owner = new int(42); int *should_be_owner = new int(42);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
return should_be_owner; return should_be_owner;
} }
int *returns_no_owner4() { int *returns_no_owner4() {
gsl::owner<int *> owner = new int(42); gsl::owner<int *> owner = new int(42);
return owner; return owner;
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: returning a newly created resource of type 'int *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: returning a newly created resource of type 'int *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
} }
unique_ptr<int *> returns_no_owner5() { unique_ptr<int *> returns_no_owner5() {
return unique_ptr<int *>(new int(42)); // Ok return unique_ptr<int *>(new int(42)); // Ok
} }
/// FIXME: CSA finds it, but the report is misleading. Ownersemantics can catch this /// FIXME: CSA finds it, but the report is misleading. Ownersemantics can catch this
/// by flow analysis similar to bugprone-use-after-move. /// by flow analysis similar to bugprone-use-after-move.
void csa_not_finding_leak() { void csa_not_finding_leak() {
gsl::owner<int *> o1 = new int(42); // Ok gsl::owner<int *> o1 = new int(42); // Ok
gsl::owner<int *> o2 = o1; // Ok gsl::owner<int *> o2 = o1; // Ok
o2 = new int(45); // conceptual leak, the memory from o1 is now leaked, since its considered moved in the guidelines o2 = new int(45); // conceptual leak, the memory from o1 is now leaked, since its considered moved in the guidelines
delete o2; delete o2;
// actual leak occurs here, its found, but mixed // actual leak occurs here, its found, but mixed
delete o1; delete o1;
} }
void test_assignment_and_initialization() { void test_assignment_and_initialization() {
int stack_int1 = 15; int stack_int1 = 15;
int stack_int2; int stack_int2;
gsl::owner<int *> owned_int1 = &stack_int1; // BAD gsl::owner<int *> owned_int1 = &stack_int1; // BAD
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
gsl::owner<int *> owned_int2; gsl::owner<int *> owned_int2;
owned_int2 = &stack_int2; // BAD since no owner, bad since uninitialized owned_int2 = &stack_int2; // BAD since no owner, bad since uninitialized
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'int *'
gsl::owner<int *> owned_int3 = new int(42); // Good gsl::owner<int *> owned_int3 = new int(42); // Good
owned_int3 = nullptr; // Good owned_int3 = nullptr; // Good
gsl::owner<int *> owned_int4(nullptr); // Ok gsl::owner<int *> owned_int4(nullptr); // Ok
owned_int4 = new int(42); // Good owned_int4 = new int(42); // Good
gsl::owner<int *> owned_int5 = owned_int3; // Good gsl::owner<int *> owned_int5 = owned_int3; // Good
gsl::owner<int *> owned_int6{nullptr}; // Ok gsl::owner<int *> owned_int6{nullptr}; // Ok
owned_int6 = owned_int4; // Good owned_int6 = owned_int4; // Good
// FIXME:, flow analysis for the case of reassignment. Value must be released before // FIXME:, flow analysis for the case of reassignment. Value must be released before
owned_int6 = owned_int3; // BAD, because reassignment without resource release owned_int6 = owned_int3; // BAD, because reassignment without resource release
auto owned_int7 = returns_owner1(); // Bad, since type deduction eliminates the owner wrapper auto owned_int7 = returns_owner1(); // Bad, since type deduction eliminates the owner wrapper
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
// CHECK-MESSAGES: [[@LINE-2]]:3: note: type deduction did not result in an owner // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
const auto owned_int8 = returns_owner2(); // Bad, since type deduction eliminates the owner wrapper const auto owned_int8 = returns_owner2(); // Bad, since type deduction eliminates the owner wrapper
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *const' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *const' with a newly created 'gsl::owner<>'
// CHECK-MESSAGES: [[@LINE-2]]:3: note: type deduction did not result in an owner // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
gsl::owner<int *> owned_int9 = returns_owner1(); // Ok gsl::owner<int *> owned_int9 = returns_owner1(); // Ok
int *unowned_int3 = returns_owner1(); // Bad int *unowned_int3 = returns_owner1(); // Bad
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
gsl::owner<int *> owned_int10; gsl::owner<int *> owned_int10;
owned_int10 = returns_owner1(); // Ok owned_int10 = returns_owner1(); // Ok
int *unowned_int4; int *unowned_int4;
unowned_int4 = returns_owner1(); // Bad unowned_int4 = returns_owner1(); // Bad
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
gsl::owner<int *> owned_int11 = returns_no_owner1(); // Bad since no owner gsl::owner<int *> owned_int11 = returns_no_owner1(); // Bad since no owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
gsl::owner<int *> owned_int12; gsl::owner<int *> owned_int12;
owned_int12 = returns_no_owner1(); // Bad since no owner owned_int12 = returns_no_owner1(); // Bad since no owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'int *'
int *unowned_int5 = returns_no_owner1(); // Ok int *unowned_int5 = returns_no_owner1(); // Ok
int *unowned_int6; int *unowned_int6;
unowned_int6 = returns_no_owner1(); // Ok unowned_int6 = returns_no_owner1(); // Ok
int *unowned_int7 = new int(42); // Bad, since resource not assigned to an owner int *unowned_int7 = new int(42); // Bad, since resource not assigned to an owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
int *unowned_int8; int *unowned_int8;
unowned_int8 = new int(42); unowned_int8 = new int(42);
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
gsl::owner<int *> owned_int13 = nullptr; // Ok gsl::owner<int *> owned_int13 = nullptr; // Ok
} }
void test_deletion() { void test_deletion() {
gsl::owner<int *> owned_int1 = new int(42); gsl::owner<int *> owned_int1 = new int(42);
delete owned_int1; // Good delete owned_int1; // Good
gsl::owner<int *> owned_int2 = new int[42]; gsl::owner<int *> owned_int2 = new int[42];
delete[] owned_int2; // Good delete[] owned_int2; // Good
int *unowned_int1 = new int(42); // BAD, since new creates and owner int *unowned_int1 = new int(42); // BAD, since new creates and owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
delete unowned_int1; // BAD, since no owner delete unowned_int1; // BAD, since no owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead // CHECK-NOTES: [[@LINE-1]]:3: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
// CHECK-MESSAGES: [[@LINE-4]]:3: note: variable declared here // CHECK-NOTES: [[@LINE-4]]:3: note: variable declared here
int *unowned_int2 = new int[42]; // BAD, since new creates and owner int *unowned_int2 = new int[42]; // BAD, since new creates and owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
delete[] unowned_int2; // BAD since no owner delete[] unowned_int2; // BAD since no owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead // CHECK-NOTES: [[@LINE-1]]:3: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
// CHECK-MESSAGES: [[@LINE-4]]:3: note: variable declared here // CHECK-NOTES: [[@LINE-4]]:3: note: variable declared here
delete new int(42); // Technically ok, but stupid delete new int(42); // Technically ok, but stupid
delete[] new int[42]; // Technically ok, but stupid delete[] new int[42]; // Technically ok, but stupid
} }
void test_owner_function_calls() { void test_owner_function_calls() {
int stack_int = 42; int stack_int = 42;
int *unowned_int1 = &stack_int; int *unowned_int1 = &stack_int;
takes_owner(&stack_int); // BAD takes_owner(&stack_int); // BAD
// CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *'
takes_owner(unowned_int1); // BAD takes_owner(unowned_int1); // BAD
// CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *'
gsl::owner<int *> owned_int1 = new int(42); gsl::owner<int *> owned_int1 = new int(42);
takes_owner(owned_int1); // Ok takes_owner(owned_int1); // Ok
takes_owner_and_more(42, &stack_int, 42.0f); // BAD takes_owner_and_more(42, &stack_int, 42.0f); // BAD
// CHECK-MESSAGES: [[@LINE-1]]:28: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:28: warning: expected argument of type 'gsl::owner<>'; got 'int *'
takes_owner_and_more(42, unowned_int1, 42.0f); // BAD takes_owner_and_more(42, unowned_int1, 42.0f); // BAD
// CHECK-MESSAGES: [[@LINE-1]]:28: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:28: warning: expected argument of type 'gsl::owner<>'; got 'int *'
takes_owner_and_more(42, new int(42), 42.0f); // Ok, since new is consumed by owner takes_owner_and_more(42, new int(42), 42.0f); // Ok, since new is consumed by owner
takes_owner_and_more(42, owned_int1, 42.0f); // Ok, since owner as argument takes_owner_and_more(42, owned_int1, 42.0f); // Ok, since owner as argument
takes_templated_owner(owned_int1); // Ok takes_templated_owner(owned_int1); // Ok
takes_templated_owner(new int(42)); // Ok takes_templated_owner(new int(42)); // Ok
takes_templated_owner(unowned_int1); // Bad takes_templated_owner(unowned_int1); // Bad
// CHECK-MESSAGES: [[@LINE-1]]:25: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:25: warning: expected argument of type 'gsl::owner<>'; got 'int *'
takes_owner(returns_owner1()); // Ok takes_owner(returns_owner1()); // Ok
takes_owner(returns_no_owner1()); // BAD takes_owner(returns_no_owner1()); // BAD
// CHECK-MESSAGES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:15: warning: expected argument of type 'gsl::owner<>'; got 'int *'
} }
void test_unowned_function_calls() { void test_unowned_function_calls() {
int stack_int = 42; int stack_int = 42;
int *unowned_int1 = &stack_int; int *unowned_int1 = &stack_int;
gsl::owner<int *> owned_int1 = new int(42); gsl::owner<int *> owned_int1 = new int(42);
takes_pointer(&stack_int); // Ok takes_pointer(&stack_int); // Ok
takes_pointer(unowned_int1); // Ok takes_pointer(unowned_int1); // Ok
takes_pointer(owned_int1); // Ok takes_pointer(owned_int1); // Ok
takes_pointer(new int(42)); // Bad, since new creates and owner takes_pointer(new int(42)); // Bad, since new creates and owner
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>'
takes_pointer(returns_owner1()); // Bad takes_pointer(returns_owner1()); // Bad
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>'
takes_pointer(returns_no_owner1()); // Ok takes_pointer(returns_no_owner1()); // Ok
} }
// FIXME: Typedefing owner<> to something else does not work. // FIXME: Typedefing owner<> to something else does not work.
// This might be necessary for code already having a similar typedef like owner<> and // This might be necessary for code already having a similar typedef like owner<> and
// replacing it with owner<>. This might be the same problem as with templates. // replacing it with owner<>. This might be the same problem as with templates.
// The canonical type will ignore the owner<> alias, since its a typedef as well. // The canonical type will ignore the owner<> alias, since its a typedef as well.
Show All 27 Lines
} }
#endif #endif
struct ArbitraryClass {}; struct ArbitraryClass {};
struct ClassWithOwner { // Does not define destructor, necessary with owner struct ClassWithOwner { // Does not define destructor, necessary with owner
ClassWithOwner() : owner_var(nullptr) {} // Ok ClassWithOwner() : owner_var(nullptr) {} // Ok
ClassWithOwner(ArbitraryClass &other) : owner_var(&other) {} ClassWithOwner(ArbitraryClass &other) : owner_var(&other) {}
// CHECK-MESSAGES: [[@LINE-1]]:43: warning: expected initialization of owner member variable with value of type 'gsl::owner<>'; got 'ArbitraryClass *' // CHECK-NOTES: [[@LINE-1]]:43: warning: expected initialization of owner member variable with value of type 'gsl::owner<>'; got 'ArbitraryClass *'
ClassWithOwner(gsl::owner<ArbitraryClass *> other) : owner_var(other) {} // Ok ClassWithOwner(gsl::owner<ArbitraryClass *> other) : owner_var(other) {} // Ok
ClassWithOwner(gsl::owner<ArbitraryClass *> data, int /* unused */) { // Ok ClassWithOwner(gsl::owner<ArbitraryClass *> data, int /* unused */) { // Ok
owner_var = data; // Ok owner_var = data; // Ok
} }
ClassWithOwner(ArbitraryClass *bad_data, int /* unused */, int /* unused */) { ClassWithOwner(ArbitraryClass *bad_data, int /* unused */, int /* unused */) {
owner_var = bad_data; owner_var = bad_data;
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *' // CHECK-NOTES: [[@LINE-1]]:5: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *'
} }
ClassWithOwner(ClassWithOwner &&other) : owner_var{other.owner_var} {} // Ok ClassWithOwner(ClassWithOwner &&other) : owner_var{other.owner_var} {} // Ok
ClassWithOwner &operator=(ClassWithOwner &&other) { ClassWithOwner &operator=(ClassWithOwner &&other) {
owner_var = other.owner_var; // Ok owner_var = other.owner_var; // Ok
return *this; return *this;
} }
// Returning means, that the owner is "moved", so the class should not access this // Returning means, that the owner is "moved", so the class should not access this
// variable anymore after this method gets called. // variable anymore after this method gets called.
gsl::owner<ArbitraryClass *> buggy_but_returns_owner() { return owner_var; } gsl::owner<ArbitraryClass *> buggy_but_returns_owner() { return owner_var; }
gsl::owner<ArbitraryClass *> owner_var; gsl::owner<ArbitraryClass *> owner_var;
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'ClassWithOwner' to implement a destructor to release the owned resource // CHECK-NOTES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'ClassWithOwner' to implement a destructor to release the owned resource
}; };
class DefaultedDestructor { // Bad since default constructor with owner class DefaultedDestructor { // Bad since default constructor with owner
~DefaultedDestructor() = default; // Bad, since will not destroy the owner ~DefaultedDestructor() = default; // Bad, since will not destroy the owner
gsl::owner<int *> Owner; gsl::owner<int *> Owner;
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'DefaultedDestructor' to implement a destructor to release the owned resource // CHECK-NOTES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'DefaultedDestructor' to implement a destructor to release the owned resource
}; };
struct DeletedDestructor { struct DeletedDestructor {
~DeletedDestructor() = delete; ~DeletedDestructor() = delete;
gsl::owner<int *> Owner; gsl::owner<int *> Owner;
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'DeletedDestructor' to implement a destructor to release the owned resource // CHECK-NOTES: [[@LINE-1]]:3: warning: member variable of type 'gsl::owner<>' requires the class 'DeletedDestructor' to implement a destructor to release the owned resource
}; };
void test_class_with_owner() { void test_class_with_owner() {
ArbitraryClass A; ArbitraryClass A;
ClassWithOwner C1; // Ok ClassWithOwner C1; // Ok
ClassWithOwner C2{A}; // Bad, since the owner would be initialized with an non-owner, but catched in the class ClassWithOwner C2{A}; // Bad, since the owner would be initialized with an non-owner, but catched in the class
ClassWithOwner C3{gsl::owner<ArbitraryClass *>(new ArbitraryClass)}; // Ok ClassWithOwner C3{gsl::owner<ArbitraryClass *>(new ArbitraryClass)}; // Ok
const auto Owner1 = C3.buggy_but_returns_owner(); // BAD, deduces Owner1 to ArbitraryClass *const const auto Owner1 = C3.buggy_but_returns_owner(); // BAD, deduces Owner1 to ArbitraryClass *const
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *const' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *const' with a newly created 'gsl::owner<>'
// CHECK-MESSAGES: [[@LINE-2]]:3: note: type deduction did not result in an owner // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
auto Owner2 = C2.buggy_but_returns_owner(); // BAD, deduces Owner2 to ArbitraryClass * auto Owner2 = C2.buggy_but_returns_owner(); // BAD, deduces Owner2 to ArbitraryClass *
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *' with a newly created 'gsl::owner<>' // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *' with a newly created 'gsl::owner<>'
// CHECK-MESSAGES: [[@LINE-2]]:3: note: type deduction did not result in an owner // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
Owner2 = &A; // Ok, since type deduction did NOT result in owner<int*> Owner2 = &A; // Ok, since type deduction did NOT result in owner<int*>
gsl::owner<ArbitraryClass *> Owner3 = C1.buggy_but_returns_owner(); // Ok, still an owner gsl::owner<ArbitraryClass *> Owner3 = C1.buggy_but_returns_owner(); // Ok, still an owner
Owner3 = &A; // Bad, since assignment of non-owner to owner Owner3 = &A; // Bad, since assignment of non-owner to owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *'
} }
template <typename T> template <typename T>
struct HeapArray { // Ok, since destructor with owner struct HeapArray { // Ok, since destructor with owner
HeapArray() : _data(nullptr), size(0) {} // Ok HeapArray() : _data(nullptr), size(0) {} // Ok
HeapArray(int size) : _data(new int[size]), size(size) {} // Ok HeapArray(int size) : _data(new int[size]), size(size) {} // Ok
HeapArray(int size, T val) { HeapArray(int size, T val) {
_data = new int[size]; // Ok _data = new int[size]; // Ok
size = size; size = size;
for (auto i = 0u; i < size; ++i) for (auto i = 0u; i < size; ++i)
_data[i] = val; // Ok _data[i] = val; // Ok
} }
HeapArray(int size, T val, int *problematic) : _data{problematic}, size(size) {} // Bad HeapArray(int size, T val, int *problematic) : _data{problematic}, size(size) {} // Bad
// CHECK-MESSAGES: [[@LINE-1]]:50: warning: expected initialization of owner member variable with value of type 'gsl::owner<>'; got 'void' // CHECK-NOTES: [[@LINE-1]]:50: warning: expected initialization of owner member variable with value of type 'gsl::owner<>'; got 'void'
// FIXME: void is incorrect type, probably wrong thing matched // FIXME: void is incorrect type, probably wrong thing matched
HeapArray(HeapArray &&other) : _data(other._data), size(other.size) { // Ok HeapArray(HeapArray &&other) : _data(other._data), size(other.size) { // Ok
other._data = nullptr; // Ok other._data = nullptr; // Ok
other.size = 0; other.size = 0;
} }
HeapArray<T> &operator=(HeapArray<T> &&other) { HeapArray<T> &operator=(HeapArray<T> &&other) {
Show All 16 Linesvoid test_inner_template() {
HeapArray<int> Array3(100, 0); HeapArray<int> Array3(100, 0);
HeapArray<int> Array4(100, 0, nullptr); HeapArray<int> Array4(100, 0, nullptr);
Array1 = static_cast<HeapArray<int> &&>(Array2); Array1 = static_cast<HeapArray<int> &&>(Array2);
HeapArray<int> Array5(static_cast<HeapArray<int> &&>(Array3)); HeapArray<int> Array5(static_cast<HeapArray<int> &&>(Array3));
int *NonOwningPtr = Array1.data(); // Ok int *NonOwningPtr = Array1.data(); // Ok
gsl::owner<int *> OwningPtr = Array1.data(); // Bad, since it does not return the owner gsl::owner<int *> OwningPtr = Array1.data(); // Bad, since it does not return the owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
} }
// FIXME: Typededuction removes the owner - wrapper, therefore gsl::owner can not be used // FIXME: Typededuction removes the owner - wrapper, therefore gsl::owner can not be used
// with Template classes like this. Is there a walkaround? // with Template classes like this. Is there a walkaround?
template <typename T> template <typename T>
struct TemplateValue { struct TemplateValue {
TemplateValue() = default; TemplateValue() = default;
TemplateValue(T t) : val{t} {} TemplateValue(T t) : val{t} {}
void setVal(const T &t) { val = t; } void setVal(const T &t) { val = t; }
const T getVal() const { return val; } const T getVal() const { return val; }
T val; T val;
}; };
// FIXME: Same typededcution problems // FIXME: Same typededcution problems
template <typename T> template <typename T>
void template_function(T t) { void template_function(T t) {
gsl::owner<int *> owner_t = t; // Probably bad, since type deduction still wrong gsl::owner<int *> owner_t = t; // Probably bad, since type deduction still wrong
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'T' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'T'
// CHECK-MESSAGES: [[@LINE-2]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-2]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
} }
// FIXME: Same typededcution problems // FIXME: Same typededcution problems
void test_templates() { void test_templates() {
int stack_int = 42; int stack_int = 42;
int *stack_ptr1 = &stack_int; int *stack_ptr1 = &stack_int;
TemplateValue<gsl::owner<int *>> Owner0; // Ok, T should be owner, but is int* TemplateValue<gsl::owner<int *>> Owner0; // Ok, T should be owner, but is int*
TemplateValue<gsl::owner<int *>> Owner1(new int(42)); // Ok, T should be owner, but is int* TemplateValue<gsl::owner<int *>> Owner1(new int(42)); // Ok, T should be owner, but is int*
Owner1.setVal(&stack_int); // Bad since non-owner assignment Owner1.setVal(&stack_int); // Bad since non-owner assignment
Owner1.setVal(stack_ptr1); // Bad since non-owner assignment Owner1.setVal(stack_ptr1); // Bad since non-owner assignment
//Owner1.setVal(new int(42)); // Ok, but since type deduction is wrong, this one is considered harmful //Owner1.setVal(new int(42)); // Ok, but since type deduction is wrong, this one is considered harmful
int *stack_ptr2 = Owner1.getVal(); // Bad, initializing non-owner with owner int *stack_ptr2 = Owner1.getVal(); // Bad, initializing non-owner with owner
TemplateValue<int *> NonOwner1(new int(42)); // Bad, T is int *, hence dynamic memory to non-owner TemplateValue<int *> NonOwner1(new int(42)); // Bad, T is int *, hence dynamic memory to non-owner
gsl::owner<int *> IntOwner1 = NonOwner1.getVal(); // Bad, since owner initialized with non-owner gsl::owner<int *> IntOwner1 = NonOwner1.getVal(); // Bad, since owner initialized with non-owner
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *' // CHECK-NOTES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
template_function(IntOwner1); // Ok, but not actually ok, since type deduction removes owner template_function(IntOwner1); // Ok, but not actually ok, since type deduction removes owner
template_function(stack_ptr1); // Bad, but type deduction gets it wrong template_function(stack_ptr1); // Bad, but type deduction gets it wrong
} }