[clang-tidy] Fix PR#37210 'Out-of-class template constructor only half-fixed with modernize-pass-by-value'

[f00kat]

Summary

Existing 'modernize-pass-by-value' check works only with non template values in initializers.
Now we also skip cases when the value has type 'TemplateSpecializedType' inside 'cxxConstructExpr'.

[aaron.ballman]

LGTM

[f00kat]

Can you commit it please?

[aaron.ballman]

In D75159#1897349, @f00kat wrote:

Can you commit it please?

Happy to do so, but you may want to consider getting git access yourself as you've authored quite a few patches. For more information: https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

I've commit this on your behalf in 365c99fd7d5461be902a5cec54d773cb82b56101

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

AST_MATCHER(CXXRecordDecl, isMoveConstructible) {
   for (const CXXConstructorDecl *Ctor : Node.ctors()) {
     if (Ctor->isMoveConstructor() && !Ctor->isDeleted())
       return true;
   }
   return false;
 }
 } // namespace
 
-static TypeMatcher constRefType() {
-  return lValueReferenceType(pointee(isConstQualified()));
+static TypeMatcher notTemplateSpecConstRefType() {
+  return lValueReferenceType(
+      pointee(unless(templateSpecializationType()), isConstQualified()));
 }
 
 static TypeMatcher nonConstValueType() {
   return qualType(unless(anyOf(referenceType(), isConstQualified())));
 }
 
 /// Whether or not \p ParamDecl is used exactly one time in \p Ctor.
 ///
Finder->addMatcher(
           forEachConstructorInitializer(
               cxxCtorInitializer(
                   unless(isBaseInitializer()),
                   // Clang builds a CXXConstructExpr only when it knows which
                   // constructor will be called. In dependent contexts a
                   // ParenListExpr is generated instead of a CXXConstructExpr,
                   // filtering out templates automatically for us.
                   withInitializer(cxxConstructExpr(
-                      has(ignoringParenImpCasts(declRefExpr(to(
-                          parmVarDecl(
+                      has(ignoringParenImpCasts(declRefExpr(
+                          to(parmVarDecl(
                                  hasType(qualType(
-                                  // Match only const-ref or a non-const value
-                                  // parameters. Rvalues and const-values
-                                  // shouldn't be modified.
-                                  ValuesOnly ? nonConstValueType()
-                                             : anyOf(constRefType(),
-                                                     nonConstValueType()))))
+                                     // Match only const-ref or a non-const
+                                     // value parameters. Rvalues,
+                                     // TemplateSpecializationValues and
+                                     // const-values shouldn't be modified.
+                                     ValuesOnly
+                                         ? nonConstValueType()
+                                         : anyOf(notTemplateSpecConstRefType(),
                                  .bind("Param"))))),
                       hasDeclaration(cxxConstructorDecl(
                           isCopyConstructor(), unless(isDeleted()),
                           hasDeclContext(
                               cxxRecordDecl(isMoveConstructible())))))))
                   .bind("Initializer")))
           .bind("Ctor"),
       this);
 }

clang-tools-extra/test/clang-tidy/checkers/modernize-pass-by-value.cpp

 template <typename T> struct J {
   J(const T &M) : M(M) {}
   // CHECK-FIXES: J(const T &M) : M(M) {}
   T M;
 };
 J<Movable> j1(Movable());
 J<NotMovable> j2(NotMovable());
 
+template<class T>
+struct MovableTemplateT
+{
+  MovableTemplateT() {}
+  MovableTemplateT(const MovableTemplateT& o) { }
+  MovableTemplateT(MovableTemplateT&& o) { }
+};
+
+template <class T>
+struct J2 {
+  J2(const MovableTemplateT<T>& A);
+  // CHECK-FIXES: J2(const MovableTemplateT<T>& A);
+  MovableTemplateT<T> M;
+};
+
+template <class T>
+J2<T>::J2(const MovableTemplateT<T>& A) : M(A) {}
+// CHECK-FIXES: J2<T>::J2(const MovableTemplateT<T>& A) : M(A) {}
+J2<int> j3(MovableTemplateT<int>{});
+
 struct K_Movable {
   K_Movable() = default;
   K_Movable(const K_Movable &) = default;
   K_Movable(K_Movable &&o) { dummy = o.dummy; }
   int dummy;
 };
 
 // Test with movable type with an user defined move constructor.