clang/AST/Type.h

132     /// This object can be modified without requiring retains or
325   // Fast qualifiers are those that can be allocated directly
406   /// qualifiers can be safely used as an object with these qualifiers.
411       // ObjC GC qualifiers can match, be added, or be removed, but can't be
696   // Don't promise in the API that anything besides 'const' can be
999 /// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1049 /// ExtQuals - We can encode up to four bits in the low bits of a
1120 /// which determines whether a member function's "this" object can be an
1281     /// This is never true of rvalue references but can also be false
1434   /// A type that can describe objects, but which lacks information needed to
1439   /// that can be completed (such as a C struct, C++ class, or Objective-C
1489   /// isComplexIntegerType() can be used to test for complex integers.
1509   /// isComplexIntegerType() can be used to test for complex integers.
1557   // FIXME: change this to 'raw' interface type, so we can used 'interface' type
1650   /// hasObjCPointerRepresentation - Whether this type can represent
1672   // the best type we can.
1770   /// isSpecifierType - Returns true if this type can be represented by some
1819 // We can do canonical leaf types faster, because we don't have to
1894   /// whether it is a call expression), which means they can (and
2227   ArrayType(TypeClass tc, QualType et, QualType can,
2230     : Type(tc, can, et->isDependentType() || tc == DependentSizedArray,
2268   ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2270     : ArrayType(ConstantArray, et, can, sm, tq,
2274   ConstantArrayType(TypeClass tc, QualType et, QualType can,
2276     : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()),
2292   /// can require, which limits the maximum size of the array.
2317   IncompleteArrayType(QualType et, QualType can,
2319     : ArrayType(IncompleteArray, et, can, sm, tq,
2367   VariableArrayType(QualType et, QualType can, Expr *e,
2370     : ArrayType(VariableArray, et, can, sm, tq,
2425   DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
2477                               QualType can, Expr *SizeExpr, SourceLocation loc);
2823 /// arguments, not as having a single void argument. Such a type can have an
3033   /// A function template whose last parameter is a parameter pack can be
3128   TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
3129     : Type(tc, can, can->isDependentType(),
3130            can->isInstantiationDependentType(),
3131            can->isVariablyModifiedType(),
3134     assert(!isa<TypedefType>(can) && "Invalid canonical type");
3152   TypeOfExprType(Expr *E, QualType can = QualType());
3191   TypeOfType(QualType T, QualType can)
3192     : Type(TypeOf, can, T->isDependentType(),
3197     assert(!isa<TypedefType>(can) && "Invalid canonical type");
3218   DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
3293   TagType(TypeClass TC, const TagDecl *D, QualType can);
3836 /// types can only occur within the scope of a particular templated
4824   //   Compound types can be constructed in the following ways:
5115 /// \brief Determines whether this is a type for which one can define
5121 /// \brief Determines whether this type can decay to a pointer type.