clang/AST/Type.h

166     /// This object can be modified without requiring retains or
409   // Fast qualifiers are those that can be allocated directly
499            // for __constant can be used as __generic.
531   /// qualifiers can be safely used as an object with these qualifiers.
534            // ObjC GC qualifiers can match, be added, or be removed, but can't
552   /// and one is None (which can only happen in non-ARC modes).
808   // Determines if a type can form `T&`.
827   /// Determine whether instances of this type can be placed in immutable
944   // Don't promise in the API that anything besides 'const' can be
1246     /// this case is zero-valued so that values of this enum can be used as a
1272     /// this case is zero-valued so that values of this enum can be used as a
1428 /// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1479 /// We can encode up to four bits in the low bits of a
1551 /// This determines whether a member function's "this" object can be an
1790     /// This is never true of rvalue references but can also be false
2131   /// reference types, or a pointer to a reference type (which can only be
2136   /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
2146   /// 'riscv_rvv_vector_bits' type attribute, which can be applied to a single
2159   /// A type that can describe objects, but which lacks information needed to
2164   /// that can be completed (such as a C struct, C++ class, or Objective-C
2216   /// isComplexIntegerType() can be used to test for complex integers.
2241   /// isComplexIntegerType() can be used to test for complex integers.
2301   // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2460   /// Whether this type can represent an objective pointer type for the
2482   // the best type we can.
2617   /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2621   /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2625   /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2629   /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2637   /// Returns true if this type can be represented by some
2668   /// Determine whether the given type can have a nullability
2672   ///        this type can have nullability because it is dependent.
2686   /// \returns an array of type arguments that can be substituted for
2722 // We can do canonical leaf types faster, because we don't have to
2826   /// whether it is a call expression), which means they can (and
2921 /// engine for arbitrary reasons.  For example, array and function types can
2922 /// decay, and function types can have their calling conventions adjusted.
3151   ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
3188   ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
3190       : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
3193       assert(!can.isNull() && "canonical constant array should not have size");
3221   /// can require, which limits the maximum size of the array.
3245   IncompleteArrayType(QualType et, QualType can,
3247       : ArrayType(IncompleteArray, et, can, sm, tq) {}
3296   VariableArrayType(QualType et, QualType can, Expr *e,
3299       : ArrayType(VariableArray, et, can, sm, tq, e),
3353   DependentSizedArrayType(QualType et, QualType can, Expr *e,
3405   DependentAddressSpaceType(QualType PointeeType, QualType can,
3448   DependentSizedExtVectorType(QualType ElementType, QualType can,
3800   /// Interesting information about a specific parameter that can't simply
4052   /// of function type attributes that can be set on function types, including
4066         0b111'111'11 // We can't support more than 8 bits because of
4183 /// parameters, not as having a single void parameter. Such a type can have
4226   // * Optionally a Qualifiers object to represent extra qualifiers that can't
4561   /// A function template whose last parameter is a parameter pack can be
4754               QualType can);
4905   DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
5007   TagType(TypeClass TC, const TagDecl *D, QualType can);
5583   /// argument is dependent can depend on the conversions performed on it
5670 /// Make a best-effort determination of whether the type T can be produced by
5690 /// types can only occur within the scope of a particular templated
6093 /// This class wraps the list of protocol qualifiers. For types that can
6094 /// take ObjC protocol qualifers, they can subclass this class.
6149 /// Represents a type parameter type in Objective C. It can take
6178                     QualType can,
6798 /// A client can read the relevant info using TypeLoc wrappers, e.g:
7060   //   Compound types can be constructed in the following ways:
7500 /// Determines whether this is a type for which one can define
7515 /// Determines whether this type can decay to a pointer type.
7627   // Just because the canonical type is correct does not mean we can use cast<>,