diff options
Diffstat (limited to 'include/clang/Sema/Initialization.h')
| -rw-r--r-- | include/clang/Sema/Initialization.h | 494 |
1 files changed, 247 insertions, 247 deletions
diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h index c0f38420d2..1e6423c99d 100644 --- a/include/clang/Sema/Initialization.h +++ b/include/clang/Sema/Initialization.h @@ -45,49 +45,49 @@ class CXXConstructorDecl; class ObjCMethodDecl; class Sema; -/// \brief Describes an entity that is being initialized. +/// Describes an entity that is being initialized. class InitializedEntity { public: - /// \brief Specifies the kind of entity being initialized. + /// Specifies the kind of entity being initialized. enum EntityKind { - /// \brief The entity being initialized is a variable. + /// The entity being initialized is a variable. EK_Variable, - /// \brief The entity being initialized is a function parameter. + /// The entity being initialized is a function parameter. EK_Parameter, - /// \brief The entity being initialized is the result of a function call. + /// The entity being initialized is the result of a function call. EK_Result, - /// \brief The entity being initialized is an exception object that + /// The entity being initialized is an exception object that /// is being thrown. EK_Exception, - /// \brief The entity being initialized is a non-static data member + /// The entity being initialized is a non-static data member /// subobject. EK_Member, - /// \brief The entity being initialized is an element of an array. + /// The entity being initialized is an element of an array. EK_ArrayElement, - /// \brief The entity being initialized is an object (or array of + /// The entity being initialized is an object (or array of /// objects) allocated via new. EK_New, - /// \brief The entity being initialized is a temporary object. + /// The entity being initialized is a temporary object. EK_Temporary, - /// \brief The entity being initialized is a base member subobject. + /// The entity being initialized is a base member subobject. EK_Base, - /// \brief The initialization is being done by a delegating constructor. + /// The initialization is being done by a delegating constructor. EK_Delegating, - /// \brief The entity being initialized is an element of a vector. + /// The entity being initialized is an element of a vector. /// or vector. EK_VectorElement, - /// \brief The entity being initialized is a field of block descriptor for + /// The entity being initialized is a field of block descriptor for /// the copied-in c++ object. EK_BlockElement, @@ -95,27 +95,27 @@ public: /// copied-in lambda object that's used in the lambda to block conversion. EK_LambdaToBlockConversionBlockElement, - /// \brief The entity being initialized is the real or imaginary part of a + /// The entity being initialized is the real or imaginary part of a /// complex number. EK_ComplexElement, - /// \brief The entity being initialized is the field that captures a + /// The entity being initialized is the field that captures a /// variable in a lambda. EK_LambdaCapture, - /// \brief The entity being initialized is the initializer for a compound + /// The entity being initialized is the initializer for a compound /// literal. EK_CompoundLiteralInit, - /// \brief The entity being implicitly initialized back to the formal + /// The entity being implicitly initialized back to the formal /// result type. EK_RelatedResult, - /// \brief The entity being initialized is a function parameter; function + /// The entity being initialized is a function parameter; function /// is member of group of audited CF APIs. EK_Parameter_CF_Audited, - /// \brief The entity being initialized is a structured binding of a + /// The entity being initialized is a structured binding of a /// decomposition declaration. EK_Binding, @@ -125,73 +125,73 @@ public: }; private: - /// \brief The kind of entity being initialized. + /// The kind of entity being initialized. EntityKind Kind; - /// \brief If non-NULL, the parent entity in which this + /// If non-NULL, the parent entity in which this /// initialization occurs. const InitializedEntity *Parent = nullptr; - /// \brief The type of the object or reference being initialized. + /// The type of the object or reference being initialized. QualType Type; - /// \brief The mangling number for the next reference temporary to be created. + /// The mangling number for the next reference temporary to be created. mutable unsigned ManglingNumber = 0; struct LN { - /// \brief When Kind == EK_Result, EK_Exception, EK_New, the + /// When Kind == EK_Result, EK_Exception, EK_New, the /// location of the 'return', 'throw', or 'new' keyword, /// respectively. When Kind == EK_Temporary, the location where /// the temporary is being created. unsigned Location; - /// \brief Whether the entity being initialized may end up using the + /// Whether the entity being initialized may end up using the /// named return value optimization (NRVO). bool NRVO; }; struct VD { - /// \brief The VarDecl, FieldDecl, or BindingDecl being initialized. + /// The VarDecl, FieldDecl, or BindingDecl being initialized. ValueDecl *VariableOrMember; - /// \brief When Kind == EK_Member, whether this is an implicit member + /// When Kind == EK_Member, whether this is an implicit member /// initialization in a copy or move constructor. These can perform array /// copies. bool IsImplicitFieldInit; }; struct C { - /// \brief The name of the variable being captured by an EK_LambdaCapture. + /// The name of the variable being captured by an EK_LambdaCapture. IdentifierInfo *VarID; - /// \brief The source location at which the capture occurs. + /// The source location at which the capture occurs. unsigned Location; }; union { - /// \brief When Kind == EK_Variable, EK_Member or EK_Binding, the variable. + /// When Kind == EK_Variable, EK_Member or EK_Binding, the variable. VD Variable; - /// \brief When Kind == EK_RelatedResult, the ObjectiveC method where + /// When Kind == EK_RelatedResult, the ObjectiveC method where /// result type was implicitly changed to accommodate ARC semantics. ObjCMethodDecl *MethodDecl; - /// \brief When Kind == EK_Parameter, the ParmVarDecl, with the + /// When Kind == EK_Parameter, the ParmVarDecl, with the /// low bit indicating whether the parameter is "consumed". uintptr_t Parameter; - /// \brief When Kind == EK_Temporary or EK_CompoundLiteralInit, the type + /// When Kind == EK_Temporary or EK_CompoundLiteralInit, the type /// source information for the temporary. TypeSourceInfo *TypeInfo; struct LN LocAndNRVO; - /// \brief When Kind == EK_Base, the base specifier that provides the + /// When Kind == EK_Base, the base specifier that provides the /// base class. The lower bit specifies whether the base is an inherited /// virtual base. uintptr_t Base; - /// \brief When Kind == EK_ArrayElement, EK_VectorElement, or + /// When Kind == EK_ArrayElement, EK_VectorElement, or /// EK_ComplexElement, the index of the array or vector element being /// initialized. unsigned Index; @@ -201,11 +201,11 @@ private: InitializedEntity() = default; - /// \brief Create the initialization entity for a variable. + /// Create the initialization entity for a variable. InitializedEntity(VarDecl *Var, EntityKind EK = EK_Variable) : Kind(EK), Type(Var->getType()), Variable{Var, false} {} - /// \brief Create the initialization entity for the result of a + /// Create the initialization entity for the result of a /// function, throwing an object, performing an explicit cast, or /// initializing a parameter for which there is no declaration. InitializedEntity(EntityKind Kind, SourceLocation Loc, QualType Type, @@ -215,17 +215,17 @@ private: LocAndNRVO.NRVO = NRVO; } - /// \brief Create the initialization entity for a member subobject. + /// Create the initialization entity for a member subobject. InitializedEntity(FieldDecl *Member, const InitializedEntity *Parent, bool Implicit) : Kind(EK_Member), Parent(Parent), Type(Member->getType()), Variable{Member, Implicit} {} - /// \brief Create the initialization entity for an array element. + /// Create the initialization entity for an array element. InitializedEntity(ASTContext &Context, unsigned Index, const InitializedEntity &Parent); - /// \brief Create the initialization entity for a lambda capture. + /// Create the initialization entity for a lambda capture. InitializedEntity(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc) : Kind(EK_LambdaCapture), Type(FieldType) { Capture.VarID = VarID; @@ -233,18 +233,18 @@ private: } public: - /// \brief Create the initialization entity for a variable. + /// Create the initialization entity for a variable. static InitializedEntity InitializeVariable(VarDecl *Var) { return InitializedEntity(Var); } - /// \brief Create the initialization entity for a parameter. + /// Create the initialization entity for a parameter. static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm) { return InitializeParameter(Context, Parm, Parm->getType()); } - /// \brief Create the initialization entity for a parameter, but use + /// Create the initialization entity for a parameter, but use /// another type. static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm, @@ -262,7 +262,7 @@ public: return Entity; } - /// \brief Create the initialization entity for a parameter that is + /// Create the initialization entity for a parameter that is /// only known by its type. static InitializedEntity InitializeParameter(ASTContext &Context, QualType Type, @@ -275,7 +275,7 @@ public: return Entity; } - /// \brief Create the initialization entity for the result of a function. + /// Create the initialization entity for the result of a function. static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type, bool NRVO) { return InitializedEntity(EK_Result, ReturnLoc, Type, NRVO); @@ -292,28 +292,28 @@ public: BlockVarLoc, Type, NRVO); } - /// \brief Create the initialization entity for an exception object. + /// Create the initialization entity for an exception object. static InitializedEntity InitializeException(SourceLocation ThrowLoc, QualType Type, bool NRVO) { return InitializedEntity(EK_Exception, ThrowLoc, Type, NRVO); } - /// \brief Create the initialization entity for an object allocated via new. + /// Create the initialization entity for an object allocated via new. static InitializedEntity InitializeNew(SourceLocation NewLoc, QualType Type) { return InitializedEntity(EK_New, NewLoc, Type); } - /// \brief Create the initialization entity for a temporary. + /// Create the initialization entity for a temporary. static InitializedEntity InitializeTemporary(QualType Type) { return InitializeTemporary(nullptr, Type); } - /// \brief Create the initialization entity for a temporary. + /// Create the initialization entity for a temporary. static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo) { return InitializeTemporary(TypeInfo, TypeInfo->getType()); } - /// \brief Create the initialization entity for a temporary. + /// Create the initialization entity for a temporary. static InitializedEntity InitializeTemporary(TypeSourceInfo *TypeInfo, QualType Type) { InitializedEntity Result(EK_Temporary, SourceLocation(), Type); @@ -321,7 +321,7 @@ public: return Result; } - /// \brief Create the initialization entity for a related result. + /// Create the initialization entity for a related result. static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type) { InitializedEntity Result(EK_RelatedResult, SourceLocation(), Type); @@ -329,18 +329,18 @@ public: return Result; } - /// \brief Create the initialization entity for a base class subobject. + /// Create the initialization entity for a base class subobject. static InitializedEntity InitializeBase(ASTContext &Context, const CXXBaseSpecifier *Base, bool IsInheritedVirtualBase, const InitializedEntity *Parent = nullptr); - /// \brief Create the initialization entity for a delegated constructor. + /// Create the initialization entity for a delegated constructor. static InitializedEntity InitializeDelegation(QualType Type) { return InitializedEntity(EK_Delegating, SourceLocation(), Type); } - /// \brief Create the initialization entity for a member subobject. + /// Create the initialization entity for a member subobject. static InitializedEntity InitializeMember(FieldDecl *Member, const InitializedEntity *Parent = nullptr, @@ -348,7 +348,7 @@ public: return InitializedEntity(Member, Parent, Implicit); } - /// \brief Create the initialization entity for a member subobject. + /// Create the initialization entity for a member subobject. static InitializedEntity InitializeMember(IndirectFieldDecl *Member, const InitializedEntity *Parent = nullptr, @@ -356,26 +356,26 @@ public: return InitializedEntity(Member->getAnonField(), Parent, Implicit); } - /// \brief Create the initialization entity for an array element. + /// Create the initialization entity for an array element. static InitializedEntity InitializeElement(ASTContext &Context, unsigned Index, const InitializedEntity &Parent) { return InitializedEntity(Context, Index, Parent); } - /// \brief Create the initialization entity for a structured binding. + /// Create the initialization entity for a structured binding. static InitializedEntity InitializeBinding(VarDecl *Binding) { return InitializedEntity(Binding, EK_Binding); } - /// \brief Create the initialization entity for a lambda capture. + /// Create the initialization entity for a lambda capture. static InitializedEntity InitializeLambdaCapture(IdentifierInfo *VarID, QualType FieldType, SourceLocation Loc) { return InitializedEntity(VarID, FieldType, Loc); } - /// \brief Create the entity for a compound literal initializer. + /// Create the entity for a compound literal initializer. static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI) { InitializedEntity Result(EK_CompoundLiteralInit, SourceLocation(), TSI->getType()); @@ -383,18 +383,18 @@ public: return Result; } - /// \brief Determine the kind of initialization. + /// Determine the kind of initialization. EntityKind getKind() const { return Kind; } - /// \brief Retrieve the parent of the entity being initialized, when + /// Retrieve the parent of the entity being initialized, when /// the initialization itself is occurring within the context of a /// larger initialization. const InitializedEntity *getParent() const { return Parent; } - /// \brief Retrieve type being initialized. + /// Retrieve type being initialized. QualType getType() const { return Type; } - /// \brief Retrieve complete type-source information for the object being + /// Retrieve complete type-source information for the object being /// constructed, if known. TypeSourceInfo *getTypeSourceInfo() const { if (Kind == EK_Temporary || Kind == EK_CompoundLiteralInit) @@ -403,17 +403,17 @@ public: return nullptr; } - /// \brief Retrieve the name of the entity being initialized. + /// Retrieve the name of the entity being initialized. DeclarationName getName() const; - /// \brief Retrieve the variable, parameter, or field being + /// Retrieve the variable, parameter, or field being /// initialized. ValueDecl *getDecl() const; - /// \brief Retrieve the ObjectiveC method being initialized. + /// Retrieve the ObjectiveC method being initialized. ObjCMethodDecl *getMethodDecl() const { return MethodDecl; } - /// \brief Determine whether this initialization allows the named return + /// Determine whether this initialization allows the named return /// value optimization, which also applies to thrown objects. bool allowsNRVO() const; @@ -422,52 +422,52 @@ public: getKind() == EK_Parameter_CF_Audited); } - /// \brief Determine whether this initialization consumes the + /// Determine whether this initialization consumes the /// parameter. bool isParameterConsumed() const { assert(isParameterKind() && "Not a parameter"); return (Parameter & 1); } - /// \brief Retrieve the base specifier. + /// Retrieve the base specifier. const CXXBaseSpecifier *getBaseSpecifier() const { assert(getKind() == EK_Base && "Not a base specifier"); return reinterpret_cast<const CXXBaseSpecifier *>(Base & ~0x1); } - /// \brief Return whether the base is an inherited virtual base. + /// Return whether the base is an inherited virtual base. bool isInheritedVirtualBase() const { assert(getKind() == EK_Base && "Not a base specifier"); return Base & 0x1; } - /// \brief Determine whether this is an array new with an unknown bound. + /// Determine whether this is an array new with an unknown bound. bool isVariableLengthArrayNew() const { return getKind() == EK_New && dyn_cast_or_null<IncompleteArrayType>( getType()->getAsArrayTypeUnsafe()); } - /// \brief Is this the implicit initialization of a member of a class from + /// Is this the implicit initialization of a member of a class from /// a defaulted constructor? bool isImplicitMemberInitializer() const { return getKind() == EK_Member && Variable.IsImplicitFieldInit; } - /// \brief Determine the location of the 'return' keyword when initializing + /// Determine the location of the 'return' keyword when initializing /// the result of a function call. SourceLocation getReturnLoc() const { assert(getKind() == EK_Result && "No 'return' location!"); return SourceLocation::getFromRawEncoding(LocAndNRVO.Location); } - /// \brief Determine the location of the 'throw' keyword when initializing + /// Determine the location of the 'throw' keyword when initializing /// an exception object. SourceLocation getThrowLoc() const { assert(getKind() == EK_Exception && "No 'throw' location!"); return SourceLocation::getFromRawEncoding(LocAndNRVO.Location); } - /// \brief If this is an array, vector, or complex number element, get the + /// If this is an array, vector, or complex number element, get the /// element's index. unsigned getElementIndex() const { assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement || @@ -475,7 +475,7 @@ public: return Index; } - /// \brief If this is already the initializer for an array or vector + /// If this is already the initializer for an array or vector /// element, sets the element index. void setElementIndex(unsigned Index) { assert(getKind() == EK_ArrayElement || getKind() == EK_VectorElement || @@ -483,13 +483,13 @@ public: this->Index = Index; } - /// \brief For a lambda capture, return the capture's name. + /// For a lambda capture, return the capture's name. StringRef getCapturedVarName() const { assert(getKind() == EK_LambdaCapture && "Not a lambda capture!"); return Capture.VarID->getName(); } - /// \brief Determine the location of the capture when initializing + /// Determine the location of the capture when initializing /// field from a captured variable in a lambda. SourceLocation getCaptureLoc() const { assert(getKind() == EK_LambdaCapture && "Not a lambda capture!"); @@ -510,12 +510,12 @@ private: unsigned dumpImpl(raw_ostream &OS) const; }; -/// \brief Describes the kind of initialization being performed, along with +/// Describes the kind of initialization being performed, along with /// location information for tokens related to the initialization (equal sign, /// parentheses). class InitializationKind { public: - /// \brief The kind of initialization being performed. + /// The kind of initialization being performed. enum InitKind { /// Direct initialization IK_Direct, @@ -534,7 +534,7 @@ public: }; private: - /// \brief The context of the initialization. + /// The context of the initialization. enum InitContext { /// Normal context IC_Normal, @@ -555,13 +555,13 @@ private: IC_FunctionalCast }; - /// \brief The kind of initialization being performed. + /// The kind of initialization being performed. InitKind Kind : 8; - /// \brief The context of the initialization. + /// The context of the initialization. InitContext Context : 8; - /// \brief The source locations involved in the initialization. + /// The source locations involved in the initialization. SourceLocation Locations[3]; InitializationKind(InitKind Kind, InitContext Context, SourceLocation Loc1, @@ -573,7 +573,7 @@ private: } public: - /// \brief Create a direct initialization. + /// Create a direct initialization. static InitializationKind CreateDirect(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc) { @@ -593,14 +593,14 @@ public: RBraceLoc); } - /// \brief Create a direct initialization due to a cast that isn't a C-style + /// Create a direct initialization due to a cast that isn't a C-style /// or functional cast. static InitializationKind CreateCast(SourceRange TypeRange) { return InitializationKind(IK_Direct, IC_StaticCast, TypeRange.getBegin(), TypeRange.getBegin(), TypeRange.getEnd()); } - /// \brief Create a direct initialization for a C-style cast. + /// Create a direct initialization for a C-style cast. static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList) { @@ -611,7 +611,7 @@ public: TypeRange.getEnd()); } - /// \brief Create a direct initialization for a functional cast. + /// Create a direct initialization for a functional cast. static InitializationKind CreateFunctionalCast(SourceRange TypeRange, bool InitList) { return InitializationKind(InitList ? IK_DirectList : IK_Direct, @@ -619,7 +619,7 @@ public: TypeRange.getBegin(), TypeRange.getEnd()); } - /// \brief Create a copy initialization. + /// Create a copy initialization. static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs = false) { @@ -628,12 +628,12 @@ public: InitLoc, EqualLoc, EqualLoc); } - /// \brief Create a default initialization. + /// Create a default initialization. static InitializationKind CreateDefault(SourceLocation InitLoc) { return InitializationKind(IK_Default, IC_Normal, InitLoc, InitLoc, InitLoc); } - /// \brief Create a value initialization. + /// Create a value initialization. static InitializationKind CreateValue(SourceLocation InitLoc, SourceLocation LParenLoc, SourceLocation RParenLoc, @@ -642,7 +642,7 @@ public: InitLoc, LParenLoc, RParenLoc); } - /// \brief Create an initialization from an initializer (which, for direct + /// Create an initialization from an initializer (which, for direct /// initialization from a parenthesized list, will be a ParenListExpr). static InitializationKind CreateForInit(SourceLocation Loc, bool DirectInit, Expr *Init) { @@ -653,45 +653,45 @@ public: return CreateDirect(Loc, Init->getLocStart(), Init->getLocEnd()); } - /// \brief Determine the initialization kind. + /// Determine the initialization kind. InitKind getKind() const { return Kind; } - /// \brief Determine whether this initialization is an explicit cast. + /// Determine whether this initialization is an explicit cast. bool isExplicitCast() const { return Context >= IC_StaticCast; } - /// \brief Determine whether this initialization is a C-style cast. + /// Determine whether this initialization is a C-style cast. bool isCStyleOrFunctionalCast() const { return Context >= IC_CStyleCast; } - /// \brief Determine whether this is a C-style cast. + /// Determine whether this is a C-style cast. bool isCStyleCast() const { return Context == IC_CStyleCast; } - /// \brief Determine whether this is a functional-style cast. + /// Determine whether this is a functional-style cast. bool isFunctionalCast() const { return Context == IC_FunctionalCast; } - /// \brief Determine whether this initialization is an implicit + /// Determine whether this initialization is an implicit /// value-initialization, e.g., as occurs during aggregate /// initialization. bool isImplicitValueInit() const { return Context == IC_Implicit; } - /// \brief Retrieve the location at which initialization is occurring. + /// Retrieve the location at which initialization is occurring. SourceLocation getLocation() const { return Locations[0]; } - /// \brief Retrieve the source range that covers the initialization. + /// Retrieve the source range that covers the initialization. SourceRange getRange() const { return SourceRange(Locations[0], Locations[2]); } - /// \brief Retrieve the location of the equal sign for copy initialization + /// Retrieve the location of the equal sign for copy initialization /// (if present). SourceLocation getEqualLoc() const { assert(Kind == IK_Copy && "Only copy initialization has an '='"); @@ -700,11 +700,11 @@ public: bool isCopyInit() const { return Kind == IK_Copy; } - /// \brief Retrieve whether this initialization allows the use of explicit + /// Retrieve whether this initialization allows the use of explicit /// constructors. bool AllowExplicit() const { return !isCopyInit(); } - /// \brief Retrieve whether this initialization allows the use of explicit + /// Retrieve whether this initialization allows the use of explicit /// conversion functions when binding a reference. If the reference is the /// first parameter in a copy or move constructor, such conversions are /// permitted even though we are performing copy-initialization. @@ -718,7 +718,7 @@ public: return Kind == IK_Direct || Kind == IK_Value || Kind == IK_DirectList; } - /// \brief Retrieve the source range containing the locations of the open + /// Retrieve the source range containing the locations of the open /// and closing parentheses or braces for value, direct, and direct list /// initializations. SourceRange getParenOrBraceRange() const { @@ -729,159 +729,159 @@ public: } }; -/// \brief Describes the sequence of initializations required to initialize +/// Describes the sequence of initializations required to initialize /// a given object or reference with a set of arguments. class InitializationSequence { public: - /// \brief Describes the kind of initialization sequence computed. + /// Describes the kind of initialization sequence computed. enum SequenceKind { - /// \brief A failed initialization sequence. The failure kind tells what + /// A failed initialization sequence. The failure kind tells what /// happened. FailedSequence = 0, - /// \brief A dependent initialization, which could not be + /// A dependent initialization, which could not be /// type-checked due to the presence of dependent types or /// dependently-typed expressions. DependentSequence, - /// \brief A normal sequence. + /// A normal sequence. NormalSequence }; - /// \brief Describes the kind of a particular step in an initialization + /// Describes the kind of a particular step in an initialization /// sequence. enum StepKind { - /// \brief Resolve the address of an overloaded function to a specific + /// Resolve the address of an overloaded function to a specific /// function declaration. SK_ResolveAddressOfOverloadedFunction, - /// \brief Perform a derived-to-base cast, producing an rvalue. + /// Perform a derived-to-base cast, producing an rvalue. SK_CastDerivedToBaseRValue, - /// \brief Perform a derived-to-base cast, producing an xvalue. + /// Perform a derived-to-base cast, producing an xvalue. SK_CastDerivedToBaseXValue, - /// \brief Perform a derived-to-base cast, producing an lvalue. + /// Perform a derived-to-base cast, producing an lvalue. SK_CastDerivedToBaseLValue, - /// \brief Reference binding to an lvalue. + /// Reference binding to an lvalue. SK_BindReference, - /// \brief Reference binding to a temporary. + /// Reference binding to a temporary. SK_BindReferenceToTemporary, - /// \brief An optional copy of a temporary object to another + /// An optional copy of a temporary object to another /// temporary object, which is permitted (but not required) by /// C++98/03 but not C++0x. SK_ExtraneousCopyToTemporary, - /// \brief Direct-initialization from a reference-related object in the + /// Direct-initialization from a reference-related object in the /// final stage of class copy-initialization. SK_FinalCopy, - /// \brief Perform a user-defined conversion, either via a conversion + /// Perform a user-defined conversion, either via a conversion /// function or via a constructor. SK_UserConversion, - /// \brief Perform a qualification conversion, producing an rvalue. + /// Perform a qualification conversion, producing an rvalue. SK_QualificationConversionRValue, - /// \brief Perform a qualification conversion, producing an xvalue. + /// Perform a qualification conversion, producing an xvalue. SK_QualificationConversionXValue, - /// \brief Perform a qualification conversion, producing an lvalue. + /// Perform a qualification conversion, producing an lvalue. SK_QualificationConversionLValue, - /// \brief Perform a conversion adding _Atomic to a type. + /// Perform a conversion adding _Atomic to a type. SK_AtomicConversion, - /// \brief Perform a load from a glvalue, producing an rvalue. + /// Perform a load from a glvalue, producing an rvalue. SK_LValueToRValue, - /// \brief Perform an implicit conversion sequence. + /// Perform an implicit conversion sequence. SK_ConversionSequence, - /// \brief Perform an implicit conversion sequence without narrowing. + /// Perform an implicit conversion sequence without narrowing. SK_ConversionSequenceNoNarrowing, - /// \brief Perform list-initialization without a constructor. + /// Perform list-initialization without a constructor. SK_ListInitialization, - /// \brief Unwrap the single-element initializer list for a reference. + /// Unwrap the single-element initializer list for a reference. SK_UnwrapInitList, - /// \brief Rewrap the single-element initializer list for a reference. + /// Rewrap the single-element initializer list for a reference. SK_RewrapInitList, - /// \brief Perform initialization via a constructor. + /// Perform initialization via a constructor. SK_ConstructorInitialization, - /// \brief Perform initialization via a constructor, taking arguments from + /// Perform initialization via a constructor, taking arguments from /// a single InitListExpr. SK_ConstructorInitializationFromList, - /// \brief Zero-initialize the object + /// Zero-initialize the object SK_ZeroInitialization, - /// \brief C assignment + /// C assignment SK_CAssignment, - /// \brief Initialization by string + /// Initialization by string SK_StringInit, - /// \brief An initialization that "converts" an Objective-C object + /// An initialization that "converts" an Objective-C object /// (not a point to an object) to another Objective-C object type. SK_ObjCObjectConversion, - /// \brief Array indexing for initialization by elementwise copy. + /// Array indexing for initialization by elementwise copy. SK_ArrayLoopIndex, - /// \brief Array initialization by elementwise copy. + /// Array initialization by elementwise copy. SK_ArrayLoopInit, - /// \brief Array initialization (from an array rvalue). + /// Array initialization (from an array rvalue). SK_ArrayInit, - /// \brief Array initialization (from an array rvalue) as a GNU extension. + /// Array initialization (from an array rvalue) as a GNU extension. SK_GNUArrayInit, - /// \brief Array initialization from a parenthesized initializer list. + /// Array initialization from a parenthesized initializer list. /// This is a GNU C++ extension. SK_ParenthesizedArrayInit, - /// \brief Pass an object by indirect copy-and-restore. + /// Pass an object by indirect copy-and-restore. SK_PassByIndirectCopyRestore, - /// \brief Pass an object by indirect restore. + /// Pass an object by indirect restore. SK_PassByIndirectRestore, - /// \brief Produce an Objective-C object pointer. + /// Produce an Objective-C object pointer. SK_ProduceObjCObject, - /// \brief Construct a std::initializer_list from an initializer list. + /// Construct a std::initializer_list from an initializer list. SK_StdInitializerList, - /// \brief Perform initialization via a constructor taking a single + /// Perform initialization via a constructor taking a single /// std::initializer_list argument. SK_StdInitializerListConstructorCall, - /// \brief Initialize an OpenCL sampler from an integer. + /// Initialize an OpenCL sampler from an integer. SK_OCLSamplerInit, - /// \brief Initialize queue_t from 0. + /// Initialize queue_t from 0. SK_OCLZeroQueue, - /// \brief Passing zero to a function where OpenCL event_t is expected. + /// Passing zero to a function where OpenCL event_t is expected. SK_OCLZeroEvent }; - /// \brief A single step in the initialization sequence. + /// A single step in the initialization sequence. class Step { public: - /// \brief The kind of conversion or initialization step we are taking. + /// The kind of conversion or initialization step we are taking. StepKind Kind; - // \brief The type that results from this initialization. + // The type that results from this initialization. QualType Type; struct F { @@ -891,7 +891,7 @@ public: }; union { - /// \brief When Kind == SK_ResolvedOverloadedFunction or Kind == + /// When Kind == SK_ResolvedOverloadedFunction or Kind == /// SK_UserConversion, the function that the expression should be /// resolved to or the conversion function to call, respectively. /// When Kind == SK_ConstructorInitialization or SK_ListConstruction, @@ -903,11 +903,11 @@ public: /// For construct decls, the naming class is the target type. struct F Function; - /// \brief When Kind = SK_ConversionSequence, the implicit conversion + /// When Kind = SK_ConversionSequence, the implicit conversion /// sequence. ImplicitConversionSequence *ICS; - /// \brief When Kind = SK_RewrapInitList, the syntactic form of the + /// When Kind = SK_RewrapInitList, the syntactic form of the /// wrapping list. InitListExpr *WrappingSyntacticList; }; @@ -916,154 +916,154 @@ public: }; private: - /// \brief The kind of initialization sequence computed. + /// The kind of initialization sequence computed. enum SequenceKind SequenceKind; - /// \brief Steps taken by this initialization. + /// Steps taken by this initialization. SmallVector<Step, 4> Steps; public: - /// \brief Describes why initialization failed. + /// Describes why initialization failed. enum FailureKind { - /// \brief Too many initializers provided for a reference. + /// Too many initializers provided for a reference. FK_TooManyInitsForReference, - /// \brief Reference initialized from a parenthesized initializer list. + /// Reference initialized from a parenthesized initializer list. FK_ParenthesizedListInitForReference, - /// \brief Array must be initialized with an initializer list. + /// Array must be initialized with an initializer list. FK_ArrayNeedsInitList, - /// \brief Array must be initialized with an initializer list or a + /// Array must be initialized with an initializer list or a /// string literal. FK_ArrayNeedsInitListOrStringLiteral, - /// \brief Array must be initialized with an initializer list or a + /// Array must be initialized with an initializer list or a /// wide string literal. FK_ArrayNeedsInitListOrWideStringLiteral, - /// \brief Initializing a wide char array with narrow string literal. + /// Initializing a wide char array with narrow string literal. FK_NarrowStringIntoWideCharArray, - /// \brief Initializing char array with wide string literal. + /// Initializing char array with wide string literal. FK_WideStringIntoCharArray, - /// \brief Initializing wide char array with incompatible wide string + /// Initializing wide char array with incompatible wide string /// literal. FK_IncompatWideStringIntoWideChar, - /// \brief Initializing char8_t array with plain string literal. + /// Initializing char8_t array with plain string literal. FK_PlainStringIntoUTF8Char, - /// \brief Initializing char array with UTF-8 string literal. + /// Initializing char array with UTF-8 string literal. FK_UTF8StringIntoPlainChar, - /// \brief Array type mismatch. + /// Array type mismatch. FK_ArrayTypeMismatch, - /// \brief Non-constant array initializer + /// Non-constant array initializer FK_NonConstantArrayInit, - /// \brief Cannot resolve the address of an overloaded function. + /// Cannot resolve the address of an overloaded function. FK_AddressOfOverloadFailed, - /// \brief Overloading due to reference initialization failed. + /// Overloading due to reference initialization failed. FK_ReferenceInitOverloadFailed, - /// \brief Non-const lvalue reference binding to a temporary. + /// Non-const lvalue reference binding to a temporary. FK_NonConstLValueReferenceBindingToTemporary, - /// \brief Non-const lvalue reference binding to a bit-field. + /// Non-const lvalue reference binding to a bit-field. FK_NonConstLValueReferenceBindingToBitfield, - /// \brief Non-const lvalue reference binding to a vector element. + /// Non-const lvalue reference binding to a vector element. FK_NonConstLValueReferenceBindingToVectorElement, - /// \brief Non-const lvalue reference binding to an lvalue of unrelated + /// Non-const lvalue reference binding to an lvalue of unrelated /// type. FK_NonConstLValueReferenceBindingToUnrelated, - /// \brief Rvalue reference binding to an lvalue. + /// Rvalue reference binding to an lvalue. FK_RValueReferenceBindingToLValue, - /// \brief Reference binding drops qualifiers. + /// Reference binding drops qualifiers. FK_ReferenceInitDropsQualifiers, - /// \brief Reference binding failed. + /// Reference binding failed. FK_ReferenceInitFailed, - /// \brief Implicit conversion failed. + /// Implicit conversion failed. FK_ConversionFailed, - /// \brief Implicit conversion failed. + /// Implicit conversion failed. FK_ConversionFromPropertyFailed, - /// \brief Too many initializers for scalar + /// Too many initializers for scalar FK_TooManyInitsForScalar, - /// \brief Scalar initialized from a parenthesized initializer list. + /// Scalar initialized from a parenthesized initializer list. FK_ParenthesizedListInitForScalar, - /// \brief Reference initialization from an initializer list + /// Reference initialization from an initializer list FK_ReferenceBindingToInitList, - /// \brief Initialization of some unused destination type with an + /// Initialization of some unused destination type with an /// initializer list. FK_InitListBadDestinationType, - /// \brief Overloading for a user-defined conversion failed. + /// Overloading for a user-defined conversion failed. FK_UserConversionOverloadFailed, - /// \brief Overloading for initialization by constructor failed. + /// Overloading for initialization by constructor failed. FK_ConstructorOverloadFailed, - /// \brief Overloading for list-initialization by constructor failed. + /// Overloading for list-initialization by constructor failed. FK_ListConstructorOverloadFailed, - /// \brief Default-initialization of a 'const' object. + /// Default-initialization of a 'const' object. FK_DefaultInitOfConst, - /// \brief Initialization of an incomplete type. + /// Initialization of an incomplete type. FK_Incomplete, - /// \brief Variable-length array must not have an initializer. + /// Variable-length array must not have an initializer. FK_VariableLengthArrayHasInitializer, - /// \brief List initialization failed at some point. + /// List initialization failed at some point. FK_ListInitializationFailed, - /// \brief Initializer has a placeholder type which cannot be + /// Initializer has a placeholder type which cannot be /// resolved by initialization. FK_PlaceholderType, - /// \brief Trying to take the address of a function that doesn't support + /// Trying to take the address of a function that doesn't support /// having its address taken. FK_AddressOfUnaddressableFunction, - /// \brief List-copy-initialization chose an explicit constructor. + /// List-copy-initialization chose an explicit constructor. FK_ExplicitConstructor, }; private: - /// \brief The reason why initialization failed. + /// The reason why initialization failed. FailureKind Failure; - /// \brief The failed result of overload resolution. + /// The failed result of overload resolution. OverloadingResult FailedOverloadResult; - /// \brief The candidate set created when initialization failed. + /// The candidate set created when initialization failed. OverloadCandidateSet FailedCandidateSet; - /// \brief The incomplete type that caused a failure. + /// The incomplete type that caused a failure. QualType FailedIncompleteType; - /// \brief The fixit that needs to be applied to make this initialization + /// The fixit that needs to be applied to make this initialization /// succeed. std::string ZeroInitializationFixit; SourceLocation ZeroInitializationFixitLoc; public: - /// \brief Call for initializations are invalid but that would be valid + /// Call for initializations are invalid but that would be valid /// zero initialzations if Fixit was applied. void SetZeroInitializationFixit(const std::string& Fixit, SourceLocation L) { ZeroInitializationFixit = Fixit; @@ -1071,12 +1071,12 @@ public: } private: - /// \brief Prints a follow-up note that highlights the location of + /// Prints a follow-up note that highlights the location of /// the initialized entity, if it's remote. void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity); public: - /// \brief Try to perform initialization of the given entity, creating a + /// Try to perform initialization of the given entity, creating a /// record of the steps required to perform the initialization. /// /// The generated initialization sequence will either contain enough @@ -1107,7 +1107,7 @@ public: ~InitializationSequence(); - /// \brief Perform the actual initialization of the given entity based on + /// Perform the actual initialization of the given entity based on /// the computed initialization sequence. /// /// \param S the semantic analysis object. @@ -1134,7 +1134,7 @@ public: MultiExprArg Args, QualType *ResultType = nullptr); - /// \brief Diagnose an potentially-invalid initialization sequence. + /// Diagnose an potentially-invalid initialization sequence. /// /// \returns true if the initialization sequence was ill-formed, /// false otherwise. @@ -1143,16 +1143,16 @@ public: const InitializationKind &Kind, ArrayRef<Expr *> Args); - /// \brief Determine the kind of initialization sequence computed. + /// Determine the kind of initialization sequence computed. enum SequenceKind getKind() const { return SequenceKind; } - /// \brief Set the kind of sequence computed. + /// Set the kind of sequence computed. void setSequenceKind(enum SequenceKind SK) { SequenceKind = SK; } - /// \brief Determine whether the initialization sequence is valid. + /// Determine whether the initialization sequence is valid. explicit operator bool() const { return !Failed(); } - /// \brief Determine whether the initialization sequence is invalid. + /// Determine whether the initialization sequence is invalid. bool Failed() const { return SequenceKind == FailedSequence; } using step_iterator = SmallVectorImpl<Step>::const_iterator; @@ -1164,18 +1164,18 @@ public: step_range steps() const { return {step_begin(), step_end()}; } - /// \brief Determine whether this initialization is a direct reference + /// Determine whether this initialization is a direct reference /// binding (C++ [dcl.init.ref]). bool isDirectReferenceBinding() const; - /// \brief Determine whether this initialization failed due to an ambiguity. + /// Determine whether this initialization failed due to an ambiguity. bool isAmbiguous() const; - /// \brief Determine whether this initialization is direct call to a + /// Determine whether this initialization is direct call to a /// constructor. bool isConstructorInitialization() const; - /// \brief Returns whether the last step in this initialization sequence is a + /// Returns whether the last step in this initialization sequence is a /// narrowing conversion, defined by C++0x [dcl.init.list]p7. /// /// If this function returns true, *isInitializerConstant will be set to @@ -1186,7 +1186,7 @@ public: bool *isInitializerConstant, APValue *ConstantValue) const; - /// \brief Add a new step in the initialization that resolves the address + /// Add a new step in the initialization that resolves the address /// of an overloaded function to a specific function declaration. /// /// \param Function the function to which the overloaded function reference @@ -1195,7 +1195,7 @@ public: DeclAccessPair Found, bool HadMultipleCandidates); - /// \brief Add a new step in the initialization that performs a derived-to- + /// Add a new step in the initialization that performs a derived-to- /// base cast. /// /// \param BaseType the base type to which we will be casting. @@ -1205,14 +1205,14 @@ public: void AddDerivedToBaseCastStep(QualType BaseType, ExprValueKind Category); - /// \brief Add a new step binding a reference to an object. + /// Add a new step binding a reference to an object. /// /// \param BindingTemporary True if we are binding a reference to a temporary /// object (thereby extending its lifetime); false if we are binding to an /// lvalue or an lvalue treated as an rvalue. void AddReferenceBindingStep(QualType T, bool BindingTemporary); - /// \brief Add a new step that makes an extraneous copy of the input + /// Add a new step that makes an extraneous copy of the input /// to a temporary of the same class type. /// /// This extraneous copy only occurs during reference binding in @@ -1224,40 +1224,40 @@ public: /// \param T The type of the temporary being created. void AddExtraneousCopyToTemporary(QualType T); - /// \brief Add a new step that makes a copy of the input to an object of + /// Add a new step that makes a copy of the input to an object of /// the given type, as the final step in class copy-initialization. void AddFinalCopy(QualType T); - /// \brief Add a new step invoking a conversion function, which is either + /// Add a new step invoking a conversion function, which is either /// a constructor or a conversion function. void AddUserConversionStep(FunctionDecl *Function, DeclAccessPair FoundDecl, QualType T, bool HadMultipleCandidates); - /// \brief Add a new step that performs a qualification conversion to the + /// Add a new step that performs a qualification conversion to the /// given type. void AddQualificationConversionStep(QualType Ty, ExprValueKind Category); - /// \brief Add a new step that performs conversion from non-atomic to atomic + /// Add a new step that performs conversion from non-atomic to atomic /// type. void AddAtomicConversionStep(QualType Ty); - /// \brief Add a new step that performs a load of the given type. + /// Add a new step that performs a load of the given type. /// /// Although the term "LValueToRValue" is conventional, this applies to both /// lvalues and xvalues. void AddLValueToRValueStep(QualType Ty); - /// \brief Add a new step that applies an implicit conversion sequence. + /// Add a new step that applies an implicit conversion sequence. void AddConversionSequenceStep(const ImplicitConversionSequence &ICS, QualType T, bool TopLevelOfInitList = false); - /// \brief Add a list-initialization step. + /// Add a list-initialization step. void AddListInitializationStep(QualType T); - /// \brief Add a constructor-initialization step. + /// Add a constructor-initialization step. /// /// \param FromInitList The constructor call is syntactically an initializer /// list. @@ -1268,59 +1268,59 @@ public: bool HadMultipleCandidates, bool FromInitList, bool AsInitList); - /// \brief Add a zero-initialization step. + /// Add a zero-initialization step. void AddZeroInitializationStep(QualType T); - /// \brief Add a C assignment step. + /// Add a C assignment step. // // FIXME: It isn't clear whether this should ever be needed; // ideally, we would handle everything needed in C in the common // path. However, that isn't the case yet. void AddCAssignmentStep(QualType T); - /// \brief Add a string init step. + /// Add a string init step. void AddStringInitStep(QualType T); - /// \brief Add an Objective-C object conversion step, which is + /// Add an Objective-C object conversion step, which is /// always a no-op. void AddObjCObjectConversionStep(QualType T); - /// \brief Add an array initialization loop step. + /// Add an array initialization loop step. void AddArrayInitLoopStep(QualType T, QualType EltTy); - /// \brief Add an array initialization step. + /// Add an array initialization step. void AddArrayInitStep(QualType T, bool IsGNUExtension); - /// \brief Add a parenthesized array initialization step. + /// Add a parenthesized array initialization step. void AddParenthesizedArrayInitStep(QualType T); - /// \brief Add a step to pass an object by indirect copy-restore. + /// Add a step to pass an object by indirect copy-restore. void AddPassByIndirectCopyRestoreStep(QualType T, bool shouldCopy); - /// \brief Add a step to "produce" an Objective-C object (by + /// Add a step to "produce" an Objective-C object (by /// retaining it). void AddProduceObjCObjectStep(QualType T); - /// \brief Add a step to construct a std::initializer_list object from an + /// Add a step to construct a std::initializer_list object from an /// initializer list. void AddStdInitializerListConstructionStep(QualType T); - /// \brief Add a step to initialize an OpenCL sampler from an integer + /// Add a step to initialize an OpenCL sampler from an integer /// constant. void AddOCLSamplerInitStep(QualType T); - /// \brief Add a step to initialize an OpenCL event_t from a NULL + /// Add a step to initialize an OpenCL event_t from a NULL /// constant. void AddOCLZeroEventStep(QualType T); - /// \brief Add a step to initialize an OpenCL queue_t from 0. + /// Add a step to initialize an OpenCL queue_t from 0. void AddOCLZeroQueueStep(QualType T); - /// \brief Add steps to unwrap a initializer list for a reference around a + /// Add steps to unwrap a initializer list for a reference around a /// single element and rewrap it at the end. void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic); - /// \brief Note that this initialization sequence failed. + /// Note that this initialization sequence failed. void SetFailed(FailureKind Failure) { SequenceKind = FailedSequence; this->Failure = Failure; @@ -1328,40 +1328,40 @@ public: "Incomplete type failure requires a type!"); } - /// \brief Note that this initialization sequence failed due to failed + /// Note that this initialization sequence failed due to failed /// overload resolution. void SetOverloadFailure(FailureKind Failure, OverloadingResult Result); - /// \brief Retrieve a reference to the candidate set when overload + /// Retrieve a reference to the candidate set when overload /// resolution fails. OverloadCandidateSet &getFailedCandidateSet() { return FailedCandidateSet; } - /// \brief Get the overloading result, for when the initialization + /// Get the overloading result, for when the initialization /// sequence failed due to a bad overload. OverloadingResult getFailedOverloadResult() const { return FailedOverloadResult; } - /// \brief Note that this initialization sequence failed due to an + /// Note that this initialization sequence failed due to an /// incomplete type. void setIncompleteTypeFailure(QualType IncompleteType) { FailedIncompleteType = IncompleteType; SetFailed(FK_Incomplete); } - /// \brief Determine why initialization failed. + /// Determine why initialization failed. FailureKind getFailureKind() const { assert(Failed() && "Not an initialization failure!"); return Failure; } - /// \brief Dump a representation of this initialization sequence to + /// Dump a representation of this initialization sequence to /// the given stream, for debugging purposes. void dump(raw_ostream &OS) const; - /// \brief Dump a representation of this initialization sequence to + /// Dump a representation of this initialization sequence to /// standard error, for debugging purposes. void dump() const; }; |