diff --git a/clangd/index/IndexAction.cpp b/clangd/index/IndexAction.cpp
index be30ea6..b7ceb6f 100644
--- a/clangd/index/IndexAction.cpp
+++ b/clangd/index/IndexAction.cpp
@@ -121,42 +121,32 @@
   IncludeGraph &IG;
 };
 
-/// Returns an ASTConsumer that wraps \p Inner and additionally instructs the
-/// parser to skip bodies of functions in the files that should not be
-/// processed.
-static std::unique_ptr<ASTConsumer>
-skipProcessedFunctions(std::unique_ptr<ASTConsumer> Inner,
-                       std::function<bool(FileID)> ShouldIndexFile) {
-  class SkipProcessedFunctions : public ASTConsumer {
-  public:
-    SkipProcessedFunctions(std::function<bool(FileID)> FileFilter)
-        : ShouldIndexFile(std::move(FileFilter)), Context(nullptr) {
-      assert(this->ShouldIndexFile);
-    }
+/// An ASTConsumer that instructs the parser to skip bodies of functions in the
+/// files that should not be processed.
+class SkipProcessedFunctions : public ASTConsumer {
+public:
+  SkipProcessedFunctions(std::function<bool(FileID)> FileFilter)
+      : ShouldIndexFile(std::move(FileFilter)), Context(nullptr) {
+    assert(this->ShouldIndexFile);
+  }
 
-    void Initialize(ASTContext &Context) override { this->Context = &Context; }
-    bool shouldSkipFunctionBody(Decl *D) override {
-      assert(Context && "Initialize() was never called.");
-      auto &SM = Context->getSourceManager();
-      auto FID = SM.getFileID(SM.getExpansionLoc(D->getLocation()));
-      if (!FID.isValid())
-        return false;
-      return !ShouldIndexFile(FID);
-    }
+  void Initialize(ASTContext &Context) override { this->Context = &Context; }
+  bool shouldSkipFunctionBody(Decl *D) override {
+    assert(Context && "Initialize() was never called.");
+    auto &SM = Context->getSourceManager();
+    auto FID = SM.getFileID(SM.getExpansionLoc(D->getLocation()));
+    if (!FID.isValid())
+      return false;
+    return !ShouldIndexFile(FID);
+  }
 
-  private:
-    std::function<bool(FileID)> ShouldIndexFile;
-    const ASTContext *Context;
-  };
-  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
-  Consumers.push_back(
-      std::make_unique<SkipProcessedFunctions>(ShouldIndexFile));
-  Consumers.push_back(std::move(Inner));
-  return std::make_unique<MultiplexConsumer>(std::move(Consumers));
-}
+private:
+  std::function<bool(FileID)> ShouldIndexFile;
+  const ASTContext *Context;
+};
 
 // Wraps the index action and reports index data after each translation unit.
