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

Derived Classes

tools/clang/include/clang/AST/DeclCXX.h
 3169 class ConstructorUsingShadowDecl final : public UsingShadowDecl {

Declarations

gen/tools/clang/include/clang/AST/DeclNodes.inc
  347 USINGSHADOW(UsingShadow, NamedDecl)
tools/clang/include/clang/AST/ASTContext.h
  124 class UsingShadowDecl;
tools/clang/include/clang/Sema/CodeCompleteConsumer.h
   50 class UsingShadowDecl;
tools/clang/include/clang/Sema/Sema.h
  196   class UsingShadowDecl;

References

include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h
   75       typename std::add_pointer<typename std::add_const<T>::type>::type;
include/llvm/Support/Casting.h
   57   static inline bool doit(const From &Val) {
   58     return To::classof(&Val);
   66   static inline bool doit(const From &) { return true; }
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  309   return cast<X>(Val);
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  360                             typename cast_retty<X, Y>::ret_type>::type
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
tools/clang/include/clang/AST/ASTContext.h
  498   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  498   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
  917   void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
  918                                           UsingShadowDecl *Pattern);
  919   UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);
  919   UsingShadowDecl *getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst);
tools/clang/include/clang/AST/ASTNodeTraverser.h
  540   void VisitUsingShadowDecl(const UsingShadowDecl *D) {
tools/clang/include/clang/AST/ASTTypeTraits.h
   65     return ASTNodeKind(KindToKindId<T>::Id);
   65     return ASTNodeKind(KindToKindId<T>::Id);
   65     return ASTNodeKind(KindToKindId<T>::Id);
  234   static DynTypedNode create(const T &Node) {
  235     return BaseConverter<T>::create(Node);
  259   const T &getUnchecked() const {
  260     return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
  394     static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
  399     static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
  401       return *cast<T>(static_cast<const BaseT *>(
  469     : public DynCastPtrConverter<T, Decl> {};
tools/clang/include/clang/AST/Decl.h
 4406     decl_type *MostRecent = First->getNextRedeclaration();
 4407     RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
tools/clang/include/clang/AST/DeclBase.h
 2536   static ::clang::DeclContext *doit(const FromTy *Val) {
 2537     return FromTy::castToDeclContext(Val);
tools/clang/include/clang/AST/DeclCXX.h
 3068 class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
 3080   using redeclarable_base = Redeclarable<UsingShadowDecl>;
 3082   UsingShadowDecl *getNextRedeclarationImpl() override {
 3086   UsingShadowDecl *getPreviousDeclImpl() override {
 3090   UsingShadowDecl *getMostRecentDeclImpl() override {
 3103   static UsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
 3106     return new (C, DC) UsingShadowDecl(UsingShadow, C, DC, Loc, Using, Target);
 3109   static UsingShadowDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 3121   UsingShadowDecl *getCanonicalDecl() override {
 3124   const UsingShadowDecl *getCanonicalDecl() const {
 3149   UsingShadowDecl *getNextUsingShadowDecl() const {
 3150     return dyn_cast_or_null<UsingShadowDecl>(UsingOrNextShadow);
 3169 class ConstructorUsingShadowDecl final : public UsingShadowDecl {
 3291   llvm::PointerIntPair<UsingShadowDecl *, 1, bool> FirstUsingShadow;
 3339     UsingShadowDecl *Current = nullptr;
 3342     using value_type = UsingShadowDecl *;
 3343     using reference = UsingShadowDecl *;
 3344     using pointer = UsingShadowDecl *;
 3349     explicit shadow_iterator(UsingShadowDecl *C) : Current(C) {}
 3391   void addShadowDecl(UsingShadowDecl *S);
 3392   void removeShadowDecl(UsingShadowDecl *S);
tools/clang/include/clang/AST/JSONNodeDumper.h
  172   template <typename T> void writePreviousDeclImpl(const Redeclarable<T> *D) {
  173     const T *Prev = D->getPreviousDecl();
  230   void VisitUsingShadowDecl(const UsingShadowDecl *USD);
tools/clang/include/clang/AST/Redeclarable.h
  113     DeclLink(PreviousTag, decl_type *D) : Link(NotKnownLatest(Previous(D))) {}
  122     decl_type *getPrevious(const decl_type *D) const {
  122     decl_type *getPrevious(const decl_type *D) const {
  137     void setPrevious(decl_type *D) {
  142     void setLatest(decl_type *D) {
  166   static DeclLink PreviousDeclLink(decl_type *D) {
  187   decl_type *First;
  189   decl_type *getNextRedeclaration() const {
  203   decl_type *getPreviousDecl() {
  208   const decl_type *getPreviousDecl() const {
  215   decl_type *getFirstDecl() { return First; }
  219   const decl_type *getFirstDecl() const { return First; }
  225   decl_type *getMostRecentDecl() {
  230   const decl_type *getMostRecentDecl() const {
  236   void setPreviousDecl(decl_type *PrevDecl);
  241     decl_type *Current = nullptr;
  242     decl_type *Starter;
  246     using value_type = decl_type *;
  247     using reference = decl_type *;
  248     using pointer = decl_type *;
  253     explicit redecl_iterator(decl_type *C) : Current(C), Starter(C) {}
  271       decl_type *Next = Current->getNextRedeclaration();
tools/clang/include/clang/AST/TextNodeDumper.h
  331   void VisitUsingShadowDecl(const UsingShadowDecl *D);
tools/clang/include/clang/ASTMatchers/ASTMatchers.h
 3508   if (const UsingShadowDecl *UsingDecl = dyn_cast<UsingShadowDecl>(FoundDecl))
 3508   if (const UsingShadowDecl *UsingDecl = dyn_cast<UsingShadowDecl>(FoundDecl))
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
  302   virtual bool matches(const T &Node,
  309     return matches(DynNode.getUnchecked<T>(), Finder, Builder);
  345   DynTypedMatcher(MatcherInterface<T> *Implementation)
  346       : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
  436     return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  445   template <typename T> Matcher<T> convertTo() const {
  447     return unconditionalConvertTo<T>();
  454   template <typename T> Matcher<T> unconditionalConvertTo() const;
  499   explicit Matcher(MatcherInterface<T> *Implementation)
  507           typename std::enable_if<std::is_base_of<From, T>::value &&
  508                                !std::is_same<From, T>::value>::type * = nullptr)
  520             std::is_same<T, QualType>::value &&
  529     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
  534   bool matches(const T &Node,
  581     return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
  596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
 1243   operator Matcher<T>() const {
 1245                ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
 1246         .template unconditionalConvertTo<T>();
 1255 class BindableMatcher : public Matcher<T> {
 1257   explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
 1258   explicit BindableMatcher(MatcherInterface<T> *Implementation)
 1265   Matcher<T> bind(StringRef ID) const {
 1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
 1376 BindableMatcher<T> makeAllOfComposite(
 1377     ArrayRef<const Matcher<T> *> InnerMatchers) {
 1388   using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
 1395           ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
 1397           .template unconditionalConvertTo<T>());
 1408     ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
 1557     : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
 1558                               makeDynCastAllOfComposite<SourceT, TargetT>> {
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
  199   ast_matchers::internal::Matcher<T> getTypedMatcher() const {
  202         ->template convertTo<T>();
  227       : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
  228   typedef ast_matchers::internal::Matcher<T> MatcherT;
  232     return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/include/clang/Sema/CodeCompleteConsumer.h
  856   const UsingShadowDecl *ShadowDecl = nullptr;
tools/clang/include/clang/Sema/Sema.h
 5058   void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
 5061                             UsingShadowDecl *&PrevShadow);
 5062   UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,
 5064                                         UsingShadowDecl *PrevDecl);
tools/clang/include/clang/Serialization/ASTReader.h
 1887   T *ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I) {
 1888     return cast_or_null<T>(GetDecl(ReadDeclID(F, R, I)));
 2541   T *readDeclAs() {
 2542     return Reader->ReadDeclAs<T>(*F, Record, Idx);
tools/clang/lib/AST/ASTContext.cpp
 1472 UsingShadowDecl *
 1473 ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
 1474   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
 1474   llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
 1483 ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
 1484                                                UsingShadowDecl *Pattern) {
tools/clang/lib/AST/ASTImporter.cpp
  162     Expected<T *> import(T *From) {
  162     Expected<T *> import(T *From) {
  166       return cast_or_null<T>(*ToOrErr);
  170     Expected<T *> import(const T *From) {
  170     Expected<T *> import(const T *From) {
  217           -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
  218         return ToDeclT::Create(std::forward<Args>(args)...);
  229     LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
  229     LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
  234       CallOverloadedCreateFun<ToDeclT> OC;
  256     GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
  257                                    FromDeclT *FromD, Args &&... args) {
  262       ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
  482     ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
 4302   for (UsingShadowDecl *FromShadow : D->shadows()) {
 4303     if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
 4313 ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
 4331   UsingShadowDecl *ToShadow;
 4339   if (UsingShadowDecl *FromPattern =
 4341     if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
tools/clang/lib/AST/Decl.cpp
 1676 template<typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
 1773   while (auto *UD = dyn_cast<UsingShadowDecl>(ND))
 1773   while (auto *UD = dyn_cast<UsingShadowDecl>(ND))
 1790   if (isa<UsingShadowDecl>(D))
 1791     D = cast<UsingShadowDecl>(D)->getTargetDecl();
tools/clang/lib/AST/DeclCXX.cpp
 1304   if (auto *Shadow = dyn_cast<UsingShadowDecl>(D)) {
 1304   if (auto *Shadow = dyn_cast<UsingShadowDecl>(D)) {
 2815 UsingShadowDecl *
 2817   return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell());
 2821   const UsingShadowDecl *Shadow = this;
 2822   while (const auto *NextShadow =
 2823              dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
 2849 void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
 2859 void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
 2868       dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
 2873   UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
 2875     Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
tools/clang/lib/AST/DeclPrinter.cpp
  101     void VisitUsingShadowDecl(UsingShadowDecl *D);
 1579   for (const auto *Shadow : D->shadows()) {
 1604 void DeclPrinter::VisitUsingShadowDecl(UsingShadowDecl *D) {
tools/clang/lib/AST/JSONNodeDumper.cpp
  734 void JSONNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *USD) {
tools/clang/lib/AST/TextNodeDumper.cpp
   31 static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
   32   const T *Prev = D->getPreviousDecl();
 1734 void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h
   75     return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
   78   static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
   79     return Value.getMatcher().getTypedMatcher<T>();
   83     return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
  361     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
tools/clang/lib/CodeGen/Address.h
  108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGDebugInfo.cpp
 4560   const UsingShadowDecl &USD = **UD.shadow_begin();
tools/clang/lib/Frontend/ASTUnit.cpp
  291   if (isa<UsingShadowDecl>(ND))
tools/clang/lib/Index/IndexDecl.cpp
  592     for (const auto *I : D->shadows())
tools/clang/lib/Sema/SemaAccess.cpp
 1296   if (UsingShadowDecl *Shadow =
 1297                          dyn_cast<UsingShadowDecl>(Entity.getTargetDecl())) {
tools/clang/lib/Sema/SemaCUDA.cpp
  576     if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(D))
  576     if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(D))
tools/clang/lib/Sema/SemaChecking.cpp
 9092         if (const UsingShadowDecl *UsingD = dyn_cast<UsingShadowDecl>(I)) {
 9092         if (const UsingShadowDecl *UsingD = dyn_cast<UsingShadowDecl>(I)) {
tools/clang/lib/Sema/SemaCodeComplete.cpp
 1065   if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
 1065   if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
 1238   if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
 1238   if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
tools/clang/lib/Sema/SemaDecl.cpp
 1569   return isa<UsingShadowDecl>(D) ||
 3053 static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS,
 3162     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
 3162     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
 3981       if (auto *Shadow =
 3982               dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
 3988       if (auto *Shadow =
 3989               dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
15121     if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
15121     if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {
tools/clang/lib/Sema/SemaDeclCXX.cpp
 6582     for (auto *D : Shadow->redecls()) {
 8281     if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
 8281     if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*I))
10030                                 UsingShadowDecl *&PrevShadow) {
10083   if (isa<UsingShadowDecl>(Target))
10084     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
10116       if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
10116       if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(*I))
10196 UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
10199                                             UsingShadowDecl *PrevDecl) {
10202   if (isa<UsingShadowDecl>(Target)) {
10203     Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
10211   UsingShadowDecl *Shadow;
10219     Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
10266 void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
10642     UsingShadowDecl *PrevDecl = nullptr;
tools/clang/lib/Sema/SemaExpr.cpp
 2848     if (isa<UsingShadowDecl>(D))
 2849       D = cast<UsingShadowDecl>(D)->getTargetDecl();
tools/clang/lib/Sema/SemaInit.cpp
 4539       if (isa<UsingShadowDecl>(D))
 4540         D = cast<UsingShadowDecl>(D)->getTargetDecl();
 5194         if (isa<UsingShadowDecl>(D))
 5195           D = cast<UsingShadowDecl>(D)->getTargetDecl();
tools/clang/lib/Sema/SemaLookup.cpp
  369   if (Kind == Sema::LookupUsingDeclName && isa<UsingShadowDecl>(D) &&
  370       !isa<UsingShadowDecl>(Existing))
 3396     if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
 3396     if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
 3560       if (auto *USD = dyn_cast<UsingShadowDecl>(D))
 3560       if (auto *USD = dyn_cast<UsingShadowDecl>(D))
 3699       if (isa<UsingShadowDecl>(ND) && isa<UsingDecl>(D) &&
 3700           cast<UsingShadowDecl>(ND)->getUsingDecl() == D)
tools/clang/lib/Sema/SemaModule.cpp
  663   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
  663   if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
tools/clang/lib/Sema/SemaOpenMP.cpp
12781       if (auto *USD = dyn_cast<UsingShadowDecl>(D))
12781       if (auto *USD = dyn_cast<UsingShadowDecl>(D))
12792         if (auto *USD = dyn_cast<UsingShadowDecl>(D))
12792         if (auto *USD = dyn_cast<UsingShadowDecl>(D))
tools/clang/lib/Sema/SemaOverload.cpp
 1001     if (isa<UsingShadowDecl>(OldD)) {
 1008       OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
 1028           HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
 3439         if (isa<UsingShadowDecl>(D))
 3440           D = cast<UsingShadowDecl>(D)->getTargetDecl();
 4479     if (isa<UsingShadowDecl>(D))
 4480       D = cast<UsingShadowDecl>(D)->getTargetDecl();
 5812     if (isa<UsingShadowDecl>(D))
 5813       D = cast<UsingShadowDecl>(D)->getTargetDecl();
 6641   if (isa<UsingShadowDecl>(Decl))
 6642     Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
 7803       if (isa<UsingShadowDecl>(D))
 7804         D = cast<UsingShadowDecl>(D)->getTargetDecl();
 7875       if (isa<UsingShadowDecl>(D))
 7876         D = cast<UsingShadowDecl>(D)->getTargetDecl();
11985   if (isa<UsingShadowDecl>(Callee))
11986     Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
13407       if (isa<UsingShadowDecl>(Func))
13408         Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
13650     if (isa<UsingShadowDecl>(D))
13651       D = cast<UsingShadowDecl>(D)->getTargetDecl();
tools/clang/lib/Sema/SemaTemplate.cpp
 1502   if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
 1502   if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
  647 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
  647 static DeclT *getPreviousDeclForInstantiation(DeclT *D) {
  648   DeclT *Result = D->getPreviousDecl();
 2803   for (auto *Shadow : D->shadows()) {
 2817     UsingShadowDecl *PrevDecl = nullptr;
 2821     } else if (UsingShadowDecl *OldPrev =
 2823       PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
 2827     UsingShadowDecl *InstShadow =
 2839 Decl *TemplateDeclInstantiator::VisitUsingShadowDecl(UsingShadowDecl *D) {
 5147 static bool isInstantiationOf(UsingShadowDecl *Pattern,
 5148                               UsingShadowDecl *Instance,
 5248   if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
 5248   if (auto *Shadow = dyn_cast<UsingShadowDecl>(Other))
 5249     return isInstantiationOf(cast<UsingShadowDecl>(D), Shadow, Ctx);
 5551       if (isa<UsingShadowDecl>(D)) {
tools/clang/lib/Sema/TreeTransform.h
10856       if (isa<UsingShadowDecl>(OldD))
10873         for (auto *SD : UD->shadows())
tools/clang/lib/Serialization/ASTReaderDecl.cpp
  144     T *ReadDeclAs() {
  145       return Record.readDeclAs<T>();
  249       operator T*() const { return dyn_cast_or_null<T>(Existing); }
  249       operator T*() const { return dyn_cast_or_null<T>(Existing); }
  395     void VisitUsingShadowDecl(UsingShadowDecl *D);
  412     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
  415     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
  419     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
  419     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
 1594   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>());
 1610 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
 1616   auto *Pattern = ReadDeclAs<UsingShadowDecl>();
 1616   auto *Pattern = ReadDeclAs<UsingShadowDecl>();
 2394   auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
 2394   auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
 2400     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
 2404   auto *DAsT = static_cast<T *>(D);
 2430   auto *D = static_cast<T *>(DBase);
 2434     mergeRedeclarable(D, cast<T>(Existing), Redecl, TemplatePatternID);
 2436     if (T *Existing = ExistingRes)
 2496   auto *D = static_cast<T *>(DBase);
 2497   T *ExistingCanon = Existing->getCanonicalDecl();
 2498   T *DCanon = D->getCanonicalDecl();
 2506     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
 3096   if (const auto *USX = dyn_cast<UsingShadowDecl>(X)) {
 3096   if (const auto *USX = dyn_cast<UsingShadowDecl>(X)) {
 3097     const auto *USY = cast<UsingShadowDecl>(Y);
 3097     const auto *USY = cast<UsingShadowDecl>(Y);
 3381 Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
 3408                                            Redeclarable<DeclT> *D,
 3410   D->RedeclLink.setPrevious(cast<DeclT>(Previous));
 3411   D->First = cast<DeclT>(Previous)->First;
 3567 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
 3568   D->RedeclLink.setLatest(cast<DeclT>(Latest));
 3589 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
 3688     D = UsingShadowDecl::CreateDeserialized(Context, ID);
tools/clang/lib/Serialization/ASTWriterDecl.cpp
  114     void VisitUsingShadowDecl(UsingShadowDecl *D);
  129     template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
 1251 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
 1722   T *First = D->getFirstDecl();
 1723   T *MostRecent = First->getMostRecentDecl();
 1724   T *DAsT = static_cast<T *>(D);
tools/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp
  253     if (auto *UsingShadow = llvm::dyn_cast<UsingShadowDecl>(Decl)) {
  324     for (const auto *UsingShadow : Using->shadows()) {
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp
  861       for (const auto *UsingShadow : Using->shadows()) {
tools/clang/tools/extra/clang-tidy/misc/UnusedUsingDeclsCheck.cpp
   96     for (const auto *UsingShadow : Using->shadows()) {
  150       if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
  150       if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
tools/clang/tools/extra/clangd/FindTarget.cpp
  143       for (const UsingShadowDecl *S : UD->shadows())
  149     } else if (const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
  149     } else if (const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
  182         if (auto *USD = llvm::dyn_cast<UsingShadowDecl>(DRE->getFoundDecl()))
  188         if (auto *USD =
  189                 llvm::dyn_cast<UsingShadowDecl>(ME->getFoundDecl().getDecl()))
tools/clang/tools/extra/clangd/unittests/QualityTests.cpp
  140     auto *Shadow =
tools/clang/tools/extra/modularize/Modularize.cpp
  622         isa<TypeAliasTemplateDecl>(ND) || isa<UsingShadowDecl>(ND) ||
tools/clang/tools/libclang/CIndex.cpp
 6382                        MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
 6527     return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
tools/clang/unittests/AST/ASTImporterTest.cpp
 1047                                             UsingShadowDecl> usingShadowDecl;
tools/lldb/source/Symbol/ClangASTContext.cpp
 1925     clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
 1925     clang::UsingShadowDecl *shadow_decl = clang::UsingShadowDecl::Create(
10006             for (clang::UsingShadowDecl *usd : ud->shadows()) {
10121               for (clang::UsingShadowDecl *usd : ud->shadows()) {
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_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
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1580     { typedef _Tp const     type; };
 1629     { typedef _Tp   type; };
 1983     { typedef _Up     type; };
 1999     { typedef typename remove_reference<_Tp>::type*     type; };
 2003     : public __add_pointer_helper<_Tp>