[clang-tidy] Fix misc-unused-using-decls for user-defined literals

[v1nh1shungry]

Summary

Current version complains unused using-declaration even if the target
user-defined literal is used.

[ymandel]

Thank you!

[v1nh1shungry]

@ymandel Thank you for reviewing!

If this patch is okay to land, could you please help me commit it? Thanks again!

[ymandel]

In D138204#3933861, @v1nh1shungry wrote:

@ymandel Thank you for reviewing!

If this patch is okay to land, could you please help me commit it? Thanks again!

Sure. I'm running tests now and, assuming all's green, i'll commit in a few minutes.

clang-tools-extra/clang-tidy/misc/UnusedUsingDeclsCheck.cpp

Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
                      this);
   Finder->addMatcher(
       callExpr(hasDeclaration(functionDecl(
           forEachTemplateArgument(templateArgument().bind("used"))))),
       this);
   Finder->addMatcher(loc(templateSpecializationType(forEachTemplateArgument(
                          templateArgument().bind("used")))),
                      this);
+  Finder->addMatcher(userDefinedLiteral().bind("used"), this);
   // Cases where we can identify the UsingShadowDecl directly, rather than
   // just its target.
   // FIXME: cover more cases in this way, as the AST supports it.
   auto ThroughShadowMatcher = throughUsingDecl(namedDecl().bind("usedShadow"));
   Finder->addMatcher(declRefExpr(ThroughShadowMatcher), this);
   Finder->addMatcher(loc(usingType(ThroughShadowMatcher)), this);
 }
 
if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
     return;
   }
   // Check the uninstantiated template function usage.
   if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
     for (const NamedDecl *ND : ULE->decls()) {
       if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
         removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
     }
+    return;
   }
+  // Check user-defined literals
+  if (const auto *UDL = Result.Nodes.getNodeAs<UserDefinedLiteral>("used"))
+    removeFromFoundDecls(UDL->getCalleeDecl());
 }
 
 void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {
   if (!D)
     return;
   // FIXME: Currently, we don't handle the using-decls being used in different
   // scopes (such as different namespaces, different functions). Instead of
   // giving an incorrect message, we mark all of them as used.

clang-tools-extra/test/clang-tidy/checkers/misc/unused-using-decls.cpp

 int UsedFunc() { return 1; }
 int UnusedFunc() { return 1; }
 template <typename T> int UsedTemplateFunc() { return 1; }
 template <typename T> int UnusedTemplateFunc() { return 1; }
 template <typename T> int UsedInTemplateFunc() { return 1; }
 void OverloadFunc(int);
 void OverloadFunc(double);
 int FuncUsedByUsingDeclInMacro() { return 1; }
+long double operator""_w(long double);
 
 class ostream {
 public:
   ostream &operator<<(ostream &(*PF)(ostream &));
 };
 extern ostream cout;
 ostream &endl(ostream &os);
 

 using n::UsedFunc;
 using n::UsedTemplateFunc;
 using n::UnusedInstance; // UnusedInstance
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'UnusedInstance' is unused
 // CHECK-FIXES: {{^}}// UnusedInstance
 using n::UnusedFunc; // UnusedFunc
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'UnusedFunc' is unused
 // CHECK-FIXES: {{^}}// UnusedFunc
+using n::operator""_w;
 using n::cout;
 using n::endl;
 
 using n::UsedInTemplateFunc;
 using n::J;
 template <typename T> void Callee() {
   J<T> j;
   UsedInTemplateFunc<T>();
void g() {
   vector<C> data;
   D::i = 1;
   F<int> f;
   void (*func)() = &G::func;
   int *i = &H::i;
   UsedInstance.i;
   UsedFunc();
   UsedTemplateFunc<int>();
+  1.5_w;
   cout << endl;
   Color2 color2;
   int t1 = Color3::Yellow;
   int t2 = Blue;
 
   MyClass a;
   int t3 = 0;
   a.func1<AA>(&t3);