-class IndexAction : public WrapperFrontendAction {
+class IndexAction : public ASTFrontendAction {
 public:
   IndexAction(std::shared_ptr<SymbolCollector> C,
               std::unique_ptr<CanonicalIncludes> Includes,
@@ -165,11 +155,10 @@
               std::function<void(RefSlab)> RefsCallback,
               std::function<void(RelationSlab)> RelationsCallback,
               std::function<void(IncludeGraph)> IncludeGraphCallback)
-      : WrapperFrontendAction(index::createIndexingAction(C, Opts, nullptr)),
-        SymbolsCallback(SymbolsCallback), RefsCallback(RefsCallback),
-        RelationsCallback(RelationsCallback),
+      : SymbolsCallback(SymbolsCallback),
+        RefsCallback(RefsCallback), RelationsCallback(RelationsCallback),
         IncludeGraphCallback(IncludeGraphCallback), Collector(C),
-        Includes(std::move(Includes)),
+        Includes(std::move(Includes)), Opts(Opts),
         PragmaHandler(collectIWYUHeaderMaps(this->Includes.get())) {}
 
   std::unique_ptr<ASTConsumer>
@@ -179,9 +168,13 @@
     if (IncludeGraphCallback != nullptr)
       CI.getPreprocessor().addPPCallbacks(
           std::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
-    return skipProcessedFunctions(
-        WrapperFrontendAction::CreateASTConsumer(CI, InFile),
-        [this](FileID FID) { return Collector->shouldIndexFile(FID); });
+
+    std::vector<std::unique_ptr<ASTConsumer>> Consumers;
+    Consumers.push_back(std::make_unique<SkipProcessedFunctions>(
+        [this](FileID FID) { return Collector->shouldIndexFile(FID); }));
+    Consumers.push_back(index::createIndexingASTConsumer(
+        Collector, Opts, CI.getPreprocessorPtr()));
+    return std::make_unique<MultiplexConsumer>(std::move(Consumers));
   }
 
   bool BeginInvocation(CompilerInstance &CI) override {
@@ -195,13 +188,10 @@
     // bodies. The ASTConsumer will take care of skipping only functions inside
     // the files that we have already processed.
     CI.getFrontendOpts().SkipFunctionBodies = true;
-
-    return WrapperFrontendAction::BeginInvocation(CI);
+    return true;
   }
 
   void EndSourceFileAction() override {
-    WrapperFrontendAction::EndSourceFileAction();
-
     SymbolsCallback(Collector->takeSymbols());
     if (RefsCallback != nullptr)
       RefsCallback(Collector->takeRefs());
@@ -224,6 +214,7 @@
   std::function<void(IncludeGraph)> IncludeGraphCallback;
   std::shared_ptr<SymbolCollector> Collector;
   std::unique_ptr<CanonicalIncludes> Includes;
+  index::IndexingOptions Opts;
   std::unique_ptr<CommentHandler> PragmaHandler;
   IncludeGraph IG;
 };
diff --git a/clangd/unittests/SymbolCollectorTests.cpp b/clangd/unittests/SymbolCollectorTests.cpp
index 16b8ae8..a9248e1 100644
--- a/clangd/unittests/SymbolCollectorTests.cpp
+++ b/clangd/unittests/SymbolCollectorTests.cpp
@@ -201,30 +201,30 @@
       : COpts(std::move(COpts)), PragmaHandler(PragmaHandler) {}
 
   clang::FrontendAction *create() override {
-    class WrappedIndexAction : public WrapperFrontendAction {
+    class IndexAction : public ASTFrontendAction {
     public:
-      WrappedIndexAction(std::shared_ptr<SymbolCollector> C,
-                         const index::IndexingOptions &Opts,
-                         CommentHandler *PragmaHandler)
-          : WrapperFrontendAction(
-                index::createIndexingAction(C, Opts, nullptr)),
+      IndexAction(std::shared_ptr<index::IndexDataConsumer> DataConsumer,
+                  const index::IndexingOptions &Opts,
+                  CommentHandler *PragmaHandler)
+          : DataConsumer(std::move(DataConsumer)), Opts(Opts),
             PragmaHandler(PragmaHandler) {}
 
       std::unique_ptr<ASTConsumer>
       CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
         if (PragmaHandler)
           CI.getPreprocessor().addCommentHandler(PragmaHandler);
-        return WrapperFrontendAction::CreateASTConsumer(CI, InFile);
+        return createIndexingASTConsumer(DataConsumer, Opts, CI.getPreprocessorPtr());
       }
 
       bool BeginInvocation(CompilerInstance &CI) override {
         // Make the compiler parse all comments.
         CI.getLangOpts().CommentOpts.ParseAllComments = true;
-        return WrapperFrontendAction::BeginInvocation(CI);
+        return true;
       }
 
     private:
-      index::IndexingOptions IndexOpts;
+      std::shared_ptr<index::IndexDataConsumer> DataConsumer;
+      index::IndexingOptions Opts;
       CommentHandler *PragmaHandler;
     };
     index::IndexingOptions IndexOpts;
@@ -232,8 +232,7 @@
         index::IndexingOptions::SystemSymbolFilterKind::All;
     IndexOpts.IndexFunctionLocals = false;
     Collector = std::make_shared<SymbolCollector>(COpts);
-    return new WrappedIndexAction(Collector, std::move(IndexOpts),
-                                  PragmaHandler);
+    return new IndexAction(Collector, std::move(IndexOpts), PragmaHandler);
   }
 
   std::shared_ptr<SymbolCollector> Collector;