Skip to content

Commit c9aea86

Browse files
JonasTothJonasToth
committedOct 18, 2017
[clang-tidy] introduce legacy resource functions to 'cppcoreguidelines-owning-memory'
Summary: This patch introduces support for legacy C-style resource functions that must obey the 'owner<>' semantics. - added legacy creators like malloc,fopen,... - added legacy consumers like free,fclose,... This helps codes that mostly benefit from owner: Legacy, C-Style code that isn't feasable to port directly to RAII but needs a step in between to identify actual resource management and just using the resources. Reviewers: aaron.ballman, alexfh, hokein Reviewed By: aaron.ballman Subscribers: nemanjai, JDevlieghere, xazax.hun, kbarton Differential Revision: https://reviews.llvm.org/D38396 llvm-svn: 316092
·
llvmorg-21-initllvmorg-6.0.0-rc1
1 parent 13ce95b commit c9aea86

File tree

5 files changed

+377
-6
lines changed

5 files changed

+377
-6
lines changed
 

‎clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

+71-3
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,21 @@ namespace clang {
2222
namespace tidy {
2323
namespace cppcoreguidelines {
2424

25+
// FIXME: Copied from 'NoMallocCheck.cpp'. Has to be refactored into 'util' or
26+
// something like that.
27+
namespace {
28+
Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
29+
const std::vector<std::string> NameList =
30+
utils::options::parseStringList(FunctionNames);
31+
return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
32+
}
33+
} // namespace
34+
35+
void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
36+
Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
37+
Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);
38+
}
39+
2540
/// Match common cases, where the owner semantic is relevant, like function
2641
/// calls, delete expressions and others.
2742
void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
@@ -30,10 +45,31 @@ void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
3045

3146
const auto OwnerDecl = typeAliasTemplateDecl(hasName("::gsl::owner"));
3247
const auto IsOwnerType = hasType(OwnerDecl);
48+
49+
const auto LegacyCreatorFunctions = hasAnyListedName(LegacyResourceProducers);
50+
const auto LegacyConsumerFunctions =
51+
hasAnyListedName(LegacyResourceConsumers);
52+
53+
// Legacy functions that are use for resource management but cannot be
54+
// updated to use `gsl::owner<>`, like standard C memory management.
55+
const auto CreatesLegacyOwner =
56+
callExpr(callee(functionDecl(LegacyCreatorFunctions)));
57+
// C-style functions like `::malloc()` sometimes create owners as void*
58+
// which is expected to be cast to the correct type in C++. This case
59+
// must be catched explicitly.
60+
const auto LegacyOwnerCast =
61+
castExpr(hasSourceExpression(CreatesLegacyOwner));
62+
// Functions that do manual resource management but cannot be updated to use
63+
// owner. Best example is `::free()`.
64+
const auto LegacyOwnerConsumers = functionDecl(LegacyConsumerFunctions);
65+
3366
const auto CreatesOwner =
34-
anyOf(cxxNewExpr(), callExpr(callee(functionDecl(
35-
returns(qualType(hasDeclaration(OwnerDecl)))))));
36-
const auto ConsideredOwner = anyOf(IsOwnerType, CreatesOwner);
67+
anyOf(cxxNewExpr(),
68+
callExpr(callee(
69+
functionDecl(returns(qualType(hasDeclaration(OwnerDecl)))))),
70+
CreatesLegacyOwner, LegacyOwnerCast);
71+
72+
const auto ConsideredOwner = eachOf(IsOwnerType, CreatesOwner);
3773

3874
// Find delete expressions that delete non-owners.
3975
Finder->addMatcher(
@@ -43,6 +79,21 @@ void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
4379
.bind("delete_expr"),
4480
this);
4581

