[clangd] NFC: Only pass ASTContext and TokenBuffer in getFoldingRanges API

[kbobyrev]

Summary

Follow-up on https://reviews.llvm.org/D88553#inline-837013

[sammccall]

This doesn't feel quite right to me - we're going to need to get PP conditional regions, include blocks etc from the ParsedAST (they're not in ASTContext).
My sense is that we'll need a fairly random subset of ParsedAST, and so ParsedAST is a reasonable abstraction unless it's hard to produce for tests. But it isn't!

What's the motivation for this change?

[kbobyrev]

In D90588#2368021, @sammccall wrote:

This doesn't feel quite right to me - we're going to need to get PP conditional regions, include blocks etc from the ParsedAST (they're not in ASTContext).
My sense is that we'll need a fairly random subset of ParsedAST, and so ParsedAST is a reasonable abstraction unless it's hard to produce for tests. But it isn't!

What's the motivation for this change?

Aww that comment is regarding syntax::buildSyntaxTree weren't you? I thought this was about getFoldingRanges API... Sorry.

[sammccall]

In D90588#2370604, @kbobyrev wrote:

In D90588#2368021, @sammccall wrote:

This doesn't feel quite right to me - we're going to need to get PP conditional regions, include blocks etc from the ParsedAST (they're not in ASTContext).
My sense is that we'll need a fairly random subset of ParsedAST, and so ParsedAST is a reasonable abstraction unless it's hard to produce for tests. But it isn't!

What's the motivation for this change?

Aww that comment is regarding syntax::buildSyntaxTree weren't you? I thought this was about getFoldingRanges API... Sorry.

Oops, sorry - yes :-(

My the point there was that the traversal roots for building the syntax tree are the ASTContext's traversal scope, which defaults to TUDecl, so passing in TUDecl is misleading there.

clang-tools-extra/clangd/ClangdServer.cpp

 }
 
 void ClangdServer::foldingRanges(llvm::StringRef File,
                                  Callback<std::vector<FoldingRange>> CB) {
   auto Action =
       [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
-        CB(clangd::getFoldingRanges(InpAST->AST));
+        CB(clangd::getFoldingRanges(InpAST->AST.getASTContext(),
+                                    InpAST->AST.getTokens()));
       };
   WorkScheduler.runWithAST("foldingRanges", File, std::move(Action),
                            TUScheduler::InvalidateOnUpdate);
 }
 
 void ClangdServer::findReferences(PathRef File, Position Pos, uint32_t Limit,
                                   Callback<ReferencesResult> CB) {
   auto Action = [Pos, Limit, CB = std::move(CB),

clang-tools-extra/clangd/SemanticSelection.h

 //===--- SemanticSelection.h -------------------------------------*- C++-*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Features for giving interesting semantic ranges around the cursor.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTICSELECTION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTICSELECTION_H
 #include "ParsedAST.h"
 #include "Protocol.h"
+#include "clang/Tooling/Syntax/Tokens.h"
 #include "llvm/Support/Error.h"
 #include <vector>
 namespace clang {
 namespace clangd {
 
 /// Returns the list of all interesting ranges around the Position \p Pos.
 /// The interesting ranges corresponds to the AST nodes in the SelectionTree
 /// containing \p Pos.
 /// If pos is not in any interesting range, return [Pos, Pos).
 llvm::Expected<SelectionRange> getSemanticRanges(ParsedAST &AST, Position Pos);
 
 /// Returns a list of ranges whose contents might be collapsible in an editor.
 /// This should include large scopes, preprocessor blocks etc.
-llvm::Expected<std::vector<FoldingRange>> getFoldingRanges(ParsedAST &AST);
+llvm::Expected<std::vector<FoldingRange>>
+getFoldingRanges(ASTContext &Context, const syntax::TokenBuffer &Tokens);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTICSELECTION_H

clang-tools-extra/clangd/SemanticSelection.cpp

 //===--- SemanticSelection.cpp -----------------------------------*- C++-*-===//
 //
 // 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 "SemanticSelection.h"
 #include "FindSymbols.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "Selection.h"
 #include "SourceCode.h"
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Tooling/Syntax/BuildTree.h"
 #include "clang/Tooling/Syntax/Nodes.h"
 #include "clang/Tooling/Syntax/Tree.h"
 #include "llvm/ADT/ArrayRef.h"
llvm::Expected<SelectionRange> getSemanticRanges(ParsedAST &AST, Position Pos) {
 
   return std::move(Head);
 }
 
 // FIXME(kirillbobyrev): Collect comments, PP conditional regions, includes and
 // other code regions (e.g. public/private/protected sections of classes,
 // control flow statement bodies).
 // Related issue: https://github.com/clangd/clangd/issues/310
-llvm::Expected<std::vector<FoldingRange>> getFoldingRanges(ParsedAST &AST) {
-  syntax::Arena A(AST.getSourceManager(), AST.getLangOpts(), AST.getTokens());
+llvm::Expected<std::vector<FoldingRange>>
+getFoldingRanges(ASTContext &Context, const syntax::TokenBuffer &Tokens) {
+  syntax::Arena A(Context.getSourceManager(), Context.getLangOpts(), Tokens);
   const auto *SyntaxTree =
-      syntax::buildSyntaxTree(A, *AST.getASTContext().getTranslationUnitDecl());
-  return collectFoldingRanges(SyntaxTree, AST.getSourceManager());
+      syntax::buildSyntaxTree(A, *Context.getTranslationUnitDecl());
+  return collectFoldingRanges(SyntaxTree, Context.getSourceManager());
 }
 
 } // namespace clangd
 } // namespace clang

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

const char *Tests[] = {
           // Braces are located at the same line: no folding range here.
           void getFooBar() { }
         };
       )cpp",
   };
   for (const char *Test : Tests) {
     auto T = Annotations(Test);
     auto AST = TestTU::withCode(T.code()).build();
-    EXPECT_THAT(gatherFoldingRanges(llvm::cantFail(getFoldingRanges(AST))),
+    EXPECT_THAT(gatherFoldingRanges(llvm::cantFail(
+                    getFoldingRanges(AST.getASTContext(), AST.getTokens()))),
                 UnorderedElementsAreArray(T.ranges()))
         << Test;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang