[clangd][Index][NFC] Make local class collection optional

[kadircet]

Summary

This introduces an option to symbolcollector for controlling whether
function-local classes and their methods should be collected.

The patch defaults the option to true, which is the existing behaviour.

We are suspecting this switch has caused blow ups in memory usage for some big
codebases, so would like the ability to turn them off.

[sammccall]

This seems reasonable, but having found the problem, do we still want to land it?

[kadircet]

This seems reasonable, but having found the problem, do we still want to land it?

I suppose not.

clang-tools-extra/clangd/index/IndexAction.cpp

std::unique_ptr<FrontendAction> createStaticIndexingAction(
     SymbolCollector::Options Opts,
     std::function<void(SymbolSlab)> SymbolsCallback,
     std::function<void(RefSlab)> RefsCallback,
     std::function<void(RelationSlab)> RelationsCallback,
     std::function<void(IncludeGraph)> IncludeGraphCallback) {
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
-  // We index function-local classes and its member functions only.
-  IndexOpts.IndexFunctionLocals = true;
+  IndexOpts.IndexFunctionLocals = Opts.CollectFunctionLocalClasses;
   Opts.CollectIncludePath = true;
   if (Opts.Origin == SymbolOrigin::Unknown)
     Opts.Origin = SymbolOrigin::Static;
   Opts.StoreAllDocumentation = false;
   if (RefsCallback != nullptr) {
     Opts.RefFilter = RefKind::All;
     Opts.RefsInHeaders = true;
   }

clang-tools-extra/clangd/index/SymbolCollector.h

struct Options {
     bool CollectMainFileRefs = false;
     /// If set to true, SymbolCollector will collect doc for all symbols.
     /// Note that documents of symbols being indexed for completion will always
     /// be collected regardless of this option.
     bool StoreAllDocumentation = false;
     /// If this is set, only collect symbols/references from a file if
     /// `FileFilter(SM, FID)` is true. If not set, all files are indexed.
     std::function<bool(const SourceManager &, FileID)> FileFilter = nullptr;
+    /// Collect function-local classes and its member functions.
+    bool CollectFunctionLocalClasses = true;
   };
 
   SymbolCollector(Options Opts);
   ~SymbolCollector();
 
   /// Returns true is \p ND should be collected.
   static bool shouldCollectSymbol(const NamedDecl &ND, const ASTContext &ASTCtx,
                                   const Options &Opts, bool IsMainFileSymbol);

clang-tools-extra/clangd/index/SymbolCollector.cpp

if (IsMainFileOnly && !Opts.CollectMainFileSymbols)
     return false;
 
   // Skip symbols in anonymous namespaces in header files.
   if (!IsMainFileOnly && ND.isInAnonymousNamespace())
     return false;
 
   // For function local symbols, index only classes and its member functions.
   if (index::isFunctionLocalSymbol(&ND))
-    return isa<RecordDecl>(ND) ||
-           (ND.isCXXInstanceMember() && ND.isFunctionOrFunctionTemplate());
+    return Opts.CollectFunctionLocalClasses &&
+           (isa<RecordDecl>(ND) ||
+            (ND.isCXXInstanceMember() && ND.isFunctionOrFunctionTemplate()));
 
   // We want most things but not "local" symbols such as symbols inside
   // FunctionDecl, BlockDecl, ObjCMethodDecl and OMPDeclareReductionDecl.
   // FIXME: Need a matcher for ExportDecl in order to include symbols declared
   // within an export.
   const auto *DeclCtx = ND.getDeclContext();
   switch (DeclCtx->getDeclKind()) {
   case Decl::TranslationUnit:

clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp

public:
 
   // build() must have been called.
   bool shouldCollect(llvm::StringRef Name, bool Qualified = true) {
     assert(AST.hasValue());
     const NamedDecl &ND =
         Qualified ? findDecl(*AST, Name) : findUnqualifiedDecl(*AST, Name);
     const SourceManager &SM = AST->getSourceManager();
     bool MainFile = isInsideMainFile(ND.getBeginLoc(), SM);
-    return SymbolCollector::shouldCollectSymbol(
-        ND, AST->getASTContext(), SymbolCollector::Options(), MainFile);
+    return SymbolCollector::shouldCollectSymbol(ND, AST->getASTContext(), Opts,
+                                                MainFile);
   }
 
 protected:
   std::string HeaderName = "f.h";
   std::string FileName = "f.cpp";
   TestTU File;
   llvm::Optional<ParsedAST> AST; // Initialized after build.
+  SymbolCollector::Options Opts;
 };
 
 TEST_F(ShouldCollectSymbolTest, ShouldCollectSymbol) {
   build(R"(
     namespace nx {
     class X{};
     auto f() { int Local; } // auto ensures function body is parsed.
     struct { int x; } var;
TEST_F(ShouldCollectSymbolTest, ShouldCollectSymbol) {
   EXPECT_TRUE(shouldCollect("InMain"));
   EXPECT_TRUE(shouldCollect("InAnonymous", /*Qualified=*/false));
   EXPECT_TRUE(shouldCollect("g"));
 
   EXPECT_FALSE(shouldCollect("Local", /*Qualified=*/false));
 }
 
 TEST_F(ShouldCollectSymbolTest, CollectLocalClassesAndVirtualMethods) {
-  build(R"(
+  build(/*HeaderCode=*/"", /*Code=*/R"(
     namespace nx {
-    auto f() {
+    void f() {
       int Local;
       auto LocalLambda = [&](){
         Local++;
         class ClassInLambda{};
         return Local;
       };
-    } // auto ensures function body is parsed.
-    auto foo() {
+    }
+    void foo() {
       class LocalBase {
         virtual void LocalVirtual();
         void LocalConcrete();
         int BaseMember;
       };
     }
     } // namespace nx
-  )",
-        "");
-  auto AST = File.build();
+  )");
+  for (bool CollectLocalClasses : {true, false}) {
+    Opts.CollectFunctionLocalClasses = CollectLocalClasses;
     EXPECT_FALSE(shouldCollect("Local", /*Qualified=*/false));
-  EXPECT_TRUE(shouldCollect("ClassInLambda", /*Qualified=*/false));
-  EXPECT_TRUE(shouldCollect("LocalBase", /*Qualified=*/false));
-  EXPECT_TRUE(shouldCollect("LocalVirtual", /*Qualified=*/false));
-  EXPECT_TRUE(shouldCollect("LocalConcrete", /*Qualified=*/false));
     EXPECT_FALSE(shouldCollect("BaseMember", /*Qualified=*/false));
     EXPECT_FALSE(shouldCollect("Local", /*Qualified=*/false));
+
+    EXPECT_EQ(CollectLocalClasses,
+              shouldCollect("ClassInLambda", /*Qualified=*/false));
+    EXPECT_EQ(CollectLocalClasses,
+              shouldCollect("LocalBase", /*Qualified=*/false));
+    EXPECT_EQ(CollectLocalClasses,
+              shouldCollect("LocalVirtual", /*Qualified=*/false));
+    EXPECT_EQ(CollectLocalClasses,
+              shouldCollect("LocalConcrete", /*Qualified=*/false));
+  }
 }
 
 TEST_F(ShouldCollectSymbolTest, NoPrivateProtoSymbol) {
   HeaderName = "f.proto.h";
   build(
       R"(// Generated by the protocol buffer compiler.  DO NOT EDIT!
          namespace nx {
            class Top_Level {};