reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   21 class ParsedAST;

   25 class ParsedAST;

   26 class ParsedAST;

   30 class ParsedAST;

   29 class ParsedAST;

   18 class ParsedAST;

References

   39     T value;
   60   explicit OptionalStorage(in_place_t, Args &&... args)
   61       : value(std::forward<Args>(args)...), hasVal(true) {}
   72   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
   76   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
   81   T &&getValue() && noexcept {
   87   template <class... Args> void emplace(Args &&... args) {
   89     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
   89     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
  106       ::new ((void *)std::addressof(value)) T(std::move(y));
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {

   91     T t;
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;

   71   void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override {
  310     auto &AST = InpAST->AST;

  182   DocumentOutline(ParsedAST &AST) : AST(AST) {}
  261   ParsedAST *
  264 std::vector<DocumentSymbol> collectDocSymbols(ParsedAST &AST) {
  269 llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST &AST) {

   44 llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST &AST);

   72                                                     ParsedAST &AST,
  126 std::vector<const Decl *> getIndexableLocalDecls(ParsedAST &AST) {

   27                                                     ParsedAST &AST,
   32 std::vector<const Decl *> getIndexableLocalDecls(ParsedAST &AST);

  213 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS) {
  217 llvm::Optional<ParsedAST>
  409 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
  411 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
  411 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
  504 llvm::Optional<ParsedAST>
  521   return ParsedAST::build(

   50   static llvm::Optional<ParsedAST>
   58   ParsedAST(ParsedAST &&Other);
   59   ParsedAST &operator=(ParsedAST &&Other);
   59   ParsedAST &operator=(ParsedAST &&Other);
  138 llvm::Optional<ParsedAST>
  146 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS);

  121   ParsedAST *
  124   HighlightingTokenCollector(ParsedAST &AST) : AST(AST) {}
  460 std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST) {

   70 std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST);

   29 llvm::Expected<std::vector<Range>> getSemanticRanges(ParsedAST &AST,

   27 llvm::Expected<std::vector<Range>> getSemanticRanges(ParsedAST &AST,

  105   void put(Key K, std::unique_ptr<ParsedAST> V) {
  113     std::unique_ptr<ParsedAST> ForCleanup = std::move(LRU.back().second);
  123   llvm::Optional<std::unique_ptr<ParsedAST>> take(Key K) {
  128     std::unique_ptr<ParsedAST> V = std::move(Existing->second);
  137   using KVPair = std::pair<Key, std::unique_ptr<ParsedAST>>;
  486     llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
  488       llvm::Optional<ParsedAST> NewAST =
  491       AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
  532     llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
  539       llvm::Optional<ParsedAST> NewAST =
  546       AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;

   36   ParsedAST *
  129   virtual void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) {}

  200 std::vector<const Decl *> getDeclAtPosition(ParsedAST &AST,
  238 std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
  397 findRefs(const std::vector<const Decl *> &Decls, ParsedAST &AST) {
  412 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
  728 static HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
  857 llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
  878 bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg) {
  882 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
  918 std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
  985 std::vector<SymbolDetails> getSymbolInfo(ParsedAST &AST, Position Pos) {
 1157 const CXXRecordDecl *findRecordTypeAt(ParsedAST &AST, Position Pos) {
 1215 getTypeHierarchy(ParsedAST &AST, Position Pos, int ResolveLevels,
 1306 llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,

   49 std::vector<LocatedSymbol> locateSymbolAt(ParsedAST &AST, Position Pos,
   53 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,
  123 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
  129 std::vector<Location> findReferences(ParsedAST &AST, Position Pos,
  134 std::vector<SymbolDetails> getSymbolInfo(ParsedAST &AST, Position Pos);
  137 const CXXRecordDecl *findRecordTypeAt(ParsedAST &AST, Position Pos);
  144     ParsedAST &AST, Position Pos, int Resolve, TypeHierarchyDirection Direction,
  154 llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
  159 bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg);
  162 llvm::DenseSet<const Decl *> getNonLocalDeclRefs(ParsedAST &AST,

   80 SlabTuple indexMainDecls(ParsedAST &AST) {
  256 void FileIndex::updateMain(PathRef Path, ParsedAST &AST) {

  106   void updateMain(PathRef Path, ParsedAST &AST);
  140 SlabTuple indexMainDecls(ParsedAST &AST);

  142 findOccurrencesWithinFile(ParsedAST &AST, const NamedDecl *RenameDecl) {
  162 renameWithinFile(ParsedAST &AST, llvm::StringRef File, Position Pos,

   26 renameWithinFile(ParsedAST &AST, llvm::StringRef File, Position Pos,

   48 Tweak::Selection::Selection(const SymbolIndex *Index, ParsedAST &AST,

   50     Selection(const SymbolIndex *Index, ParsedAST &AST, unsigned RangeBegin,
   57     ParsedAST *

  710   auto Parsed = TU.build();

   78   llvm::Optional<ParsedAST> AST;

  153   auto AST = File.build();
  331   auto AST = Test.build();
  359   auto AST = TU.build();
  382   auto AST = TU.build();
  401   auto HeaderAST = Header.build();
  402   auto CppAST = Cpp.build();

   77     auto AST = TU.build();
  528     auto AST = TU.build();

  105   auto AST = TU.build();
  178     auto HeaderAST = TU.build();
  244     auto AST = TU.build();

  369   auto AST = Test.build();
  376   auto StaticAST = Test.build();

   81   auto AST = TU.build();
  101   auto AST = TU.build();
  115   auto AST = TU.build();
  151   auto AST = TU.build();
  179   auto AST = TU.build();
  205   auto AST = TU.build();
  275   ParsedAST AST = TU.build();

   35   auto AST = TestTU::withCode(Test.code()).build();

   54   auto AST = Header.build();
  117   auto AST = Test.build();
  357   auto AST = Header.build();
  400   auto AST = Header.build();
  424   auto AST = Header.build();
  456   auto AST = Header.build();
  476   auto AST = Header.build();

   81     auto AST = TU.build();
  178     auto AST = TU.build();

   22 SelectionTree makeSelectionTree(const StringRef MarkedCode, ParsedAST &AST) {
   39 Range nodeRange(const SelectionTree::Node *N, ParsedAST &AST) {
  300     auto AST = TU.build();
  329   auto AST = TestTU::withCode(Annotations(Code).code()).build();
  370     auto AST = TestTU::withCode(Test.code()).build();
  395   auto AST = TU.build();
  409   auto AST = TestTU::withCode(Annotations(Test).code()).build();

  114   auto AST = TU.build();

  143     auto AST = TestTU::withCode(T.code()).build();

  359     auto AST = TestTU::withCode(TestCase.code()).build();
  484   auto AST = TU.build();
  510   auto AST = TU.build();
  549   ParsedAST AST = TestTU::withCode(Test.code()).build();
  586   auto AST = TU.build();
  611   auto AST = TU.build();

  137   llvm::Optional<ParsedAST> AST; // Initialized after build.
  153   auto AST = File.build();

  329     auto AST = TestTU::withCode(TestInput.code()).build();

   71       void onMainAST(PathRef File, ParsedAST &AST, PublishFn Publish) override {

   22 ParsedAST TestTU::build() const {
   82   auto AST = build();
   89   auto AST = build();
  118 const NamedDecl &findDecl(ParsedAST &AST, llvm::StringRef QName) {
  139 const NamedDecl &findDecl(ParsedAST &AST,
  159 const NamedDecl &findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name) {

   67   ParsedAST build() const;
   75 const NamedDecl &findDecl(ParsedAST &AST, llvm::StringRef QName);
   77 const NamedDecl &findDecl(ParsedAST &AST,
   80 const NamedDecl &findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name);

   76   ParsedAST AST = TU.build();
   98   ParsedAST AST = TU.build();

   70   auto AST = TU.build();
   94   auto AST = TU.build();
  117   auto AST = TU.build();
  146   auto AST = TU.build();
  182   auto AST = TU.build();
  209   auto AST = TU.build();
  231 const NamedDecl &findDeclWithTemplateArgs(ParsedAST &AST,
  259   auto AST = TU.build();
  288   auto AST = TU.build();
  319   auto AST = TU.build();
  369   auto AST = TU.build();
  403   auto AST = TU.build();
  439   auto AST = TU.build();
  624   auto AST = TU.build();

  108     auto AST = TestTU::withCode(T.code()).build();
  161     auto AST = TestTU::withCode(Main.code()).build();
  219   auto AST = TestTU::withCode(Test.code()).build();
  472     auto AST = TU.build();
  512   auto AST = TestTU::withCode(T.code()).build();
  535   auto AST = TestTU::withCode(T.code()).build();
 1012     auto AST = TU.build();
 1843     auto AST = TU.build();
 2050     auto AST = TestTU::withCode(T.code()).build();
 2110     auto AST = TestTU::withCode(T.code()).build();
 2127   auto AST = TU.build();
 2180     auto AST = TestTU::withCode(File.code()).build();
 2199     auto AST = TestTU::withCode(File.code()).build();
 2269     auto AST = TestTU::withCode(File.code()).build();

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1955     { typedef _Tp     type; };