diff options
Diffstat (limited to 'include/clang/AST/Type.h')
| -rw-r--r-- | include/clang/AST/Type.h | 234 |
1 files changed, 117 insertions, 117 deletions
diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index 65fdcae98d..6638655033 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// // /// \file -/// \brief C Language Family Type Representation +/// C Language Family Type Representation /// /// This file defines the clang::Type interface and subclasses, used to /// represent types for languages in the C family. @@ -445,7 +445,7 @@ public: } } - /// \brief Remove the qualifiers from the given set from this set. + /// Remove the qualifiers from the given set from this set. void removeQualifiers(Qualifiers Q) { // If the other set doesn't have any non-boolean qualifiers, just // bit-and the inverse in. @@ -508,7 +508,7 @@ public: (!other.hasUnaligned() || hasUnaligned()); } - /// \brief Determines if these qualifiers compatibly include another set of + /// Determines if these qualifiers compatibly include another set of /// qualifiers from the narrow perspective of Objective-C ARC lifetime. /// /// One set of Objective-C lifetime qualifiers compatibly includes the other @@ -528,7 +528,7 @@ public: return hasConst(); } - /// \brief Determine whether this set of qualifiers is a strict superset of + /// Determine whether this set of qualifiers is a strict superset of /// another set of qualifiers, not considering qualifier compatibility. bool isStrictSupersetOf(Qualifiers Other) const; @@ -554,7 +554,7 @@ public: return *this; } - /// \brief Compute the difference between two qualifier sets. + /// Compute the difference between two qualifier sets. friend Qualifiers operator-(Qualifiers L, Qualifiers R) { L -= R; return L; @@ -719,69 +719,69 @@ public: return Value.getPointer().isNull(); } - /// \brief Determine whether this particular QualType instance has the + /// Determine whether this particular QualType instance has the /// "const" qualifier set, without looking through typedefs that may have /// added "const" at a different level. bool isLocalConstQualified() const { return (getLocalFastQualifiers() & Qualifiers::Const); } - /// \brief Determine whether this type is const-qualified. + /// Determine whether this type is const-qualified. bool isConstQualified() const; - /// \brief Determine whether this particular QualType instance has the + /// Determine whether this particular QualType instance has the /// "restrict" qualifier set, without looking through typedefs that may have /// added "restrict" at a different level. bool isLocalRestrictQualified() const { return (getLocalFastQualifiers() & Qualifiers::Restrict); } - /// \brief Determine whether this type is restrict-qualified. + /// Determine whether this type is restrict-qualified. bool isRestrictQualified() const; - /// \brief Determine whether this particular QualType instance has the + /// Determine whether this particular QualType instance has the /// "volatile" qualifier set, without looking through typedefs that may have /// added "volatile" at a different level. bool isLocalVolatileQualified() const { return (getLocalFastQualifiers() & Qualifiers::Volatile); } - /// \brief Determine whether this type is volatile-qualified. + /// Determine whether this type is volatile-qualified. bool isVolatileQualified() const; - /// \brief Determine whether this particular QualType instance has any + /// Determine whether this particular QualType instance has any /// qualifiers, without looking through any typedefs that might add /// qualifiers at a different level. bool hasLocalQualifiers() const { return getLocalFastQualifiers() || hasLocalNonFastQualifiers(); } - /// \brief Determine whether this type has any qualifiers. + /// Determine whether this type has any qualifiers. bool hasQualifiers() const; - /// \brief Determine whether this particular QualType instance has any + /// Determine whether this particular QualType instance has any /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType /// instance. bool hasLocalNonFastQualifiers() const { return Value.getPointer().is<const ExtQuals*>(); } - /// \brief Retrieve the set of qualifiers local to this particular QualType + /// Retrieve the set of qualifiers local to this particular QualType /// instance, not including any qualifiers acquired through typedefs or /// other sugar. Qualifiers getLocalQualifiers() const; - /// \brief Retrieve the set of qualifiers applied to this type. + /// Retrieve the set of qualifiers applied to this type. Qualifiers getQualifiers() const; - /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// Retrieve the set of CVR (const-volatile-restrict) qualifiers /// local to this particular QualType instance, not including any qualifiers /// acquired through typedefs or other sugar. unsigned getLocalCVRQualifiers() const { return getLocalFastQualifiers(); } - /// \brief Retrieve the set of CVR (const-volatile-restrict) qualifiers + /// Retrieve the set of CVR (const-volatile-restrict) qualifiers /// applied to this type. unsigned getCVRQualifiers() const; @@ -789,7 +789,7 @@ public: return QualType::isConstant(*this, Ctx); } - /// \brief Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10). + /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10). bool isPODType(const ASTContext &Context) const; /// Return true if this is a POD type according to the rules of the C++98 @@ -879,12 +879,12 @@ public: QualType getCanonicalType() const; - /// \brief Return this type with all of the instance-specific qualifiers + /// Return this type with all of the instance-specific qualifiers /// removed, but without removing any qualifiers that may have been applied /// through typedefs. QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); } - /// \brief Retrieve the unqualified variant of the given type, + /// Retrieve the unqualified variant of the given type, /// removing as little sugar as possible. /// /// This routine looks through various kinds of sugar to find the @@ -915,17 +915,17 @@ public: /// ASTContext::getUnqualifiedArrayType. inline SplitQualType getSplitUnqualifiedType() const; - /// \brief Determine whether this type is more qualified than the other + /// Determine whether this type is more qualified than the other /// given type, requiring exact equality for non-CVR qualifiers. bool isMoreQualifiedThan(QualType Other) const; - /// \brief Determine whether this type is at least as qualified as the other + /// Determine whether this type is at least as qualified as the other /// given type, requiring exact equality for non-CVR qualifiers. bool isAtLeastAsQualifiedAs(QualType Other) const; QualType getNonReferenceType() const; - /// \brief Determine the type of a (typically non-lvalue) expression with the + /// Determine the type of a (typically non-lvalue) expression with the /// specified result type. /// /// This routine should be used for expressions for which the return type is @@ -951,7 +951,7 @@ public: return getSplitDesugaredType(*this); } - /// \brief Return the specified type with one level of "sugar" removed from + /// Return the specified type with one level of "sugar" removed from /// the type. /// /// This routine takes off the first typedef, typeof, etc. If the outer level @@ -1272,7 +1272,7 @@ struct PointerLikeTypeTraits<clang::QualType> { namespace clang { -/// \brief Base class that is common to both the \c ExtQuals and \c Type +/// Base class that is common to both the \c ExtQuals and \c Type /// classes, which allows \c QualType to access the common fields between the /// two. class ExtQualsTypeCommonBase { @@ -1280,14 +1280,14 @@ class ExtQualsTypeCommonBase { friend class QualType; friend class Type; - /// \brief The "base" type of an extended qualifiers type (\c ExtQuals) or + /// The "base" type of an extended qualifiers type (\c ExtQuals) or /// a self-referential pointer (for \c Type). /// /// This pointer allows an efficient mapping from a QualType to its /// underlying type pointer. const Type *const BaseType; - /// \brief The canonical type of this type. A QualType. + /// The canonical type of this type. A QualType. QualType CanonicalType; ExtQualsTypeCommonBase(const Type *baseType, QualType canon) @@ -1368,25 +1368,25 @@ public: /// This determines whether a member function's "this" object can be an /// lvalue, rvalue, or neither. enum RefQualifierKind { - /// \brief No ref-qualifier was provided. + /// No ref-qualifier was provided. RQ_None = 0, - /// \brief An lvalue ref-qualifier was provided (\c &). + /// An lvalue ref-qualifier was provided (\c &). RQ_LValue, - /// \brief An rvalue ref-qualifier was provided (\c &&). + /// An rvalue ref-qualifier was provided (\c &&). RQ_RValue }; /// Which keyword(s) were used to create an AutoType. enum class AutoTypeKeyword { - /// \brief auto + /// auto Auto, - /// \brief decltype(auto) + /// decltype(auto) DecltypeAuto, - /// \brief __auto_type (GNU extension) + /// __auto_type (GNU extension) GNUAutoType }; @@ -1445,21 +1445,21 @@ private: /// Whether this type is a variably-modified type (C99 6.7.5). unsigned VariablyModified : 1; - /// \brief Whether this type contains an unexpanded parameter pack + /// Whether this type contains an unexpanded parameter pack /// (for C++11 variadic templates). unsigned ContainsUnexpandedParameterPack : 1; - /// \brief True if the cache (i.e. the bitfields here starting with + /// True if the cache (i.e. the bitfields here starting with /// 'Cache') is valid. mutable unsigned CacheValid : 1; - /// \brief Linkage of this type. + /// Linkage of this type. mutable unsigned CachedLinkage : 3; - /// \brief Whether this type involves and local or unnamed types. + /// Whether this type involves and local or unnamed types. mutable unsigned CachedLocalOrUnnamed : 1; - /// \brief Whether this type comes from an AST file. + /// Whether this type comes from an AST file. mutable unsigned FromAST : 1; bool isCacheValid() const { @@ -1524,7 +1524,7 @@ protected: /// cv-qualifier-seq, [...], are part of the function type. unsigned TypeQuals : 4; - /// \brief The ref-qualifier associated with a \c FunctionProtoType. + /// The ref-qualifier associated with a \c FunctionProtoType. /// /// This is a value of type \c RefQualifierKind. unsigned RefQualifier : 2; @@ -1629,7 +1629,7 @@ protected: private: template <class T> friend class TypePropertyCache; - /// \brief Set whether this type comes from an AST file. + /// Set whether this type comes from an AST file. void setFromAST(bool V = true) const { TypeBits.FromAST = V; } @@ -1680,10 +1680,10 @@ public: TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); } - /// \brief Whether this type comes from an AST file. + /// Whether this type comes from an AST file. bool isFromAST() const { return TypeBits.FromAST; } - /// \brief Whether this type is or contains an unexpanded parameter + /// Whether this type is or contains an unexpanded parameter /// pack, used to support C++0x variadic templates. /// /// A type that contains a parameter pack shall be expanded by the @@ -1721,7 +1721,7 @@ public: /// determine its size (e.g. void, or a fwd declared struct). Clients of this /// routine will need to determine if the size is actually required. /// - /// \brief Def If non-null, and the type refers to some kind of declaration + /// Def If non-null, and the type refers to some kind of declaration /// that can be completed (such as a C struct, C++ class, or Objective-C /// class), will be set to the declaration. bool isIncompleteType(NamedDecl **Def = nullptr) const; @@ -1732,7 +1732,7 @@ public: return !isFunctionType(); } - /// \brief Determine whether this type is an object type. + /// Determine whether this type is an object type. bool isObjectType() const { // C++ [basic.types]p8: // An object type is a (possibly cv-qualified) type that is not a @@ -1927,7 +1927,7 @@ public: /// somehow depends on a template parameter (C++ [temp.dep.type]). bool isDependentType() const { return TypeBits.Dependent; } - /// \brief Determine whether this type is an instantiation-dependent type, + /// Determine whether this type is an instantiation-dependent type, /// meaning that the type involves a template parameter (even if the /// definition does not actually depend on the type substituted for that /// template parameter). @@ -1935,24 +1935,24 @@ public: return TypeBits.InstantiationDependent; } - /// \brief Determine whether this type is an undeduced type, meaning that + /// Determine whether this type is an undeduced type, meaning that /// it somehow involves a C++11 'auto' type or similar which has not yet been /// deduced. bool isUndeducedType() const; - /// \brief Whether this type is a variably-modified type (C99 6.7.5). + /// Whether this type is a variably-modified type (C99 6.7.5). bool isVariablyModifiedType() const { return TypeBits.VariablyModified; } - /// \brief Whether this type involves a variable-length array type + /// Whether this type involves a variable-length array type /// with a definite size. bool hasSizedVLAType() const; - /// \brief Whether this type is or contains a local or unnamed type. + /// Whether this type is or contains a local or unnamed type. bool hasUnnamedOrLocalType() const; bool isOverloadableType() const; - /// \brief Determine wither this type is a C++ elaborated-type-specifier. + /// Determine wither this type is a C++ elaborated-type-specifier. bool isElaboratedTypeSpecifier() const; bool canDecayToPointerType() const; @@ -1966,19 +1966,19 @@ public: /// purpose of GC'ability bool hasObjCPointerRepresentation() const; - /// \brief Determine whether this type has an integer representation + /// Determine whether this type has an integer representation /// of some sort, e.g., it is an integer type or a vector. bool hasIntegerRepresentation() const; - /// \brief Determine whether this type has an signed integer representation + /// Determine whether this type has an signed integer representation /// of some sort, e.g., it is an signed integer type or a vector. bool hasSignedIntegerRepresentation() const; - /// \brief Determine whether this type has an unsigned integer representation + /// Determine whether this type has an unsigned integer representation /// of some sort, e.g., it is an unsigned integer type or a vector. bool hasUnsignedIntegerRepresentation() const; - /// \brief Determine whether this type has a floating-point representation + /// Determine whether this type has a floating-point representation /// of some sort, e.g., it is a floating-point type or a vector thereof. bool hasFloatingRepresentation() const; @@ -1998,12 +1998,12 @@ public: const ObjCObjectPointerType *getAsObjCQualifiedClassType() const; const ObjCObjectType *getAsObjCQualifiedInterfaceType() const; - /// \brief Retrieves the CXXRecordDecl that this type refers to, either + /// Retrieves the CXXRecordDecl that this type refers to, either /// because the type is a RecordType or because it is the injected-class-name /// type of a class template or class template partial specialization. CXXRecordDecl *getAsCXXRecordDecl() const; - /// \brief Retrieves the TagDecl that this type refers to, either + /// Retrieves the TagDecl that this type refers to, either /// because the type is a TagType or because it is the injected-class-name /// type of a class template or class template partial specialization. TagDecl *getAsTagDecl() const; @@ -2183,16 +2183,16 @@ public: void dump(llvm::raw_ostream &OS) const; }; -/// \brief This will check for a TypedefType by removing any existing sugar +/// This will check for a TypedefType by removing any existing sugar /// until it reaches a TypedefType or a non-sugared type. template <> const TypedefType *Type::getAs() const; -/// \brief This will check for a TemplateSpecializationType by removing any +/// This will check for a TemplateSpecializationType by removing any /// existing sugar until it reaches a TemplateSpecializationType or a /// non-sugared type. template <> const TemplateSpecializationType *Type::getAs() const; -/// \brief This will check for an AttributedType by removing any existing sugar +/// This will check for an AttributedType by removing any existing sugar /// until it reaches an AttributedType or a non-sugared type. template <> const AttributedType *Type::getAs() const; @@ -2707,13 +2707,13 @@ public: bool isSugared() const { return false; } QualType desugar() const { return QualType(this, 0); } - /// \brief Determine the number of bits required to address a member of + /// Determine the number of bits required to address a member of // an array with the given element type and number of elements. static unsigned getNumAddressingBits(const ASTContext &Context, QualType ElementType, const llvm::APInt &NumElements); - /// \brief Determine the maximum number of active bits that an array's size + /// Determine the maximum number of active bits that an array's size /// can require, which limits the maximum size of the array. static unsigned getMaxSizeBits(const ASTContext &Context); @@ -2844,7 +2844,7 @@ class DependentSizedArrayType : public ArrayType { const ASTContext &Context; - /// \brief An assignment expression that will instantiate to the + /// An assignment expression that will instantiate to the /// size of the array. /// /// The expression itself might be null, in which case the array @@ -3293,7 +3293,7 @@ public: bool isVolatile() const { return getTypeQuals() & Qualifiers::Volatile; } bool isRestrict() const { return getTypeQuals() & Qualifiers::Restrict; } - /// \brief Determine the type of an expression that calls a function of + /// Determine the type of an expression that calls a function of /// this type. QualType getCallResultType(const ASTContext &Context) const { return getReturnType().getNonLValueExprType(Context); @@ -3488,7 +3488,7 @@ public: private: friend class ASTContext; // ASTContext creates these. - /// \brief Determine whether there are any argument types that + /// Determine whether there are any argument types that /// contain an unexpanded parameter pack. static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray, unsigned numArgs) { @@ -3653,7 +3653,7 @@ public: return *reinterpret_cast<Expr *const *>(param_type_end()); } - /// \brief If this function type has an exception specification which hasn't + /// If this function type has an exception specification which hasn't /// been determined yet (either because it has not been evaluated or because /// it has not been instantiated), this is the function whose exception /// specification is represented by this type. @@ -3664,7 +3664,7 @@ public: return reinterpret_cast<FunctionDecl *const *>(param_type_end())[0]; } - /// \brief If this function type has an uninstantiated exception + /// If this function type has an uninstantiated exception /// specification, this is the function whose exception specification /// should be instantiated to find the exception specification for /// this type. @@ -3793,7 +3793,7 @@ public: bool Canonical); }; -/// \brief Represents the dependent type named by a dependently-scoped +/// Represents the dependent type named by a dependently-scoped /// typename using declaration, e.g. /// using typename Base<T>::foo; /// @@ -3864,16 +3864,16 @@ protected: public: Expr *getUnderlyingExpr() const { return TOExpr; } - /// \brief Remove a single level of sugar. + /// Remove a single level of sugar. QualType desugar() const; - /// \brief Returns whether this type directly provides sugar. + /// Returns whether this type directly provides sugar. bool isSugared() const; static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; } }; -/// \brief Internal representation of canonical, dependent +/// Internal representation of canonical, dependent /// `typeof(expr)` types. /// /// This class is used internally by the ASTContext to manage @@ -3913,10 +3913,10 @@ class TypeOfType : public Type { public: QualType getUnderlyingType() const { return TOType; } - /// \brief Remove a single level of sugar. + /// Remove a single level of sugar. QualType desugar() const { return getUnderlyingType(); } - /// \brief Returns whether this type directly provides sugar. + /// Returns whether this type directly provides sugar. bool isSugared() const { return true; } static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; } @@ -3936,16 +3936,16 @@ public: Expr *getUnderlyingExpr() const { return E; } QualType getUnderlyingType() const { return UnderlyingType; } - /// \brief Remove a single level of sugar. + /// Remove a single level of sugar. QualType desugar() const; - /// \brief Returns whether this type directly provides sugar. + /// Returns whether this type directly provides sugar. bool isSugared() const; static bool classof(const Type *T) { return T->getTypeClass() == Decltype; } }; -/// \brief Internal representation of canonical, dependent +/// Internal representation of canonical, dependent /// decltype(expr) types. /// /// This class is used internally by the ASTContext to manage @@ -4001,7 +4001,7 @@ public: } }; -/// \brief Internal representation of canonical, dependent +/// Internal representation of canonical, dependent /// __underlying_type(type) types. /// /// This class is used internally by the ASTContext to manage @@ -4321,7 +4321,7 @@ public: } }; -/// \brief Represents the result of substituting a type for a template +/// Represents the result of substituting a type for a template /// type parameter. /// /// Within an instantiated template, all template type parameters have @@ -4372,7 +4372,7 @@ public: } }; -/// \brief Represents the result of substituting a set of types for a template +/// Represents the result of substituting a set of types for a template /// type parameter pack. /// /// When a pack expansion in the source code contains multiple parameter packs @@ -4387,14 +4387,14 @@ public: class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode { friend class ASTContext; - /// \brief The original type parameter. + /// The original type parameter. const TemplateTypeParmType *Replaced; - /// \brief A pointer to the set of template arguments that this + /// A pointer to the set of template arguments that this /// parameter pack is instantiated with. const TemplateArgument *Arguments; - /// \brief The number of template arguments in \c Arguments. + /// The number of template arguments in \c Arguments. unsigned NumArguments; SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param, @@ -4424,7 +4424,7 @@ public: } }; -/// \brief Common base class for placeholders for types that get replaced by +/// Common base class for placeholders for types that get replaced by /// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced /// class template types, and (eventually) constrained type names from the C++ /// Concepts TS. @@ -4457,7 +4457,7 @@ public: bool isSugared() const { return !isCanonicalUnqualified(); } QualType desugar() const { return getCanonicalTypeInternal(); } - /// \brief Get the type deduced for this placeholder type, or null if it's + /// Get the type deduced for this placeholder type, or null if it's /// either not been deduced or was deduced to a dependent type. QualType getDeducedType() const { return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType(); @@ -4472,7 +4472,7 @@ public: } }; -/// \brief Represents a C++11 auto or C++14 decltype(auto) type. +/// Represents a C++11 auto or C++14 decltype(auto) type. class AutoType : public DeducedType, public llvm::FoldingSetNode { friend class ASTContext; // ASTContext creates these @@ -4508,7 +4508,7 @@ public: } }; -/// \brief Represents a C++17 deduced template specialization type. +/// Represents a C++17 deduced template specialization type. class DeducedTemplateSpecializationType : public DeducedType, public llvm::FoldingSetNode { friend class ASTContext; // ASTContext creates these @@ -4545,7 +4545,7 @@ public: } }; -/// \brief Represents a type template specialization; the template +/// Represents a type template specialization; the template /// must be a class template, a type alias template, or a template /// template parameter. A template which cannot be resolved to one of /// these, e.g. because it is written with a dependent scope @@ -4605,7 +4605,7 @@ public: return isa<InjectedClassNameType>(getCanonicalTypeInternal()); } - /// \brief Determine if this template specialization type is for a type alias + /// Determine if this template specialization type is for a type alias /// template that has been substituted. /// /// Nearly every template specialization type whose template is an alias @@ -4674,7 +4674,7 @@ public: } }; -/// \brief Print a template argument list, including the '<' and '>' +/// Print a template argument list, including the '<' and '>' /// enclosing the template arguments. void printTemplateArgumentList(raw_ostream &OS, ArrayRef<TemplateArgument> Args, @@ -4757,47 +4757,47 @@ public: } }; -/// \brief The kind of a tag type. +/// The kind of a tag type. enum TagTypeKind { - /// \brief The "struct" keyword. + /// The "struct" keyword. TTK_Struct, - /// \brief The "__interface" keyword. + /// The "__interface" keyword. TTK_Interface, - /// \brief The "union" keyword. + /// The "union" keyword. TTK_Union, - /// \brief The "class" keyword. + /// The "class" keyword. TTK_Class, - /// \brief The "enum" keyword. + /// The "enum" keyword. TTK_Enum }; -/// \brief The elaboration keyword that precedes a qualified type name or +/// The elaboration keyword that precedes a qualified type name or /// introduces an elaborated-type-specifier. enum ElaboratedTypeKeyword { - /// \brief The "struct" keyword introduces the elaborated-type-specifier. + /// The "struct" keyword introduces the elaborated-type-specifier. ETK_Struct, - /// \brief The "__interface" keyword introduces the elaborated-type-specifier. + /// The "__interface" keyword introduces the elaborated-type-specifier. ETK_Interface, - /// \brief The "union" keyword introduces the elaborated-type-specifier. + /// The "union" keyword introduces the elaborated-type-specifier. ETK_Union, - /// \brief The "class" keyword introduces the elaborated-type-specifier. + /// The "class" keyword introduces the elaborated-type-specifier. ETK_Class, - /// \brief The "enum" keyword introduces the elaborated-type-specifier. + /// The "enum" keyword introduces the elaborated-type-specifier. ETK_Enum, - /// \brief The "typename" keyword precedes the qualified type name, e.g., + /// The "typename" keyword precedes the qualified type name, e.g., /// \c typename T::type. ETK_Typename, - /// \brief No keyword precedes the qualified type name. + /// No keyword precedes the qualified type name. ETK_None }; @@ -4848,7 +4848,7 @@ public: static CannotCastToThisType classof(const Type *); }; -/// \brief Represents a type that was referred to using an elaborated type +/// Represents a type that was referred to using an elaborated type /// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type, /// or both. /// @@ -4909,7 +4909,7 @@ public: } }; -/// \brief Represents a qualified type name for which the type name is +/// Represents a qualified type name for which the type name is /// dependent. /// /// DependentNameType represents a class of dependent types that involve a @@ -4924,10 +4924,10 @@ public: class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode { friend class ASTContext; // ASTContext creates these - /// \brief The nested name specifier containing the qualifier. + /// The nested name specifier containing the qualifier. NestedNameSpecifier *NNS; - /// \brief The type that this typename specifier refers to. + /// The type that this typename specifier refers to. const IdentifierInfo *Name; DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, @@ -4984,7 +4984,7 @@ class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) DependentTemplateSpecializationType /// The identifier of the template. const IdentifierInfo *Name; - /// \brief The number of template arguments named in this class template + /// The number of template arguments named in this class template /// specialization. unsigned NumArgs; @@ -5006,12 +5006,12 @@ public: NestedNameSpecifier *getQualifier() const { return NNS; } const IdentifierInfo *getIdentifier() const { return Name; } - /// \brief Retrieve the template arguments. + /// Retrieve the template arguments. const TemplateArgument *getArgs() const { return getArgBuffer(); } - /// \brief Retrieve the number of template arguments. + /// Retrieve the number of template arguments. unsigned getNumArgs() const { return NumArgs; } const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h @@ -5044,7 +5044,7 @@ public: } }; -/// \brief Represents a pack expansion of types. +/// Represents a pack expansion of types. /// /// Pack expansions are part of C++11 variadic templates. A pack /// expansion contains a pattern, which itself contains one or more @@ -5069,10 +5069,10 @@ public: class PackExpansionType : public Type, public llvm::FoldingSetNode { friend class ASTContext; // ASTContext creates these - /// \brief The pattern of the pack expansion. + /// The pattern of the pack expansion. QualType Pattern; - /// \brief The number of expansions that this pack expansion will + /// The number of expansions that this pack expansion will /// generate when substituted (+1), or indicates that /// /// This field will only have a non-zero value when some of the parameter @@ -5090,12 +5090,12 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode { NumExpansions(NumExpansions ? *NumExpansions + 1 : 0) {} public: - /// \brief Retrieve the pattern of this pack expansion, which is the + /// Retrieve the pattern of this pack expansion, which is the /// type that will be repeatedly instantiated when instantiating the /// pack expansion itself. QualType getPattern() const { return Pattern; } - /// \brief Retrieve the number of expansions that this pack expansion will + /// Retrieve the number of expansions that this pack expansion will /// generate, if known. Optional<unsigned> getNumExpansions() const { if (NumExpansions) @@ -6321,13 +6321,13 @@ inline bool Type::isUndeducedType() const { return DT && !DT->isDeduced(); } -/// \brief Determines whether this is a type for which one can define +/// Determines whether this is a type for which one can define /// an overloaded operator. inline bool Type::isOverloadableType() const { return isDependentType() || isRecordType() || isEnumeralType(); } -/// \brief Determines whether this type can decay to a pointer type. +/// Determines whether this type can decay to a pointer type. inline bool Type::canDecayToPointerType() const { return isFunctionType() || isArrayType(); } |