Remove 'explicit' keyword from constructors with multiple (non-default) arguments.

[alexfh]

Summary

Remove 'explicit' keyword from constructors with multiple (non-default)
arguments (clang-tidy google-explicit-constructor check).

[dblaikie]

Fwiw, if I'm not mistaken, explicit on more - than - one - arg actors does
have some meaning in c++11. It means you can't construct from a braced init
list.

I'm not sure if that's important to you/this warning.

[alexfh]

There's actually value in declaring multiple-argument constructrors explicit, thus the patch is not needed. Maybe even the opposite is needed: adding explicit to most constructors. But this will be a different patch anyway.

clang-tidy/google/ExplicitConstructorCheck.cpp

 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,
   // isImplicit means that it's a compiler-generated constructor.
   if (Ctor->isOutOfLine() || Ctor->isImplicit() || Ctor->isDeleted())
     return;
 
-  if (Ctor->isExplicit() && Ctor->isCopyOrMoveConstructor()) {
+  bool IsSingleArgumentCtor =
+      Ctor->getNumParams() > 0 && Ctor->getMinRequiredArguments() <= 1;
+  bool RequiredExplicit =
+      !Ctor->isCopyOrMoveConstructor() && IsSingleArgumentCtor;
+
+  if (Ctor->isExplicit() && !RequiredExplicit) {
     auto isKWExplicit = [](const Token &Tok) {
       return Tok.is(tok::raw_identifier) &&
              Tok.getRawIdentifier() == "explicit";
     };
     SourceRange ExplicitTokenRange =
         FindToken(*Result.SourceManager, Result.Context->getLangOpts(),
                   Ctor->getOuterLocStart(), Ctor->getLocEnd(), isKWExplicit);
+    StringRef ConstructorType =
+        !IsSingleArgumentCtor ? "Multiple arguments"
+                              : (Ctor->isMoveConstructor() ? "Move" : "Copy");
     DiagnosticBuilder Diag =
         diag(Ctor->getLocation(), "%0 constructor declared explicit.")
-        << (Ctor->isMoveConstructor() ? "Move" : "Copy");
+        << ConstructorType;
     if (ExplicitTokenRange.isValid()) {
       Diag << FixItHint::CreateRemoval(
           CharSourceRange::getCharRange(ExplicitTokenRange));
     }
-  }
-
-  if (Ctor->isExplicit() || Ctor->isCopyOrMoveConstructor() ||
-      Ctor->getNumParams() == 0 || Ctor->getMinRequiredArguments() > 1)
     return;
+  }
 
+  if (!Ctor->isExplicit() && RequiredExplicit) {
     SourceLocation Loc = Ctor->getLocation();
     diag(Loc, "Single-argument constructors must be explicit")
         << FixItHint::CreateInsertion(Loc, "explicit ");
   }
+}
 
 } // namespace tidy
 } // namespace clang

unittests/clang-tidy/GoogleModuleTest.cpp

TEST(ExplicitConstructorCheckTest, OutOfLineDefinitions) {
   EXPECT_EQ("class C { explicit C(int i); }; C::C(int i) {}",
             runCheckOnCode<ExplicitConstructorCheck>(
                 "class C { C(int i); }; C::C(int i) {}"));
 }
 
 TEST(ExplicitConstructorCheckTest, RemoveExplicit) {
   EXPECT_EQ("class A { A(const A&); };\n"
             "class B { /*asdf*/  B(B&&); };\n"
-            "class C { /*asdf*/  C(const C&, int i = 0); };",
+            "class C { /*asdf*/  C(const C&, int i = 0); };\n"
+            "class D { D(int a, int b); };\n"
+            "class D2 { explicit D2(int a, int b = 0); };\n"
+            "class E { E(int a, int b, int c = 0); };",
             runCheckOnCode<ExplicitConstructorCheck>(
                 "class A { explicit    A(const A&); };\n"
                 "class B { explicit   /*asdf*/  B(B&&); };\n"
-                "class C { explicit/*asdf*/  C(const C&, int i = 0); };"));
+                "class C { explicit/*asdf*/  C(const C&, int i = 0); };\n"
+                "class D { explicit D(int a, int b); };\n"
+                "class D2 { explicit D2(int a, int b = 0); };\n"
+                "class E { explicit E(int a, int b, int c = 0); };"));
 }
 
 TEST(ExplicitConstructorCheckTest, RemoveExplicitWithMacros) {
   EXPECT_EQ(
       "#define A(T) class T##Bar { explicit T##Bar(const T##Bar &b) {} };\n"
       "A(Foo);",
       runCheckOnCode<ExplicitConstructorCheck>(
           "#define A(T) class T##Bar { explicit T##Bar(const T##Bar &b) {} };\n"
           "A(Foo);"));
 }
 
 } // namespace test
 } // namespace tidy
 } // namespace clang