[clang-tidy] Detect dependent initializer_lists in google-explicit-constructor.

[alexfh]

Summary

Detect constructors taking a single std::initializer_list even when it
is instantiation-dependent.

[djasper]

Looks good.

clang-tidy/google/ExplicitConstructorCheck.cpp

58–59

I am fine with removing the extra-check here as I don't think it'll lead to a significant amount of false negatives, but please mention that in the patch description.

test/clang-tidy/google-explicit-constructor.cpp

66

I recommend not checking the full error message every time. It is just too much churn if the warning gets changed.

[alexfh]

Addressed review comments.

clang-tidy/google/ExplicitConstructorCheck.cpp

58–59

The main reason to remove the qualified name comparison was to make the check consistent with the newly added handling of instantiation-dependent argument types (where I was lazy to check qualified name).

After thinking a bit, I'll better make both consistent in a different way. PTAL.

test/clang-tidy/google-explicit-constructor.cpp

66

You're right. I removed the check name, but I can make the patterns even shorter.

[djasper]

Still looks good.

clang-tidy/google/ExplicitConstructorCheck.cpp

if (Pred(Tok)) {
       Lex.LexFromRawLexer(NextTok);
       return SourceRange(Tok.getLocation(), NextTok.getLocation());
     }
   } while (Tok.isNot(tok::eof) && Tok.getLocation() < EndLoc);
 
   return SourceRange();
 }
 
-bool isStdInitializerList(QualType Type) {
-  if (const RecordType *RT = Type.getCanonicalType()->getAs<RecordType>()) {
-    if (ClassTemplateSpecializationDecl *Specialization =
-            dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl())) {
-      ClassTemplateDecl *Template = Specialization->getSpecializedTemplate();
-      // First use the fast getName() method to avoid unnecessary calls to the
-      // slow getQualifiedNameAsString().
-      return Template->getName() == "initializer_list" &&
-             Template->getQualifiedNameAsString() == "std::initializer_list";
-    }
+bool declIsStdInitializerList(const NamedDecl *D) {
+  return D->getName() == "initializer_list" &&
+         D->getQualifiedNameAsString() == "std::initializer_list";
+
+bool isStdInitializerList(QualType Type) {
+  Type = Type.getCanonicalType();
+  if (const auto *TS = Type->getAs<TemplateSpecializationType>()) {
+    if (const TemplateDecl *TD = TS->getTemplateName().getAsTemplateDecl())
+      return declIsStdInitializerList(TD);
+  }
+  if (const auto *RT = Type->getAs<RecordType>()) {
+    if (const auto *Specialization =
+            dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()))
+      return declIsStdInitializerList(Specialization->getSpecializedTemplate());
   }
   return false;
 }
 
 void ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
   const CXXConstructorDecl *Ctor =
       Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
   // Do not be confused: isExplicit means 'explicit' keyword is present,

test/clang-tidy/google-explicit-constructor.cpp

struct A {
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: copy constructor should not be declared explicit [google-explicit-constructor]
   // CHECK-FIXES: {{^  }}A(const A& a) {}
 
   A(int x1) {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors must be explicit [google-explicit-constructor]
   // CHECK-FIXES: {{^  }}explicit A(int x1) {}
 
   A(double x2, double y = 3.14) {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors must be explicit
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
   // CHECK-FIXES: {{^  }}explicit A(double x2, double y = 3.14) {}
 };
 
 struct B {
   B(std::initializer_list<int> list1) {}
   B(const std::initializer_list<unsigned> &list2) {}
   B(std::initializer_list<unsigned> &&list3) {}
 
   explicit B(::std::initializer_list<double> list4) {}
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor should not be declared explicit [google-explicit-constructor]
   // CHECK-FIXES: {{^  }}B(::std::initializer_list<double> list4) {}
 
   explicit B(const ::std::initializer_list<char> &list5) {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor should not be declared explicit [google-explicit-constructor]
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
   // CHECK-FIXES: {{^  }}B(const ::std::initializer_list<char> &list5) {}
 
   explicit B(::std::initializer_list<char> &&list6) {}
-  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor should not be declared explicit [google-explicit-constructor]
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
   // CHECK-FIXES: {{^  }}B(::std::initializer_list<char> &&list6) {}
 };
 
 using namespace std;
 
 struct C {
   C(initializer_list<int> list1) {}
   C(const initializer_list<unsigned> &list2) {}
   C(initializer_list<unsigned> &&list3) {}
 };
 
+template <typename T>
+struct C2 {
+  C2(initializer_list<int> list1) {}
+  C2(const initializer_list<unsigned> &list2) {}
+  C2(initializer_list<unsigned> &&list3) {}
+
+  explicit C2(initializer_list<double> list4) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
+  // CHECK-FIXES: {{^  }}C2(initializer_list<double> list4) {}
+};
+
+template <typename T>
+struct C3 {
+  C3(initializer_list<T> list1) {}
+  C3(const std::initializer_list<T*> &list2) {}
+  C3(::std::initializer_list<T**> &&list3) {}
+
+  template <typename U>
+  C3(initializer_list<U> list3) {}
+};
+
 struct D {
   template <typename T>
   explicit D(T t) {}
 };
 
 template <typename T>
 struct E {
+  E(T *pt) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
+  // CHECK-FIXES: {{^  }}explicit E(T *pt) {}
+  template <typename U>
+  E(U *pu) {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
+  // CHECK-FIXES: {{^  }}explicit E(U *pu) {}
+
   explicit E(T t) {}
   template <typename U>
   explicit E(U u) {}
 };
 
 void f(std::initializer_list<int> list) {
   D d(list);
   E<decltype(list)> e(list);
   E<int> e2(list);
 }
+