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

References

   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
   66   using mapped_type = ValueT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  237     TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
  249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
  299   ValueT &operator[](const KeyT &Key) {
  311   ValueT &operator[](KeyT &&Key) {
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  516                             ValueArgs &&... Values) {
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  526                                       ValueT &&Value, LookupKeyT &Lookup) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)

   74   using CallPtrT = ReturnT (*)(void *CallableAddr,
  156   static ReturnT CallImpl(void *CallableAddr, AdjustedParamT<ParamTs>... Params) {
  276   ReturnT operator()(ParamTs... Params) {

   39     T value;
   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) {
  237   template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
  238     Storage.emplace(std::forward<ArgTypes>(Args)...);
  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) && {

  129   ValueTy second;
  134   StringMapEntryStorage(size_t strLen, InitTy &&... InitVals)
  135       : StringMapEntryBase(strLen), second(std::forward<InitTy>(InitVals)...) {}
  138   const ValueTy &getValue() const { return second; }
  139   ValueTy &getValue() { return second; }
  141   void setValue(const ValueTy &V) { second = V; }
  158 class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
  160   using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
  179                                 InitTy &&... InitVals) {
  192     new (NewItem) StringMapEntry(KeyLength, std::forward<InitTy>(InitVals)...);
  204   static StringMapEntry *Create(StringRef Key, InitType &&... InitVal) {
  246   using MapEntryTy = StringMapEntry<ValueTy>;
  260   StringMap(std::initializer_list<std::pair<StringRef, ValueTy>> List)
  330   using mapped_type = ValueTy;
  331   using value_type = StringMapEntry<ValueTy>;
  334   using const_iterator = StringMapConstIterator<ValueTy>;
  335   using iterator = StringMapIterator<ValueTy>;
  350   iterator_range<StringMapKeyIterator<ValueTy>> keys() const {
  369   ValueTy lookup(StringRef Key) const {
  378   ValueTy &operator[](StringRef Key) { return try_emplace(Key).first->second; }
  413   std::pair<iterator, bool> insert(std::pair<StringRef, ValueTy> KV) {
  432   std::pair<iterator, bool> try_emplace(StringRef Key, ArgsTy &&... Args) {
  441     Bucket = MapEntryTy::Create(Key, Allocator, std::forward<ArgsTy>(Args)...);
  531     : public StringMapIterBase<StringMapConstIterator<ValueTy>,
  532                                const StringMapEntry<ValueTy>> {
  533   using base = StringMapIterBase<StringMapConstIterator<ValueTy>,
  534                                  const StringMapEntry<ValueTy>>;
  542   const StringMapEntry<ValueTy> &operator*() const {
  548 class StringMapIterator : public StringMapIterBase<StringMapIterator<ValueTy>,
  549                                                    StringMapEntry<ValueTy>> {
  551       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
  551       StringMapIterBase<StringMapIterator<ValueTy>, StringMapEntry<ValueTy>>;
  559   StringMapEntry<ValueTy> &operator*() const {
  563   operator StringMapConstIterator<ValueTy>() const {

   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;

 1155 std::future<SymbolSlab> startAsyncFuzzyFind(const SymbolIndex &Index,
 1157   return runAsync<SymbolSlab>([&Index, Req]() {
 1159     SymbolSlab::Builder Syms;
 1387     SymbolSlab IndexResults = Opts.Index ? queryIndex() : SymbolSlab();
 1448     auto IndexResults = (Opts.Index && allowIndex(Recorder->CCContext))
 1473   SymbolSlab queryIndex() {
 1505     SymbolSlab::Builder ResultsBuilder;

  237   std::future<SymbolSlab> Result;

  130   llvm::Optional<const SymbolSlab *> Symbols = lookupCached(*ID);
  133   const SymbolSlab &Syms = **Symbols;
  144 std::vector<Fix> IncludeFixer::fixesForSymbols(const SymbolSlab &Syms) const {
  397   if (llvm::Optional<const SymbolSlab *> Syms = fuzzyFindCached(Req))
  403 llvm::Optional<const SymbolSlab *>
  414   SymbolSlab::Builder Matches;
  421   auto Syms = std::move(Matches).build();
  426 llvm::Optional<const SymbolSlab *>
  440   SymbolSlab::Builder Matches;
  442   auto Syms = std::move(Matches).build();

   56   std::vector<Fix> fixesForSymbols(const SymbolSlab &Syms) const;
   87   mutable llvm::StringMap<SymbolSlab> FuzzyFindCache;
   88   mutable llvm::DenseMap<SymbolID, SymbolSlab> LookupCache;
   90   llvm::Optional<const SymbolSlab *>
   92   llvm::Optional<const SymbolSlab *> lookupCached(const SymbolID &ID) const;

  124 std::future<T> runAsync(llvm::unique_function<T()> Action) {
  124 std::future<T> runAsync(llvm::unique_function<T()> Action) {

  288     SymbolSlab::Builder Syms;
  297     auto SS = std::make_unique<SymbolSlab>(std::move(Syms).build());
  463               ? std::make_unique<SymbolSlab>(std::move(*LS.Shard->Symbols))

   67   auto Syms = Collector.takeSymbols();
   95 void FileSymbols::update(PathRef Path, std::unique_ptr<SymbolSlab> Symbols,
  120   std::vector<std::shared_ptr<SymbolSlab>> SymbolSlabs;
  247       Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Slabs))),
  259       Path, std::make_unique<SymbolSlab>(std::move(std::get<0>(Contents))),

   66   void update(PathRef Path, std::unique_ptr<SymbolSlab> Slab,
   85   llvm::StringMap<std::shared_ptr<SymbolSlab>> FileToSymbols;
  135 using SlabTuple = std::tuple<SymbolSlab, RefSlab, RelationSlab>;

  131               std::function<void(SymbolSlab)> SymbolsCallback,
  191   std::function<void(SymbolSlab)> SymbolsCallback;
  206     std::function<void(SymbolSlab)> SymbolsCallback,

   28     std::function<void(SymbolSlab)> SymbolsCallback,

   19 std::unique_ptr<SymbolIndex> MemIndex::build(SymbolSlab Slab, RefSlab Refs,

   24   MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations) {
   37   MemIndex(SymbolRange &&Symbols, RefRange &&Refs, RelationRange &&Relations,
   39       : MemIndex(std::forward<SymbolRange>(Symbols),
   48   static std::unique_ptr<SymbolIndex> build(SymbolSlab Symbols, RefSlab Refs,

   41   SymbolSlab::Builder DynB;
   49   SymbolSlab Dyn = std::move(DynB).build();
   74   SymbolSlab::Builder B;

  467     SymbolSlab::Builder Symbols;
  672   SymbolSlab Symbols;

   43   llvm::Optional<SymbolSlab> Symbols;
   56   const SymbolSlab *Symbols = nullptr;

   37 SymbolSlab::const_iterator SymbolSlab::find(const SymbolID &ID) const {
   54 SymbolSlab SymbolSlab::Builder::build() && {

  217     SymbolSlab build() &&;

  111   SymbolSlab takeSymbols() { return std::move(Symbols).build(); }
  135   SymbolSlab::Builder Symbols;

  357   SymbolSlab::Builder Symbols;

   26 std::unique_ptr<SymbolIndex> Dex::build(SymbolSlab Symbols, RefSlab Refs,

   46   Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations)
   61   Dex(SymbolRange &&Symbols, RefsRange &&Refs, RelationsRange &&Relations,
   71   static std::unique_ptr<SymbolIndex> build(SymbolSlab, RefSlab, RelationSlab);

   85   SymbolSlab::Builder Symbols;

  165   auto Syms = runFuzzyFind(Idx, "common");
  588     SymbolSlab::Builder SB;
  590     Source.update("", std::make_unique<SymbolSlab>(std::move(SB).build()),

   93   SymbolSlab::Builder Slab;

  746   SymbolSlab::Builder B;

  520   SymbolSlab::Builder Slab;
  583   SymbolSlab::Builder Slab;

   67 std::unique_ptr<SymbolSlab> numSlab(int Begin, int End) {
   68   SymbolSlab::Builder Slab;
   71   return std::make_unique<SymbolSlab>(std::move(Slab).build());
  108     SymbolSlab::Builder S;
  110     return std::make_unique<SymbolSlab>(std::move(S).build());
  212   auto Symbols = runFuzzyFind(M, "");
  223   auto Symbols = runFuzzyFind(*TU.index(), "");
  242   auto Symbols = runFuzzyFind(M, "");
  406   auto Symbols = runFuzzyFind(Index, "");

  116   SymbolSlab::Builder AllSymbols;

   64   SymbolSlab::Builder B;
   72   SymbolSlab S = std::move(B).build();
  228   SymbolSlab::Builder B;
  360   auto HeaderSymbols = TestTU::withHeaderCode("class Foo;").headerSymbols();

   53   auto Symbols = Header.headerSymbols();
  356   auto Symbols = Header.headerSymbols();
  385   auto Symbols = Header.headerSymbols();
  423   auto Symbols = Header.headerSymbols();

  160 std::vector<std::string> YAMLFromSymbols(const SymbolSlab &Slab) {

  293   SymbolSlab Symbols;
  612   auto HeaderSymbols = TestTU::withHeaderCode(Header.code()).headerSymbols();
  622   auto MainSymbols =

  127 SymbolSlab runFuzzyFind(const SymbolIndex &Index, llvm::StringRef Query) {
  134 SymbolSlab runFuzzyFind(const SymbolIndex &Index, const FuzzyFindRequest &Req) {
  135   SymbolSlab::Builder Builder;

   52 SymbolSlab runFuzzyFind(const SymbolIndex &Index, StringRef Query);
   53 SymbolSlab runFuzzyFind(const SymbolIndex &Index, const FuzzyFindRequest &Req);

   76 SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames) {
   77   SymbolSlab::Builder Slab;
   83 SymbolSlab generateNumSymbols(int Begin, int End) {

   35 SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames);
   38 SymbolSlab generateNumSymbols(int Begin, int End);

   81 SymbolSlab TestTU::headerSymbols() const {
   97 const Symbol &findSymbol(const SymbolSlab &Slab, llvm::StringRef QName) {

   68   SymbolSlab headerSymbols() const;
   73 const Symbol &findSymbol(const SymbolSlab &, llvm::StringRef QName);

 1834   SymbolSlab::Builder Symbols;

   58     constexpr _Res
   63     constexpr _Res
   69     constexpr _Res

   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;

   58     begin(const _Container& __cont) -> decltype(__cont.begin())

   93     class shared_ptr : public __shared_ptr<_Tp>
  107       using element_type = typename __shared_ptr<_Tp>::element_type;
  236 	shared_ptr(const shared_ptr<_Yp>& __r) noexcept
  253 	shared_ptr(shared_ptr<_Yp>&& __r) noexcept
  277 	shared_ptr(unique_ptr<_Yp, _Del>&& __r)
  299 	_Assignable<const shared_ptr<_Yp>&>
  300 	operator=(const shared_ptr<_Yp>& __r) noexcept
  324 	_Assignable<shared_ptr<_Yp>>
  325 	operator=(shared_ptr<_Yp>&& __r) noexcept
  332 	_Assignable<unique_ptr<_Yp, _Del>>
  333 	operator=(unique_ptr<_Yp, _Del>&& __r)
  352       shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)

  653 	__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
  660 	  using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
  882     : is_convertible<_Yp*, _Tp*>::type
  882     : is_convertible<_Yp*, _Tp*>::type
  956       using element_type = _Tp;
 1035     : public __shared_ptr_access<_Tp, _Lp>
 1038       using element_type = typename remove_extent<_Tp>::type;
 1126 	__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 1138 	__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 1157 	__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 1192 	_Assignable<_Yp>
 1193 	operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 1218 	_Assignable<_Yp>
 1219 	operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 1226 	_UniqAssignable<_Yp, _Del>
 1227 	operator=(unique_ptr<_Yp, _Del>&& __r)
 1272       swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
 1344       __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
 1377 	typename enable_if<!__has_esft_base<_Yp2>::value>::type
 1378 	_M_enable_shared_from_this_with(_Yp*) noexcept
 1386 	static _Tp1*
 1387 	_S_raw_ptr(_Tp1* __ptr)
 1601       using element_type = typename remove_extent<_Tp>::type;
 1684       __shared_ptr<_Tp, _Lp>
 1720       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept

   62     : std::unary_function<_T1, _Res> { };
  314       _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
  317 	    std::forward<_ArgTypes>(__args)...);
  390     : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
  595       _Res operator()(_ArgTypes... __args) const;
  628       using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
  689 	typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
  706       return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);

  108       typedef _Arg 	argument_type;   

  100 	return __and_<is_constructible<_T1, const _U1&>,
  100 	return __and_<is_constructible<_T1, const _U1&>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  209     : private __pair_base<_T1, _T2>
  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  332        explicit pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  342 	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
  379 		__and_<is_copy_assignable<_T1>,
  380 		       is_copy_assignable<_T2>>::value,
  390 		__and_<is_move_assignable<_T1>,
  391 		       is_move_assignable<_T2>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)
  522     constexpr pair<typename __decay_and_strip<_T1>::__type,
  524     make_pair(_T1&& __x, _T2&& __y)
  526       typedef typename __decay_and_strip<_T1>::__type __ds_type1;
  529       return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));

   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
  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)...)); }

   85     : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
   85     : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
   88 	std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
   88 	std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
  108       _Tp*
  112       const _Tp*

  230 	__gnu_cxx::__aligned_buffer<_Res>	_M_storage;
  234 	typedef _Res result_type;
  245 	_Res&
  249 	_M_set(const _Res& __res)
  256 	_M_set(_Res&& __res)
  258 	  ::new (_M_storage._M_addr()) _Res(std::move(__res));
  675       typedef __future_base::_Result<_Res>&	__result_type;
  738       __basic_future(const shared_future<_Res>&) noexcept;
  742       __basic_future(shared_future<_Res>&&) noexcept;
  746       __basic_future(future<_Res>&&) noexcept;
  761     class future : public __basic_future<_Res>
  766         friend future<__async_result_of<_Fn, _Args...>>
  766         friend future<__async_result_of<_Fn, _Args...>>
  769       typedef __basic_future<_Res> _Base_type;
  792       _Res
  799       shared_future<_Res> share() noexcept;
  891     class shared_future : public __basic_future<_Res>
  893       typedef __basic_future<_Res> _Base_type;
  902       shared_future(future<_Res>&& __uf) noexcept
  924       const _Res&
 1597       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
 1601       typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
 1662       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
 1685       typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;

   56     struct __is_empty_non_tuple : is_empty<_Tp> { };
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  133 	: _M_head_impl(std::forward<_UHead>(__h)) { }
  159       static constexpr _Head&
  162       static constexpr const _Head&
  165       _Head _M_head_impl;
  187       private _Head_base<_Idx, _Head>
  192       typedef _Head_base<_Idx, _Head> _Base;
  194       static constexpr _Head&
  197       static constexpr const _Head&
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  218 	  _Base(std::forward<_UHead>(__head)) { }
  227 	_Base(std::forward<_Head>(_M_head(__in))) { }
  230         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
  235         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
  248 		    const _Head& __head, const _Tail&... __tail)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  508       return  __not_<is_same<tuple<_Elements...>,
  556     class tuple : public _Tuple_impl<0, _Elements...>
  558       typedef _Tuple_impl<0, _Elements...> _Inherited;
  598             _Elements...>;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  628                       _Elements...>;
  636                       _Elements...>;
  646         constexpr tuple(_UElements&&... __elements)
  647         : _Inherited(std::forward<_UElements>(__elements)...) { }
  668             _Elements...>;
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
 1288       typedef _Head type;
 1302     constexpr _Head&
 1303     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1304     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 1307     constexpr const _Head&
 1308     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1314     get(tuple<_Elements...>& __t) noexcept
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1320     get(const tuple<_Elements...>& __t) noexcept
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1326     get(tuple<_Elements...>&& __t) noexcept
 1328       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
 1328       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
 1328       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
 1447     constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
 1448     make_tuple(_Elements&&... __args)
 1450       typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 1452       return __result_type(std::forward<_Elements>(__args)...);

  194     { typedef _Tp type; };
  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
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  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
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_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>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 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; };
 1637     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1942     { typedef _Tp     type; };
 1955     { typedef _Tp     type; };
 2104     { typedef typename remove_cv<_Up>::type __type; };
 2118       typedef typename remove_reference<_Tp>::type __remove_type;
 2131       typedef _Tp __type;
 2144 	typename decay<_Tp>::type>::__type __type;
 2253     inline typename add_rvalue_reference<_Tp>::type
 2277     struct __result_of_success : __success_type<_Tp>
 2427       static __result_of_success<decltype(
 2428       std::declval<_Fn>()(std::declval<_Args>()...)
 2439       typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
 2452 	_Functor, _ArgTypes...
 2458     : public __invoke_result<_Functor, _ArgTypes...>

 1844   AssertionResult operator()(const char* value_text, const T& x) const {
 1856     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
 1856     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);

  410   typedef RawContainer type;
  413   static const_reference ConstReference(const RawContainer& container) {
  415     testing::StaticAssertTypeEq<RawContainer,
  419   static type Copy(const RawContainer& container) { return container; }

  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  377   for (typename C::const_iterator it = container.begin();
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  853 void UniversalPrint(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  981 ::std::string PrintToString(const T& value) {
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

  795 struct RemoveConst { typedef T type; };  // NOLINT
  797 struct RemoveConst<const T> { typedef T type; };  // NOLINT
  933                             typename C::iterator* /* it */ = NULL,
  934                             typename C::const_iterator* /* const_it */ = NULL) {