[clangd] Collect macros in static index.

[hokein]

Summary

We are missing macros in static index.

symbols: before 407 K vs after 420 K
dex memory usage (static index): before 299 MB vs 304 MB

[kadircet]

unittests/clangd/BackgroundIndexTests.cpp

128

Shouldn't we also have Named("A") in here ?

[hokein]

unittests/clangd/BackgroundIndexTests.cpp

128

The symbol A is filtered out (as it is defined via a compile command-line option -DA=1).

[sammccall]

So I'm not sure this is actually going to be a win.

When building google's big static index, we index these symbols and then throw most of them away (a high usage threshold applies).
But there's no mechanism here to do that.
If we do index *all* of these, how often are they going to be good vs bad results?

Is there a motivating case for the sorts of macros you are missing?

clangd/index/IndexAction.cpp

std::unique_ptr<FrontendAction> createStaticIndexingAction(
     std::function<void(SymbolSlab)> SymbolsCallback,
     std::function<void(RefSlab)> RefsCallback,
     std::function<void(IncludeGraph)> IncludeGraphCallback) {
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
   Opts.CollectIncludePath = true;
   Opts.CountReferences = true;
+  Opts.CollectMacro = true;
   Opts.Origin = SymbolOrigin::Static;
   if (RefsCallback != nullptr) {
     Opts.RefFilter = RefKind::All;
     Opts.RefsInHeaders = true;
   }
   auto Includes = llvm::make_unique<CanonicalIncludes>();
   addSystemHeadersMapping(Includes.get());
   Opts.Includes = Includes.get();
   return llvm::make_unique<IndexAction>(
       std::make_shared<SymbolCollector>(std::move(Opts)), std::move(Includes),
       IndexOpts, SymbolsCallback, RefsCallback, IncludeGraphCallback);
 }
 
 } // namespace clangd
 } // namespace clang

unittests/clangd/BackgroundIndexTests.cpp

TEST_F(BackgroundIndexTest, IndexTwoFiles) {
   Cmd.Filename = testPath("root/A.cc");
   Cmd.Directory = testPath("root");
   Cmd.CommandLine = {"clang++", "-DA=1", testPath("root/A.cc")};
   CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
 
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   EXPECT_THAT(
       runFuzzyFind(Idx, ""),
       UnorderedElementsAre(Named("common"), Named("A_CC"), Named("g"),
                            AllOf(Named("f_b"), Declared(), Not(Defined()))));
 
   Cmd.Filename = testPath("root/B.cc");
   Cmd.CommandLine = {"clang++", Cmd.Filename};
   CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
 
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   // B_CC is dropped as we don't collect symbols from A.h in this compilation.
   EXPECT_THAT(runFuzzyFind(Idx, ""),
               UnorderedElementsAre(Named("common"), Named("A_CC"), Named("g"),
+                                   Named("A"),
                                    AllOf(Named("f_b"), Declared(), Defined())));
 
   auto Syms = runFuzzyFind(Idx, "common");
   EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
   auto Common = *Syms.begin();
   EXPECT_THAT(getRefs(Idx, Common.ID),
               RefsAre({FileURI("unittest:///root/A.h"),
                        FileURI("unittest:///root/A.cc"),