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

Declarations

gen/tools/clang/include/clang/AST/TypeNodes.inc
   56 NON_CANONICAL_TYPE(Paren, Type)

References

include/llvm/ADT/FoldingSet.h
  221   static void Profile(const T &X, FoldingSetNodeID &ID) {
  224   static void Profile(T &X, FoldingSetNodeID &ID) {
  232   static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,
  240   static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID);
  250   : public DefaultFoldingSetTrait<T> {};
  369   FoldingSetTrait<T>::Profile(X, TempID);
  375   FoldingSetTrait<T>::Profile(X, TempID);
  410   using iterator = FoldingSetIterator<T>;
  415   using const_iterator = FoldingSetIterator<const T>;
  420   using bucket_iterator = FoldingSetBucketIterator<T>;
  432   bool RemoveNode(T *N) { return FoldingSetBase::RemoveNode(N); }
  437   T *GetOrInsertNode(T *N) {
  437   T *GetOrInsertNode(T *N) {
  444   T *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos) {
  451   void InsertNode(T *N, void *InsertPos) {
  457   void InsertNode(T *N) {
  473 template <class T> class FoldingSet final : public FoldingSetImpl<T> {
  474   using Super = FoldingSetImpl<T>;
  480     T *TN = static_cast<T *>(N);
  481     FoldingSetTrait<T>::Profile(*TN, ID);
  488     T *TN = static_cast<T *>(N);
  489     return FoldingSetTrait<T>::Equals(*TN, ID, IDHash, TempID);
  495     T *TN = static_cast<T *>(N);
  496     return FoldingSetTrait<T>::ComputeHash(*TN, TempID);
include/llvm/Support/Casting.h
   58     return To::classof(&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,
  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;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  331                             typename cast_retty<X, const Y>::ret_type>::type
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  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;
tools/clang/include/clang/AST/ASTContext.h
  212   mutable llvm::FoldingSet<ParenType> ParenTypes;
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);
  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 *>(
  479     : public DynCastPtrConverter<T, Type> {};
tools/clang/include/clang/AST/RecursiveASTVisitor.h
 1063 DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
 1309 DEF_TRAVERSE_TYPELOC(ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
tools/clang/include/clang/AST/Type.h
  963     if (isa<ParenType>(*this))
 6858 template <typename T> const T *Type::getAs() const {
 6859   static_assert(!TypeIsArrayType<T>::value,
 6863   if (const auto *Ty = dyn_cast<T>(this))
 6863   if (const auto *Ty = dyn_cast<T>(this))
 6867   if (!isa<T>(CanonicalType))
 6872   return cast<T>(getUnqualifiedDesugaredType());
 6894     else if (const auto *P = dyn_cast<ParenType>(Ty))
 6894     else if (const auto *P = dyn_cast<ParenType>(Ty))
tools/clang/include/clang/AST/TypeLoc.h
  370     return TypeClass::classof(Ty);
  405   const TypeClass *getTypePtr() const {
  406     return cast<TypeClass>(Base::getTypePtr());
 1125   : public ConcreteTypeLoc<UnqualTypeLoc, ParenTypeLoc, ParenType,
tools/clang/include/clang/ASTMatchers/ASTMatchers.h
 5624 extern const AstTypeMatcher<ParenType> parenType;
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>();
  479 class WrapperMatcherInterface : public MatcherInterface<T> {
  499   explicit Matcher(MatcherInterface<T> *Implementation)
  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>());
 1067   using head = T1;
 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>> {
 1625 class TypeTraverseMatcher : public WrapperMatcherInterface<T> {
 1632   bool matches(const T &Node, ASTMatchFinder *Finder,
 1693   template <typename OuterT> operator Matcher<OuterT>() const {
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/lib/AST/ASTContext.cpp
 2144     return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
 2853   if (const auto *PT = dyn_cast<ParenType>(Orig))
 2853   if (const auto *PT = dyn_cast<ParenType>(Orig))
 4312   ParenType::Profile(ID, InnerType);
 4315   ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
 4322     ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
 4327   T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
 7976     } else if (const ParenType *Paren = dyn_cast<ParenType>(Ty)) {
 7976     } else if (const ParenType *Paren = dyn_cast<ParenType>(Ty)) {
tools/clang/lib/AST/ASTDiagnostic.cpp
   40     if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
   40     if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
tools/clang/lib/AST/ASTImporter.cpp
  328     ExpectedType VisitParenType(const ParenType *T);
 1252 ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
tools/clang/lib/AST/ASTStructuralEquivalence.cpp
  686     if (!IsStructurallyEquivalent(Context, cast<ParenType>(T1)->getInnerType(),
  687                                   cast<ParenType>(T2)->getInnerType()))
tools/clang/lib/AST/DeclPrinter.cpp
  161     else if (const ParenType *PTy = BaseType->getAs<ParenType>())
  161     else if (const ParenType *PTy = BaseType->getAs<ParenType>())
  646   while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
  646   while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
tools/clang/lib/AST/ODRHash.cpp
  954   void VisitParenType(const ParenType *T) {
tools/clang/lib/AST/Type.cpp
  430   while (const auto *PT = T->getAs<ParenType>())
  430   while (const auto *PT = T->getAs<ParenType>())
 1015   QualType VisitParenType(const ParenType *T) {
 1783     Type *VisitParenType(const ParenType *T) {
tools/clang/lib/AST/TypePrinter.cpp
 1343 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
 1351 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
  819 const AstTypeMatcher<ParenType> parenType;
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>());
  466       ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
  469         DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
  778     ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/CodeGen/Address.h
  108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGDebugInfo.cpp
 2886       T = cast<ParenType>(T)->getInnerType();
tools/clang/lib/Sema/SemaChecking.cpp
13022   if (const auto *ParenTy = dyn_cast<ParenType>(PType)) {
13022   if (const auto *ParenTy = dyn_cast<ParenType>(PType)) {
tools/clang/lib/Sema/SemaDecl.cpp
 5756   if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
 5756   if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
tools/clang/lib/Sema/SemaExprObjC.cpp
 4218       if (const ParenType *PT = dyn_cast<ParenType>(DT))
 4218       if (const ParenType *PT = dyn_cast<ParenType>(DT))
tools/clang/lib/Sema/SemaType.cpp
 4571           if (isa<ParenType>(T)) {
 6341         } else if (isa<ParenType>(Ty)) {
 6342           T = cast<ParenType>(Ty)->getInnerType();
 6411         QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
tools/clang/lib/Sema/TreeTransform.h
 6262   QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
 6262   QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
 6266   QualType Result = TL.getType();
 6268       Inner != TL.getInnerLoc().getType()) {
 6274   ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(Result);
 6275   NewTL.setLParenLoc(TL.getLParenLoc());
 6276   NewTL.setRParenLoc(TL.getRParenLoc());
tools/clang/lib/Serialization/ASTWriter.cpp
  516 void ASTTypeWriter::VisitParenType(const ParenType *T) {
tools/clang/tools/libclang/CXType.cpp
  138     if (auto *PTT = T->getAs<ParenType>()) {
tools/lldb/source/Symbol/ClangASTContext.cpp
 2586         llvm::cast<clang::ParenType>(qual_type)->desugar());
 2716         ast, llvm::cast<clang::ParenType>(qual_type)->desugar(),
 2779         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 2817         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 2903         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3049           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3218           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 3273           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3386           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3472           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3527           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 3741           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 4082     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 4333     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 4604       return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 4745           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 5262     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 5428     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 5699             llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())
 5865             llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())
 6078     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 6157         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 6202         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 6325         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 6393         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 6514         llvm::cast<clang::ParenType>(qual_type)->desugar());
 7045                                   llvm::cast<clang::ParenType>(parent_qual_type)
 7401       return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 7623       return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 7684     return CompilerType(this, llvm::cast<clang::ParenType>(qual_type)
 7735         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
 8756         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
 9347         llvm::cast<clang::ParenType>(qual_type)->desugar();
 9699           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr())
 9804           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
tools/lldb/source/Symbol/ClangASTImporter.cpp
  472         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
  548         llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
usr/include/c++/7.4.0/type_traits
  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
  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
  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
 1447     : public __and_<is_destructible<_Tp>, integral_constant<bool,
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1659     { typedef _Tp&&   type; };
 1955     { typedef _Tp     type; };