171 lines · c
1//===--- ParsedAST.h - Building translation units ----------------*- C++-*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// This file exposes building a file as if it were open in clangd, and defines10// the ParsedAST structure that holds the results.11//12// This is similar to a clang -fsyntax-only run that produces a clang AST, but13// we have several customizations:14// - preamble handling15// - capturing diagnostics for later access16// - running clang-tidy checks17//18//===----------------------------------------------------------------------===//19 20#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H21#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H22 23#include "CollectMacros.h"24#include "Compiler.h"25#include "Diagnostics.h"26#include "Headers.h"27#include "Preamble.h"28#include "clang-include-cleaner/Record.h"29#include "support/Path.h"30#include "clang/Frontend/FrontendAction.h"31#include "clang/Lex/Preprocessor.h"32#include "clang/Tooling/Syntax/Tokens.h"33#include "llvm/ADT/ArrayRef.h"34#include "llvm/ADT/StringRef.h"35#include <memory>36#include <optional>37#include <string>38#include <vector>39 40namespace clang {41class HeuristicResolver;42class Sema;43namespace clangd {44 45/// Stores and provides access to parsed AST.46class ParsedAST {47public:48 /// Attempts to run Clang and store the parsed AST.49 /// If \p Preamble is non-null it is reused during parsing.50 /// This function does not check if preamble is valid to reuse.51 static std::optional<ParsedAST>52 build(llvm::StringRef Filename, const ParseInputs &Inputs,53 std::unique_ptr<clang::CompilerInvocation> CI,54 llvm::ArrayRef<Diag> CompilerInvocationDiags,55 std::shared_ptr<const PreambleData> Preamble);56 57 ParsedAST(ParsedAST &&Other);58 ParsedAST &operator=(ParsedAST &&Other);59 60 ~ParsedAST();61 62 ParsedAST(const ParsedAST &Other) = delete;63 ParsedAST &operator=(const ParsedAST &Other) = delete;64 65 /// Note that the returned ast will not contain decls from the preamble that66 /// were not deserialized during parsing. Clients should expect only decls67 /// from the main file to be in the AST.68 ASTContext &getASTContext();69 const ASTContext &getASTContext() const;70 71 Sema &getSema();72 73 Preprocessor &getPreprocessor();74 std::shared_ptr<Preprocessor> getPreprocessorPtr();75 const Preprocessor &getPreprocessor() const;76 77 SourceManager &getSourceManager() {78 return getASTContext().getSourceManager();79 }80 const SourceManager &getSourceManager() const {81 return getASTContext().getSourceManager();82 }83 84 const LangOptions &getLangOpts() const {85 return getASTContext().getLangOpts();86 }87 88 /// This function returns top-level decls present in the main file of the AST.89 /// The result does not include the decls that come from the preamble.90 /// (These should be const, but RecursiveASTVisitor requires Decl*).91 ArrayRef<Decl *> getLocalTopLevelDecls();92 ArrayRef<const Decl *> getLocalTopLevelDecls() const;93 94 llvm::ArrayRef<Diag> getDiagnostics() const;95 96 /// Returns the estimated size of the AST and the accessory structures, in97 /// bytes. Does not include the size of the preamble.98 std::size_t getUsedBytes() const;99 const IncludeStructure &getIncludeStructure() const;100 101 /// Gets all macro references (definition, expansions) present in the main102 /// file, including those in the preamble region.103 const MainFileMacros &getMacros() const;104 /// Gets all pragma marks in the main file.105 const std::vector<PragmaMark> &getMarks() const;106 /// Tokens recorded while parsing the main file.107 /// (!) does not have tokens from the preamble.108 const syntax::TokenBuffer &getTokens() const { return Tokens; }109 /// Returns the PramaIncludes for preamble + main file includes.110 const include_cleaner::PragmaIncludes &getPragmaIncludes() const;111 112 /// Returns the version of the ParseInputs this AST was built from.113 llvm::StringRef version() const { return Version; }114 115 /// Returns the path passed by the caller when building this AST.116 PathRef tuPath() const { return TUPath; }117 118 /// Returns the version of the ParseInputs used to build Preamble part of this119 /// AST. Might be std::nullopt if no Preamble is used.120 std::optional<llvm::StringRef> preambleVersion() const;121 122 const HeuristicResolver *getHeuristicResolver() const {123 return Resolver.get();124 }125 126private:127 ParsedAST(PathRef TUPath, llvm::StringRef Version,128 std::shared_ptr<const PreambleData> Preamble,129 std::unique_ptr<CompilerInstance> Clang,130 std::unique_ptr<FrontendAction> Action, syntax::TokenBuffer Tokens,131 MainFileMacros Macros, std::vector<PragmaMark> Marks,132 std::vector<Decl *> LocalTopLevelDecls, std::vector<Diag> Diags,133 IncludeStructure Includes, include_cleaner::PragmaIncludes PI);134 Path TUPath;135 std::string Version;136 // In-memory preambles must outlive the AST, it is important that this member137 // goes before Clang and Action.138 std::shared_ptr<const PreambleData> Preamble;139 // We store an "incomplete" FrontendAction (i.e. no EndSourceFile was called140 // on it) and CompilerInstance used to run it. That way we don't have to do141 // complex memory management of all Clang structures on our own. (They are142 // stored in CompilerInstance and cleaned up by143 // FrontendAction.EndSourceFile).144 std::unique_ptr<CompilerInstance> Clang;145 std::unique_ptr<FrontendAction> Action;146 /// Tokens recorded after the preamble finished.147 /// - Includes all spelled tokens for the main file.148 /// - Includes expanded tokens produced **after** preamble.149 /// - Does not have spelled or expanded tokens for files from preamble.150 syntax::TokenBuffer Tokens;151 152 /// All macro definitions and expansions in the main file.153 MainFileMacros Macros;154 // Pragma marks in the main file.155 std::vector<PragmaMark> Marks;156 // Diags emitted while parsing this AST (including preamble and compiler157 // invocation).158 std::vector<Diag> Diags;159 // Top-level decls inside the current file. Not that this does not include160 // top-level decls from the preamble.161 std::vector<Decl *> LocalTopLevelDecls;162 IncludeStructure Includes;163 include_cleaner::PragmaIncludes PI;164 std::unique_ptr<HeuristicResolver> Resolver;165};166 167} // namespace clangd168} // namespace clang169 170#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H171