[clang-tidy] Ignore ADL-style using decls in unused-using-decls check.

[alexfh]

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

47

I don't think using declarations in functions are inherently related to ADL. This check doesn't seem like a useful heuristic.

[hokein]

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

47

Yeah, the current work around is only to ignore all using-decls in function context which is not perfect. I didn't find out a better way.

[alexfh]

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

47

If we're talking about this pattern:

using std::swap;
...
::ns::T x, y;
swap(x, y); // ::ns::swap() is used

then for each function name resolved using ADL, we can find all using declarations for the same name in different namespaces and mark them used. WDYT?

[hokein]

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

47

Great, this idea looks good to me. Will make the change.

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-// A function that helps to tell whether a TargetDecl will be checked.
-// We only check a TargetDecl if :
-//   * The corresponding UsingDecl is not defined in macros or in class
-//     definitions.
-//   * Only variable, function and class types are considered.
+// A function that helps to tell whether a TargetDecl of a UsingDecl will be
+// checked. We only check variable, function and class types.
 static bool ShouldCheckDecl(const Decl *TargetDecl) {
-  // Ignores using-declarations defined in macros.
-  if (TargetDecl->getLocation().isMacroID())
-    return false;
-
-  // Ignores using-declarations defined in class definition.
-  if (isa<CXXRecordDecl>(TargetDecl->getDeclContext()))
-    return false;
-
   return isa<RecordDecl>(TargetDecl) || isa<ClassTemplateDecl>(TargetDecl) ||
          isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl) ||
          isa<FunctionTemplateDecl>(TargetDecl);
 }
 
 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
   auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
   Finder->addMatcher(loc(recordType(DeclMatcher)), this);
   Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
   Finder->addMatcher(declRefExpr().bind("used"), this);
   Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
                      this);
 }
 
 void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
+    // Ignores using-declarations defined in macros.
+    if (Using->getLocation().isMacroID())
+      return;
+    // Ignores using-declarations defined in class definitions.
+    if (isa<CXXRecordDecl>(Using->getDeclContext()))
+      return;
+    // Ignores using-declarations defined in function definitions to avoid
+    // arguement-dependent lookup.
+    if (isa<FunctionDecl>(Using->getDeclContext()))
+      return;
+
     UsingDeclContext Context(Using);
     Context.UsingDeclRange = CharSourceRange::getCharRange(
         Using->getLocStart(),
         Lexer::findLocationAfterToken(
             Using->getLocEnd(), tok::semi, *Result.SourceManager,
             Result.Context->getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     for (const auto *UsingShadow : Using->shadows()) {

test/clang-tidy/misc-unused-using-decls.cpp

 #define DEFINE_INT(name)        \
   namespace INT {               \
   static const int _##name = 1; \
   }                             \
   using INT::_##name
 DEFINE_INT(test);
 #undef DEFIND_INT
 
+namespace N1 {
+  struct S {};
+  template<int X> void f(S);
+}
+namespace N2 {
+  template<class T> void f(T t);
+}
+
 // ----- Usages -----
 void f(B b);
 void g() {
   vector<C> data;
   D::i = 1;
   F<int> f;
   void (*func)() = &G::func;
   int *i = &H::i;
   UsedInstance.i;
   UsedFunc();
   UsedTemplateFunc<int>();
   cout << endl;
 }
 
+void ADL(N1::S s) {
+  using N2::f;
+  f<3>(s);
+}