diff options
Diffstat (limited to 'clang/lib/Sema/SemaOverload.cpp')
| -rw-r--r-- | clang/lib/Sema/SemaOverload.cpp | 78 |
1 files changed, 39 insertions, 39 deletions
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 362fe71f3ca..f2f30a4ba7b 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -583,7 +583,7 @@ namespace { }; } -/// \brief Convert from Sema's representation of template deduction information +/// Convert from Sema's representation of template deduction information /// to the form used in overload-candidate information. DeductionFailureInfo clang::MakeDeductionFailureInfo(ASTContext &Context, @@ -1192,7 +1192,7 @@ bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old, return false; } -/// \brief Checks availability of the function depending on the current +/// Checks availability of the function depending on the current /// function context. Inside an unavailable function, unavailability is ignored. /// /// \returns true if \arg FD is unavailable and current context is inside @@ -1210,7 +1210,7 @@ bool Sema::isFunctionConsideredUnavailable(FunctionDecl *FD) { return true; } -/// \brief Tries a user-defined conversion from From to ToType. +/// Tries a user-defined conversion from From to ToType. /// /// Produces an implicit conversion sequence for when a standard conversion /// is not an option. See TryImplicitConversion for more information. @@ -1422,7 +1422,7 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType, return PerformImplicitConversion(From, ToType, ICS, Action); } -/// \brief Determine whether the conversion from FromType to ToType is a valid +/// Determine whether the conversion from FromType to ToType is a valid /// conversion that strips "noexcept" or "noreturn" off the nested function /// type. bool Sema::IsFunctionConversion(QualType FromType, QualType ToType, @@ -1519,7 +1519,7 @@ bool Sema::IsFunctionConversion(QualType FromType, QualType ToType, return true; } -/// \brief Determine whether the conversion from FromType to ToType is a valid +/// Determine whether the conversion from FromType to ToType is a valid /// vector conversion. /// /// \param ICK Will be set to the vector conversion kind, if this is a vector @@ -2119,7 +2119,7 @@ bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) { return false; } -/// \brief Determine if a conversion is a complex promotion. +/// Determine if a conversion is a complex promotion. /// /// A complex promotion is defined as a complex -> complex conversion /// where the conversion between the underlying real types is a @@ -2353,7 +2353,7 @@ bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, return false; } -/// \brief Adopt the given qualifiers for the given type. +/// Adopt the given qualifiers for the given type. static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){ Qualifiers TQs = T.getQualifiers(); @@ -2541,7 +2541,7 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, return false; } -/// \brief Determine whether this is an Objective-C writeback conversion, +/// Determine whether this is an Objective-C writeback conversion, /// used for parameter passing when performing automatic reference counting. /// /// \param FromType The type we're converting form. @@ -2601,7 +2601,7 @@ bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType, IncompatibleObjC)) return false; - /// \brief Construct the type we're converting to, which is a pointer to + /// Construct the type we're converting to, which is a pointer to /// __autoreleasing pointee. FromPointee = Context.getQualifiedType(FromPointee, FromQuals); ConvertedType = Context.getPointerType(FromPointee); @@ -3137,7 +3137,7 @@ Sema::IsQualificationConversion(QualType FromType, QualType ToType, return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType); } -/// \brief - Determine whether this is a conversion from a scalar type to an +/// - Determine whether this is a conversion from a scalar type to an /// atomic type. /// /// If successful, updates \c SCS's second and third steps in the conversion @@ -3480,7 +3480,7 @@ Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) { return true; } -/// \brief Compare the user-defined conversion functions or constructors +/// Compare the user-defined conversion functions or constructors /// of two user-defined conversion sequences to determine whether any ordering /// is possible. static ImplicitConversionSequence::CompareKind @@ -3682,7 +3682,7 @@ compareStandardConversionSubsets(ASTContext &Context, return ImplicitConversionSequence::Indistinguishable; } -/// \brief Determine whether one of the given reference bindings is better +/// Determine whether one of the given reference bindings is better /// than the other based on what kind of bindings they are. static bool isBetterReferenceBindingKind(const StandardConversionSequence &SCS1, @@ -4207,7 +4207,7 @@ CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc, return ImplicitConversionSequence::Indistinguishable; } -/// \brief Determine whether the given type is valid, e.g., it is not an invalid +/// Determine whether the given type is valid, e.g., it is not an invalid /// C++ class. static bool isTypeValid(QualType T) { if (CXXRecordDecl *Record = T->getAsCXXRecordDecl()) @@ -4310,7 +4310,7 @@ Sema::CompareReferenceRelationship(SourceLocation Loc, return Ref_Related; } -/// \brief Look for a user-defined conversion to a value reference-compatible +/// Look for a user-defined conversion to a value reference-compatible /// with DeclType. Return true if something definite is found. static bool FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, @@ -4437,7 +4437,7 @@ FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, llvm_unreachable("Invalid OverloadResult!"); } -/// \brief Compute an implicit conversion sequence for reference +/// Compute an implicit conversion sequence for reference /// initialization. static ImplicitConversionSequence TryReferenceInit(Sema &S, Expr *Init, QualType DeclType, @@ -5649,7 +5649,7 @@ collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType, } } -/// \brief Attempt to convert the given expression to a type which is accepted +/// Attempt to convert the given expression to a type which is accepted /// by the given converter. /// /// This routine will attempt to convert an expression of class type to a @@ -6375,7 +6375,7 @@ bool Sema::diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND, }); } -/// \brief Add all of the function declarations in the given function set to +/// Add all of the function declarations in the given function set to /// the overload candidate set. void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns, ArrayRef<Expr *> Args, @@ -6611,7 +6611,7 @@ Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl, } } -/// \brief Add a C++ member function template as a candidate to the candidate +/// Add a C++ member function template as a candidate to the candidate /// set, using template argument deduction to produce an appropriate member /// function template specialization. void @@ -6679,7 +6679,7 @@ Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, Conversions); } -/// \brief Add a C++ function template specialization as a candidate +/// Add a C++ function template specialization as a candidate /// in the candidate set, using template argument deduction to produce /// an appropriate function template specialization. void @@ -7020,7 +7020,7 @@ Sema::AddConversionCandidate(CXXConversionDecl *Conversion, } } -/// \brief Adds a conversion function template specialization +/// Adds a conversion function template specialization /// candidate to the overload set, using template argument deduction /// to deduce the template arguments of the conversion function /// template from the type that we are converting to (C++ @@ -7175,7 +7175,7 @@ void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion, } } -/// \brief Add overload candidates for overloaded operators that are +/// Add overload candidates for overloaded operators that are /// member functions. /// /// Add the overloaded operator candidates that are member functions @@ -7311,18 +7311,18 @@ class BuiltinCandidateTypeSet { /// used in the built-in candidates. TypeSet EnumerationTypes; - /// \brief The set of vector types that will be used in the built-in + /// The set of vector types that will be used in the built-in /// candidates. TypeSet VectorTypes; - /// \brief A flag indicating non-record types are viable candidates + /// A flag indicating non-record types are viable candidates bool HasNonRecordTypes; - /// \brief A flag indicating whether either arithmetic or enumeration types + /// A flag indicating whether either arithmetic or enumeration types /// were present in the candidate set. bool HasArithmeticOrEnumeralTypes; - /// \brief A flag indicating whether the nullptr type was present in the + /// A flag indicating whether the nullptr type was present in the /// candidate set. bool HasNullPtrType; @@ -7575,7 +7575,7 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, } } -/// \brief Helper function for AddBuiltinOperatorCandidates() that adds +/// Helper function for AddBuiltinOperatorCandidates() that adds /// the volatile- and non-volatile-qualified assignment operators for the /// given type to the candidate set. static void AddBuiltinAssignmentOperatorCandidates(Sema &S, @@ -7653,7 +7653,7 @@ static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) { namespace { -/// \brief Helper class to manage the addition of builtin operator overload +/// Helper class to manage the addition of builtin operator overload /// candidates. It provides shared state and utility methods used throughout /// the process, as well as a helper method to add each group of builtin /// operator overloads from the standard to a candidate set. @@ -7726,7 +7726,7 @@ class BuiltinOperatorOverloadBuilder { "Enough inline storage for all arithmetic types."); } - /// \brief Helper method to factor out the common pattern of adding overloads + /// Helper method to factor out the common pattern of adding overloads /// for '++' and '--' builtin operators. void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy, bool HasVolatile, @@ -8862,7 +8862,7 @@ void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, } } -/// \brief Add function candidates found via argument-dependent lookup +/// Add function candidates found via argument-dependent lookup /// to the set of overloading candidates. /// /// This routine performs argument-dependent name lookup based on the @@ -9235,7 +9235,7 @@ void Sema::diagnoseEquivalentInternalLinkageDeclarations( } } -/// \brief Computes the best viable function (C++ 13.3.3) +/// Computes the best viable function (C++ 13.3.3) /// within an overload candidate set. /// /// \param Loc The location of the function name (or operator symbol) for @@ -9411,7 +9411,7 @@ static bool isFunctionAlwaysEnabled(const ASTContext &Ctx, return true; } -/// \brief Returns true if we can take the address of the function. +/// Returns true if we can take the address of the function. /// /// \param Complain - If true, we'll emit a diagnostic /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are @@ -11265,7 +11265,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, return Fn; } -/// \brief Given an expression that refers to an overloaded function, try to +/// Given an expression that refers to an overloaded function, try to /// resolve that function to a single function that can have its address taken. /// This will modify `Pair` iff it returns non-null. /// @@ -11301,7 +11301,7 @@ Sema::resolveAddressOfOnlyViableOverloadCandidate(Expr *E, return Result; } -/// \brief Given an overloaded function, tries to turn it into a non-overloaded +/// Given an overloaded function, tries to turn it into a non-overloaded /// function reference using resolveAddressOfOnlyViableOverloadCandidate. This /// will perform access checks, diagnose the use of the resultant decl, and, if /// requested, potentially perform a function-to-pointer decay. @@ -11331,7 +11331,7 @@ bool Sema::resolveAndFixAddressOfOnlyViableOverloadCandidate( return true; } -/// \brief Given an expression that refers to an overloaded function, try to +/// Given an expression that refers to an overloaded function, try to /// resolve that overloaded function expression down to a single function. /// /// This routine can only resolve template-ids that refer to a single function @@ -11500,7 +11500,7 @@ bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization( return true; } -/// \brief Add a single candidate to the overload set. +/// Add a single candidate to the overload set. static void AddOverloadedCallCandidate(Sema &S, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, @@ -11539,7 +11539,7 @@ static void AddOverloadedCallCandidate(Sema &S, assert(!KnownValid && "unhandled case in overloaded call candidate"); } -/// \brief Add the overload candidates named by callee and/or found by argument +/// Add the overload candidates named by callee and/or found by argument /// dependent lookup to the given overload set. void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, ArrayRef<Expr *> Args, @@ -11831,7 +11831,7 @@ BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, RParenLoc); } -/// \brief Constructs and populates an OverloadedCandidateSet from +/// Constructs and populates an OverloadedCandidateSet from /// the given function. /// \returns true when an the ExprResult output parameter has been set. bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn, @@ -12037,7 +12037,7 @@ static bool IsOverloaded(const UnresolvedSetImpl &Functions) { (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin())); } -/// \brief Create a unary operation that may resolve to an overloaded +/// Create a unary operation that may resolve to an overloaded /// operator. /// /// \param OpLoc The location of the operator itself (e.g., '*'). @@ -12228,7 +12228,7 @@ Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, return CreateBuiltinUnaryOp(OpLoc, Opc, Input); } -/// \brief Create a binary operation that may resolve to an overloaded +/// Create a binary operation that may resolve to an overloaded /// operator. /// /// \param OpLoc The location of the operator itself (e.g., '+'). |
