blob: eb0ee6c1fd8a0e4d487f5c832786423bbea7415f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
//===- unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp ------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "CheckerRegistration.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
#include "clang/Tooling/Tooling.h"
#include "gtest/gtest.h"
namespace clang {
namespace ento {
namespace {
class TestReturnValueUnderConstructionChecker
: public Checker<check::PostCall> {
public:
void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
// Only calls with origin expression are checked. These are `returnC()`,
// `returnD()`, C::C() and D::D().
if (!Call.getOriginExpr())
return;
// Since `returnC` returns an object by value, the invocation results
// in an object of type `C` constructed into variable `c`. Thus the
// return value of `CallEvent::getReturnValueUnderConstruction()` must
// be non-empty and has to be a `MemRegion`.
Optional<SVal> RetVal = Call.getReturnValueUnderConstruction();
ASSERT_TRUE(RetVal);
ASSERT_TRUE(RetVal->getAsRegion());
const auto *RetReg = cast<TypedValueRegion>(RetVal->getAsRegion());
const Expr *OrigExpr = Call.getOriginExpr();
ASSERT_EQ(OrigExpr->getType(), RetReg->getValueType());
}
};
void addTestReturnValueUnderConstructionChecker(
AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
AnOpts.CheckersAndPackages =
{{"test.TestReturnValueUnderConstruction", true}};
AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
Registry.addChecker<TestReturnValueUnderConstructionChecker>(
"test.TestReturnValueUnderConstruction", "", "");
});
}
TEST(TestReturnValueUnderConstructionChecker,
ReturnValueUnderConstructionChecker) {
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
R"(class C {
public:
C(int nn): n(nn) {}
virtual ~C() {}
private:
int n;
};
C returnC(int m) {
C c(m);
return c;
}
void foo() {
C c = returnC(1);
})"));
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
R"(class C {
public:
C(int nn): n(nn) {}
explicit C(): C(0) {}
virtual ~C() {}
private:
int n;
};
C returnC() {
C c;
return c;
}
void foo() {
C c = returnC();
})"));
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
R"(class C {
public:
C(int nn): n(nn) {}
virtual ~C() {}
private:
int n;
};
class D: public C {
public:
D(int nn): C(nn) {}
virtual ~D() {}
};
D returnD(int m) {
D d(m);
return d;
}
void foo() {
D d = returnD(1);
})"));
}
} // namespace
} // namespace ento
} // namespace clang
|
