LCOV - code coverage report
Current view: top level - clang/tools/extra/clangd - ClangdUnit.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 0 1 0.0 %
Date: 2018-06-17 00:07:59 Functions: 0 3 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===--- ClangdUnit.h -------------------------------------------*- C++-*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===---------------------------------------------------------------------===//
       9             : 
      10             : #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDUNIT_H
      11             : #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDUNIT_H
      12             : 
      13             : #include "Diagnostics.h"
      14             : #include "Function.h"
      15             : #include "Headers.h"
      16             : #include "Path.h"
      17             : #include "Protocol.h"
      18             : #include "clang/Frontend/FrontendAction.h"
      19             : #include "clang/Frontend/PrecompiledPreamble.h"
      20             : #include "clang/Lex/Preprocessor.h"
      21             : #include "clang/Serialization/ASTBitCodes.h"
      22             : #include "clang/Tooling/CompilationDatabase.h"
      23             : #include "clang/Tooling/Core/Replacement.h"
      24             : #include <memory>
      25             : #include <string>
      26             : #include <vector>
      27             : 
      28             : namespace llvm {
      29             : class raw_ostream;
      30             : }
      31             : 
      32             : namespace clang {
      33             : class PCHContainerOperations;
      34             : 
      35             : namespace vfs {
      36             : class FileSystem;
      37             : }
      38             : 
      39             : namespace tooling {
      40             : struct CompileCommand;
      41             : }
      42             : 
      43             : namespace clangd {
      44             : 
      45             : // Stores Preamble and associated data.
      46             : struct PreambleData {
      47             :   PreambleData(PrecompiledPreamble Preamble, std::vector<Diag> Diags,
      48             :                std::vector<Inclusion> Inclusions);
      49             : 
      50             :   tooling::CompileCommand CompileCommand;
      51             :   PrecompiledPreamble Preamble;
      52             :   std::vector<Diag> Diags;
      53             :   // Processes like code completions and go-to-definitions will need #include
      54             :   // information, and their compile action skips preamble range.
      55             :   std::vector<Inclusion> Inclusions;
      56             : };
      57             : 
      58             : /// Information required to run clang, e.g. to parse AST or do code completion.
      59           0 : struct ParseInputs {
      60             :   tooling::CompileCommand CompileCommand;
      61             :   IntrusiveRefCntPtr<vfs::FileSystem> FS;
      62             :   std::string Contents;
      63             : };
      64             : 
      65             : /// Stores and provides access to parsed AST.
      66             : class ParsedAST {
      67             : public:
      68             :   /// Attempts to run Clang and store parsed AST. If \p Preamble is non-null
      69             :   /// it is reused during parsing.
      70             :   static llvm::Optional<ParsedAST>
      71             :   Build(std::unique_ptr<clang::CompilerInvocation> CI,
      72             :         std::shared_ptr<const PreambleData> Preamble,
      73             :         std::unique_ptr<llvm::MemoryBuffer> Buffer,
      74             :         std::shared_ptr<PCHContainerOperations> PCHs,
      75             :         IntrusiveRefCntPtr<vfs::FileSystem> VFS);
      76             : 
      77             :   ParsedAST(ParsedAST &&Other);
      78             :   ParsedAST &operator=(ParsedAST &&Other);
      79             : 
      80             :   ~ParsedAST();
      81             : 
      82             :   /// Note that the returned ast will not contain decls from the preamble that
      83             :   /// were not deserialized during parsing. Clients should expect only decls
      84             :   /// from the main file to be in the AST.
      85             :   ASTContext &getASTContext();
      86             :   const ASTContext &getASTContext() const;
      87             : 
      88             :   Preprocessor &getPreprocessor();
      89             :   std::shared_ptr<Preprocessor> getPreprocessorPtr();
      90             :   const Preprocessor &getPreprocessor() const;
      91             : 
      92             :   /// This function returns top-level decls present in the main file of the AST.
      93             :   /// The result does not include the decls that come from the preamble.
      94             :   /// (These should be const, but RecursiveASTVisitor requires Decl*).
      95             :   ArrayRef<Decl *> getLocalTopLevelDecls();
      96             : 
      97             :   const std::vector<Diag> &getDiagnostics() const;
      98             : 
      99             :   /// Returns the esitmated size of the AST and the accessory structures, in
     100             :   /// bytes. Does not include the size of the preamble.
     101             :   std::size_t getUsedBytes() const;
     102             :   const std::vector<Inclusion> &getInclusions() const;
     103             : 
     104             : private:
     105             :   ParsedAST(std::shared_ptr<const PreambleData> Preamble,
     106             :             std::unique_ptr<CompilerInstance> Clang,
     107             :             std::unique_ptr<FrontendAction> Action,
     108             :             std::vector<Decl *> LocalTopLevelDecls, std::vector<Diag> Diags,
     109             :             std::vector<Inclusion> Inclusions);
     110             : 
     111             :   // In-memory preambles must outlive the AST, it is important that this member
     112             :   // goes before Clang and Action.
     113             :   std::shared_ptr<const PreambleData> Preamble;
     114             :   // We store an "incomplete" FrontendAction (i.e. no EndSourceFile was called
     115             :   // on it) and CompilerInstance used to run it. That way we don't have to do
     116             :   // complex memory management of all Clang structures on our own. (They are
     117             :   // stored in CompilerInstance and cleaned up by
     118             :   // FrontendAction.EndSourceFile).
     119             :   std::unique_ptr<CompilerInstance> Clang;
     120             :   std::unique_ptr<FrontendAction> Action;
     121             : 
     122             :   // Data, stored after parsing.
     123             :   std::vector<Diag> Diags;
     124             :   // Top-level decls inside the current file. Not that this does not include
     125             :   // top-level decls from the preamble.
     126             :   std::vector<Decl *> LocalTopLevelDecls;
     127             :   std::vector<Inclusion> Inclusions;
     128             : };
     129             : 
     130             : using PreambleParsedCallback = std::function<void(
     131             :     PathRef Path, ASTContext &, std::shared_ptr<clang::Preprocessor>)>;
     132             : 
     133             : /// Builds compiler invocation that could be used to build AST or preamble.
     134             : std::unique_ptr<CompilerInvocation>
     135             : buildCompilerInvocation(const ParseInputs &Inputs);
     136             : 
     137             : /// Rebuild the preamble for the new inputs unless the old one can be reused.
     138             : /// If \p OldPreamble can be reused, it is returned unchanged.
     139             : /// If \p OldPreamble is null, always builds the preamble.
     140             : /// If \p PreambleCallback is set, it will be run on top of the AST while
     141             : /// building the preamble. Note that if the old preamble was reused, no AST is
     142             : /// built and, therefore, the callback will not be executed.
     143             : std::shared_ptr<const PreambleData>
     144             : buildPreamble(PathRef FileName, CompilerInvocation &CI,
     145             :               std::shared_ptr<const PreambleData> OldPreamble,
     146             :               const tooling::CompileCommand &OldCompileCommand,
     147             :               const ParseInputs &Inputs,
     148             :               std::shared_ptr<PCHContainerOperations> PCHs, bool StoreInMemory,
     149             :               PreambleParsedCallback PreambleCallback);
     150             : 
     151             : /// Build an AST from provided user inputs. This function does not check if
     152             : /// preamble can be reused, as this function expects that \p Preamble is the
     153             : /// result of calling buildPreamble.
     154             : llvm::Optional<ParsedAST>
     155             : buildAST(PathRef FileName, std::unique_ptr<CompilerInvocation> Invocation,
     156             :          const ParseInputs &Inputs,
     157             :          std::shared_ptr<const PreambleData> Preamble,
     158             :          std::shared_ptr<PCHContainerOperations> PCHs);
     159             : 
     160             : /// Get the beginning SourceLocation at a specified \p Pos.
     161             : /// May be invalid if Pos is, or if there's no identifier.
     162             : SourceLocation getBeginningOfIdentifier(ParsedAST &Unit, const Position &Pos,
     163             :                                         const FileID FID);
     164             : 
     165             : /// For testing/debugging purposes. Note that this method deserializes all
     166             : /// unserialized Decls, so use with care.
     167             : void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS);
     168             : 
     169             : } // namespace clangd
     170             : } // namespace clang
     171             : #endif

Generated by: LCOV version 1.13