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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// RUN: %check_clang_tidy %s performance-unnecessary-value-param %t -- -- -fdelayed-template-parsing
struct ExpensiveToCopyType {
const ExpensiveToCopyType & constReference() const {
return *this;
}
void nonConstMethod();
virtual ~ExpensiveToCopyType();
};
void mutate(ExpensiveToCopyType &);
void mutate(ExpensiveToCopyType *);
void useAsConstReference(const ExpensiveToCopyType &);
void useByValue(ExpensiveToCopyType);
// This class simulates std::pair<>. It is trivially copy constructible
// and trivially destructible, but not trivially copy assignable.
class SomewhatTrivial {
public:
SomewhatTrivial();
SomewhatTrivial(const SomewhatTrivial&) = default;
~SomewhatTrivial() = default;
SomewhatTrivial& operator=(const SomewhatTrivial&);
};
void positiveExpensiveConstValue(const ExpensiveToCopyType Obj);
// CHECK-FIXES: void positiveExpensiveConstValue(const ExpensiveToCopyType& Obj);
void positiveExpensiveConstValue(const ExpensiveToCopyType Obj) {
// CHECK-MESSAGES: [[@LINE-1]]:60: warning: the const qualified parameter 'Obj' is copied for each invocation; consider making it a reference [performance-unnecessary-value-param]
// CHECK-FIXES: void positiveExpensiveConstValue(const ExpensiveToCopyType& Obj) {
}
void positiveExpensiveValue(ExpensiveToCopyType Obj);
// CHECK-FIXES: void positiveExpensiveValue(const ExpensiveToCopyType& Obj);
void positiveExpensiveValue(ExpensiveToCopyType Obj) {
// CHECK-MESSAGES: [[@LINE-1]]:49: warning: the parameter 'Obj' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param]
// CHECK-FIXES: void positiveExpensiveValue(const ExpensiveToCopyType& Obj) {
Obj.constReference();
useAsConstReference(Obj);
auto Copy = Obj;
useByValue(Obj);
}
void positiveWithComment(const ExpensiveToCopyType /* important */ S);
// CHECK-FIXES: void positiveWithComment(const ExpensiveToCopyType& /* important */ S);
void positiveWithComment(const ExpensiveToCopyType /* important */ S) {
// CHECK-MESSAGES: [[@LINE-1]]:68: warning: the const qualified
// CHECK-FIXES: void positiveWithComment(const ExpensiveToCopyType& /* important */ S) {
}
void positiveUnnamedParam(const ExpensiveToCopyType) {
// CHECK-MESSAGES: [[@LINE-1]]:52: warning: the const qualified parameter #1
// CHECK-FIXES: void positiveUnnamedParam(const ExpensiveToCopyType&) {
}
void positiveAndNegative(const ExpensiveToCopyType ConstCopy, const ExpensiveToCopyType& ConstRef, ExpensiveToCopyType Copy);
// CHECK-FIXES: void positiveAndNegative(const ExpensiveToCopyType& ConstCopy, const ExpensiveToCopyType& ConstRef, const ExpensiveToCopyType& Copy);
void positiveAndNegative(const ExpensiveToCopyType ConstCopy, const ExpensiveToCopyType& ConstRef, ExpensiveToCopyType Copy) {
// CHECK-MESSAGES: [[@LINE-1]]:52: warning: the const qualified parameter 'ConstCopy'
// CHECK-MESSAGES: [[@LINE-2]]:120: warning: the parameter 'Copy'
// CHECK-FIXES: void positiveAndNegative(const ExpensiveToCopyType& ConstCopy, const ExpensiveToCopyType& ConstRef, const ExpensiveToCopyType& Copy) {
}
struct PositiveConstValueConstructor {
PositiveConstValueConstructor(const ExpensiveToCopyType ConstCopy) {}
// CHECK-MESSAGES: [[@LINE-1]]:59: warning: the const qualified parameter 'ConstCopy'
// CHECK-FIXES: PositiveConstValueConstructor(const ExpensiveToCopyType& ConstCopy) {}
};
template <typename T> void templateWithNonTemplatizedParameter(const ExpensiveToCopyType S, T V) {
// CHECK-MESSAGES: [[@LINE-1]]:90: warning: the const qualified parameter 'S'
// CHECK-FIXES: template <typename T> void templateWithNonTemplatizedParameter(const ExpensiveToCopyType& S, T V) {
}
void instantiated() {
templateWithNonTemplatizedParameter(ExpensiveToCopyType(), ExpensiveToCopyType());
templateWithNonTemplatizedParameter(ExpensiveToCopyType(), 5);
}
template <typename T> void negativeTemplateType(const T V) {
}
void negativeArray(const ExpensiveToCopyType[]) {
}
void negativePointer(ExpensiveToCopyType* Obj) {
}
void negativeConstPointer(const ExpensiveToCopyType* Obj) {
}
void negativeConstReference(const ExpensiveToCopyType& Obj) {
}
void negativeReference(ExpensiveToCopyType& Obj) {
}
void negativeUniversalReference(ExpensiveToCopyType&& Obj) {
}
void negativeSomewhatTrivialConstValue(const SomewhatTrivial Somewhat) {
}
void negativeSomewhatTrivialValue(SomewhatTrivial Somewhat) {
}
void negativeConstBuiltIn(const int I) {
}
void negativeValueBuiltIn(int I) {
}
void negativeValueIsMutatedByReference(ExpensiveToCopyType Obj) {
mutate(Obj);
}
void negativeValueIsMutatatedByPointer(ExpensiveToCopyType Obj) {
mutate(&Obj);
}
void negativeValueIsReassigned(ExpensiveToCopyType Obj) {
Obj = ExpensiveToCopyType();
}
void negativeValueNonConstMethodIsCalled(ExpensiveToCopyType Obj) {
Obj.nonConstMethod();
}
struct PositiveValueUnusedConstructor {
PositiveValueUnusedConstructor(ExpensiveToCopyType Copy) {}
// CHECK-MESSAGES: [[@LINE-1]]:54: warning: the parameter 'Copy'
// CHECK-FIXES: PositiveValueUnusedConstructor(const ExpensiveToCopyType& Copy) {}
};
struct PositiveValueCopiedConstructor {
PositiveValueCopiedConstructor(ExpensiveToCopyType Copy) : Field(Copy) {}
// CHECK-MESSAGES: [[@LINE-1]]:54: warning: the parameter 'Copy'
// CHECK-FIXES: PositiveValueCopiedConstructor(const ExpensiveToCopyType& Copy) : Field(Copy) {}
ExpensiveToCopyType Field;
};
template <typename T>
struct Container {
typedef const T & const_reference;
};
void NegativeTypedefParam(const Container<ExpensiveToCopyType>::const_reference Param) {
}
#define UNNECESSARY_VALUE_PARAM_IN_MACRO_BODY() \
void inMacro(const ExpensiveToCopyType T) { \
} \
// Ensure fix is not applied.
// CHECK-FIXES: void inMacro(const ExpensiveToCopyType T) {
UNNECESSARY_VALUE_PARAM_IN_MACRO_BODY()
// CHECK-MESSAGES: [[@LINE-1]]:1: warning: the const qualified parameter 'T'
#define UNNECESSARY_VALUE_PARAM_IN_MACRO_ARGUMENT(ARGUMENT) \
ARGUMENT
UNNECESSARY_VALUE_PARAM_IN_MACRO_ARGUMENT(void inMacroArgument(const ExpensiveToCopyType InMacroArg) {})
// CHECK-MESSAGES: [[@LINE-1]]:90: warning: the const qualified parameter 'InMacroArg'
// CHECK-FIXES: void inMacroArgument(const ExpensiveToCopyType InMacroArg) {}
struct VirtualMethod {
virtual ~VirtualMethod() {}
virtual void handle(ExpensiveToCopyType T) const = 0;
};
struct NegativeOverriddenMethod : public VirtualMethod {
void handle(ExpensiveToCopyType Overridden) const {
// CHECK-FIXES: handle(ExpensiveToCopyType Overridden) const {
}
};
struct NegativeDeletedMethod {
~NegativeDeletedMethod() {}
NegativeDeletedMethod& operator=(NegativeDeletedMethod N) = delete;
// CHECK-FIXES: NegativeDeletedMethod& operator=(NegativeDeletedMethod N) = delete;
};
|