82+
// Ignoring the implicit casts is vital because the legacy owners do not work
83+
// with the 'owner<>' annotation and therefore always implicitly cast to the
84+
// legacy type (even 'void *').
85+
//
86+
// Furthermore, legacy owner functions are assumed to use raw pointers for
87+
// resources. This check assumes that all pointer arguments of a legacy
88+
// functions shall be 'gsl::owner<>'.
89+
Finder->addMatcher(
90+
callExpr(
91+
allOf(callee(LegacyOwnerConsumers),
92+
hasAnyArgument(allOf(unless(ignoringImpCasts(ConsideredOwner)),
93+
hasType(pointerType())))))
94+
.bind("legacy_consumer"),
95+
this);
96+
4697
// Matching assignment to owners, with the rhs not being an owner nor creating
4798
// one.
4899
Finder->addMatcher(binaryOperator(allOf(matchers::isAssignmentOperator(),
@@ -133,6 +184,7 @@ void OwningMemoryCheck::check(const MatchFinder::MatchResult &Result) {
133184

134185
bool CheckExecuted = false;
135186
CheckExecuted |= handleDeletion(Nodes);
187+
CheckExecuted |= handleLegacyConsumers(Nodes);
136188
CheckExecuted |= handleExpectedOwner(Nodes);
137189
CheckExecuted |= handleAssignmentAndInit(Nodes);
138190
CheckExecuted |= handleAssignmentFromNewOwner(Nodes);
@@ -168,6 +220,22 @@ bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) {
168220
return false;
169221
}
170222

223+
bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) {
224+
// Result of matching for legacy consumer-functions like `::free()`.
225+
const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
226+
227+
// FIXME: `freopen` should be handled seperately because it takes the filename
228+
// as a pointer, which should not be an owner. The argument that is an owner
229+
// is known and the false positive coming from the filename can be avoided.
230+
if (LegacyConsumer) {
231+
diag(LegacyConsumer->getLocStart(),
232+
"calling legacy resource function without passing a 'gsl::owner<>'")
233+
<< LegacyConsumer->getSourceRange();
234+
return true;
235+
}
236+
return false;
237+
}
238+
171239
bool OwningMemoryCheck::handleExpectedOwner(const BoundNodes &Nodes) {
172240
// Result of function call matchers.
173241
const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");

‎clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

+20-1
Original file line numberDiff line numberDiff line change
@@ -24,17 +24,36 @@ namespace cppcoreguidelines {
2424
class OwningMemoryCheck : public ClangTidyCheck {
2525
public:
2626
OwningMemoryCheck(StringRef Name, ClangTidyContext *Context)
27-
: ClangTidyCheck(Name, Context) {}
27+
: ClangTidyCheck(Name, Context),
28+
LegacyResourceProducers(Options.get(
29+
"LegacyResourceProducers", "::malloc;::aligned_alloc;::realloc;"
30+
"::calloc;::fopen;::freopen;::tmpfile")),
31+
LegacyResourceConsumers(Options.get(
32+
"LegacyResourceConsumers", "::free;::realloc;::freopen;::fclose")) {
33+
}
34+
35+
/// Make configuration of checker discoverable.
36+
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
37+
2838
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
2939
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
3040

3141
private:
3242
bool handleDeletion(const ast_matchers::BoundNodes &Nodes);
43+
bool handleLegacyConsumers(const ast_matchers::BoundNodes &Nodes);
3344
bool handleExpectedOwner(const ast_matchers::BoundNodes &Nodes);
3445
bool handleAssignmentAndInit(const ast_matchers::BoundNodes &Nodes);
3546
bool handleAssignmentFromNewOwner(const ast_matchers::BoundNodes &Nodes);
3647
bool handleReturnValues(const ast_matchers::BoundNodes &Nodes);
3748
bool handleOwnerMembers(const ast_matchers::BoundNodes &Nodes);
49+
50+
/// List of old C-style functions that create resources.
51+
/// Defaults to
52+
/// `::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile`.
53+
const std::string LegacyResourceProducers;
54+
/// List of old C-style functions that consume or release resources.
55+
/// Defaults to `::free;::realloc;::freopen;::fclose`.
56+
const std::string LegacyResourceConsumers;
3857
};
3958

4059
} // namespace cppcoreguidelines

‎clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-owning-memory.rst

+31-2
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,8 @@ the `Guideline Support Library <https://github.com/isocpp/CppCoreGuidelines/blob
2020
All checks are purely type based and not (yet) flow sensitive.
2121

2222
The following examples will demonstrate the correct and incorrect initializations
23-
of owners, assignment is handled the same way.
23+
of owners, assignment is handled the same way. Note that both ``new`` and
24+
``malloc()``-like resource functions are considered to produce resources.
2425

2526
.. code-block:: c++
2627

@@ -69,6 +70,33 @@ argument get called with either a ``gsl::owner<T*>`` or a newly created resource
6970
expects_owner(Owner); // Good
7071
expects_owner(new int(42)); // Good as well, recognized created resource
7172

73+
// Port legacy code for better resource-safety
74+
gsl::owner<FILE*> File = fopen("my_file.txt", "rw+");
75+
FILE* BadFile = fopen("another_file.txt", "w"); // Bad, warned
76+
77+
// ... use the file
78+
79+
fclose(File); // Ok, File is annotated as 'owner<>'
80+
fclose(BadFile); // BadFile is not an 'owner<>', will be warned
81+
82+
83+
Options
84+
-------
85+
86+
.. option:: LegacyResourceProducers
87+
88+
Semicolon-separated list of fully qualified names of legacy functions that create
89+
resources but cannot introduce ``gsl::owner<>``.
90+
Defaults to ``::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile``.
91+
92+
93+
.. option:: LegacyResourceConsumers
94+
95+
Semicolon-separated list of fully qualified names of legacy functions expecting
96+
resource owners as pointer arguments but cannot introduce ``gsl::owner<>``.
97+
Defaults to ``::free;::realloc;::freopen;::fclose``.
98+
99+
72100
Limitations
73101
-----------
74102

@@ -82,7 +110,8 @@ Using ``gsl::owner<T*>`` in a typedef or alias is not handled correctly.
82110
The ``gsl::owner<T*>`` is declared as a templated type alias.
83111
In template functions and classes, like in the example below, the information
84112
of the type aliases gets lost. Therefore using ``gsl::owner<T*>`` in a heavy templated
85-
code base might lead to false positives.
113+
code base might lead to false positives.
114+
This limitation results in ``std::vector<gsl::owner<T*>>`` not being diagnosed correctly.
86115

87116
.. code-block:: c++
88117

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

+61
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
// RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t
2+
3+
namespace gsl {
4+
template <typename T>
5+
using owner = T;
6+
}
7+
8+
namespace std {
9+
10+
// Not actually a vector, but more a dynamic, fixed size array. Just to demonstrate
11+
// functionality or the lack of the same.
12+
template <typename T>
13+
class vector {
14+
public:
15+
vector(unsigned long size, T val) : data{new T[size]}, size{size} {
16+
for (unsigned long i = 0ul; i < size; ++i) {
17+
data[i] = val;
18+
}
19+
}
20+
21+
T *begin() { return data; }
22+
T *end() { return &data[size]; }
23+
T &operator[](unsigned long index) { return data[index]; }
24+
25+
private:
26+
T *data;
27+
unsigned long size;
28+
};
29+
30+
} // namespace std
31+
32+
// All of the following codesnippets should be valid with appropriate 'owner<>' anaylsis,
33+
// but currently the type information of 'gsl::owner<>' gets lost in typededuction.
34+
int main() {
35+
std::vector<gsl::owner<int *>> OwnerStdVector(100, nullptr);
36+
37+
// Rangebased looping in resource vector.
38+
for (auto *Element : OwnerStdVector) {
39+
Element = new int(42);
40+
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
41+
}
42+
for (auto *Element : OwnerStdVector) {
43+
delete Element;
44+
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
45+
// CHECK-MESSAGES: [[@LINE-3]]:8: note: variable declared here
46+
}
47+
48+
// Indexbased looping in resource vector.
49+
for (int i = 0; i < 100; ++i) {
50+
OwnerStdVector[i] = new int(42);
51+
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'
52+
}
53+
for (int i = 0; i < 100; ++i) {
54+
delete OwnerStdVector[i];
55+
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead
56+
// A note gets emitted here pointing to the return value of the operator[] from the
57+
// vector implementation. Maybe this is considered misleading.
58+
}
59+
60+
return 0;
61+
}

‎clang-tools-extra/test/clang-tidy/cppcoreguidelines-owning-memory-legacy-functions.cpp

+194
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,194 @@
1+
// RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t \
2+
// RUN: -config='{CheckOptions: \
3+
// RUN: [{key: cppcoreguidelines-owning-memory.LegacyResourceProducers, value: "::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile"}, \
4+
// RUN: {key: cppcoreguidelines-owning-memory.LegacyResourceConsumers, value: "::free;::realloc;::freopen;::fclose"}]}' \
5+
// RUN: -- -std=c++11 -nostdlib -nostdinc++
6+
7+
namespace gsl {
8+
template <class T>
9+
using owner = T;
10+
} // namespace gsl
11+
12+
extern "C" {
13+
using size_t = unsigned long;
14+
using FILE = int;
15+
16+
void *malloc(size_t ByteCount);
17+
void *aligned_alloc(size_t Alignment, size_t Size);
18+
void *calloc(size_t Count, size_t SizeSingle);
19+
void *realloc(void *Resource, size_t NewByteCount);
20+
void free(void *Resource);
21+
22+
FILE *tmpfile(void);
23+
FILE *fopen(const char *filename, const char *mode);
24+
FILE *freopen(const char *filename, const char *mode, FILE *stream);
25+
void fclose(FILE *Resource);
26+
}
27+
28+
namespace std {
29+
using ::FILE;
30+
using ::size_t;
31+
32+
using ::fclose;
33+
using ::fopen;
34+
using ::freopen;
35+
using ::tmpfile;
36+
37+
using ::aligned_alloc;
38+
using ::calloc;
39+
using ::free;
40+
using ::malloc;
41+
using ::realloc;
42+
} // namespace std
43+
44+
void nonOwningCall(int *Resource, size_t Size) {}
45+
void nonOwningCall(FILE *Resource) {}
46+
47+
void consumesResource(gsl::owner<int *> Resource, size_t Size) {}
48+
void consumesResource(gsl::owner<FILE *> Resource) {}
49+
50+
void testNonCasted(void *Resource) {}
51+
52+
void testNonCastedOwner(gsl::owner<void *> Resource) {}
53+
54+
FILE *fileFactory1() { return ::fopen("new_file.txt", "w"); }
55+
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: returning a newly created resource of type 'FILE *' (aka 'int *') or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
56+
gsl::owner<FILE *> fileFactory2() { return std::fopen("new_file.txt", "w"); } // Ok
57+
58+
int *arrayFactory1() { return (int *)std::malloc(100); }
59+
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: returning a newly created resource of type 'int *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
60+
gsl::owner<int *> arrayFactory2() { return (int *)std::malloc(100); } // Ok
61+
void *dataFactory1() { return std::malloc(100); }
62+
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: returning a newly created resource of type 'void *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>'
63+
gsl::owner<void *> dataFactory2() { return std::malloc(100); } // Ok
64+
65+
void test_resource_creators() {
66+
const unsigned int ByteCount = 25 * sizeof(int);
67+
int Bad = 42;
68+
69+
int *IntArray1 = (int *)std::malloc(ByteCount);
70+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
71+
int *IntArray2 = static_cast<int *>(std::malloc(ByteCount)); // Bad
72+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
73+
void *IntArray3 = std::malloc(ByteCount);
74+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'void *' with a newly created 'gsl::owner<>'
75+
76+
int *IntArray4 = (int *)::malloc(ByteCount);
77+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
78+
int *IntArray5 = static_cast<int *>(::malloc(ByteCount)); // Bad
79+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
80+
void *IntArray6 = ::malloc(ByteCount);
81+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'void *' with a newly created 'gsl::owner<>'
82+
83+
gsl::owner<int *> IntArray7 = (int *)malloc(ByteCount); // Ok
84+
gsl::owner<void *> IntArray8 = malloc(ByteCount); // Ok
85+
86+
gsl::owner<int *> IntArray9 = &Bad;
87+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'int *'
88+
89+
nonOwningCall((int *)malloc(ByteCount), 25);
90+
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>'
91+
nonOwningCall((int *)::malloc(ByteCount), 25);
92+
// CHECK-MESSAGES: [[@LINE-1]]:24: warning: initializing non-owner argument of type 'int *' with a newly created 'gsl::owner<>'
93+
94+
consumesResource((int *)malloc(ByteCount), 25); // Ok
95+
consumesResource((int *)::malloc(ByteCount), 25); // Ok
96+
97+
testNonCasted(malloc(ByteCount));
98+
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'void *' with a newly created 'gsl::owner<>'
99+
testNonCastedOwner(gsl::owner<void *>(malloc(ByteCount))); // Ok
100+
testNonCastedOwner(malloc(ByteCount)); // Ok
101+
102+
FILE *File1 = std::fopen("test_name.txt", "w+");
103+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
104+
FILE *File2 = ::fopen("test_name.txt", "w+");
105+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
106+
107+
gsl::owner<FILE *> File3 = ::fopen("test_name.txt", "w+"); // Ok
108+
109+
FILE *File4;
110+
File4 = ::fopen("test_name.txt", "w+");
111+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: assigning newly created 'gsl::owner<>' to non-owner 'FILE *' (aka 'int *')
112+
113+
gsl::owner<FILE *> File5;
114+
File5 = ::fopen("test_name.txt", "w+"); // Ok
115+
File5 = File1;
116+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'FILE *' (aka 'int *')
117+
118+
gsl::owner<FILE *> File6 = File1;
119+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: expected initialization with value of type 'gsl::owner<>'; got 'FILE *' (aka 'int *')
120+
121+
FILE *File7 = tmpfile();
122+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
123+
gsl::owner<FILE *> File8 = tmpfile(); // Ok
124+
125+
nonOwningCall(::fopen("test_name.txt", "r"));
126+
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
127+
nonOwningCall(std::fopen("test_name.txt", "r"));
128+
// CHECK-MESSAGES: [[@LINE-1]]:17: warning: initializing non-owner argument of type 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
129+
130+
consumesResource(::fopen("test_name.txt", "r")); // Ok
131+
132+
int *HeapPointer3 = (int *)aligned_alloc(16ul, 4ul * 32ul);
133+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
134+
gsl::owner<int *> HeapPointer4 = static_cast<int *>(aligned_alloc(16ul, 4ul * 32ul)); // Ok
135+
136+
void *HeapPointer5 = calloc(10ul, 4ul);
137+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'void *' with a newly created 'gsl::owner<>'
138+
gsl::owner<void *> HeapPointer6 = calloc(10ul, 4ul); // Ok
139+
}
140+
141+
void test_legacy_consumers() {
142+
int StackInteger = 42;
143+
144+
int *StackPointer = &StackInteger;
145+
int *HeapPointer1 = (int *)malloc(100);
146+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
147+
gsl::owner<int *> HeapPointer2 = (int *)malloc(100);
148+
149+
std::free(StackPointer);
150+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
151+
std::free(HeapPointer1);
152+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
153+
std::free(HeapPointer2); // Ok
154+
// CHECK MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
155+
156+
// FIXME: the check complains about initialization of 'void *' with new created owner.
157+
// This happens, because the argument of `free` is not marked as 'owner<>' (and cannot be),
158+
// and the check will not figure out could be meant as owner.
159+
// This property will probably never be fixed, because it is probably a rather rare
160+
// use-case and 'owner<>' should be wrapped in RAII classes anyway!
161+
std::free(std::malloc(100)); // Ok but silly :)
162+
// CHECK-MESSAGES: [[@LINE-1]]:13: warning: initializing non-owner argument of type 'void *' with a newly created 'gsl::owner<>'
163+
164+
// Demonstrate, that multi-argument functions are diagnosed as well.
165+
std::realloc(StackPointer, 200);
166+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
167+
std::realloc(HeapPointer1, 200);
168+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
169+
std::realloc(HeapPointer2, 200); // Ok
170+
std::realloc(std::malloc(100), 200); // Ok but silly
171+
// CHECK-MESSAGES: [[@LINE-1]]:16: warning: initializing non-owner argument of type 'void *' with a newly created 'gsl::owner<>'
172+
173+
fclose(fileFactory1());
174+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling legacy resource function without passing a 'gsl::owner<>'
175+
fclose(fileFactory2()); // Ok, same as FIXME with `free(malloc(100))` applies here
176+
// CHECK-MESSAGES: [[@LINE-1]]:10: warning: initializing non-owner argument of type 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
177+
178+
gsl::owner<FILE *> File1 = fopen("testfile.txt", "r"); // Ok
179+
FILE *File2 = freopen("testfile.txt", "w", File1);
180+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
181+
// CHECK-MESSAGES: [[@LINE-2]]:17: warning: calling legacy resource function without passing a 'gsl::owner<>'
182+
// FIXME: The warning for not passing and owner<> is a false positive since both the filename and the
183+
// mode are not supposed to be owners but still pointers. The check is to coarse for
184+
// this function. Maybe `freopen` gets special treatment.
185+
186+
gsl::owner<FILE *> File3 = freopen("testfile.txt", "w", File2); // Bad, File2 no owner
187+
// CHECK-MESSAGES: [[@LINE-1]]:30: warning: calling legacy resource function without passing a 'gsl::owner<>'
188+
189+
FILE *TmpFile = tmpfile();
190+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
191+
FILE *File6 = freopen("testfile.txt", "w", TmpFile); // Bad, both return and argument
192+
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: initializing non-owner 'FILE *' (aka 'int *') with a newly created 'gsl::owner<>'
193+
// CHECK-MESSAGES: [[@LINE-2]]:17: warning: calling legacy resource function without passing a 'gsl::owner<>'
194+
}

0 commit comments

Comments
 (0)
Please sign in to comment.