[clang-tools-extra] Allow unnecessary-value-param to match templated functions including lambdas with auto. (PR #97767)
Julian Schmidt via cfe-commits
cfe-commits at lists.llvm.org
Sat Jul 6 03:22:18 PDT 2024
================
@@ -0,0 +1,93 @@
+// RUN: %check_clang_tidy -std=c++14-or-later %s performance-unnecessary-value-param %t
+
+struct ExpensiveToCopyType {
+ virtual ~ExpensiveToCopyType();
+};
+
+template <typename T> void templateWithNonTemplatizedParameter(const ExpensiveToCopyType S, T V) {
+ // CHECK-MESSAGES: [[@LINE-1]]:90: warning: the const qualified parameter 'S'
+ // CHECK-MESSAGES: [[@LINE-2]]:95: warning: the parameter 'V'
+ // CHECK-FIXES: template <typename T> void templateWithNonTemplatizedParameter(const ExpensiveToCopyType& S, const T& V) {
+}
+
+void instantiatedWithExpensiveValue() {
+ templateWithNonTemplatizedParameter(
+ ExpensiveToCopyType(), ExpensiveToCopyType());
+ templateWithNonTemplatizedParameter(ExpensiveToCopyType(), 5);
+}
+
+template <typename T> void templateWithNonTemplatizedParameterCheapTemplate(const ExpensiveToCopyType S, T V) {
+ // CHECK-MESSAGES: [[@LINE-1]]:103: warning: the const qualified parameter 'S'
+ // CHECK-FIXES: template <typename T> void templateWithNonTemplatizedParameterCheapTemplate(const ExpensiveToCopyType& S, T V) {
+}
+
+void instantiatedWithCheapValue() {
+ templateWithNonTemplatizedParameterCheapTemplate(ExpensiveToCopyType(), 5);
+}
+
+template <typename T> void nonInstantiatedTemplateWithConstValue(const T S) {}
+template <typename T> void nonInstantiatedTemplateWithNonConstValue(T S) {}
+
+template <typename T> void instantiatedTemplateSpecialization(T NoSpecS) {}
+template <>
+void instantiatedTemplateSpecialization<ExpensiveToCopyType>(
+ ExpensiveToCopyType SpecS) {
+ // CHECK-MESSAGES: [[@LINE-1]]:25: warning: the parameter 'SpecS'
+ // When updating a template specialization, we also update the main template.
----------------
5chmidti wrote:
> Note that it is template specialization and not an overload.
Template specialization must have exactly the same signature.
Whoops, I must have done something weird to think this works.
Then what I would have originally written applies:
When a specialization A is defined in another TU, applying a fix to specialization B from the analyzed TU or the underlying template, will make A no longer compile. The same goes for specializations in headers that are not included, and also specializations that are:
```c++
template <typename T> void instantiatedTemplateSpecialization(T NoSpecS) {}
template <>
void instantiatedTemplateSpecialization<ExpensiveToCopyType>(
ExpensiveToCopyType SpecS) {
// CHECK-MESSAGES: [[@LINE-1]]:25: warning: the parameter 'SpecS'
// When updating a template specialization, we also update the main template.
// CHECK-FIXES: const T& NoSpecS
// CHECK-FIXES: const ExpensiveToCopyType& SpecS
// CHECK-FIXES: const int& SpecS <- fails, no fix generated it seems
}
template <>
void instantiatedTemplateSpecialization<int>(
int SpecS) {
}
```
https://github.com/llvm/llvm-project/pull/97767
More information about the cfe-commits
mailing list