[include-cleaner] Check macros against stdlib database

[hokein]

thanks, good catch!

clang-tools-extra/include-cleaner/lib/LocateSymbol.cpp

 //===--- LocateSymbol.cpp - Find locations providing a symbol -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AnalysisInternal.h"
+#include "clang-include-cleaner/Types.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/Support/Casting.h"
 #include <utility>
 #include <vector>
std::vector<Hinted<SymbolLocation>> locateDecl(const Decl &D) {
   //   class SourceManager; // likely an incidental forward decl.
   //   namespace my_own_ns {}
   //   }
   for (auto *Redecl : D.redecls())
     Result.push_back({Redecl->getLocation(), declHints(Redecl)});
   return Result;
 }
 
+std::vector<Hinted<SymbolLocation>> locateMacro(const Macro &M) {
+  // FIXME: Should we also provide physical locations?
+  if (auto SS = tooling::stdlib::Symbol::named("", M.Name->getName()))
+    return {{*SS, Hints::CompleteSymbol}};
+  return {{M.Definition, Hints::CompleteSymbol}};
+}
 } // namespace
 
 std::vector<Hinted<SymbolLocation>> locateSymbol(const Symbol &S) {
   switch (S.kind()) {
   case Symbol::Declaration:
     return locateDecl(S.declaration());
   case Symbol::Macro:
-    return {{S.macro().Definition, Hints::CompleteSymbol}};
+    return locateMacro(S.macro());
   }
   llvm_unreachable("Unknown Symbol::Kind enum");
 }
 
 } // namespace clang::include_cleaner

clang-tools-extra/include-cleaner/unittests/LocateSymbolTest.cpp

for (auto &Case : Cases) {
     SCOPED_TRACE(Case);
     LocateExample Test(Case);
     EXPECT_THAT(locateSymbol(Test.findDecl("foo")),
                 ElementsAreArray(Test.points()));
   }
 }
 
 TEST(LocateSymbol, Stdlib) {
+  {
     LocateExample Test("namespace std { struct vector; }");
-  EXPECT_THAT(locateSymbol(Test.findDecl("vector")),
-              ElementsAre(*tooling::stdlib::Symbol::named("std::", "vector")));
+    EXPECT_THAT(
+        locateSymbol(Test.findDecl("vector")),
   }
+  {
+    LocateExample Test("#define assert(x)\nvoid foo() { assert(true); }");
+    EXPECT_THAT(locateSymbol(Test.findMacro("assert")),
+                ElementsAre(*tooling::stdlib::Symbol::named("", "assert")));
+  }
+}
 
 TEST(LocateSymbol, Macros) {
   // Make sure we preserve the last one.
   LocateExample Test("#define FOO\n#undef FOO\n#define ^FOO");
   EXPECT_THAT(locateSymbol(Test.findMacro("FOO")),
               ElementsAreArray(Test.points()));
 }