diff options
Diffstat (limited to 'clang/lib/Sema')
39 files changed, 1058 insertions, 1058 deletions
diff --git a/clang/lib/Sema/AnalysisBasedWarnings.cpp b/clang/lib/Sema/AnalysisBasedWarnings.cpp index 984239746e0..5ea2979900e 100644 --- a/clang/lib/Sema/AnalysisBasedWarnings.cpp +++ b/clang/lib/Sema/AnalysisBasedWarnings.cpp @@ -122,7 +122,7 @@ static void CheckUnreachable(Sema &S, AnalysisDeclContext &AC) { } namespace { -/// \brief Warn on logical operator errors in CFGBuilder +/// Warn on logical operator errors in CFGBuilder class LogicalErrorHandler : public CFGCallback { Sema &S; @@ -1650,7 +1650,7 @@ class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler { void setVerbose(bool b) { Verbose = b; } - /// \brief Emit all buffered diagnostics in order of sourcelocation. + /// Emit all buffered diagnostics in order of sourcelocation. /// We need to output diagnostics produced while iterating through /// the lockset in deterministic order, so this function orders diagnostics /// and outputs them. diff --git a/clang/lib/Sema/CodeCompleteConsumer.cpp b/clang/lib/Sema/CodeCompleteConsumer.cpp index d012e55e3da..70b31897561 100644 --- a/clang/lib/Sema/CodeCompleteConsumer.cpp +++ b/clang/lib/Sema/CodeCompleteConsumer.cpp @@ -621,7 +621,7 @@ PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, } } -/// \brief Retrieve the effective availability of the given declaration. +/// Retrieve the effective availability of the given declaration. static AvailabilityResult getDeclAvailability(const Decl *D) { AvailabilityResult AR = D->getAvailability(); if (isa<EnumConstantDecl>(D)) @@ -683,7 +683,7 @@ void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) { Availability = CXAvailability_NotAccessible; } -/// \brief Retrieve the name that should be used to order a result. +/// Retrieve the name that should be used to order a result. /// /// If the name needs to be constructed as a string, that string will be /// saved into Saved and the returned StringRef will refer to it. diff --git a/clang/lib/Sema/CoroutineStmtBuilder.h b/clang/lib/Sema/CoroutineStmtBuilder.h index 3b7ee7afcb7..d15cf0b756e 100644 --- a/clang/lib/Sema/CoroutineStmtBuilder.h +++ b/clang/lib/Sema/CoroutineStmtBuilder.h @@ -33,16 +33,16 @@ class CoroutineStmtBuilder : public CoroutineBodyStmt::CtorArgs { CXXRecordDecl *PromiseRecordDecl = nullptr; public: - /// \brief Construct a CoroutineStmtBuilder and initialize the promise + /// Construct a CoroutineStmtBuilder and initialize the promise /// statement and initial/final suspends from the FunctionScopeInfo. CoroutineStmtBuilder(Sema &S, FunctionDecl &FD, sema::FunctionScopeInfo &Fn, Stmt *Body); - /// \brief Build the coroutine body statements, including the + /// Build the coroutine body statements, including the /// "promise dependent" statements when the promise type is not dependent. bool buildStatements(); - /// \brief Build the coroutine body statements that require a non-dependent + /// Build the coroutine body statements that require a non-dependent /// promise type in order to construct. /// /// For example different new/delete overloads are selected depending on diff --git a/clang/lib/Sema/IdentifierResolver.cpp b/clang/lib/Sema/IdentifierResolver.cpp index f31c5174bf1..dbd52dee1ee 100644 --- a/clang/lib/Sema/IdentifierResolver.cpp +++ b/clang/lib/Sema/IdentifierResolver.cpp @@ -257,7 +257,7 @@ enum DeclMatchKind { } // namespace -/// \brief Compare two declarations to see whether they are different or, +/// Compare two declarations to see whether they are different or, /// if they are the same, whether the new declaration should replace the /// existing declaration. static DeclMatchKind compareDeclarations(NamedDecl *Existing, NamedDecl *New) { diff --git a/clang/lib/Sema/JumpDiagnostics.cpp b/clang/lib/Sema/JumpDiagnostics.cpp index 55582f8c61b..58a7862370c 100644 --- a/clang/lib/Sema/JumpDiagnostics.cpp +++ b/clang/lib/Sema/JumpDiagnostics.cpp @@ -216,7 +216,7 @@ static ScopePair GetDiagForGotoScopeDecl(Sema &S, const Decl *D) { return ScopePair(0U, 0U); } -/// \brief Build scope information for a declaration that is part of a DeclStmt. +/// Build scope information for a declaration that is part of a DeclStmt. void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) { // If this decl causes a new scope, push and switch to it. std::pair<unsigned,unsigned> Diags = GetDiagForGotoScopeDecl(S, D); @@ -233,7 +233,7 @@ void JumpScopeChecker::BuildScopeInformation(Decl *D, unsigned &ParentScope) { BuildScopeInformation(Init, ParentScope); } -/// \brief Build scope information for a captured block literal variables. +/// Build scope information for a captured block literal variables. void JumpScopeChecker::BuildScopeInformation(VarDecl *D, const BlockDecl *BDecl, unsigned &ParentScope) { diff --git a/clang/lib/Sema/MultiplexExternalSemaSource.cpp b/clang/lib/Sema/MultiplexExternalSemaSource.cpp index 46238fb3e40..9370cf27ef4 100644 --- a/clang/lib/Sema/MultiplexExternalSemaSource.cpp +++ b/clang/lib/Sema/MultiplexExternalSemaSource.cpp @@ -16,7 +16,7 @@ using namespace clang; -///\brief Constructs a new multiplexing external sema source and appends the +///Constructs a new multiplexing external sema source and appends the /// given element to it. /// MultiplexExternalSemaSource::MultiplexExternalSemaSource(ExternalSemaSource &s1, @@ -28,7 +28,7 @@ MultiplexExternalSemaSource::MultiplexExternalSemaSource(ExternalSemaSource &s1, // pin the vtable here. MultiplexExternalSemaSource::~MultiplexExternalSemaSource() {} -///\brief Appends new source to the source list. +///Appends new source to the source list. /// ///\param[in] source - An ExternalSemaSource. /// diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index b964cb2f0ef..eb336ee8f0f 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -395,7 +395,7 @@ ASTMutationListener *Sema::getASTMutationListener() const { return getASTConsumer().GetASTMutationListener(); } -///\brief Registers an external source. If an external source already exists, +///Registers an external source. If an external source already exists, /// creates a multiplex external source and appends to it. /// ///\param[in] E - A non-null external sema source. @@ -416,7 +416,7 @@ void Sema::addExternalSource(ExternalSemaSource *E) { } } -/// \brief Print out statistics about the semantic analysis. +/// Print out statistics about the semantic analysis. void Sema::PrintStats() const { llvm::errs() << "\n*** Semantic Analysis Stats:\n"; llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; @@ -536,7 +536,7 @@ CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { llvm_unreachable("unknown scalar type kind"); } -/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. +/// Used to prune the decls of Sema's UnusedFileScopedDecls vector. static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { if (D->getMostRecentDecl()->isUsed()) return true; @@ -724,7 +724,7 @@ void Sema::LoadExternalWeakUndeclaredIdentifiers() { typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap; -/// \brief Returns true, if all methods and nested classes of the given +/// Returns true, if all methods and nested classes of the given /// CXXRecordDecl are defined in this translation unit. /// /// Should only be called from ActOnEndOfTranslationUnit so that all @@ -764,7 +764,7 @@ static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, return Complete; } -/// \brief Returns true, if the given CXXRecordDecl is fully defined in this +/// Returns true, if the given CXXRecordDecl is fully defined in this /// translation unit, i.e. all methods are defined or pure virtual and all /// friends, friend functions and nested classes are fully defined in this /// translation unit. @@ -1310,7 +1310,7 @@ Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { return Builder; } -/// \brief Looks through the macro-expansion chain for the given +/// Looks through the macro-expansion chain for the given /// location, looking for a macro expansion with the given name. /// If one is found, returns true and sets the location to that /// expansion loc. @@ -1331,7 +1331,7 @@ bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { return false; } -/// \brief Determines the active Scope associated with the given declaration +/// Determines the active Scope associated with the given declaration /// context. /// /// This routine maps a declaration context to the active Scope object that @@ -1360,7 +1360,7 @@ Scope *Sema::getScopeForContext(DeclContext *Ctx) { return nullptr; } -/// \brief Enter a new function scope +/// Enter a new function scope void Sema::PushFunctionScope() { if (FunctionScopes.empty()) { // Use PreallocatedFunctionScope to avoid allocating memory when possible. @@ -1424,7 +1424,7 @@ void Sema::PopCompoundScope() { CurFunction->CompoundScopes.pop_back(); } -/// \brief Determine whether any errors occurred within this function/method/ +/// Determine whether any errors occurred within this function/method/ /// block. bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); @@ -1547,7 +1547,7 @@ void ExternalSemaSource::ReadUndefinedButUsed( void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {} -/// \brief Figure out if an expression could be turned into a call. +/// Figure out if an expression could be turned into a call. /// /// Use this when trying to recover from an error where the programmer may have /// written just the name of a function instead of actually calling it. @@ -1649,7 +1649,7 @@ bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, return false; } -/// \brief Give notes for a set of overloads. +/// Give notes for a set of overloads. /// /// A companion to tryExprAsCall. In cases when the name that the programmer /// wrote was an overloaded function, we may be able to make some guesses about diff --git a/clang/lib/Sema/SemaAccess.cpp b/clang/lib/Sema/SemaAccess.cpp index 98a918bd7d6..44d41ea4b05 100644 --- a/clang/lib/Sema/SemaAccess.cpp +++ b/clang/lib/Sema/SemaAccess.cpp @@ -1712,7 +1712,7 @@ Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, return CheckAccess(*this, OpLoc, Entity); } -/// \brief Checks access to a member. +/// Checks access to a member. Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc, CXXRecordDecl *NamingClass, DeclAccessPair Found) { diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp index 66c8e9c70ef..b2e03ad370a 100644 --- a/clang/lib/Sema/SemaAttr.cpp +++ b/clang/lib/Sema/SemaAttr.cpp @@ -389,7 +389,7 @@ bool Sema::UnifySection(StringRef SectionName, return false; } -/// \brief Called on well formed \#pragma bss_seg(). +/// Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, @@ -410,7 +410,7 @@ void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName); } -/// \brief Called on well formed \#pragma bss_seg(). +/// Called on well formed \#pragma bss_seg(). void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName) { UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation); diff --git a/clang/lib/Sema/SemaCUDA.cpp b/clang/lib/Sema/SemaCUDA.cpp index 99265efdaf0..c5deef8708e 100644 --- a/clang/lib/Sema/SemaCUDA.cpp +++ b/clang/lib/Sema/SemaCUDA.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// /// \file -/// \brief This file implements semantic analysis for CUDA constructs. +/// This file implements semantic analysis for CUDA constructs. /// //===----------------------------------------------------------------------===// diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp index 6da4d2a2619..61a82aa721c 100644 --- a/clang/lib/Sema/SemaCXXScopeSpec.cpp +++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp @@ -24,7 +24,7 @@ #include "llvm/ADT/STLExtras.h" using namespace clang; -/// \brief Find the current instantiation that associated with the given type. +/// Find the current instantiation that associated with the given type. static CXXRecordDecl *getCurrentInstantiationOf(QualType T, DeclContext *CurContext) { if (T.isNull()) @@ -44,7 +44,7 @@ static CXXRecordDecl *getCurrentInstantiationOf(QualType T, return nullptr; } -/// \brief Compute the DeclContext that is associated with the given type. +/// Compute the DeclContext that is associated with the given type. /// /// \param T the type for which we are attempting to find a DeclContext. /// @@ -59,7 +59,7 @@ DeclContext *Sema::computeDeclContext(QualType T) { return ::getCurrentInstantiationOf(T, CurContext); } -/// \brief Compute the DeclContext that is associated with the given +/// Compute the DeclContext that is associated with the given /// scope specifier. /// /// \param SS the C++ scope specifier as it appears in the source @@ -172,7 +172,7 @@ bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) { return SS.getScopeRep()->isDependent(); } -/// \brief If the given nested name specifier refers to the current +/// If the given nested name specifier refers to the current /// instantiation, return the declaration that corresponds to that /// current instantiation (C++0x [temp.dep.type]p1). /// @@ -188,7 +188,7 @@ CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) { return ::getCurrentInstantiationOf(T, CurContext); } -/// \brief Require that the context specified by SS be complete. +/// Require that the context specified by SS be complete. /// /// If SS refers to a type, this routine checks whether the type is /// complete enough (or can be made complete enough) for name lookup @@ -305,7 +305,7 @@ bool Sema::ActOnSuperScopeSpecifier(SourceLocation SuperLoc, return false; } -/// \brief Determines whether the given declaration is an valid acceptable +/// Determines whether the given declaration is an valid acceptable /// result for name lookup of a nested-name-specifier. /// \param SD Declaration checked for nested-name-specifier. /// \param IsExtension If not null and the declaration is accepted as an @@ -350,7 +350,7 @@ bool Sema::isAcceptableNestedNameSpecifier(const NamedDecl *SD, return false; } -/// \brief If the given nested-name-specifier begins with a bare identifier +/// If the given nested-name-specifier begins with a bare identifier /// (e.g., Base::), perform name lookup for that identifier as a /// nested-name-specifier within the given scope, and return the result of that /// name lookup. @@ -443,7 +443,7 @@ class NestedNameSpecifierValidatorCCC : public CorrectionCandidateCallback { } -/// \brief Build a new nested-name-specifier for "identifier::", as described +/// Build a new nested-name-specifier for "identifier::", as described /// by ActOnCXXNestedNameSpecifier. /// /// \param S Scope in which the nested-name-specifier occurs. @@ -967,7 +967,7 @@ bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, } namespace { - /// \brief A structure that stores a nested-name-specifier annotation, + /// A structure that stores a nested-name-specifier annotation, /// including both the nested-name-specifier struct NestedNameSpecifierAnnotation { NestedNameSpecifier *NNS; diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 8c5c789b29f..d0c00cc78a6 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -684,7 +684,7 @@ static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx) { return false; } -// \brief Performs semantic analysis for the read/write_pipe call. +// Performs semantic analysis for the read/write_pipe call. // \param S Reference to the semantic analyzer. // \param Call A pointer to the builtin call. // \return True if a semantic error has been found, false otherwise. @@ -738,7 +738,7 @@ static bool SemaBuiltinRWPipe(Sema &S, CallExpr *Call) { return false; } -// \brief Performs a semantic analysis on the {work_group_/sub_group_ +// Performs a semantic analysis on the {work_group_/sub_group_ // /_}reserve_{read/write}_pipe // \param S Reference to the semantic analyzer. // \param Call The call to the builtin function to be analyzed. @@ -767,7 +767,7 @@ static bool SemaBuiltinReserveRWPipe(Sema &S, CallExpr *Call) { return false; } -// \brief Performs a semantic analysis on {work_group_/sub_group_ +// Performs a semantic analysis on {work_group_/sub_group_ // /_}commit_{read/write}_pipe // \param S Reference to the semantic analyzer. // \param Call The call to the builtin function to be analyzed. @@ -790,7 +790,7 @@ static bool SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call) { return false; } -// \brief Performs a semantic analysis on the call to built-in Pipe +// Performs a semantic analysis on the call to built-in Pipe // Query Functions. // \param S Reference to the semantic analyzer. // \param Call The call to the builtin function to be analyzed. @@ -808,8 +808,8 @@ static bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call) { return false; } -// \brief OpenCL v2.0 s6.13.9 - Address space qualifier functions. -// \brief Performs semantic analysis for the to_global/local/private call. +// OpenCL v2.0 s6.13.9 - Address space qualifier functions. +// Performs semantic analysis for the to_global/local/private call. // \param S Reference to the semantic analyzer. // \param BuiltinID ID of the builtin function. // \param Call A pointer to the builtin call. @@ -2573,7 +2573,7 @@ bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, /// Checks if a the given expression evaluates to null. /// -/// \brief Returns true if the value evaluates to null. +/// Returns true if the value evaluates to null. static bool CheckNonNullExpr(Sema &S, const Expr *Expr) { // If the expression has non-null type, it doesn't evaluate to null. if (auto nullability @@ -2617,7 +2617,7 @@ bool Sema::GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx) { return false; } -/// \brief Diagnose use of %s directive in an NSString which is being passed +/// Diagnose use of %s directive in an NSString which is being passed /// as formatting string to formatting method. static void DiagnoseCStringFormatDirectiveInCFAPI(Sema &S, @@ -5706,7 +5706,7 @@ void CheckFormatHandler::EmitFormatDiagnostic(PartialDiagnostic PDiag, Loc, IsStringLocation, StringRange, FixIt); } -/// \brief If the format string is not within the function call, emit a note +/// If the format string is not within the function call, emit a note /// so that the function call and string are in diagnostic messages. /// /// \param InFunctionCall if true, the format string is within the function @@ -7319,7 +7319,7 @@ void Sema::CheckMaxUnsignedZero(const CallExpr *Call, //===--- CHECK: Standard memory functions ---------------------------------===// -/// \brief Takes the expression passed to the size_t parameter of functions +/// Takes the expression passed to the size_t parameter of functions /// such as memcmp, strncat, etc and warns if it's a comparison. /// /// This is to catch typos like `if (memcmp(&a, &b, sizeof(a) > 0))`. @@ -7350,7 +7350,7 @@ static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, return true; } -/// \brief Determine whether the given type is or contains a dynamic class type +/// Determine whether the given type is or contains a dynamic class type /// (e.g., whether it has a vtable). static const CXXRecordDecl *getContainedDynamicClass(QualType T, bool &IsContained) { @@ -7381,7 +7381,7 @@ static const CXXRecordDecl *getContainedDynamicClass(QualType T, return nullptr; } -/// \brief If E is a sizeof expression, returns its argument expression, +/// If E is a sizeof expression, returns its argument expression, /// otherwise returns NULL. static const Expr *getSizeOfExprArg(const Expr *E) { if (const UnaryExprOrTypeTraitExpr *SizeOf = @@ -7392,7 +7392,7 @@ static const Expr *getSizeOfExprArg(const Expr *E) { return nullptr; } -/// \brief If E is a sizeof expression, returns its argument type. +/// If E is a sizeof expression, returns its argument type. static QualType getSizeOfArgType(const Expr *E) { if (const UnaryExprOrTypeTraitExpr *SizeOf = dyn_cast<UnaryExprOrTypeTraitExpr>(E)) @@ -7494,7 +7494,7 @@ struct SearchNonTrivialToCopyField } -/// \brief Check for dangerous or invalid arguments to memset(). +/// Check for dangerous or invalid arguments to memset(). /// /// This issues warnings on known problematic, dangerous or unspecified /// arguments to the standard 'memset', 'memcpy', 'memmove', and 'memcmp' @@ -9077,7 +9077,7 @@ static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E) { AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc()); } -/// \brief Implements -Wsign-compare. +/// Implements -Wsign-compare. /// /// \param E the binary operator to check for warnings static void AnalyzeComparison(Sema &S, BinaryOperator *E) { @@ -10197,7 +10197,7 @@ static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc) { return false; } -/// \brief Diagnose pointers that are always non-null. +/// Diagnose pointers that are always non-null. /// \param E the expression containing the pointer /// \param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is /// compared to a null pointer @@ -10444,12 +10444,12 @@ void Sema::CheckForIntOverflow (Expr *E) { namespace { -/// \brief Visitor for expressions which looks for unsequenced operations on the +/// Visitor for expressions which looks for unsequenced operations on the /// same object. class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { using Base = EvaluatedExprVisitor<SequenceChecker>; - /// \brief A tree of sequenced regions within an expression. Two regions are + /// A tree of sequenced regions within an expression. Two regions are /// unsequenced if one is an ancestor or a descendent of the other. When we /// finish processing an expression with sequencing, such as a comma /// expression, we fold its tree nodes into its parent, since they are @@ -10463,7 +10463,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { SmallVector<Value, 8> Values; public: - /// \brief A region within an expression which may be sequenced with respect + /// A region within an expression which may be sequenced with respect /// to some other region. class Seq { friend class SequenceTree; @@ -10479,7 +10479,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { SequenceTree() { Values.push_back(Value(0)); } Seq root() const { return Seq(0); } - /// \brief Create a new sequence of operations, which is an unsequenced + /// Create a new sequence of operations, which is an unsequenced /// subset of \p Parent. This sequence of operations is sequenced with /// respect to other children of \p Parent. Seq allocate(Seq Parent) { @@ -10487,12 +10487,12 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { return Seq(Values.size() - 1); } - /// \brief Merge a sequence of operations into its parent. + /// Merge a sequence of operations into its parent. void merge(Seq S) { Values[S.Index].Merged = true; } - /// \brief Determine whether two operations are unsequenced. This operation + /// Determine whether two operations are unsequenced. This operation /// is asymmetric: \p Cur should be the more recent sequence, and \p Old /// should have been merged into its parent as appropriate. bool isUnsequenced(Seq Cur, Seq Old) { @@ -10507,7 +10507,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { } private: - /// \brief Pick a representative for a sequence. + /// Pick a representative for a sequence. unsigned representative(unsigned K) { if (Values[K].Merged) // Perform path compression as we go. @@ -10628,7 +10628,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { bool EvalOK = true; } *EvalTracker = nullptr; - /// \brief Find the object which is produced by the specified expression, + /// Find the object which is produced by the specified expression, /// if any. Object getObject(Expr *E, bool Mod) const { E = E->IgnoreParenCasts(); @@ -10650,7 +10650,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { return nullptr; } - /// \brief Note that an object was modified or used by an expression. + /// Note that an object was modified or used by an expression. void addUsage(UsageInfo &UI, Object O, Expr *Ref, UsageKind UK) { Usage &U = UI.Uses[UK]; if (!U.Use || !Tree.isUnsequenced(Region, U.Seq)) { @@ -10661,7 +10661,7 @@ class SequenceChecker : public EvaluatedExprVisitor<SequenceChecker> { } } - /// \brief Check whether a modification or use conflicts with a prior usage. + /// Check whether a modification or use conflicts with a prior usage. void checkUsage(Object O, UsageInfo &UI, Expr *Ref, UsageKind OtherKind, bool IsModMod) { if (UI.Diagnosed) @@ -11134,7 +11134,7 @@ void Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) { << TRange << Op->getSourceRange(); } -/// \brief Check whether this array fits the idiom of a size-one tail padded +/// Check whether this array fits the idiom of a size-one tail padded /// array member of a struct. /// /// We avoid emitting out-of-bounds access warnings for such arrays as they are @@ -12150,7 +12150,7 @@ void Sema::DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2); -/// \brief Check if two enumeration types are layout-compatible. +/// Check if two enumeration types are layout-compatible. static bool isLayoutCompatible(ASTContext &C, EnumDecl *ED1, EnumDecl *ED2) { // C++11 [dcl.enum] p8: // Two enumeration types are layout-compatible if they have the same @@ -12159,7 +12159,7 @@ static bool isLayoutCompatible(ASTContext &C, EnumDecl *ED1, EnumDecl *ED2) { C.hasSameType(ED1->getIntegerType(), ED2->getIntegerType()); } -/// \brief Check if two fields are layout-compatible. +/// Check if two fields are layout-compatible. static bool isLayoutCompatible(ASTContext &C, FieldDecl *Field1, FieldDecl *Field2) { if (!isLayoutCompatible(C, Field1->getType(), Field2->getType())) @@ -12180,7 +12180,7 @@ static bool isLayoutCompatible(ASTContext &C, FieldDecl *Field1, return true; } -/// \brief Check if two standard-layout structs are layout-compatible. +/// Check if two standard-layout structs are layout-compatible. /// (C++11 [class.mem] p17) static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2) { @@ -12224,7 +12224,7 @@ static bool isLayoutCompatibleStruct(ASTContext &C, RecordDecl *RD1, return true; } -/// \brief Check if two standard-layout unions are layout-compatible. +/// Check if two standard-layout unions are layout-compatible. /// (C++11 [class.mem] p18) static bool isLayoutCompatibleUnion(ASTContext &C, RecordDecl *RD1, RecordDecl *RD2) { @@ -12263,7 +12263,7 @@ static bool isLayoutCompatible(ASTContext &C, RecordDecl *RD1, return isLayoutCompatibleStruct(C, RD1, RD2); } -/// \brief Check if two types are layout-compatible in C++11 sense. +/// Check if two types are layout-compatible in C++11 sense. static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2) { if (T1.isNull() || T2.isNull()) return false; @@ -12301,7 +12301,7 @@ static bool isLayoutCompatible(ASTContext &C, QualType T1, QualType T2) { //===--- CHECK: pointer_with_type_tag attribute: datatypes should match ----// -/// \brief Given a type tag expression find the type tag itself. +/// Given a type tag expression find the type tag itself. /// /// \param TypeExpr Type tag expression, as it appears in user's code. /// @@ -12372,7 +12372,7 @@ static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, } } -/// \brief Retrieve the C type corresponding to type tag TypeExpr. +/// Retrieve the C type corresponding to type tag TypeExpr. /// /// \param TypeExpr Expression that specifies a type tag. /// diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp index 50ff17a2c2a..4ed9d491dd3 100644 --- a/clang/lib/Sema/SemaCodeComplete.cpp +++ b/clang/lib/Sema/SemaCodeComplete.cpp @@ -40,10 +40,10 @@ using namespace clang; using namespace sema; namespace { - /// \brief A container of code-completion results. + /// A container of code-completion results. class ResultBuilder { public: - /// \brief The type of a name-lookup filter, which can be provided to the + /// The type of a name-lookup filter, which can be provided to the /// name-lookup routines to specify which declarations should be included in /// the result set (when it returns true) and which declarations should be /// filtered out (returns false). @@ -52,27 +52,27 @@ namespace { typedef CodeCompletionResult Result; private: - /// \brief The actual results we have found. + /// The actual results we have found. std::vector<Result> Results; - /// \brief A record of all of the declarations we have found and placed + /// A record of all of the declarations we have found and placed /// into the result set, used to ensure that no declaration ever gets into /// the result set twice. llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound; typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair; - /// \brief An entry in the shadow map, which is optimized to store + /// An entry in the shadow map, which is optimized to store /// a single (declaration, index) mapping (the common case) but /// can also store a list of (declaration, index) mappings. class ShadowMapEntry { typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector; - /// \brief Contains either the solitary NamedDecl * or a vector + /// Contains either the solitary NamedDecl * or a vector /// of (declaration, index) pairs. llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector; - /// \brief When the entry contains a single declaration, this is + /// When the entry contains a single declaration, this is /// the index associated with that entry. unsigned SingleDeclIndex; @@ -115,53 +115,53 @@ namespace { iterator end() const; }; - /// \brief A mapping from declaration names to the declarations that have + /// A mapping from declaration names to the declarations that have /// this name within a particular scope and their index within the list of /// results. typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; - /// \brief The semantic analysis object for which results are being + /// The semantic analysis object for which results are being /// produced. Sema &SemaRef; - /// \brief The allocator used to allocate new code-completion strings. + /// The allocator used to allocate new code-completion strings. CodeCompletionAllocator &Allocator; CodeCompletionTUInfo &CCTUInfo; - /// \brief If non-NULL, a filter function used to remove any code-completion + /// If non-NULL, a filter function used to remove any code-completion /// results that are not desirable. LookupFilter Filter; - /// \brief Whether we should allow declarations as + /// Whether we should allow declarations as /// nested-name-specifiers that would otherwise be filtered out. bool AllowNestedNameSpecifiers; - /// \brief If set, the type that we would prefer our resulting value + /// If set, the type that we would prefer our resulting value /// declarations to have. /// /// Closely matching the preferred type gives a boost to a result's /// priority. CanQualType PreferredType; - /// \brief A list of shadow maps, which is used to model name hiding at + /// A list of shadow maps, which is used to model name hiding at /// different levels of, e.g., the inheritance hierarchy. std::list<ShadowMap> ShadowMaps; - /// \brief If we're potentially referring to a C++ member function, the set + /// If we're potentially referring to a C++ member function, the set /// of qualifiers applied to the object type. Qualifiers ObjectTypeQualifiers; - /// \brief Whether the \p ObjectTypeQualifiers field is active. + /// Whether the \p ObjectTypeQualifiers field is active. bool HasObjectTypeQualifiers; - /// \brief The selector that we prefer. + /// The selector that we prefer. Selector PreferredSelector; - /// \brief The completion context in which we are gathering results. + /// The completion context in which we are gathering results. CodeCompletionContext CompletionContext; - /// \brief If we are in an instance method definition, the \@implementation + /// If we are in an instance method definition, the \@implementation /// object. ObjCImplementationDecl *ObjCImplementation; @@ -199,17 +199,17 @@ namespace { } } - /// \brief Determine the priority for a reference to the given declaration. + /// Determine the priority for a reference to the given declaration. unsigned getBasePriority(const NamedDecl *D); - /// \brief Whether we should include code patterns in the completion + /// Whether we should include code patterns in the completion /// results. bool includeCodePatterns() const { return SemaRef.CodeCompleter && SemaRef.CodeCompleter->includeCodePatterns(); } - /// \brief Set the filter used for code-completion results. + /// Set the filter used for code-completion results. void setFilter(LookupFilter Filter) { this->Filter = Filter; } @@ -218,12 +218,12 @@ namespace { unsigned size() const { return Results.size(); } bool empty() const { return Results.empty(); } - /// \brief Specify the preferred type. + /// Specify the preferred type. void setPreferredType(QualType T) { PreferredType = SemaRef.Context.getCanonicalType(T); } - /// \brief Set the cv-qualifiers on the object type, for us in filtering + /// Set the cv-qualifiers on the object type, for us in filtering /// calls to member functions. /// /// When there are qualifiers in this set, they will be used to filter @@ -235,7 +235,7 @@ namespace { HasObjectTypeQualifiers = true; } - /// \brief Set the preferred selector. + /// Set the preferred selector. /// /// When an Objective-C method declaration result is added, and that /// method's selector matches this preferred selector, we give that method @@ -244,27 +244,27 @@ namespace { PreferredSelector = Sel; } - /// \brief Retrieve the code-completion context for which results are + /// Retrieve the code-completion context for which results are /// being collected. const CodeCompletionContext &getCompletionContext() const { return CompletionContext; } - /// \brief Specify whether nested-name-specifiers are allowed. + /// Specify whether nested-name-specifiers are allowed. void allowNestedNameSpecifiers(bool Allow = true) { AllowNestedNameSpecifiers = Allow; } - /// \brief Return the semantic analysis object for which we are collecting + /// Return the semantic analysis object for which we are collecting /// code completion results. Sema &getSema() const { return SemaRef; } - /// \brief Retrieve the allocator used to allocate code completion strings. + /// Retrieve the allocator used to allocate code completion strings. CodeCompletionAllocator &getAllocator() const { return Allocator; } CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; } - /// \brief Determine whether the given declaration is at all interesting + /// Determine whether the given declaration is at all interesting /// as a code-completion result. /// /// \param ND the declaration that we are inspecting. @@ -274,7 +274,7 @@ namespace { bool isInterestingDecl(const NamedDecl *ND, bool &AsNestedNameSpecifier) const; - /// \brief Check whether the result is hidden by the Hiding declaration. + /// Check whether the result is hidden by the Hiding declaration. /// /// \returns true if the result is hidden and cannot be found, false if /// the hidden result could still be found. When false, \p R may be @@ -283,7 +283,7 @@ namespace { bool CheckHiddenResult(Result &R, DeclContext *CurContext, const NamedDecl *Hiding); - /// \brief Add a new result to this result set (if it isn't already in one + /// Add a new result to this result set (if it isn't already in one /// of the shadow maps), or replace an existing result (for, e.g., a /// redeclaration). /// @@ -292,7 +292,7 @@ namespace { /// \param CurContext the context in which this result will be named. void MaybeAddResult(Result R, DeclContext *CurContext = nullptr); - /// \brief Add a new result to this result set, where we already know + /// Add a new result to this result set, where we already know /// the hiding declaration (if any). /// /// \param R the result to add (if it is unique). @@ -306,19 +306,19 @@ namespace { void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, bool InBaseClass); - /// \brief Add a new non-declaration result to this result set. + /// Add a new non-declaration result to this result set. void AddResult(Result R); - /// \brief Enter into a new scope. + /// Enter into a new scope. void EnterNewScope(); - /// \brief Exit from the current scope. + /// Exit from the current scope. void ExitScope(); - /// \brief Ignore this declaration, if it is seen again. + /// Ignore this declaration, if it is seen again. void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); } - /// \brief Add a visited context. + /// Add a visited context. void addVisitedContext(DeclContext *Ctx) { CompletionContext.addVisitedContext(Ctx); } @@ -439,7 +439,7 @@ ResultBuilder::ShadowMapEntry::end() const { return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end()); } -/// \brief Compute the qualification required to get from the current context +/// Compute the qualification required to get from the current context /// (\p CurContext) to the target context (\p TargetContext). /// /// \param Context the AST context in which the qualification will be used. @@ -603,7 +603,7 @@ bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, return false; } -/// \brief A simplified classification of types used to determine whether two +/// A simplified classification of types used to determine whether two /// types are "similar enough" when adjusting priorities. SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) { switch (T->getTypeClass()) { @@ -672,7 +672,7 @@ SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) { } } -/// \brief Get the type that a given expression will have if this declaration +/// Get the type that a given expression will have if this declaration /// is used as an expression in its "typical" code-completion form. QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) { ND = ND->getUnderlyingDecl(); @@ -1057,10 +1057,10 @@ void ResultBuilder::AddResult(Result R) { Results.push_back(R); } -/// \brief Enter into a new scope. +/// Enter into a new scope. void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); } -/// \brief Exit from the current scope. +/// Exit from the current scope. void ResultBuilder::ExitScope() { for (ShadowMap::iterator E = ShadowMaps.back().begin(), EEnd = ShadowMaps.back().end(); @@ -1071,7 +1071,7 @@ void ResultBuilder::ExitScope() { ShadowMaps.pop_back(); } -/// \brief Determines whether this given declaration will be found by +/// Determines whether this given declaration will be found by /// ordinary name lookup. bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const { ND = ND->getUnderlyingDecl(); @@ -1089,7 +1089,7 @@ bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const { return ND->getIdentifierNamespace() & IDNS; } -/// \brief Determines whether this given declaration will be found by +/// Determines whether this given declaration will be found by /// ordinary name lookup but is not a type name. bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const { ND = ND->getUnderlyingDecl(); @@ -1125,7 +1125,7 @@ bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const { return false; } -/// \brief Determines whether this given declaration will be found by +/// Determines whether this given declaration will be found by /// ordinary name lookup. bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const { ND = ND->getUnderlyingDecl(); @@ -1139,7 +1139,7 @@ bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const { !isa<ObjCPropertyDecl>(ND); } -/// \brief Determines whether the given declaration is suitable as the +/// Determines whether the given declaration is suitable as the /// start of a C++ nested-name-specifier, e.g., a class or namespace. bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const { // Allow us to find class templates, too. @@ -1149,12 +1149,12 @@ bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const { return SemaRef.isAcceptableNestedNameSpecifier(ND); } -/// \brief Determines whether the given declaration is an enumeration. +/// Determines whether the given declaration is an enumeration. bool ResultBuilder::IsEnum(const NamedDecl *ND) const { return isa<EnumDecl>(ND); } -/// \brief Determines whether the given declaration is a class or struct. +/// Determines whether the given declaration is a class or struct. bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const { // Allow us to find class templates, too. if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) @@ -1169,7 +1169,7 @@ bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const { return false; } -/// \brief Determines whether the given declaration is a union. +/// Determines whether the given declaration is a union. bool ResultBuilder::IsUnion(const NamedDecl *ND) const { // Allow us to find class templates, too. if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) @@ -1181,24 +1181,24 @@ bool ResultBuilder::IsUnion(const NamedDecl *ND) const { return false; } -/// \brief Determines whether the given declaration is a namespace. +/// Determines whether the given declaration is a namespace. bool ResultBuilder::IsNamespace(const NamedDecl *ND) const { return isa<NamespaceDecl>(ND); } -/// \brief Determines whether the given declaration is a namespace or +/// Determines whether the given declaration is a namespace or /// namespace alias. bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const { return isa<NamespaceDecl>(ND->getUnderlyingDecl()); } -/// \brief Determines whether the given declaration is a type. +/// Determines whether the given declaration is a type. bool ResultBuilder::IsType(const NamedDecl *ND) const { ND = ND->getUnderlyingDecl(); return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); } -/// \brief Determines which members of a class should be visible via +/// Determines which members of a class should be visible via /// "." or "->". Only value declarations, nested name specifiers, and /// using declarations thereof should show up. bool ResultBuilder::IsMember(const NamedDecl *ND) const { @@ -1279,14 +1279,14 @@ bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const { return false; } -/// \brief Determines whether the given declaration is an Objective-C +/// Determines whether the given declaration is an Objective-C /// instance variable. bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const { return isa<ObjCIvarDecl>(ND); } namespace { - /// \brief Visible declaration consumer that adds a code-completion result + /// Visible declaration consumer that adds a code-completion result /// for each visible declaration. class CodeCompletionDeclConsumer : public VisibleDeclConsumer { ResultBuilder &Results; @@ -1313,7 +1313,7 @@ namespace { }; } -/// \brief Add type specifiers for the current language as keyword results. +/// Add type specifiers for the current language as keyword results. static void AddTypeSpecifierResults(const LangOptions &LangOpts, ResultBuilder &Results) { typedef CodeCompletionResult Result; @@ -1522,12 +1522,12 @@ static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, return Policy; } -/// \brief Retrieve a printing policy suitable for code completion. +/// Retrieve a printing policy suitable for code completion. static PrintingPolicy getCompletionPrintingPolicy(Sema &S) { return getCompletionPrintingPolicy(S.Context, S.PP); } -/// \brief Retrieve the string representation of the given type as a string +/// Retrieve the string representation of the given type as a string /// that has the appropriate lifetime for code completion. /// /// This routine provides a fast path where we provide constant strings for @@ -1561,7 +1561,7 @@ static const char *GetCompletionTypeString(QualType T, return Allocator.CopyString(Result); } -/// \brief Add a completion for "this", if we're in a member function. +/// Add a completion for "this", if we're in a member function. static void addThisCompletion(Sema &S, ResultBuilder &Results) { QualType ThisTy = S.getCurrentThisType(); if (ThisTy.isNull()) @@ -1593,7 +1593,7 @@ static void AddStaticAssertResult(CodeCompletionBuilder &Builder, Results.AddResult(CodeCompletionResult(Builder.TakeString())); } -/// \brief Add language constructs that show up for "ordinary" names. +/// Add language constructs that show up for "ordinary" names. static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S, Sema &SemaRef, @@ -2139,7 +2139,7 @@ static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Results.AddResult(Result("operator")); } -/// \brief If the given declaration has an associated type, add it as a result +/// If the given declaration has an associated type, add it as a result /// type chunk. static void AddResultTypeChunk(ASTContext &Context, const PrintingPolicy &Policy, @@ -2238,7 +2238,7 @@ static std::string formatObjCParamQualifiers(unsigned ObjCQuals, return Result; } -/// \brief Tries to find the most appropriate type location for an Objective-C +/// Tries to find the most appropriate type location for an Objective-C /// block placeholder. /// /// This function ignores things like typedefs and qualifiers in order to @@ -2372,7 +2372,7 @@ static std::string FormatFunctionParameter(const PrintingPolicy &Policy, ObjCSubsts); } -/// \brief Returns a placeholder string that corresponds to an Objective-C block +/// Returns a placeholder string that corresponds to an Objective-C block /// declaration. /// /// \param BlockDecl A declaration with an Objective-C block type. @@ -2464,7 +2464,7 @@ static std::string GetDefaultValueString(const ParmVarDecl *Param, return " " + DefValue; } -/// \brief Add function parameter chunks to the given code completion string. +/// Add function parameter chunks to the given code completion string. static void AddFunctionParameterChunks(Preprocessor &PP, const PrintingPolicy &Policy, const FunctionDecl *Function, @@ -2518,7 +2518,7 @@ static void AddFunctionParameterChunks(Preprocessor &PP, } } -/// \brief Add template parameter chunks to the given code completion string. +/// Add template parameter chunks to the given code completion string. static void AddTemplateParameterChunks(ASTContext &Context, const PrintingPolicy &Policy, const TemplateDecl *Template, @@ -2599,7 +2599,7 @@ static void AddTemplateParameterChunks(ASTContext &Context, } } -/// \brief Add a qualifier to the given code-completion string, if the +/// Add a qualifier to the given code-completion string, if the /// provided nested-name-specifier is non-NULL. static void AddQualifierToCompletionString(CodeCompletionBuilder &Result, @@ -2658,7 +2658,7 @@ AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result, Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr)); } -/// \brief Add the name of the given declaration +/// Add the name of the given declaration static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy, const NamedDecl *ND, CodeCompletionBuilder &Result) { @@ -2742,7 +2742,7 @@ CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S, CCTUInfo, IncludeBriefComments); } -/// \brief If possible, create a new code completion string for the given +/// If possible, create a new code completion string for the given /// result. /// /// \returns Either a new, heap-allocated code completion string describing @@ -3042,7 +3042,7 @@ CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx, return Result.TakeString(); } -/// \brief Add function overload parameter chunks to the given code completion +/// Add function overload parameter chunks to the given code completion /// string. static void AddOverloadParameterChunks(ASTContext &Context, const PrintingPolicy &Policy, @@ -3366,7 +3366,7 @@ static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S, llvm_unreachable("Invalid ParserCompletionContext!"); } -/// \brief If we're in a C++ virtual member function, add completion results +/// If we're in a C++ virtual member function, add completion results /// that invoke the functions we override, since it's common to invoke the /// overridden function as well as adding new functionality. /// @@ -3661,7 +3661,7 @@ struct Sema::CodeCompleteExpressionData { SmallVector<Decl *, 4> IgnoreDecls; }; -/// \brief Perform code-completion in an expression context when we know what +/// Perform code-completion in an expression context when we know what /// type we're looking for. void Sema::CodeCompleteExpression(Scope *S, const CodeCompleteExpressionData &Data) { @@ -3719,11 +3719,11 @@ void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) { CodeCompleteObjCInstanceMessage(S, E.get(), None, false); } -/// \brief The set of properties that have already been added, referenced by +/// The set of properties that have already been added, referenced by /// property name. typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet; -/// \brief Retrieve the container definition, if any? +/// Retrieve the container definition, if any? static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) { if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) { if (Interface->hasDefinition()) @@ -3741,7 +3741,7 @@ static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) { return Container; } -/// \brief Adds a block invocation code completion result for the given block +/// Adds a block invocation code completion result for the given block /// declaration \p BD. static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy, CodeCompletionBuilder &Builder, @@ -4339,7 +4339,7 @@ static void mergeCandidatesWithResults(Sema &SemaRef, } } -/// \brief Get the type of the Nth parameter from a given set of overload +/// Get the type of the Nth parameter from a given set of overload /// candidates. static QualType getParamType(Sema &SemaRef, ArrayRef<ResultCandidate> Candidates, @@ -4946,7 +4946,7 @@ void Sema::CodeCompleteConstructorInitializer( Results.data(), Results.size()); } -/// \brief Determine whether this scope denotes a namespace. +/// Determine whether this scope denotes a namespace. static bool isNamespaceScope(Scope *S) { DeclContext *DC = S->getEntity(); if (!DC) @@ -5273,7 +5273,7 @@ void Sema::CodeCompleteObjCAtExpression(Scope *S) { Results.data(),Results.size()); } -/// \brief Determine whether the addition of the given flag to an Objective-C +/// Determine whether the addition of the given flag to an Objective-C /// property's attributes will cause a conflict. static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { // Check if we've already added this flag. @@ -5369,7 +5369,7 @@ void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { Results.data(),Results.size()); } -/// \brief Describes the kind of Objective-C method that we want to find +/// Describes the kind of Objective-C method that we want to find /// via code completion. enum ObjCMethodKind { MK_Any, ///< Any kind of method, provided it means other specified criteria. @@ -5410,12 +5410,12 @@ static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, } namespace { - /// \brief A set of selectors, which is used to avoid introducing multiple + /// A set of selectors, which is used to avoid introducing multiple /// completions with the same selector into the result set. typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet; } -/// \brief Add all of the Objective-C methods in the given Objective-C +/// Add all of the Objective-C methods in the given Objective-C /// container to the set of results. /// /// The container will be a class, protocol, category, or implementation of @@ -5660,7 +5660,7 @@ void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, Results.data(), Results.size()); } -/// \brief When we have an expression with type "id", we may assume +/// When we have an expression with type "id", we may assume /// that it has some more-specific class type based on knowledge of /// common uses of Objective-C. This routine returns that class type, /// or NULL if no better result could be determined. @@ -5952,7 +5952,7 @@ void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, /*IsSuper=*/true); } -/// \brief Given a set of code-completion results for the argument of a message +/// Given a set of code-completion results for the argument of a message /// send, determine the preferred type (if any) for that argument expression. static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, unsigned NumSelIdents) { @@ -6334,7 +6334,7 @@ void Sema::CodeCompleteObjCSelector(Scope *S, Results.data(), Results.size()); } -/// \brief Add all of the protocol declarations that we find in the given +/// Add all of the protocol declarations that we find in the given /// (translation unit) context. static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, bool OnlyForwardDeclarations, @@ -6399,7 +6399,7 @@ void Sema::CodeCompleteObjCProtocolDecl(Scope *) { Results.data(),Results.size()); } -/// \brief Add all of the Objective-C interface declarations that we find in +/// Add all of the Objective-C interface declarations that we find in /// the given (translation unit) context. static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, bool OnlyForwardDeclarations, @@ -6696,7 +6696,7 @@ void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S, typedef llvm::DenseMap< Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap; -/// \brief Find all of the methods that reside in the given container +/// Find all of the methods that reside in the given container /// (and its superclasses, protocols, etc.) that meet the given /// criteria. Insert those methods into the map of known methods, /// indexed by selector so they can be easily found. @@ -6784,7 +6784,7 @@ static void FindImplementableMethods(ASTContext &Context, } } -/// \brief Add the parenthesized return or parameter type chunk to a code +/// Add the parenthesized return or parameter type chunk to a code /// completion string. static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals, @@ -6800,7 +6800,7 @@ static void AddObjCPassingTypeChunk(QualType Type, Builder.AddChunk(CodeCompletionString::CK_RightParen); } -/// \brief Determine whether the given class is or inherits from a class by +/// Determine whether the given class is or inherits from a class by /// the given name. static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) { @@ -6813,7 +6813,7 @@ static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, return InheritsFromClassNamed(Class->getSuperClass(), Name); } -/// \brief Add code completions for Objective-C Key-Value Coding (KVC) and +/// Add code completions for Objective-C Key-Value Coding (KVC) and /// Key-Value Observing (KVO). static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property, bool IsInstanceMethod, diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp index 36d5523efec..aefea981e59 100644 --- a/clang/lib/Sema/SemaCoroutine.cpp +++ b/clang/lib/Sema/SemaCoroutine.cpp @@ -1438,7 +1438,7 @@ static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) { .get(); } -/// \brief Build a variable declaration for move parameter. +/// Build a variable declaration for move parameter. static VarDecl *buildVarDecl(Sema &S, SourceLocation Loc, QualType Type, IdentifierInfo *II) { TypeSourceInfo *TInfo = S.Context.getTrivialTypeSourceInfo(Type, Loc); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 62f658345a7..6df52d54b42 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -115,7 +115,7 @@ class TypeNameValidatorCCC : public CorrectionCandidateCallback { } // end anonymous namespace -/// \brief Determine whether the token kind starts a simple-type-specifier. +/// Determine whether the token kind starts a simple-type-specifier. bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { switch (Kind) { // FIXME: Take into account the current language when deciding whether a @@ -166,7 +166,7 @@ enum class UnqualifiedTypeNameLookupResult { }; } // end anonymous namespace -/// \brief Tries to perform unqualified lookup of the type decls in bases for +/// Tries to perform unqualified lookup of the type decls in bases for /// dependent class. /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a /// type decl, \a FoundType if only type decls are found. @@ -266,7 +266,7 @@ static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); } -/// \brief If the identifier refers to a type name within this scope, +/// If the identifier refers to a type name within this scope, /// return the declaration of that type. /// /// This routine performs ordinary name lookup of the identifier II @@ -760,7 +760,7 @@ void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, } } -/// \brief Determine whether the given result set contains either a type name +/// Determine whether the given result set contains either a type name /// or static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && @@ -1315,7 +1315,7 @@ void Sema::ActOnExitFunctionContext() { assert(CurContext && "Popped translation unit!"); } -/// \brief Determine whether we allow overloading of the function +/// Determine whether we allow overloading of the function /// PrevDecl with another declaration. /// /// This routine determines whether overloading is possible, not @@ -1501,7 +1501,7 @@ static void RemoveUsingDecls(LookupResult &R) { F.done(); } -/// \brief Check for this common pattern: +/// Check for this common pattern: /// @code /// class S { /// S(const S&); // DO NOT IMPLEMENT @@ -1838,7 +1838,7 @@ void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { } } -/// \brief Look for an Objective-C class in the translation unit. +/// Look for an Objective-C class in the translation unit. /// /// \param Id The name of the Objective-C class we're looking for. If /// typo-correction fixes this name, the Id will be updated @@ -1908,7 +1908,7 @@ Scope *Sema::getNonFieldDeclScope(Scope *S) { return S; } -/// \brief Looks up the declaration of "struct objc_super" and +/// Looks up the declaration of "struct objc_super" and /// saves it for later use in building builtin declaration of /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such /// pre-existing declaration exists no action takes place. @@ -2870,7 +2870,7 @@ static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { template<typename T> static bool isExternC(T *D) { return D->isExternC(); } static bool isExternC(VarTemplateDecl *) { return false; } -/// \brief Check whether a redeclaration of an entity introduced by a +/// Check whether a redeclaration of an entity introduced by a /// using-declaration is valid, given that we know it's not an overload /// (nor a hidden tag declaration). template<typename ExpectedDecl> @@ -3563,7 +3563,7 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, return true; } -/// \brief Completes the merge of two function declarations that are +/// Completes the merge of two function declarations that are /// known to be compatible. /// /// This routine handles the merging of attributes and other @@ -4938,7 +4938,7 @@ DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { return GetNameFromUnqualifiedId(D.getName()); } -/// \brief Retrieves the declaration name from a parsed unqualified-id. +/// Retrieves the declaration name from a parsed unqualified-id. DeclarationNameInfo Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { DeclarationNameInfo NameInfo; @@ -5225,7 +5225,7 @@ bool Sema::DiagnoseClassNameShadow(DeclContext *DC, return false; } -/// \brief Diagnose a declaration whose declarator-id has the given +/// Diagnose a declaration whose declarator-id has the given /// nested-name-specifier. /// /// \param SS The nested-name-specifier of the declarator-id. @@ -5663,7 +5663,7 @@ TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, return FixedTInfo; } -/// \brief Register the given locally-scoped extern "C" declaration so +/// Register the given locally-scoped extern "C" declaration so /// that it can be found later for redeclarations. We include any extern "C" /// declaration that is not visible in the translation unit here, not just /// function-scope declarations. @@ -5684,7 +5684,7 @@ NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { return Result.empty() ? nullptr : *Result.begin(); } -/// \brief Diagnose function specifiers on a declaration of an identifier that +/// Diagnose function specifiers on a declaration of an identifier that /// does not identify a function. void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { // FIXME: We should probably indicate the identifier in question to avoid @@ -5826,7 +5826,7 @@ Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, return NewTD; } -/// \brief Determines whether the given declaration is an out-of-scope +/// Determines whether the given declaration is an out-of-scope /// previous declaration. /// /// This routine should be invoked when name lookup has found a @@ -6251,7 +6251,7 @@ bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { return true; } -/// \brief Returns true if given declaration has external C language linkage. +/// Returns true if given declaration has external C language linkage. static bool isDeclExternC(const Decl *D) { if (const auto *FD = dyn_cast<FunctionDecl>(D)) return FD->isExternC(); @@ -6958,7 +6958,7 @@ static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, return !Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()); } -/// \brief Return the declaration shadowed by the given variable \p D, or null +/// Return the declaration shadowed by the given variable \p D, or null /// if it doesn't shadow any declaration or shadowing warnings are disabled. NamedDecl *Sema::getShadowedDeclaration(const VarDecl *D, const LookupResult &R) { @@ -6975,7 +6975,7 @@ NamedDecl *Sema::getShadowedDeclaration(const VarDecl *D, : nullptr; } -/// \brief Return the declaration shadowed by the given typedef \p D, or null +/// Return the declaration shadowed by the given typedef \p D, or null /// if it doesn't shadow any declaration or shadowing warnings are disabled. NamedDecl *Sema::getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R) { @@ -6990,7 +6990,7 @@ NamedDecl *Sema::getShadowedDeclaration(const TypedefNameDecl *D, return isa<TypedefNameDecl>(ShadowedDecl) ? ShadowedDecl : nullptr; } -/// \brief Diagnose variable or built-in function shadowing. Implements +/// Diagnose variable or built-in function shadowing. Implements /// -Wshadow. /// /// This method is called whenever a VarDecl is added to a "useful" @@ -7121,7 +7121,7 @@ void Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) { } } -/// \brief Check -Wshadow without the advantage of a previous lookup. +/// Check -Wshadow without the advantage of a previous lookup. void Sema::CheckShadow(Scope *S, VarDecl *D) { if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation())) return; @@ -7491,7 +7491,7 @@ void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { } } -/// \brief Perform semantic checking on a newly-created variable +/// Perform semantic checking on a newly-created variable /// declaration. /// /// This routine performs all of the type-checking required for a @@ -7562,7 +7562,7 @@ struct FindOverriddenMethod { enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; } // end anonymous namespace -/// \brief Report an error regarding overriding, along with any relevant +/// Report an error regarding overriding, along with any relevant /// overridden methods. /// /// \param DiagID the primary error to report. @@ -7678,7 +7678,7 @@ void Sema::MarkTypoCorrectedFunctionDefinition(const NamedDecl *F) { TypoCorrectedFunctionDefinitions.insert(F); } -/// \brief Generate diagnostics for an invalid function redeclaration. +/// Generate diagnostics for an invalid function redeclaration. /// /// This routine handles generating the diagnostic messages for an invalid /// function redeclaration, including finding possible similar declarations @@ -9156,7 +9156,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, return NewFD; } -/// \brief Checks if the new declaration declared in dependent context must be +/// Checks if the new declaration declared in dependent context must be /// put in the same redeclaration chain as the specified declaration. /// /// \param D Declaration that is checked. @@ -9182,7 +9182,7 @@ bool Sema::shouldLinkDependentDeclWithPrevious(Decl *D, Decl *PrevDecl) { D->getFriendObjectKind() != Decl::FOK_None); } -/// \brief Check the target attribute of the function for MultiVersion +/// Check the target attribute of the function for MultiVersion /// validity. /// /// Returns true if there was an error, false otherwise. @@ -9333,7 +9333,7 @@ static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, return false; } -/// \brief Check the validity of a mulitversion function declaration. +/// Check the validity of a mulitversion function declaration. /// Also sets the multiversion'ness' of the function itself. /// /// This sets NewFD->isInvalidDecl() to true if there was an error. @@ -9517,7 +9517,7 @@ static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, return false; } -/// \brief Perform semantic checking of a new function declaration. +/// Perform semantic checking of a new function declaration. /// /// Performs semantic analysis of the new function declaration /// NewFD. This routine performs all semantic checking that does not @@ -11564,7 +11564,7 @@ void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { Context.addModuleInitializer(ModuleScopes.back().Module, var); } -/// \brief Determines if a variable's alignment is dependent. +/// Determines if a variable's alignment is dependent. static bool hasDependentAlignment(VarDecl *VD) { if (VD->getType()->isDependentType()) return true; @@ -12081,7 +12081,7 @@ Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { return New; } -/// \brief Synthesizes a variable for a parameter arising from a +/// Synthesizes a variable for a parameter arising from a /// typedef. ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, @@ -12584,7 +12584,7 @@ Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, return D; } -/// \brief Given the set of return statements within a function body, +/// Given the set of return statements within a function body, /// compute the variables that are subject to the named return value /// optimization. /// @@ -13089,7 +13089,7 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, return FD; } -/// \brief Adds any function attributes that we know a priori based on +/// Adds any function attributes that we know a priori based on /// the declaration of this function. /// /// These attributes can apply both to implicitly-declared builtins @@ -13281,7 +13281,7 @@ TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, return NewTD; } -/// \brief Check that this is a valid underlying type for an enum declaration. +/// Check that this is a valid underlying type for an enum declaration. bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); QualType T = TI->getType(); @@ -13331,7 +13331,7 @@ bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, return false; } -/// \brief Get diagnostic %select index for tag kind for +/// Get diagnostic %select index for tag kind for /// redeclaration diagnostic message. /// WARNING: Indexes apply to particular diagnostics only! /// @@ -13345,7 +13345,7 @@ static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { } } -/// \brief Determine if tag kind is a class-key compatible with +/// Determine if tag kind is a class-key compatible with /// class for redeclaration (class, struct, or __interface). /// /// \returns true iff the tag kind is compatible. @@ -13379,7 +13379,7 @@ Sema::NonTagKind Sema::getNonTagTypeDeclKind(const Decl *PrevDecl, llvm_unreachable("invalid TTK"); } -/// \brief Determine whether a tag with a given kind is acceptable +/// Determine whether a tag with a given kind is acceptable /// as a redeclaration of the given tag declaration. /// /// \returns true if the new tag kind is acceptable, false otherwise. @@ -13515,7 +13515,7 @@ static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, return FixItHint::CreateInsertion(NameLoc, Insertion); } -/// \brief Determine whether a tag originally declared in context \p OldDC can +/// Determine whether a tag originally declared in context \p OldDC can /// be redeclared with an unqualified name in \p NewDC (assuming name lookup /// found a declaration in \p OldDC as a previous decl, perhaps through a /// using-declaration). @@ -13536,7 +13536,7 @@ static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, return false; } -/// \brief This is invoked when we see 'struct foo' or 'struct {'. In the +/// This is invoked when we see 'struct foo' or 'struct {'. In the /// former case, Name will be non-null. In the later case, Name will be null. /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a /// reference/declaration/definition of a tag. @@ -14838,7 +14838,7 @@ FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, return NewFD; } -/// \brief Build a new FieldDecl and check its well-formedness. +/// Build a new FieldDecl and check its well-formedness. /// /// This routine builds a new FieldDecl given the fields name, type, /// record, etc. \p PrevDecl should refer to any previous declaration @@ -15708,7 +15708,7 @@ void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ProcessDeclAttributeList(S, Record, Attr); } -/// \brief Determine whether the given integral value is representable within +/// Determine whether the given integral value is representable within /// the given type T. static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, @@ -15725,7 +15725,7 @@ static bool isRepresentableIntegerValue(ASTContext &Context, return Value.getMinSignedBits() <= BitWidth; } -// \brief Given an integral type, return the next larger integral type +// Given an integral type, return the next larger integral type // (or a NULL type of no such type exists). static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { // FIXME: Int128/UInt128 support, which also needs to be introduced into diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index fd1cfc14d87..be69e15d6d7 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -59,7 +59,7 @@ static bool isFunctionOrMethod(const Decl *D) { return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D); } -/// \brief Return true if the given decl has function type (function or +/// Return true if the given decl has function type (function or /// function-typed variable) or an Objective-C method or a block. static bool isFunctionOrMethodOrBlock(const Decl *D) { return isFunctionOrMethod(D) || isa<BlockDecl>(D); @@ -189,7 +189,7 @@ static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &AL, return true; } -/// \brief Check if the attribute has exactly as many args as Num. May +/// Check if the attribute has exactly as many args as Num. May /// output an error. static bool checkAttributeNumArgs(Sema &S, const AttributeList &AL, unsigned Num) { @@ -198,7 +198,7 @@ static bool checkAttributeNumArgs(Sema &S, const AttributeList &AL, std::not_equal_to<unsigned>()); } -/// \brief Check if the attribute has at least as many args as Num. May +/// Check if the attribute has at least as many args as Num. May /// output an error. static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &AL, unsigned Num) { @@ -207,7 +207,7 @@ static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &AL, std::less<unsigned>()); } -/// \brief Check if the attribute has at most as many args as Num. May +/// Check if the attribute has at most as many args as Num. May /// output an error. static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &AL, unsigned Num) { @@ -216,7 +216,7 @@ static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &AL, std::greater<unsigned>()); } -/// \brief A helper function to provide Attribute Location for the Attr types +/// A helper function to provide Attribute Location for the Attr types /// AND the AttributeList. template <typename AttrInfo> static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value, @@ -228,7 +228,7 @@ static SourceLocation getAttrLoc(const AttributeList &AL) { return AL.getLoc(); } -/// \brief A helper function to provide Attribute Name for the Attr types +/// A helper function to provide Attribute Name for the Attr types /// AND the AttributeList. template <typename AttrInfo> static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value, @@ -240,7 +240,7 @@ static const IdentifierInfo *getAttrName(const AttributeList &AL) { return AL.getName(); } -/// \brief If Expr is a valid integer constant, get the value of the integer +/// If Expr is a valid integer constant, get the value of the integer /// expression and return success or failure. May output an error. template <typename AttrInfo> static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr, @@ -269,7 +269,7 @@ static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr, return true; } -/// \brief Wrapper around checkUInt32Argument, with an extra check to be sure +/// Wrapper around checkUInt32Argument, with an extra check to be sure /// that the result will fit into a regular (signed) int. All args have the same /// purpose as they do in checkUInt32Argument. template <typename AttrInfo> @@ -291,7 +291,7 @@ static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Ex return true; } -/// \brief Diagnose mutually exclusive attributes when present on a given +/// Diagnose mutually exclusive attributes when present on a given /// declaration. Returns true if diagnosed. template <typename AttrTy> static bool checkAttrMutualExclusion(Sema &S, Decl *D, SourceRange Range, @@ -305,7 +305,7 @@ static bool checkAttrMutualExclusion(Sema &S, Decl *D, SourceRange Range, return false; } -/// \brief Check if IdxExpr is a valid parameter index for a function or +/// Check if IdxExpr is a valid parameter index for a function or /// instance method D. May output an error. /// /// \returns true if IdxExpr is a valid index. @@ -351,7 +351,7 @@ static bool checkFunctionOrMethodParameterIndex( return true; } -/// \brief Check if the argument \p ArgNum of \p Attr is a ASCII string literal. +/// Check if the argument \p ArgNum of \p Attr is a ASCII string literal. /// If not emit an error and return false. If the argument is an identifier it /// will emit an error with a fixit hint and treat it as if it was a string /// literal. @@ -387,7 +387,7 @@ bool Sema::checkStringLiteralArgumentAttr(const AttributeList &AL, return true; } -/// \brief Applies the given attribute to the Decl without performing any +/// Applies the given attribute to the Decl without performing any /// additional semantic checking. template <typename AttrType> static void handleSimpleAttribute(Sema &S, Decl *D, const AttributeList &AL) { @@ -401,7 +401,7 @@ static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D, handleSimpleAttribute<AttrType>(S, D, AL); } -/// \brief Applies the given attribute to the Decl so long as the Decl doesn't +/// Applies the given attribute to the Decl so long as the Decl doesn't /// already have one of the given incompatible attributes. template <typename AttrType, typename IncompatibleAttrType, typename... IncompatibleAttrTypes> @@ -414,7 +414,7 @@ static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D, AL); } -/// \brief Check if the passed-in expression is of type int or bool. +/// Check if the passed-in expression is of type int or bool. static bool isIntOrBool(Expr *Exp) { QualType QT = Exp->getType(); return QT->isBooleanType() || QT->isIntegerType(); @@ -437,7 +437,7 @@ static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) { return true; } -/// \brief Check if passed in Decl is a pointer type. +/// Check if passed in Decl is a pointer type. /// Note that this function may produce an error message. /// \return true if the Decl is a pointer type; false otherwise static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, @@ -463,7 +463,7 @@ static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, return false; } -/// \brief Checks that the passed in QualType either is of RecordType or points +/// Checks that the passed in QualType either is of RecordType or points /// to RecordType. Returns the relevant RecordType, null if it does not exit. static const RecordType *getRecordType(QualType QT) { if (const auto *RT = QT->getAs<RecordType>()) @@ -555,7 +555,7 @@ static bool isCapabilityExpr(Sema &S, const Expr *Ex) { return typeHasCapability(S, Ex->getType()); } -/// \brief Checks that all attribute arguments, starting from Sidx, resolve to +/// Checks that all attribute arguments, starting from Sidx, resolve to /// a capability object. /// \param Sidx The attribute argument index to start checking with. /// \param ParamIdxOk Whether an argument can be indexing into a function @@ -765,7 +765,7 @@ static void handleAssertExclusiveLockAttr(Sema &S, Decl *D, AL.getAttributeSpellingListIndex())); } -/// \brief Checks to be sure that the given parameter number is in bounds, and +/// Checks to be sure that the given parameter number is in bounds, and /// is an integral type. Will emit appropriate diagnostics if this returns /// false. /// @@ -2137,7 +2137,7 @@ static bool checkAvailabilityAttr(Sema &S, SourceRange Range, return false; } -/// \brief Check whether the two versions match. +/// Check whether the two versions match. /// /// If either version tuple is empty, then they are assumed to match. If /// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y. @@ -6795,7 +6795,7 @@ ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message) { } -/// \brief whether we should emit a diagnostic for \c K and \c DeclVersion in +/// whether we should emit a diagnostic for \c K and \c DeclVersion in /// the context of \c Ctx. For example, we should emit an unavailable diagnostic /// in a deprecated context, but not the other way around. static bool ShouldDiagnoseAvailabilityInContext(Sema &S, AvailabilityResult K, @@ -7362,7 +7362,7 @@ public: } }; -/// \brief This class implements -Wunguarded-availability. +/// This class implements -Wunguarded-availability. /// /// This is done with a traversal of the AST of a function that makes reference /// to a partially available declaration. Whenever we encounter an \c if of the diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 1ad8ee3469b..fc2c1474159 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -1457,7 +1457,7 @@ void Sema::CheckCompleteDecompositionDeclaration(DecompositionDecl *DD) { DD->setInvalidDecl(); } -/// \brief Merge the exception specifications of two variable declarations. +/// Merge the exception specifications of two variable declarations. /// /// This is called when there's a redeclaration of a VarDecl. The function /// checks if the redeclaration might have an exception specification and @@ -1573,7 +1573,7 @@ static bool CheckConstexprParameterTypes(Sema &SemaRef, return true; } -/// \brief Get diagnostic %select index for tag kind for +/// Get diagnostic %select index for tag kind for /// record diagnostic message. /// WARNING: Indexes apply to particular diagnostics only! /// @@ -2079,7 +2079,7 @@ bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *, return false; } -/// \brief Determine whether the identifier II is a typo for the name of +/// Determine whether the identifier II is a typo for the name of /// the class type currently being defined. If so, update it to the identifier /// that should have been used. bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) { @@ -2105,7 +2105,7 @@ bool Sema::isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS) { return false; } -/// \brief Determine whether the given class is a base class of the given +/// Determine whether the given class is a base class of the given /// class, including looking at dependent bases. static bool findCircularInheritance(const CXXRecordDecl *Class, const CXXRecordDecl *Current) { @@ -2137,7 +2137,7 @@ static bool findCircularInheritance(const CXXRecordDecl *Class, return false; } -/// \brief Check the validity of a C++ base class specifier. +/// Check the validity of a C++ base class specifier. /// /// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics /// and returns NULL otherwise. @@ -2324,7 +2324,7 @@ Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, /// locally, there's no need to abstract the small size parameter. typedef llvm::SmallPtrSet<QualType, 4> IndirectBaseSet; -/// \brief Recursively add the bases of Type. Don't add Type itself. +/// Recursively add the bases of Type. Don't add Type itself. static void NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, const QualType &Type) @@ -2345,7 +2345,7 @@ NoteIndirectBases(ASTContext &Context, IndirectBaseSet &Set, } } -/// \brief Performs the actual work of attaching the given base class +/// Performs the actual work of attaching the given base class /// specifiers to a C++ class. bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, MutableArrayRef<CXXBaseSpecifier *> Bases) { @@ -2464,7 +2464,7 @@ void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl), Bases); } -/// \brief Determine whether the type \p Derived is a C++ class that is +/// Determine whether the type \p Derived is a C++ class that is /// derived from the type \p Base. bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) { if (!getLangOpts().CPlusPlus) @@ -2491,7 +2491,7 @@ bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) { return DerivedRD->isDerivedFrom(BaseRD); } -/// \brief Determine whether the type \p Derived is a C++ class that is +/// Determine whether the type \p Derived is a C++ class that is /// derived from the type \p Base. bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base, CXXBasePaths &Paths) { @@ -2643,7 +2643,7 @@ Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, } -/// @brief Builds a string representing ambiguous paths from a +/// Builds a string representing ambiguous paths from a /// specific derived class to different subobjects of the same base /// class. /// @@ -3551,7 +3551,7 @@ namespace { } } // namespace -/// \brief Enter a new C++ default initializer scope. After calling this, the +/// Enter a new C++ default initializer scope. After calling this, the /// caller must call \ref ActOnFinishCXXInClassMemberInitializer, even if /// parsing or instantiating the initializer failed. void Sema::ActOnStartCXXInClassMemberInitializer() { @@ -3560,7 +3560,7 @@ void Sema::ActOnStartCXXInClassMemberInitializer() { PushFunctionScope(); } -/// \brief This is invoked after parsing an in-class initializer for a +/// This is invoked after parsing an in-class initializer for a /// non-static C++ class member, and after instantiating an in-class initializer /// in a class template. Such actions are deferred until the class is complete. void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D, @@ -3617,7 +3617,7 @@ void Sema::ActOnFinishCXXInClassMemberInitializer(Decl *D, FD->setInClassInitializer(InitExpr); } -/// \brief Find the direct and/or virtual base specifiers that +/// Find the direct and/or virtual base specifiers that /// correspond to the given base type, for use in base initialization /// within a constructor. static bool FindBaseInitializer(Sema &SemaRef, @@ -3661,7 +3661,7 @@ static bool FindBaseInitializer(Sema &SemaRef, return DirectBaseSpec || VirtualBaseSpec; } -/// \brief Handle a C++ member initializer using braced-init-list syntax. +/// Handle a C++ member initializer using braced-init-list syntax. MemInitResult Sema::ActOnMemInitializer(Decl *ConstructorD, Scope *S, @@ -3677,7 +3677,7 @@ Sema::ActOnMemInitializer(Decl *ConstructorD, EllipsisLoc); } -/// \brief Handle a C++ member initializer using parentheses syntax. +/// Handle a C++ member initializer using parentheses syntax. MemInitResult Sema::ActOnMemInitializer(Decl *ConstructorD, Scope *S, @@ -3720,7 +3720,7 @@ private: } -/// \brief Handle a C++ member initializer. +/// Handle a C++ member initializer. MemInitResult Sema::BuildMemInitializer(Decl *ConstructorD, Scope *S, @@ -4548,7 +4548,7 @@ struct BaseAndFieldInfo { return !FieldRD->hasInClassInitializer(); } - /// \brief Determine whether the given field is, or is within, a union member + /// Determine whether the given field is, or is within, a union member /// that is inactive (because there was an initializer given for a different /// member of the union, or because the union was not initialized at all). bool isWithinInactiveUnionMember(FieldDecl *Field, @@ -4566,7 +4566,7 @@ struct BaseAndFieldInfo { }; } -/// \brief Determine whether the given type is an incomplete or zero-lenfgth +/// Determine whether the given type is an incomplete or zero-lenfgth /// array type. static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) { if (T->isIncompleteArrayType()) @@ -5576,7 +5576,7 @@ static void checkForMultipleExportedDefaultConstructors(Sema &S, } } -/// \brief Check class-level dllimport/dllexport attribute. +/// Check class-level dllimport/dllexport attribute. void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) { Attr *ClassAttr = getDLLAttr(Class); @@ -5707,7 +5707,7 @@ void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) { DelayedDllExportClasses.push_back(Class); } -/// \brief Perform propagation of DLL attributes from a derived class to a +/// Perform propagation of DLL attributes from a derived class to a /// templated base class for MS compatibility. void Sema::propagateDLLAttrToBaseClassTemplate( CXXRecordDecl *Class, Attr *ClassAttr, @@ -5916,7 +5916,7 @@ computeArgPassingRestrictions(bool DestroyedInCallee, const CXXRecordDecl *RD, return RecordDecl::APK_CannotPassInRegs; } -/// \brief Perform semantic checks on a class definition that has been +/// Perform semantic checks on a class definition that has been /// completing, introducing implicitly-declared members, checking for /// abstract types, etc. void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) { @@ -7637,7 +7637,7 @@ public: }; } // end anonymous namespace -/// \brief Add the most overriden methods from MD to Methods +/// Add the most overriden methods from MD to Methods static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) { if (MD->size_overridden_methods() == 0) @@ -7647,7 +7647,7 @@ static void AddMostOverridenMethods(const CXXMethodDecl *MD, AddMostOverridenMethods(O, Methods); } -/// \brief Check if a method overloads virtual methods in a base class without +/// Check if a method overloads virtual methods in a base class without /// overriding any. void Sema::FindHiddenVirtualMethods(CXXMethodDecl *MD, SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods) { @@ -7688,7 +7688,7 @@ void Sema::NoteHiddenVirtualMethods(CXXMethodDecl *MD, } } -/// \brief Diagnose methods which overload virtual methods in a base class +/// Diagnose methods which overload virtual methods in a base class /// without overriding any. void Sema::DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD) { if (MD->isInvalidDecl()) @@ -8656,7 +8656,7 @@ void Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R, // Namespace Handling //===----------------------------------------------------------------------===// -/// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is +/// Diagnose a mismatch in 'inline' qualifiers when a namespace is /// reopened. static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc, SourceLocation Loc, @@ -9022,7 +9022,7 @@ QualType Sema::CheckComparisonCategoryType(ComparisonCategoryType Kind, return Info->getType(); } -/// \brief Retrieve the special "std" namespace, which may require us to +/// Retrieve the special "std" namespace, which may require us to /// implicitly define the namespace. NamespaceDecl *Sema::getOrCreateStdNamespace() { if (!StdNamespace) { @@ -9165,7 +9165,7 @@ bool Sema::isInitListConstructor(const FunctionDecl *Ctor) { return isStdInitializerList(ArgType, nullptr); } -/// \brief Determine whether a using statement is in a context where it will be +/// Determine whether a using statement is in a context where it will be /// apply in all contexts. static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) { switch (CurContext->getDeclKind()) { @@ -9405,7 +9405,7 @@ Decl *Sema::ActOnUsingDeclaration(Scope *S, return UD; } -/// \brief Determine whether a using declaration considers the given +/// Determine whether a using declaration considers the given /// declarations as "equivalent", e.g., if they are redeclarations of /// the same entity or are both typedefs of the same type. static bool @@ -10727,7 +10727,7 @@ struct DeclaringSpecialMember { } } - /// \brief Are we already trying to declare this special member? + /// Are we already trying to declare this special member? bool isAlreadyBeingDeclared() const { return WasAlreadyBeingDeclared; } @@ -11135,7 +11135,7 @@ void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation, } } -/// \brief Perform any semantic analysis which needs to be delayed until all +/// Perform any semantic analysis which needs to be delayed until all /// pending class member declarations have been parsed. void Sema::ActOnFinishCXXMemberDecls() { // If the context is an invalid C++ class, just suppress these checks. @@ -11194,7 +11194,7 @@ void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, } namespace { -/// \brief An abstract base class for all helper classes used in building the +/// An abstract base class for all helper classes used in building the // copy/move operators. These classes serve as factory functions and help us // avoid using the same Expr* in the AST twice. class ExprBuilder { @@ -11379,7 +11379,7 @@ buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T, return Call.getAs<Stmt>(); } -/// \brief Builds a statement that copies/moves the given entity from \p From to +/// Builds a statement that copies/moves the given entity from \p From to /// \c To. /// /// This routine is used to copy/move the members of a class with an @@ -12688,7 +12688,7 @@ void Sema::DefineImplicitLambdaToBlockPointerConversion( } } -/// \brief Determine whether the given list arguments contains exactly one +/// Determine whether the given list arguments contains exactly one /// "real" (non-default) argument. static bool hasOneRealArgument(MultiExprArg Args) { switch (Args.size()) { @@ -12899,7 +12899,7 @@ void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) { Diag(VD->getLocation(), diag::warn_global_destructor); } -/// \brief Given a constructor and the set of arguments provided for the +/// Given a constructor and the set of arguments provided for the /// constructor, convert the arguments and add any required default arguments /// to form a proper call to this constructor. /// @@ -13500,7 +13500,7 @@ Decl *Sema::ActOnEmptyDeclaration(Scope *S, return ED; } -/// \brief Perform semantic analysis for the variable declaration that +/// Perform semantic analysis for the variable declaration that /// occurs within a C++ catch clause, returning the newly-created /// variable. VarDecl *Sema::BuildExceptionDeclaration(Scope *S, @@ -13756,7 +13756,7 @@ Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc, return Decl; } -/// \brief Perform semantic analysis of the given friend type declaration. +/// Perform semantic analysis of the given friend type declaration. /// /// \returns A friend declaration that. FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, @@ -14647,7 +14647,7 @@ bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New, return false; } -/// \brief Mark the given method pure. +/// Mark the given method pure. /// /// \param Method the method to be marked pure. /// @@ -14677,7 +14677,7 @@ void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) { Diag(D->getLocation(), diag::err_illegal_initializer); } -/// \brief Determine whether the given declaration is a global variable or +/// Determine whether the given declaration is a global variable or /// static data member. static bool isNonlocalVariable(const Decl *D) { if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(D)) @@ -15098,7 +15098,7 @@ void Sema::CheckDelegatingCtorCycles() { } namespace { - /// \brief AST visitor that finds references to the 'this' expression. + /// AST visitor that finds references to the 'this' expression. class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> { Sema &S; diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp index e1eed827167..87d37e68257 100644 --- a/clang/lib/Sema/SemaDeclObjC.cpp +++ b/clang/lib/Sema/SemaDeclObjC.cpp @@ -202,7 +202,7 @@ void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, } } -/// \brief Check a method declaration for compatibility with the Objective-C +/// Check a method declaration for compatibility with the Objective-C /// ARC conventions. bool Sema::CheckARCMethodDecl(ObjCMethodDecl *method) { ObjCMethodFamily family = method->getMethodFamily(); @@ -3366,7 +3366,7 @@ void Sema::addMethodToGlobalList(ObjCMethodList *List, Previous->setNext(new (Mem) ObjCMethodList(Method)); } -/// \brief Read the contents of the method pool for a given selector from +/// Read the contents of the method pool for a given selector from /// external storage. void Sema::ReadMethodPool(Selector Sel) { assert(ExternalSource && "We need an external AST source"); @@ -4105,7 +4105,7 @@ CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) { return (Decl::ObjCDeclQualifier) (unsigned) PQTVal; } -/// \brief Check whether the declared result type of the given Objective-C +/// Check whether the declared result type of the given Objective-C /// method declaration is compatible with the method's class. /// static Sema::ResultTypeCompatibilityKind @@ -4817,7 +4817,7 @@ void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, } } -/// \brief Build a type-check a new Objective-C exception variable declaration. +/// Build a type-check a new Objective-C exception variable declaration. VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T, SourceLocation StartLoc, SourceLocation IdLoc, diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 8522c04e73b..ee9e35e660b 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -48,7 +48,7 @@ using namespace clang; using namespace sema; -/// \brief Determine whether the use of this declaration is valid, without +/// Determine whether the use of this declaration is valid, without /// emitting diagnostics. bool Sema::CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid) { // See if this is an auto-typed variable whose initializer we are parsing. @@ -89,7 +89,7 @@ static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc) { } } -/// \brief Emit a note explaining that this function is deleted. +/// Emit a note explaining that this function is deleted. void Sema::NoteDeletedFunction(FunctionDecl *Decl) { assert(Decl->isDeleted()); @@ -117,7 +117,7 @@ void Sema::NoteDeletedFunction(FunctionDecl *Decl) { << Decl << true; } -/// \brief Determine whether a FunctionDecl was ever declared with an +/// Determine whether a FunctionDecl was ever declared with an /// explicit storage class. static bool hasAnyExplicitStorageClass(const FunctionDecl *D) { for (auto I : D->redecls()) { @@ -127,7 +127,7 @@ static bool hasAnyExplicitStorageClass(const FunctionDecl *D) { return false; } -/// \brief Check whether we're in an extern inline function and referring to a +/// Check whether we're in an extern inline function and referring to a /// variable or function with internal linkage (C11 6.7.4p3). /// /// This is only a warning because we used to silently accept this code, but @@ -190,7 +190,7 @@ void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) { } } -/// \brief Determine whether the use of this declaration is valid, and +/// Determine whether the use of this declaration is valid, and /// emit any corresponding diagnostics. /// /// This routine diagnoses various problems with referencing @@ -300,7 +300,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, return false; } -/// \brief Retrieve the message suffix that should be added to a +/// Retrieve the message suffix that should be added to a /// diagnostic complaining about the given function being deleted or /// unavailable. std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { @@ -917,7 +917,7 @@ ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, return E; } -/// \brief Converts an integer to complex float type. Helper function of +/// Converts an integer to complex float type. Helper function of /// UsualArithmeticConversions() /// /// \return false if the integer expression is an integer type and is @@ -942,7 +942,7 @@ static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, return false; } -/// \brief Handle arithmetic conversion with complex types. Helper function of +/// Handle arithmetic conversion with complex types. Helper function of /// UsualArithmeticConversions() static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, @@ -998,7 +998,7 @@ static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, return ResultType; } -/// \brief Handle arithmetic conversion from integer to float. Helper function +/// Handle arithmetic conversion from integer to float. Helper function /// of UsualArithmeticConversions() static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, @@ -1029,7 +1029,7 @@ static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, return result; } -/// \brief Handle arithmethic conversion with floating point types. Helper +/// Handle arithmethic conversion with floating point types. Helper /// function of UsualArithmeticConversions() static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, @@ -1067,7 +1067,7 @@ static QualType handleFloatConversion(Sema &S, ExprResult &LHS, /*convertFloat=*/!IsCompAssign); } -/// \brief Diagnose attempts to convert between __float128 and long double if +/// Diagnose attempts to convert between __float128 and long double if /// there is no support for such conversion. Helper function of /// UsualArithmeticConversions(). static bool unsupportedTypeConversion(const Sema &S, QualType LHSType, @@ -1123,7 +1123,7 @@ ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) { } } -/// \brief Handle integer arithmetic conversions. Helper function of +/// Handle integer arithmetic conversions. Helper function of /// UsualArithmeticConversions() template <PerformCastFn doLHSCast, PerformCastFn doRHSCast> static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, @@ -1174,7 +1174,7 @@ static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, } } -/// \brief Handle conversions with GCC complex int extension. Helper function +/// Handle conversions with GCC complex int extension. Helper function /// of UsualArithmeticConversions() static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, @@ -2484,7 +2484,7 @@ Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, return ExprResult((Expr *)nullptr); } -/// \brief Cast a base object to a member's actual type. +/// Cast a base object to a member's actual type. /// /// Logically this happens in three phases: /// @@ -2766,7 +2766,7 @@ static void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, ValueDecl *var, DeclContext *DC); -/// \brief Complete semantic analysis for a reference to the given declaration. +/// Complete semantic analysis for a reference to the given declaration. ExprResult Sema::BuildDeclarationNameExpr( const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs, @@ -3567,7 +3567,7 @@ static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, return false; } -/// \brief Check whether E is a pointer from a decayed array type (the decayed +/// Check whether E is a pointer from a decayed array type (the decayed /// pointer type is equal to T) and emit a warning if it is. static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, Expr *E) { @@ -3585,7 +3585,7 @@ static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, << ICE->getSubExpr()->getType(); } -/// \brief Check the constraints on expression operands to unary type expression +/// Check the constraints on expression operands to unary type expression /// and type traits. /// /// Completes any types necessary and validates the constraints on the operand @@ -3669,7 +3669,7 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, return false; } -/// \brief Check the constraints on operands to unary expression and type +/// Check the constraints on operands to unary expression and type /// traits. /// /// This will complete any types necessary, and validate the various constraints @@ -3923,7 +3923,7 @@ static void captureVariablyModifiedType(ASTContext &Context, QualType T, } while (!T.isNull() && T->isVariablyModifiedType()); } -/// \brief Build a sizeof or alignof expression given a type operand. +/// Build a sizeof or alignof expression given a type operand. ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, @@ -3967,7 +3967,7 @@ Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd()); } -/// \brief Build a sizeof or alignof expression given an expression +/// Build a sizeof or alignof expression given an expression /// operand. ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, @@ -4085,7 +4085,7 @@ Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, return BuildUnaryOp(S, OpLoc, Opc, Input); } -/// \brief Diagnose if arithmetic on the given ObjC pointer is illegal. +/// Diagnose if arithmetic on the given ObjC pointer is illegal. /// /// \return true on error static bool checkArithmeticOnObjCPointer(Sema &S, @@ -6261,7 +6261,7 @@ ExprResult Sema::ActOnParenListExpr(SourceLocation L, return expr; } -/// \brief Emit a specialized diagnostic when one expression is a null pointer +/// Emit a specialized diagnostic when one expression is a null pointer /// constant and the other is not a pointer. Returns true if a diagnostic is /// emitted. bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, @@ -6302,7 +6302,7 @@ bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, return true; } -/// \brief Return false if the condition expression is valid, true otherwise. +/// Return false if the condition expression is valid, true otherwise. static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) { QualType CondTy = Cond->getType(); @@ -6321,7 +6321,7 @@ static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) { return true; } -/// \brief Handle when one or both operands are void type. +/// Handle when one or both operands are void type. static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, ExprResult &RHS) { Expr *LHSExpr = LHS.get(); @@ -6338,7 +6338,7 @@ static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, return S.Context.VoidTy; } -/// \brief Return false if the NullExpr can be promoted to PointerTy, +/// Return false if the NullExpr can be promoted to PointerTy, /// true otherwise. static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, QualType PointerTy) { @@ -6351,7 +6351,7 @@ static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, return false; } -/// \brief Checks compatibility between two pointers and return the resulting +/// Checks compatibility between two pointers and return the resulting /// type. static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, @@ -6485,7 +6485,7 @@ static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, return ResultTy; } -/// \brief Return the resulting type when the operands are both block pointers. +/// Return the resulting type when the operands are both block pointers. static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, @@ -6510,7 +6510,7 @@ static QualType checkConditionalBlockPointerCompatibility(Sema &S, return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); } -/// \brief Return the resulting type when the operands are both pointers. +/// Return the resulting type when the operands are both pointers. static QualType checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, @@ -6549,7 +6549,7 @@ checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); } -/// \brief Return false if the first expression is not an integer and the second +/// Return false if the first expression is not an integer and the second /// expression is not a pointer, true otherwise. static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, Expr* PointerExpr, SourceLocation Loc, @@ -6569,7 +6569,7 @@ static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, return true; } -/// \brief Simple conversion between integer and floating point types. +/// Simple conversion between integer and floating point types. /// /// Used when handling the OpenCL conditional operator where the /// condition is a vector while the other operands are scalar. @@ -6624,7 +6624,7 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS, (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false); } -/// \brief Convert scalar operands to a vector that matches the +/// Convert scalar operands to a vector that matches the /// condition in length. /// /// Used when handling the OpenCL conditional operator where the @@ -6669,7 +6669,7 @@ OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS, return VectorTy; } -/// \brief Return false if this is a valid OpenCL condition vector +/// Return false if this is a valid OpenCL condition vector static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, SourceLocation QuestionLoc) { // OpenCL v1.1 s6.11.6 says the elements of the vector must be of @@ -6684,7 +6684,7 @@ static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, return true; } -/// \brief Return false if the vector condition type and the vector +/// Return false if the vector condition type and the vector /// result type are compatible. /// /// OpenCL v1.1 s6.11.6 requires that both vector types have the same @@ -6714,7 +6714,7 @@ static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy, return false; } -/// \brief Return the resulting type for the conditional operator in +/// Return the resulting type for the conditional operator in /// OpenCL (aka "ternary selection operator", OpenCL v1.1 /// s6.3.i) when the condition is a vector type. static QualType @@ -6749,7 +6749,7 @@ OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond, return OpenCLConvertScalarsToVectors(S, LHS, RHS, CondTy, QuestionLoc); } -/// \brief Return true if the Expr is block type +/// Return true if the Expr is block type static bool checkBlockType(Sema &S, const Expr *E) { if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { QualType Ty = CE->getCallee()->getType(); @@ -7870,7 +7870,7 @@ Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, return Incompatible; } -/// \brief Constructs a transparent union from an expression that is +/// Constructs a transparent union from an expression that is /// used to initialize the transparent union. static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, QualType UnionType, @@ -8616,7 +8616,7 @@ QualType Sema::CheckRemainderOperands( return compType; } -/// \brief Diagnose invalid arithmetic on two void pointers. +/// Diagnose invalid arithmetic on two void pointers. static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr) { S.Diag(Loc, S.getLangOpts().CPlusPlus @@ -8626,7 +8626,7 @@ static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, << RHSExpr->getSourceRange(); } -/// \brief Diagnose invalid arithmetic on a void pointer. +/// Diagnose invalid arithmetic on a void pointer. static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer) { S.Diag(Loc, S.getLangOpts().CPlusPlus @@ -8635,7 +8635,7 @@ static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, << 0 /* one pointer */ << Pointer->getSourceRange(); } -/// \brief Diagnose invalid arithmetic on a null pointer. +/// Diagnose invalid arithmetic on a null pointer. /// /// If \p IsGNUIdiom is true, the operation is using the 'p = (i8*)nullptr + n' /// idiom, which we recognize as a GNU extension. @@ -8650,7 +8650,7 @@ static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc, << S.getLangOpts().CPlusPlus << Pointer->getSourceRange(); } -/// \brief Diagnose invalid arithmetic on two function pointers. +/// Diagnose invalid arithmetic on two function pointers. static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS) { assert(LHS->getType()->isAnyPointerType()); @@ -8666,7 +8666,7 @@ static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, << LHS->getSourceRange() << RHS->getSourceRange(); } -/// \brief Diagnose invalid arithmetic on a function pointer. +/// Diagnose invalid arithmetic on a function pointer. static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, Expr *Pointer) { assert(Pointer->getType()->isAnyPointerType()); @@ -8678,7 +8678,7 @@ static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, << Pointer->getSourceRange(); } -/// \brief Emit error if Operand is incomplete pointer type +/// Emit error if Operand is incomplete pointer type /// /// \returns True if pointer has incomplete type static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, @@ -8694,7 +8694,7 @@ static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, PointeeTy, Operand->getSourceRange()); } -/// \brief Check the validity of an arithmetic pointer operand. +/// Check the validity of an arithmetic pointer operand. /// /// If the operand has pointer type, this code will check for pointer types /// which are invalid in arithmetic operations. These will be diagnosed @@ -8725,7 +8725,7 @@ static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, return true; } -/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer +/// Check the validity of a binary arithmetic operation w.r.t. pointer /// operands. /// /// This routine will diagnose any invalid arithmetic on pointer operands much @@ -8827,7 +8827,7 @@ static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, Self.Diag(OpLoc, diag::note_string_plus_scalar_silence); } -/// \brief Emit a warning when adding a char literal to a string. +/// Emit a warning when adding a char literal to a string. static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) { const Expr *StringRefExpr = LHSExpr; @@ -8878,7 +8878,7 @@ static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, } } -/// \brief Emit error when two pointers are incompatible. +/// Emit error when two pointers are incompatible. static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr) { assert(LHSExpr->getType()->isAnyPointerType()); @@ -9176,7 +9176,7 @@ static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, << RHS.get()->getSourceRange(); } -/// \brief Return the resulting type when a vector is shifted +/// Return the resulting type when a vector is shifted /// by a scalar or vector shift amount. static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { @@ -9351,7 +9351,7 @@ static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS, << LHS->getSourceRange() << RHS->getSourceRange(); } -/// \brief Diagnose bad pointer comparisons. +/// Diagnose bad pointer comparisons. static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError) { @@ -9361,7 +9361,7 @@ static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); } -/// \brief Returns false if the pointers are converted to a composite type, +/// Returns false if the pointers are converted to a composite type, /// true otherwise. static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS) { @@ -11354,7 +11354,7 @@ namespace { AO_No_Error = 4 }; } -/// \brief Diagnose invalid operand for address of operations. +/// Diagnose invalid operand for address of operations. /// /// \param Type The type of operand which cannot have its address taken. static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, @@ -12166,7 +12166,7 @@ static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, ParensRange); } -/// \brief It accepts a '&&' expr that is inside a '||' one. +/// It accepts a '&&' expr that is inside a '||' one. /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression /// in parentheses. static void @@ -12181,7 +12181,7 @@ EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, Bop->getSourceRange()); } -/// \brief Returns true if the given expression can be evaluated as a constant +/// Returns true if the given expression can be evaluated as a constant /// 'true'. static bool EvaluatesAsTrue(Sema &S, Expr *E) { bool Res; @@ -12189,7 +12189,7 @@ static bool EvaluatesAsTrue(Sema &S, Expr *E) { E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; } -/// \brief Returns true if the given expression can be evaluated as a constant +/// Returns true if the given expression can be evaluated as a constant /// 'false'. static bool EvaluatesAsFalse(Sema &S, Expr *E) { bool Res; @@ -12197,7 +12197,7 @@ static bool EvaluatesAsFalse(Sema &S, Expr *E) { E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; } -/// \brief Look for '&&' in the left hand of a '||' expr. +/// Look for '&&' in the left hand of a '||' expr. static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) { if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) { @@ -12219,7 +12219,7 @@ static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, } } -/// \brief Look for '&&' in the right hand of a '||' expr. +/// Look for '&&' in the right hand of a '||' expr. static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr) { if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) { @@ -12234,7 +12234,7 @@ static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, } } -/// \brief Look for bitwise op in the left or right hand of a bitwise op with +/// Look for bitwise op in the left or right hand of a bitwise op with /// lower precedence and emit a diagnostic together with a fixit hint that wraps /// the '&' expression in parentheses. static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, @@ -12702,7 +12702,7 @@ ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, return UO; } -/// \brief Determine whether the given expression is a qualified member +/// Determine whether the given expression is a qualified member /// access expression, of a form that could be turned into a pointer to member /// with the address-of operator. static bool isQualifiedMemberAccess(Expr *E) { @@ -14195,7 +14195,7 @@ static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func) { (Func->isImplicitlyInstantiable() || (MD && !MD->isUserProvided())); } -/// \brief Mark a function referenced, and check whether it is odr-used +/// Mark a function referenced, and check whether it is odr-used /// (C++ [basic.def.odr]p2, C99 6.9p3) void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse) { @@ -14672,7 +14672,7 @@ static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var, } -/// \brief Capture the given variable in the captured region. +/// Capture the given variable in the captured region. static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, VarDecl *Var, SourceLocation Loc, @@ -14732,7 +14732,7 @@ static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, return true; } -/// \brief Create a field within the lambda class for the variable +/// Create a field within the lambda class for the variable /// being captured. static void addAsFieldToClosureType(Sema &S, LambdaScopeInfo *LSI, QualType FieldType, QualType DeclRefType, @@ -14750,7 +14750,7 @@ static void addAsFieldToClosureType(Sema &S, LambdaScopeInfo *LSI, Lambda->addDecl(Field); } -/// \brief Capture the given variable in the lambda. +/// Capture the given variable in the lambda. static bool captureInLambda(LambdaScopeInfo *LSI, VarDecl *Var, SourceLocation Loc, @@ -15284,7 +15284,7 @@ static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, } } -/// \brief Mark a variable referenced, and check whether it is odr-used +/// Mark a variable referenced, and check whether it is odr-used /// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be /// used directly for normal expressions referring to VarDecl. void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) { @@ -15325,7 +15325,7 @@ static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, SemaRef.MarkAnyDeclReferenced(Loc, DM, MightBeOdrUse); } -/// \brief Perform reference-marking and odr-use handling for a DeclRefExpr. +/// Perform reference-marking and odr-use handling for a DeclRefExpr. void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) { // TODO: update this with DR# once a defect report is filed. // C++11 defect. The address of a pure member should not be an ODR use, even @@ -15338,7 +15338,7 @@ void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) { MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse); } -/// \brief Perform reference-marking and odr-use handling for a MemberExpr. +/// Perform reference-marking and odr-use handling for a MemberExpr. void Sema::MarkMemberReferenced(MemberExpr *E) { // C++11 [basic.def.odr]p2: // A non-overloaded function whose name appears as a potentially-evaluated @@ -15357,7 +15357,7 @@ void Sema::MarkMemberReferenced(MemberExpr *E) { MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, MightBeOdrUse); } -/// \brief Perform marking for a reference to an arbitrary declaration. It +/// Perform marking for a reference to an arbitrary declaration. It /// marks the declaration referenced, and performs odr-use checking for /// functions and variables. This method should not be used when building a /// normal expression which refers to a variable. @@ -15420,7 +15420,7 @@ void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) { } namespace { - /// \brief Helper class that marks all of the declarations referenced by + /// Helper class that marks all of the declarations referenced by /// potentially-evaluated subexpressions as "referenced". class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> { Sema &S; @@ -15493,7 +15493,7 @@ namespace { }; } -/// \brief Mark any declarations that appear within this expression or any +/// Mark any declarations that appear within this expression or any /// potentially-evaluated subexpressions as "referenced". /// /// \param SkipLocalVariables If true, don't mark local variables as @@ -15503,7 +15503,7 @@ void Sema::MarkDeclarationsReferencedInExpr(Expr *E, EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E); } -/// \brief Emit a diagnostic that describes an effect on the run-time behavior +/// Emit a diagnostic that describes an effect on the run-time behavior /// of the program being compiled. /// /// This routine emits the given diagnostic when the code currently being @@ -15660,7 +15660,7 @@ void Sema::DiagnoseAssignmentAsCondition(Expr *E) { << FixItHint::CreateReplacement(Loc, "=="); } -/// \brief Redundant parentheses over an equality comparison can indicate +/// Redundant parentheses over an equality comparison can indicate /// that the user intended an assignment used as condition. void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) { // Don't warn if the parens came from a macro. diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 1d56fc856e8..28bda7c78dc 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// /// \file -/// \brief Implements semantic analysis for C++ expressions. +/// Implements semantic analysis for C++ expressions. /// //===----------------------------------------------------------------------===// @@ -42,7 +42,7 @@ using namespace clang; using namespace sema; -/// \brief Handle the result of the special case name lookup for inheriting +/// Handle the result of the special case name lookup for inheriting /// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as /// constructor names in member using declarations, even if 'X' is not the /// name of the corresponding type. @@ -383,7 +383,7 @@ bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS, llvm_unreachable("unknown nested name specifier kind"); } -/// \brief Build a C++ typeid expression with a type operand. +/// Build a C++ typeid expression with a type operand. ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, @@ -408,7 +408,7 @@ ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, SourceRange(TypeidLoc, RParenLoc)); } -/// \brief Build a C++ typeid expression with an expression operand. +/// Build a C++ typeid expression with an expression operand. ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, Expr *E, @@ -560,7 +560,7 @@ getUuidAttrOfType(Sema &SemaRef, QualType QT, } } -/// \brief Build a Microsoft __uuidof expression with a type operand. +/// Build a Microsoft __uuidof expression with a type operand. ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, @@ -580,7 +580,7 @@ ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType, SourceRange(TypeidLoc, RParenLoc)); } -/// \brief Build a Microsoft __uuidof expression with an expression operand. +/// Build a Microsoft __uuidof expression with an expression operand. ExprResult Sema::BuildCXXUuidof(QualType TypeInfoType, SourceLocation TypeidLoc, Expr *E, @@ -1392,7 +1392,7 @@ Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, return Result; } -/// \brief Determine whether the given function is a non-placement +/// Determine whether the given function is a non-placement /// deallocation function. static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) { if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD)) @@ -1560,7 +1560,7 @@ static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, return Best && Best.HasSizeT; } -/// \brief Parsed a C++ 'new' expression (C++ 5.3.4). +/// Parsed a C++ 'new' expression (C++ 5.3.4). /// /// E.g.: /// @code new (memory) int[size][4] @endcode @@ -2119,7 +2119,7 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, Range, DirectInitRange); } -/// \brief Checks that a type is suitable as the allocated type +/// Checks that a type is suitable as the allocated type /// in a new-expression. bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) { @@ -2877,7 +2877,7 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, } namespace { -/// \brief Checks whether delete-expression, and new-expression used for +/// Checks whether delete-expression, and new-expression used for /// initializing deletee have the same array form. class MismatchingNewDeleteDetector { public: @@ -2900,7 +2900,7 @@ public: : Field(nullptr), IsArrayForm(false), EndOfTU(EndOfTU), HasUndefinedConstructors(false) {} - /// \brief Checks whether pointee of a delete-expression is initialized with + /// Checks whether pointee of a delete-expression is initialized with /// matching form of new-expression. /// /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the @@ -2911,7 +2911,7 @@ public: /// couldn't be analyzed. If at least one constructor initializes the member /// with matching type of new, the return value is \c NoMismatch. MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE); - /// \brief Analyzes a class member. + /// Analyzes a class member. /// \param Field Class member to analyze. /// \param DeleteWasArrayForm Array form-ness of the delete-expression used /// for deleting the \p Field. @@ -2924,13 +2924,13 @@ public: private: const bool EndOfTU; - /// \brief Indicates that there is at least one constructor without body. + /// Indicates that there is at least one constructor without body. bool HasUndefinedConstructors; - /// \brief Returns \c CXXNewExpr from given initialization expression. + /// Returns \c CXXNewExpr from given initialization expression. /// \param E Expression used for initializing pointee in delete-expression. /// E can be a single-element \c InitListExpr consisting of new-expression. const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E); - /// \brief Returns whether member is initialized with mismatching form of + /// Returns whether member is initialized with mismatching form of /// \c new either by the member initializer or in-class initialization. /// /// If bodies of all constructors are not visible at the end of translation @@ -2938,7 +2938,7 @@ private: /// form of \c new, mismatch cannot be proven, and this function will return /// \c NoMismatch. MismatchResult analyzeMemberExpr(const MemberExpr *ME); - /// \brief Returns whether variable is initialized with mismatching form of + /// Returns whether variable is initialized with mismatching form of /// \c new. /// /// If variable is initialized with matching form of \c new or variable is not @@ -2946,7 +2946,7 @@ private: /// If variable is initialized with mismatching form of \c new, returns false. /// \param D Variable to analyze. bool hasMatchingVarInit(const DeclRefExpr *D); - /// \brief Checks whether the constructor initializes pointee with mismatching + /// Checks whether the constructor initializes pointee with mismatching /// form of \c new. /// /// Returns true, if member is initialized with matching form of \c new in @@ -2955,7 +2955,7 @@ private: /// constructor isn't defined at the point where delete-expression is seen, or /// member isn't initialized by the constructor. bool hasMatchingNewInCtor(const CXXConstructorDecl *CD); - /// \brief Checks whether member is initialized with matching form of + /// Checks whether member is initialized with matching form of /// \c new in member initializer list. bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI); /// Checks whether member is initialized with mismatching form of \c new by @@ -3532,7 +3532,7 @@ Sema::ConditionResult Sema::ActOnConditionVariable(Decl *ConditionVar, CK == ConditionKind::ConstexprIf); } -/// \brief Check the use of the given variable as a C++ condition in an if, +/// Check the use of the given variable as a C++ condition in an if, /// while, do-while, or switch statement. ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar, SourceLocation StmtLoc, @@ -4231,7 +4231,7 @@ Sema::PerformImplicitConversion(Expr *From, QualType ToType, return From; } -/// \brief Check the completeness of a type in a unary type trait. +/// Check the completeness of a type in a unary type trait. /// /// If the particular type trait requires a complete type, tries to complete /// it. If completing the type fails, a diagnostic is emitted and false @@ -5433,7 +5433,7 @@ QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, return Result; } -/// \brief Try to convert a type to another according to C++11 5.16p3. +/// Try to convert a type to another according to C++11 5.16p3. /// /// This is part of the parameter validation for the ? operator. If either /// value operand is a class type, the two operands are attempted to be @@ -5527,7 +5527,7 @@ static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, return false; } -/// \brief Try to find a common type for two according to C++0x 5.16p5. +/// Try to find a common type for two according to C++0x 5.16p5. /// /// This is part of the parameter validation for the ? operator. If either /// value operand is a class type, overload resolution is used to find a @@ -5589,7 +5589,7 @@ static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS return true; } -/// \brief Perform an "extended" implicit conversion as returned by +/// Perform an "extended" implicit conversion as returned by /// TryClassUnification. static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) { InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); @@ -5605,7 +5605,7 @@ static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) { return false; } -/// \brief Check the operands of ?: under C++ semantics. +/// Check the operands of ?: under C++ semantics. /// /// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y /// extension. In this case, LHS == Cond. (But they're not aliases.) @@ -5967,7 +5967,7 @@ mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, llvm_unreachable("invalid ExceptionSpecificationType"); } -/// \brief Find a merged pointer type and convert the two expressions to it. +/// Find a merged pointer type and convert the two expressions to it. /// /// This finds the composite pointer type (or member pointer type) for @p E1 /// and @p E2 according to C++1z 5p14. It converts both expressions to this @@ -6734,7 +6734,7 @@ static bool CheckArrow(Sema& S, QualType& ObjectType, Expr *&Base, return false; } -/// \brief Check if it's ok to try and recover dot pseudo destructor calls on +/// Check if it's ok to try and recover dot pseudo destructor calls on /// pointer objects. static bool canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, @@ -7285,7 +7285,7 @@ static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var, return !IsVariableAConstantExpression(Var, Context); } -/// \brief Check if the current lambda has any potential captures +/// Check if the current lambda has any potential captures /// that must be captured by any of its enclosing lambdas that are ready to /// capture. If there is a lambda that can capture a nested /// potential-capture, go ahead and do so. Also, check to see if any @@ -7465,7 +7465,7 @@ class TransformTypos : public TreeTransform<TransformTypos> { llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache; llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution; - /// \brief Emit diagnostics for all of the TypoExprs encountered. + /// Emit diagnostics for all of the TypoExprs encountered. /// If the TypoExprs were successfully corrected, then the diagnostics should /// suggest the corrections. Otherwise the diagnostics will not suggest /// anything (having been passed an empty TypoCorrection). @@ -7491,7 +7491,7 @@ class TransformTypos : public TreeTransform<TransformTypos> { } } - /// \brief If corrections for the first TypoExpr have been exhausted for a + /// If corrections for the first TypoExpr have been exhausted for a /// given combination of the other TypoExprs, retry those corrections against /// the next combination of substitutions for the other TypoExprs by advancing /// to the next potential correction of the second TypoExpr. For the second diff --git a/clang/lib/Sema/SemaExprMember.cpp b/clang/lib/Sema/SemaExprMember.cpp index e03f143bcba..2e099ad6c67 100644 --- a/clang/lib/Sema/SemaExprMember.cpp +++ b/clang/lib/Sema/SemaExprMember.cpp @@ -888,7 +888,7 @@ BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow, NameInfo.getLoc()); } -/// \brief Build a MemberExpr AST node. +/// Build a MemberExpr AST node. static MemberExpr *BuildMemberExpr( Sema &SemaRef, ASTContext &C, Expr *Base, bool isArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, @@ -903,7 +903,7 @@ static MemberExpr *BuildMemberExpr( return E; } -/// \brief Determine if the given scope is within a function-try-block handler. +/// Determine if the given scope is within a function-try-block handler. static bool IsInFnTryBlockHandler(const Scope *S) { // Walk the scope stack until finding a FnTryCatchScope, or leave the // function scope. If a FnTryCatchScope is found, check whether the TryScope diff --git a/clang/lib/Sema/SemaExprObjC.cpp b/clang/lib/Sema/SemaExprObjC.cpp index c0086765349..ce73e222b67 100644 --- a/clang/lib/Sema/SemaExprObjC.cpp +++ b/clang/lib/Sema/SemaExprObjC.cpp @@ -141,7 +141,7 @@ ExprResult Sema::BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S){ return new (Context) ObjCStringLiteral(S, Ty, AtLoc); } -/// \brief Emits an error if the given method does not exist, or if the return +/// Emits an error if the given method does not exist, or if the return /// type is not an Objective-C object. static bool validateBoxingMethod(Sema &S, SourceLocation Loc, const ObjCInterfaceDecl *Class, @@ -165,7 +165,7 @@ static bool validateBoxingMethod(Sema &S, SourceLocation Loc, return true; } -/// \brief Maps ObjCLiteralKind to NSClassIdKindKind +/// Maps ObjCLiteralKind to NSClassIdKindKind static NSAPI::NSClassIdKindKind ClassKindFromLiteralKind( Sema::ObjCLiteralKind LiteralKind) { switch (LiteralKind) { @@ -189,7 +189,7 @@ static NSAPI::NSClassIdKindKind ClassKindFromLiteralKind( llvm_unreachable("LiteralKind can't be converted into a ClassKind"); } -/// \brief Validates ObjCInterfaceDecl availability. +/// Validates ObjCInterfaceDecl availability. /// ObjCInterfaceDecl, used to create ObjC literals, should be defined /// if clang not in a debugger mode. static bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl, @@ -211,7 +211,7 @@ static bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl, return true; } -/// \brief Looks up ObjCInterfaceDecl of a given NSClassIdKindKind. +/// Looks up ObjCInterfaceDecl of a given NSClassIdKindKind. /// Used to create ObjC literals, such as NSDictionary (@{}), /// NSArray (@[]) and Boxed Expressions (@()) static ObjCInterfaceDecl *LookupObjCInterfaceDeclForLiteral(Sema &S, @@ -236,7 +236,7 @@ static ObjCInterfaceDecl *LookupObjCInterfaceDeclForLiteral(Sema &S, return ID; } -/// \brief Retrieve the NSNumber factory method that should be used to create +/// Retrieve the NSNumber factory method that should be used to create /// an Objective-C literal for the given type. static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc, QualType NumberType, @@ -379,7 +379,7 @@ ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc, return BuildObjCNumericLiteral(AtLoc, Inner.get()); } -/// \brief Check that the given expression is a valid element of an Objective-C +/// Check that the given expression is a valid element of an Objective-C /// collection literal. static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element, QualType T, @@ -2324,7 +2324,7 @@ static void checkFoundationAPI(Sema &S, SourceLocation Loc, } } -/// \brief Diagnose use of %s directive in an NSString which is being passed +/// Diagnose use of %s directive in an NSString which is being passed /// as formatting string to formatting method. static void DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S, @@ -2363,7 +2363,7 @@ DiagnoseCStringFormatDirectiveInObjCAPI(Sema &S, } } -/// \brief Build an Objective-C class message expression. +/// Build an Objective-C class message expression. /// /// This routine takes care of both normal class messages and /// class messages to the superclass. @@ -2587,7 +2587,7 @@ static bool isMethodDeclaredInRootProtocol(Sema &S, const ObjCMethodDecl *M) { return false; } -/// \brief Build an Objective-C instance message expression. +/// Build an Objective-C instance message expression. /// /// This routine takes care of both normal instance messages and /// instance messages to the superclass instance. diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index be33326cd42..e64a0d66cbb 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -32,7 +32,7 @@ using namespace clang; // Sema Initialization Checking //===----------------------------------------------------------------------===// -/// \brief Check whether T is compatible with a wide character type (wchar_t, +/// Check whether T is compatible with a wide character type (wchar_t, /// char16_t or char32_t). static bool IsWideCharCompatible(QualType T, ASTContext &Context) { if (Context.typesAreCompatible(Context.getWideCharType(), T)) @@ -54,7 +54,7 @@ enum StringInitFailureKind { SIF_Other }; -/// \brief Check whether the array of type AT can be initialized by the Init +/// Check whether the array of type AT can be initialized by the Init /// expression by means of string initialization. Returns SIF_None if so, /// otherwise returns a StringInitFailureKind that describes why the /// initialization would not work. @@ -217,7 +217,7 @@ static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, namespace { -/// @brief Semantic checking for initializer lists. +/// Semantic checking for initializer lists. /// /// The InitListChecker class contains a set of routines that each /// handle the initialization of a certain kind of entity, e.g., @@ -377,7 +377,7 @@ public: bool TreatUnavailableAsInvalid); bool HadError() { return hadError; } - // @brief Retrieves the fully-structured initializer list used for + // Retrieves the fully-structured initializer list used for // semantic analysis and code generation. InitListExpr *getFullyStructuredList() const { return FullyStructuredList; } }; @@ -2025,7 +2025,7 @@ void InitListChecker::CheckStructUnionTypes( StructuredList, StructuredIndex); } -/// \brief Expand a field designator that refers to a member of an +/// Expand a field designator that refers to a member of an /// anonymous struct or union into a series of field designators that /// refers to the field within the appropriate subobject. /// @@ -2089,7 +2089,7 @@ class FieldInitializerValidatorCCC : public CorrectionCandidateCallback { } // end anonymous namespace -/// @brief Check the well-formedness of a C99 designated initializer. +/// Check the well-formedness of a C99 designated initializer. /// /// Determines whether the designated initializer @p DIE, which /// resides at the given @p Index within the initializer list @p @@ -3545,7 +3545,7 @@ static void TryListInitialization(Sema &S, InitializationSequence &Sequence, bool TreatUnavailableAsInvalid); -/// \brief When initializing from init list via constructor, handle +/// When initializing from init list via constructor, handle /// initialization of an object of type std::initializer_list<T>. /// /// \return true if we have handled initialization of an object of type @@ -3706,7 +3706,7 @@ ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, return CandidateSet.BestViableFunction(S, DeclLoc, Best); } -/// \brief Attempt initialization by constructor (C++ [dcl.init]), which +/// Attempt initialization by constructor (C++ [dcl.init]), which /// enumerates the constructors of the initialized entity and performs overload /// resolution to select the best. /// \param DestType The destination class type. @@ -3923,7 +3923,7 @@ static void TryValueInitialization(Sema &S, InitializationSequence &Sequence, InitListExpr *InitList = nullptr); -/// \brief Attempt list initialization of a reference. +/// Attempt list initialization of a reference. static void TryReferenceListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -3997,7 +3997,7 @@ static void TryReferenceListInitialization(Sema &S, } } -/// \brief Attempt list initialization (C++0x [dcl.init.list]) +/// Attempt list initialization (C++0x [dcl.init.list]) static void TryListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4192,7 +4192,7 @@ static void TryListInitialization(Sema &S, Sequence.AddListInitializationStep(DestType); } -/// \brief Try a reference initialization that involves calling a conversion +/// Try a reference initialization that involves calling a conversion /// function. static OverloadingResult TryRefInitWithConversionFunction( Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4382,7 +4382,7 @@ static void CheckCXX98CompatAccessibleCopy(Sema &S, const InitializedEntity &Entity, Expr *CurInitExpr); -/// \brief Attempt reference initialization (C++0x [dcl.init.ref]) +/// Attempt reference initialization (C++0x [dcl.init.ref]) static void TryReferenceInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4415,7 +4415,7 @@ static bool isNonReferenceableGLValue(Expr *E) { return E->refersToBitField() || E->refersToVectorElement(); } -/// \brief Reference initialization without resolving overloaded functions. +/// Reference initialization without resolving overloaded functions. static void TryReferenceInitializationCore(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4675,7 +4675,7 @@ static void TryReferenceInitializationCore(Sema &S, Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); } -/// \brief Attempt character array initialization from a string literal +/// Attempt character array initialization from a string literal /// (C++ [dcl.init.string], C99 6.7.8). static void TryStringLiteralInitialization(Sema &S, const InitializedEntity &Entity, @@ -4685,7 +4685,7 @@ static void TryStringLiteralInitialization(Sema &S, Sequence.AddStringInitStep(Entity.getType()); } -/// \brief Attempt value initialization (C++ [dcl.init]p7). +/// Attempt value initialization (C++ [dcl.init]p7). static void TryValueInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4763,7 +4763,7 @@ static void TryValueInitialization(Sema &S, Sequence.AddZeroInitializationStep(Entity.getType()); } -/// \brief Attempt default initialization (C++ [dcl.init]p6). +/// Attempt default initialization (C++ [dcl.init]p6). static void TryDefaultInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, @@ -4802,7 +4802,7 @@ static void TryDefaultInitialization(Sema &S, } } -/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]), +/// Attempt a user-defined conversion between two types (C++ [dcl.init]), /// which enumerates all conversion functions and performs overload resolution /// to select the best. static void TryUserDefinedConversion(Sema &S, @@ -5081,7 +5081,7 @@ static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) { << src->getSourceRange(); } -/// \brief Determine whether we have compatible array types for the +/// Determine whether we have compatible array types for the /// purposes of GNU by-copy array initialization. static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest, const ArrayType *Source) { @@ -5648,7 +5648,7 @@ getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) { llvm_unreachable("Invalid EntityKind!"); } -/// \brief Whether we should bind a created object as a temporary when +/// Whether we should bind a created object as a temporary when /// initializing the given entity. static bool shouldBindAsTemporary(const InitializedEntity &Entity) { switch (Entity.getKind()) { @@ -5679,7 +5679,7 @@ static bool shouldBindAsTemporary(const InitializedEntity &Entity) { llvm_unreachable("missed an InitializedEntity kind?"); } -/// \brief Whether the given entity, when initialized with an object +/// Whether the given entity, when initialized with an object /// created for that initialization, requires destruction. static bool shouldDestroyEntity(const InitializedEntity &Entity) { switch (Entity.getKind()) { @@ -5710,7 +5710,7 @@ static bool shouldDestroyEntity(const InitializedEntity &Entity) { llvm_unreachable("missed an InitializedEntity kind?"); } -/// \brief Get the location at which initialization diagnostics should appear. +/// Get the location at which initialization diagnostics should appear. static SourceLocation getInitializationLoc(const InitializedEntity &Entity, Expr *Initializer) { switch (Entity.getKind()) { @@ -5746,7 +5746,7 @@ static SourceLocation getInitializationLoc(const InitializedEntity &Entity, llvm_unreachable("missed an InitializedEntity kind?"); } -/// \brief Make a (potentially elidable) temporary copy of the object +/// Make a (potentially elidable) temporary copy of the object /// provided by the given initializer by calling the appropriate copy /// constructor. /// @@ -5911,7 +5911,7 @@ static ExprResult CopyObject(Sema &S, return CurInit; } -/// \brief Check whether elidable copy construction for binding a reference to +/// Check whether elidable copy construction for binding a reference to /// a temporary would have succeeded if we were building in C++98 mode, for /// -Wc++98-compat. static void CheckCXX98CompatAccessibleCopy(Sema &S, diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp index 1b9702f79ac..fec0d575e5b 100644 --- a/clang/lib/Sema/SemaLambda.cpp +++ b/clang/lib/Sema/SemaLambda.cpp @@ -24,7 +24,7 @@ using namespace clang; using namespace sema; -/// \brief Examines the FunctionScopeInfo stack to determine the nearest +/// Examines the FunctionScopeInfo stack to determine the nearest /// enclosing lambda (to the current lambda) that is 'capture-ready' for /// the variable referenced in the current lambda (i.e. \p VarToCapture). /// If successful, returns the index into Sema's FunctionScopeInfo stack @@ -135,7 +135,7 @@ getStackIndexOfNearestEnclosingCaptureReadyLambda( return NoLambdaIsCaptureReady; } -/// \brief Examines the FunctionScopeInfo stack to determine the nearest +/// Examines the FunctionScopeInfo stack to determine the nearest /// enclosing lambda (to the current lambda) that is 'capture-capable' for /// the variable referenced in the current lambda (i.e. \p VarToCapture). /// If successful, returns the index into Sema's FunctionScopeInfo stack @@ -263,7 +263,7 @@ CXXRecordDecl *Sema::createLambdaClosureType(SourceRange IntroducerRange, return Class; } -/// \brief Determine whether the given context is or is enclosed in an inline +/// Determine whether the given context is or is enclosed in an inline /// function. static bool isInInlineFunction(const DeclContext *DC) { while (!DC->isFileContext()) { @@ -1189,7 +1189,7 @@ QualType Sema::getLambdaConversionFunctionResultType( CallOpProto->getParamTypes(), InvokerExtInfo); } -/// \brief Add a lambda's conversion to function pointer, as described in +/// Add a lambda's conversion to function pointer, as described in /// C++11 [expr.prim.lambda]p6. static void addFunctionPointerConversion(Sema &S, SourceRange IntroducerRange, @@ -1358,7 +1358,7 @@ static void addFunctionPointerConversion(Sema &S, Class->addDecl(Invoke); } -/// \brief Add a lambda's conversion to block pointer. +/// Add a lambda's conversion to block pointer. static void addBlockPointerConversion(Sema &S, SourceRange IntroducerRange, CXXRecordDecl *Class, diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index 05bf303c98c..1e57d39e95f 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -356,7 +356,7 @@ static DeclContext *getContextForScopeMatching(Decl *D) { return D->getDeclContext()->getRedeclContext(); } -/// \brief Determine whether \p D is a better lookup result than \p Existing, +/// Determine whether \p D is a better lookup result than \p Existing, /// given that they declare the same entity. static bool isPreferredLookupResult(Sema &S, Sema::LookupNameKind Kind, NamedDecl *D, NamedDecl *Existing) { @@ -669,7 +669,7 @@ LLVM_DUMP_METHOD void LookupResult::dump() { D->dump(); } -/// \brief Lookup a builtin function, when name lookup would otherwise +/// Lookup a builtin function, when name lookup would otherwise /// fail. static bool LookupBuiltin(Sema &S, LookupResult &R) { Sema::LookupNameKind NameKind = R.getLookupKind(); @@ -713,7 +713,7 @@ static bool LookupBuiltin(Sema &S, LookupResult &R) { return false; } -/// \brief Determine whether we can declare a special member function within +/// Determine whether we can declare a special member function within /// the class at this point. static bool CanDeclareSpecialMemberFunction(const CXXRecordDecl *Class) { // We need to have a definition for the class. @@ -755,7 +755,7 @@ void Sema::ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class) { DeclareImplicitDestructor(Class); } -/// \brief Determine whether this is the name of an implicitly-declared +/// Determine whether this is the name of an implicitly-declared /// special member function. static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) { switch (Name.getNameKind()) { @@ -773,7 +773,7 @@ static bool isImplicitlyDeclaredMemberFunctionName(DeclarationName Name) { return false; } -/// \brief If there are any implicit member functions with the given name +/// If there are any implicit member functions with the given name /// that need to be declared in the given declaration context, do so. static void DeclareImplicitMemberFunctionsWithName(Sema &S, DeclarationName Name, @@ -1354,7 +1354,7 @@ void Sema::makeMergedDefinitionVisible(NamedDecl *ND) { makeMergedDefinitionVisible(Param); } -/// \brief Find the module in which the given declaration was defined. +/// Find the module in which the given declaration was defined. static Module *getDefiningModule(Sema &S, Decl *Entity) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Entity)) { // If this function was instantiated from a template, the defining module is @@ -1501,7 +1501,7 @@ bool Sema::hasVisibleMemberSpecialization( return false; } -/// \brief Determine whether a declaration is visible to name lookup. +/// Determine whether a declaration is visible to name lookup. /// /// This routine determines whether the declaration D is visible in the current /// lookup context, taking into account the current template instantiation @@ -1648,7 +1648,7 @@ bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) { return New->isExternallyDeclarable(); } -/// \brief Retrieve the visible declaration corresponding to D, if any. +/// Retrieve the visible declaration corresponding to D, if any. /// /// This routine determines whether the declaration D is visible in the current /// module, with the current imports. If not, it checks whether any @@ -1706,7 +1706,7 @@ NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const { return findAcceptableDecl(getSema(), D, IDNS); } -/// @brief Perform unqualified name lookup starting from a given +/// Perform unqualified name lookup starting from a given /// scope. /// /// Unqualified name lookup (C++ [basic.lookup.unqual], C99 6.2.1) is @@ -1844,7 +1844,7 @@ bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation) { return (ExternalSource && ExternalSource->LookupUnqualified(R, S)); } -/// @brief Perform qualified name lookup in the namespaces nominated by +/// Perform qualified name lookup in the namespaces nominated by /// using directives by the given context. /// /// C++98 [namespace.qual]p2: @@ -1950,7 +1950,7 @@ static bool LookupQualifiedNameInUsingDirectives(Sema &S, LookupResult &R, return Found; } -/// \brief Callback that looks for any member of a class with the given name. +/// Callback that looks for any member of a class with the given name. static bool LookupAnyMember(const CXXBaseSpecifier *Specifier, CXXBasePath &Path, DeclarationName Name) { RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); @@ -1959,7 +1959,7 @@ static bool LookupAnyMember(const CXXBaseSpecifier *Specifier, return !Path.Decls.empty(); } -/// \brief Determine whether the given set of member declarations contains only +/// Determine whether the given set of member declarations contains only /// static members, nested types, and enumerators. template<typename InputIterator> static bool HasOnlyStaticMembers(InputIterator First, InputIterator Last) { @@ -1991,7 +1991,7 @@ static bool HasOnlyStaticMembers(InputIterator First, InputIterator Last) { return false; } -/// \brief Perform qualified name lookup into a given context. +/// Perform qualified name lookup into a given context. /// /// Qualified name lookup (C++ [basic.lookup.qual]) is used to find /// names when the context of those names is explicit specified, e.g., @@ -2215,7 +2215,7 @@ bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, return true; } -/// \brief Performs qualified name lookup or special type of lookup for +/// Performs qualified name lookup or special type of lookup for /// "__super::" scope specifier. /// /// This routine is a convenience overload meant to be called from contexts @@ -2240,7 +2240,7 @@ bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, return LookupQualifiedName(R, LookupCtx); } -/// @brief Performs name lookup for a name that was parsed in the +/// Performs name lookup for a name that was parsed in the /// source code, and may contain a C++ scope specifier. /// /// This routine is a convenience routine meant to be called from @@ -2294,7 +2294,7 @@ bool Sema::LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, return LookupName(R, S, AllowBuiltinCreation); } -/// \brief Perform qualified name lookup into all base classes of the given +/// Perform qualified name lookup into all base classes of the given /// class. /// /// \param R captures both the lookup criteria and any lookup results found. @@ -2332,7 +2332,7 @@ bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) { return !R.empty(); } -/// \brief Produce a diagnostic describing the ambiguity that resulted +/// Produce a diagnostic describing the ambiguity that resulted /// from name lookup. /// /// \param Result The result of the ambiguous lookup to be diagnosed. @@ -2448,7 +2448,7 @@ static void CollectEnclosingNamespace(Sema::AssociatedNamespaceSet &Namespaces, Namespaces.insert(Ctx->getPrimaryContext()); } -// \brief Add the associated classes and namespaces for argument-dependent +// Add the associated classes and namespaces for argument-dependent // lookup that involves a template argument (C++ [basic.lookup.koenig]p2). static void addAssociatedClassesAndNamespaces(AssociatedLookup &Result, @@ -2498,7 +2498,7 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result, } } -// \brief Add the associated classes and namespaces for +// Add the associated classes and namespaces for // argument-dependent lookup with an argument of class type // (C++ [basic.lookup.koenig]p2). static void @@ -2593,7 +2593,7 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result, } } -// \brief Add the associated classes and namespaces for +// Add the associated classes and namespaces for // argument-dependent lookup with an argument of type T // (C++ [basic.lookup.koenig]p2). static void @@ -2757,7 +2757,7 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result, QualType Ty) { } } -/// \brief Find the associated classes and namespaces for +/// Find the associated classes and namespaces for /// argument-dependent lookup for a call with the given set of /// arguments. /// @@ -2824,7 +2824,7 @@ NamedDecl *Sema::LookupSingleName(Scope *S, DeclarationName Name, return R.getAsSingle<NamedDecl>(); } -/// \brief Find the protocol with the given name, if any. +/// Find the protocol with the given name, if any. ObjCProtocolDecl *Sema::LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc, RedeclarationKind Redecl) { @@ -3051,7 +3051,7 @@ Sema::SpecialMemberOverloadResult Sema::LookupSpecialMember(CXXRecordDecl *RD, return *Result; } -/// \brief Look up the default constructor for the given class. +/// Look up the default constructor for the given class. CXXConstructorDecl *Sema::LookupDefaultConstructor(CXXRecordDecl *Class) { SpecialMemberOverloadResult Result = LookupSpecialMember(Class, CXXDefaultConstructor, false, false, false, @@ -3060,7 +3060,7 @@ CXXConstructorDecl *Sema::LookupDefaultConstructor(CXXRecordDecl *Class) { return cast_or_null<CXXConstructorDecl>(Result.getMethod()); } -/// \brief Look up the copying constructor for the given class. +/// Look up the copying constructor for the given class. CXXConstructorDecl *Sema::LookupCopyingConstructor(CXXRecordDecl *Class, unsigned Quals) { assert(!(Quals & ~(Qualifiers::Const | Qualifiers::Volatile)) && @@ -3072,7 +3072,7 @@ CXXConstructorDecl *Sema::LookupCopyingConstructor(CXXRecordDecl *Class, return cast_or_null<CXXConstructorDecl>(Result.getMethod()); } -/// \brief Look up the moving constructor for the given class. +/// Look up the moving constructor for the given class. CXXConstructorDecl *Sema::LookupMovingConstructor(CXXRecordDecl *Class, unsigned Quals) { SpecialMemberOverloadResult Result = @@ -3082,7 +3082,7 @@ CXXConstructorDecl *Sema::LookupMovingConstructor(CXXRecordDecl *Class, return cast_or_null<CXXConstructorDecl>(Result.getMethod()); } -/// \brief Look up the constructors for the given class. +/// Look up the constructors for the given class. DeclContext::lookup_result Sema::LookupConstructors(CXXRecordDecl *Class) { // If the implicit constructors have not yet been declared, do so now. if (CanDeclareSpecialMemberFunction(Class)) { @@ -3099,7 +3099,7 @@ DeclContext::lookup_result Sema::LookupConstructors(CXXRecordDecl *Class) { return Class->lookup(Name); } -/// \brief Look up the copying assignment operator for the given class. +/// Look up the copying assignment operator for the given class. CXXMethodDecl *Sema::LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, unsigned ThisQuals) { @@ -3116,7 +3116,7 @@ CXXMethodDecl *Sema::LookupCopyingAssignment(CXXRecordDecl *Class, return Result.getMethod(); } -/// \brief Look up the moving assignment operator for the given class. +/// Look up the moving assignment operator for the given class. CXXMethodDecl *Sema::LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals, bool RValueThis, @@ -3132,7 +3132,7 @@ CXXMethodDecl *Sema::LookupMovingAssignment(CXXRecordDecl *Class, return Result.getMethod(); } -/// \brief Look for the destructor of the given class. +/// Look for the destructor of the given class. /// /// During semantic analysis, this routine should be used in lieu of /// CXXRecordDecl::getDestructor(). @@ -3389,26 +3389,26 @@ class ShadowContextRAII; class VisibleDeclsRecord { public: - /// \brief An entry in the shadow map, which is optimized to store a + /// An entry in the shadow map, which is optimized to store a /// single declaration (the common case) but can also store a list /// of declarations. typedef llvm::TinyPtrVector<NamedDecl*> ShadowMapEntry; private: - /// \brief A mapping from declaration names to the declarations that have + /// A mapping from declaration names to the declarations that have /// this name within a particular scope. typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; - /// \brief A list of shadow maps, which is used to model name hiding. + /// A list of shadow maps, which is used to model name hiding. std::list<ShadowMap> ShadowMaps; - /// \brief The declaration contexts we have already visited. + /// The declaration contexts we have already visited. llvm::SmallPtrSet<DeclContext *, 8> VisitedContexts; friend class ShadowContextRAII; public: - /// \brief Determine whether we have already visited this context + /// Determine whether we have already visited this context /// (and, if not, note that we are going to visit that context now). bool visitedContext(DeclContext *Ctx) { return !VisitedContexts.insert(Ctx).second; @@ -3418,20 +3418,20 @@ public: return VisitedContexts.count(Ctx); } - /// \brief Determine whether the given declaration is hidden in the + /// Determine whether the given declaration is hidden in the /// current scope. /// /// \returns the declaration that hides the given declaration, or /// NULL if no such declaration exists. NamedDecl *checkHidden(NamedDecl *ND); - /// \brief Add a declaration to the current shadow map. + /// Add a declaration to the current shadow map. void add(NamedDecl *ND) { ShadowMaps.back()[ND->getDeclName()].push_back(ND); } }; -/// \brief RAII object that records when we've entered a shadow context. +/// RAII object that records when we've entered a shadow context. class ShadowContextRAII { VisibleDeclsRecord &Visible; @@ -3868,7 +3868,7 @@ static void LookupPotentialTypoResult(Sema &SemaRef, bool isObjCIvarLookup, bool FindHidden); -/// \brief Check whether the declarations found for a typo correction are +/// Check whether the declarations found for a typo correction are /// visible. Set the correction's RequiresImport flag to true if none of the /// declarations are visible, false otherwise. static void checkCorrectionVisibility(Sema &SemaRef, TypoCorrection &TC) { @@ -4354,7 +4354,7 @@ void TypoCorrectionConsumer::NamespaceSpecifierSet::addNameSpecifier( DistanceMap[NumSpecifiers].push_back(SI); } -/// \brief Perform name lookup for a possible result for typo correction. +/// Perform name lookup for a possible result for typo correction. static void LookupPotentialTypoResult(Sema &SemaRef, LookupResult &Res, IdentifierInfo *Name, @@ -4408,7 +4408,7 @@ static void LookupPotentialTypoResult(Sema &SemaRef, } } -/// \brief Add keywords to the consumer as possible typo corrections. +/// Add keywords to the consumer as possible typo corrections. static void AddKeywordsToConsumer(Sema &SemaRef, TypoCorrectionConsumer &Consumer, Scope *S, CorrectionCandidateCallback &CCC, @@ -4699,7 +4699,7 @@ std::unique_ptr<TypoCorrectionConsumer> Sema::makeTypoCorrectionConsumer( return Consumer; } -/// \brief Try to "correct" a typo in the source code by finding +/// Try to "correct" a typo in the source code by finding /// visible declarations whose names are similar to the name that was /// present in the source code. /// @@ -4828,7 +4828,7 @@ TypoCorrection Sema::CorrectTypo(const DeclarationNameInfo &TypoName, return FailedCorrection(Typo, TypoName.getLoc(), RecordFailure && !SecondBestTC); } -/// \brief Try to "correct" a typo in the source code by finding +/// Try to "correct" a typo in the source code by finding /// visible declarations whose names are similar to the name that was /// present in the source code. /// @@ -5065,7 +5065,7 @@ void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl, Recover); } -/// \brief Get a "quoted.h" or <angled.h> include path to use in a diagnostic +/// Get a "quoted.h" or <angled.h> include path to use in a diagnostic /// suggesting the addition of a #include of the specified file. static std::string getIncludeStringForHeader(Preprocessor &PP, const FileEntry *E) { @@ -5144,7 +5144,7 @@ void Sema::diagnoseMissingImport(SourceLocation UseLoc, NamedDecl *Decl, createImplicitModuleImportForErrorRecovery(UseLoc, Modules[0]); } -/// \brief Diagnose a successfully-corrected typo. Separated from the correction +/// Diagnose a successfully-corrected typo. Separated from the correction /// itself to allow external validation of the result, etc. /// /// \param Correction The result of performing typo correction. diff --git a/clang/lib/Sema/SemaObjCProperty.cpp b/clang/lib/Sema/SemaObjCProperty.cpp index 7ff037018fa..2983ec51f49 100644 --- a/clang/lib/Sema/SemaObjCProperty.cpp +++ b/clang/lib/Sema/SemaObjCProperty.cpp @@ -104,7 +104,7 @@ static void checkPropertyDeclWithOwnership(Sema &S, << propertyLifetime; } -/// \brief Check this Objective-C property against a property declared in the +/// Check this Objective-C property against a property declared in the /// given protocol. static void CheckPropertyAgainstProtocol(Sema &S, ObjCPropertyDecl *Prop, @@ -1829,7 +1829,7 @@ static bool SuperClassImplementsProperty(ObjCInterfaceDecl *IDecl, return false; } -/// \brief Default synthesizes all properties which must be synthesized +/// Default synthesizes all properties which must be synthesized /// in class's \@implementation. void Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index 292cc6710aa..7da9df90acb 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// /// \file -/// \brief This file implements semantic analysis for OpenMP directives and +/// This file implements semantic analysis for OpenMP directives and /// clauses. /// //===----------------------------------------------------------------------===// @@ -41,11 +41,11 @@ static const Expr *checkMapClauseExpressionBase( OpenMPClauseKind CKind, bool NoDiagnose); namespace { -/// \brief Default data sharing attributes, which can be applied to directive. +/// Default data sharing attributes, which can be applied to directive. enum DefaultDataSharingAttributes { - DSA_unspecified = 0, /// \brief Data sharing attribute not specified. - DSA_none = 1 << 0, /// \brief Default data sharing attribute 'none'. - DSA_shared = 1 << 1, /// \brief Default data sharing attribute 'shared'. + DSA_unspecified = 0, /// Data sharing attribute not specified. + DSA_none = 1 << 0, /// Default data sharing attribute 'none'. + DSA_shared = 1 << 1, /// Default data sharing attribute 'shared'. }; /// Attributes of the defaultmap clause. @@ -54,7 +54,7 @@ enum DefaultMapAttributes { DMA_tofrom_scalar, /// Default mapping is 'tofrom:scalar'. }; -/// \brief Stack for tracking declarations used in OpenMP directives and +/// Stack for tracking declarations used in OpenMP directives and /// clauses and their data-sharing attributes. class DSAStackTy { public: @@ -134,7 +134,7 @@ private: /// get the data (loop counters etc.) about enclosing loop-based construct. /// This data is required during codegen. DoacrossDependMapTy DoacrossDepends; - /// \brief first argument (Expr *) contains optional argument of the + /// first argument (Expr *) contains optional argument of the /// 'ordered' clause, the second one is true if the regions has 'ordered' /// clause, false otherwise. llvm::PointerIntPair<const Expr *, 1, bool> OrderedRegion; @@ -153,11 +153,11 @@ private: using StackTy = SmallVector<SharingMapTy, 4>; - /// \brief Stack of used declaration and their data-sharing attributes. + /// Stack of used declaration and their data-sharing attributes. DeclSAMapTy Threadprivates; const FunctionScopeInfo *CurrentNonCapturingFunctionScope = nullptr; SmallVector<std::pair<StackTy, const FunctionScopeInfo *>, 4> Stack; - /// \brief true, if check for DSA must be from parent directive, false, if + /// true, if check for DSA must be from parent directive, false, if /// from current directive. OpenMPClauseKind ClauseKindMode = OMPC_unknown; Sema &SemaRef; @@ -168,7 +168,7 @@ private: DSAVarData getDSA(iterator &Iter, ValueDecl *D) const; - /// \brief Checks if the variable is a local for OpenMP region. + /// Checks if the variable is a local for OpenMP region. bool isOpenMPLocal(VarDecl *D, iterator Iter) const; bool isStackEmpty() const { @@ -236,28 +236,28 @@ public: return I->second; return std::make_pair(nullptr, llvm::APSInt()); } - /// \brief If 'aligned' declaration for given variable \a D was not seen yet, + /// If 'aligned' declaration for given variable \a D was not seen yet, /// add it and return NULL; otherwise return previous occurrence's expression /// for diagnostics. const Expr *addUniqueAligned(const ValueDecl *D, const Expr *NewDE); - /// \brief Register specified variable as loop control variable. + /// Register specified variable as loop control variable. void addLoopControlVariable(const ValueDecl *D, VarDecl *Capture); - /// \brief Check if the specified variable is a loop control variable for + /// Check if the specified variable is a loop control variable for /// current region. /// \return The index of the loop control variable in the list of associated /// for-loops (from outer to inner). const LCDeclInfo isLoopControlVariable(const ValueDecl *D) const; - /// \brief Check if the specified variable is a loop control variable for + /// Check if the specified variable is a loop control variable for /// parent region. /// \return The index of the loop control variable in the list of associated /// for-loops (from outer to inner). const LCDeclInfo isParentLoopControlVariable(const ValueDecl *D) const; - /// \brief Get the loop control variable for the I-th loop (or nullptr) in + /// Get the loop control variable for the I-th loop (or nullptr) in /// parent directive. const ValueDecl *getParentLoopControlVariable(unsigned I) const; - /// \brief Adds explicit data sharing attribute to the specified declaration. + /// Adds explicit data sharing attribute to the specified declaration. void addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A, DeclRefExpr *PrivateCopy = nullptr); @@ -296,19 +296,19 @@ public: ->getDecl() == VD; } - /// \brief Returns data sharing attributes from top of the stack for the + /// Returns data sharing attributes from top of the stack for the /// specified declaration. const DSAVarData getTopDSA(ValueDecl *D, bool FromParent); - /// \brief Returns data-sharing attributes for the specified declaration. + /// Returns data-sharing attributes for the specified declaration. const DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent) const; - /// \brief Checks if the specified variables has data-sharing attributes which + /// Checks if the specified variables has data-sharing attributes which /// match specified \a CPred predicate in any directive which matches \a DPred /// predicate. const DSAVarData hasDSA(ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> CPred, const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred, bool FromParent) const; - /// \brief Checks if the specified variables has data-sharing attributes which + /// Checks if the specified variables has data-sharing attributes which /// match specified \a CPred predicate in any innermost directive which /// matches \a DPred predicate. const DSAVarData @@ -316,49 +316,49 @@ public: const llvm::function_ref<bool(OpenMPClauseKind)> CPred, const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred, bool FromParent) const; - /// \brief Checks if the specified variables has explicit data-sharing + /// Checks if the specified variables has explicit data-sharing /// attributes which match specified \a CPred predicate at the specified /// OpenMP region. bool hasExplicitDSA(const ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> CPred, unsigned Level, bool NotLastprivate = false) const; - /// \brief Returns true if the directive at level \Level matches in the + /// Returns true if the directive at level \Level matches in the /// specified \a DPred predicate. bool hasExplicitDirective( const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred, unsigned Level) const; - /// \brief Finds a directive which matches specified \a DPred predicate. + /// Finds a directive which matches specified \a DPred predicate. bool hasDirective( const llvm::function_ref<bool( OpenMPDirectiveKind, const DeclarationNameInfo &, SourceLocation)> DPred, bool FromParent) const; - /// \brief Returns currently analyzed directive. + /// Returns currently analyzed directive. OpenMPDirectiveKind getCurrentDirective() const { return isStackEmpty() ? OMPD_unknown : Stack.back().first.back().Directive; } - /// \brief Returns directive kind at specified level. + /// Returns directive kind at specified level. OpenMPDirectiveKind getDirective(unsigned Level) const { assert(!isStackEmpty() && "No directive at specified level."); return Stack.back().first[Level].Directive; } - /// \brief Returns parent directive. + /// Returns parent directive. OpenMPDirectiveKind getParentDirective() const { if (isStackEmpty() || Stack.back().first.size() == 1) return OMPD_unknown; return std::next(Stack.back().first.rbegin())->Directive; } - /// \brief Set default data sharing attribute to none. + /// Set default data sharing attribute to none. void setDefaultDSANone(SourceLocation Loc) { assert(!isStackEmpty()); Stack.back().first.back().DefaultAttr = DSA_none; Stack.back().first.back().DefaultAttrLoc = Loc; } - /// \brief Set default data sharing attribute to shared. + /// Set default data sharing attribute to shared. void setDefaultDSAShared(SourceLocation Loc) { assert(!isStackEmpty()); Stack.back().first.back().DefaultAttr = DSA_shared; @@ -391,66 +391,66 @@ public: : Stack.back().first.back().DefaultMapAttrLoc; } - /// \brief Checks if the specified variable is a threadprivate. + /// Checks if the specified variable is a threadprivate. bool isThreadPrivate(VarDecl *D) { const DSAVarData DVar = getTopDSA(D, false); return isOpenMPThreadPrivate(DVar.CKind); } - /// \brief Marks current region as ordered (it has an 'ordered' clause). + /// Marks current region as ordered (it has an 'ordered' clause). void setOrderedRegion(bool IsOrdered, const Expr *Param) { assert(!isStackEmpty()); Stack.back().first.back().OrderedRegion.setInt(IsOrdered); Stack.back().first.back().OrderedRegion.setPointer(Param); } - /// \brief Returns true, if parent region is ordered (has associated + /// Returns true, if parent region is ordered (has associated /// 'ordered' clause), false - otherwise. bool isParentOrderedRegion() const { if (isStackEmpty() || Stack.back().first.size() == 1) return false; return std::next(Stack.back().first.rbegin())->OrderedRegion.getInt(); } - /// \brief Returns optional parameter for the ordered region. + /// Returns optional parameter for the ordered region. const Expr *getParentOrderedRegionParam() const { if (isStackEmpty() || Stack.back().first.size() == 1) return nullptr; return std::next(Stack.back().first.rbegin())->OrderedRegion.getPointer(); } - /// \brief Marks current region as nowait (it has a 'nowait' clause). + /// Marks current region as nowait (it has a 'nowait' clause). void setNowaitRegion(bool IsNowait = true) { assert(!isStackEmpty()); Stack.back().first.back().NowaitRegion = IsNowait; } - /// \brief Returns true, if parent region is nowait (has associated + /// Returns true, if parent region is nowait (has associated /// 'nowait' clause), false - otherwise. bool isParentNowaitRegion() const { if (isStackEmpty() || Stack.back().first.size() == 1) return false; return std::next(Stack.back().first.rbegin())->NowaitRegion; } - /// \brief Marks parent region as cancel region. + /// Marks parent region as cancel region. void setParentCancelRegion(bool Cancel = true) { if (!isStackEmpty() && Stack.back().first.size() > 1) { auto &StackElemRef = *std::next(Stack.back().first.rbegin()); StackElemRef.CancelRegion |= StackElemRef.CancelRegion || Cancel; } } - /// \brief Return true if current region has inner cancel construct. + /// Return true if current region has inner cancel construct. bool isCancelRegion() const { return isStackEmpty() ? false : Stack.back().first.back().CancelRegion; } - /// \brief Set collapse value for the region. + /// Set collapse value for the region. void setAssociatedLoops(unsigned Val) { assert(!isStackEmpty()); Stack.back().first.back().AssociatedLoops = Val; } - /// \brief Return collapse value for region. + /// Return collapse value for region. unsigned getAssociatedLoops() const { return isStackEmpty() ? 0 : Stack.back().first.back().AssociatedLoops; } - /// \brief Marks current target region as one with closely nested teams + /// Marks current target region as one with closely nested teams /// region. void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) { if (!isStackEmpty() && Stack.back().first.size() > 1) { @@ -458,11 +458,11 @@ public: TeamsRegionLoc; } } - /// \brief Returns true, if current region has closely nested teams region. + /// Returns true, if current region has closely nested teams region. bool hasInnerTeamsRegion() const { return getInnerTeamsRegionLoc().isValid(); } - /// \brief Returns location of the nested teams region (if any). + /// Returns location of the nested teams region (if any). SourceLocation getInnerTeamsRegionLoc() const { return isStackEmpty() ? SourceLocation() : Stack.back().first.back().InnerTeamsRegionLoc; @@ -822,7 +822,7 @@ void DSAStackTy::addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A, } } -/// \brief Build a variable declaration for OpenMP loop iteration variable. +/// Build a variable declaration for OpenMP loop iteration variable. static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type, StringRef Name, const AttrVec *Attrs = nullptr, DeclRefExpr *OrigRef = nullptr) { @@ -3656,99 +3656,99 @@ StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, } namespace { -/// \brief Helper class for checking canonical form of the OpenMP loops and +/// Helper class for checking canonical form of the OpenMP loops and /// extracting iteration space of each loop in the loop nest, that will be used /// for IR generation. class OpenMPIterationSpaceChecker { - /// \brief Reference to Sema. + /// Reference to Sema. Sema &SemaRef; - /// \brief A location for diagnostics (when there is no some better location). + /// A location for diagnostics (when there is no some better location). SourceLocation DefaultLoc; - /// \brief A location for diagnostics (when increment is not compatible). + /// A location for diagnostics (when increment is not compatible). SourceLocation ConditionLoc; - /// \brief A source location for referring to loop init later. + /// A source location for referring to loop init later. SourceRange InitSrcRange; - /// \brief A source location for referring to condition later. + /// A source location for referring to condition later. SourceRange ConditionSrcRange; - /// \brief A source location for referring to increment later. + /// A source location for referring to increment later. SourceRange IncrementSrcRange; - /// \brief Loop variable. + /// Loop variable. ValueDecl *LCDecl = nullptr; - /// \brief Reference to loop variable. + /// Reference to loop variable. Expr *LCRef = nullptr; - /// \brief Lower bound (initializer for the var). + /// Lower bound (initializer for the var). Expr *LB = nullptr; - /// \brief Upper bound. + /// Upper bound. Expr *UB = nullptr; - /// \brief Loop step (increment). + /// Loop step (increment). Expr *Step = nullptr; - /// \brief This flag is true when condition is one of: + /// This flag is true when condition is one of: /// Var < UB /// Var <= UB /// UB > Var /// UB >= Var bool TestIsLessOp = false; - /// \brief This flag is true when condition is strict ( < or > ). + /// This flag is true when condition is strict ( < or > ). bool TestIsStrictOp = false; - /// \brief This flag is true when step is subtracted on each iteration. + /// This flag is true when step is subtracted on each iteration. bool SubtractStep = false; public: OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc) : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {} - /// \brief Check init-expr for canonical loop form and save loop counter + /// Check init-expr for canonical loop form and save loop counter /// variable - #Var and its initialization value - #LB. bool checkAndSetInit(Stmt *S, bool EmitDiags = true); - /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags + /// Check test-expr for canonical form, save upper-bound (#UB), flags /// for less/greater and for strict/non-strict comparison. bool checkAndSetCond(Expr *S); - /// \brief Check incr-expr for canonical loop form and return true if it + /// Check incr-expr for canonical loop form and return true if it /// does not conform, otherwise save loop step (#Step). bool checkAndSetInc(Expr *S); - /// \brief Return the loop counter variable. + /// Return the loop counter variable. ValueDecl *getLoopDecl() const { return LCDecl; } - /// \brief Return the reference expression to loop counter variable. + /// Return the reference expression to loop counter variable. Expr *getLoopDeclRefExpr() const { return LCRef; } - /// \brief Source range of the loop init. + /// Source range of the loop init. SourceRange getInitSrcRange() const { return InitSrcRange; } - /// \brief Source range of the loop condition. + /// Source range of the loop condition. SourceRange getConditionSrcRange() const { return ConditionSrcRange; } - /// \brief Source range of the loop increment. + /// Source range of the loop increment. SourceRange getIncrementSrcRange() const { return IncrementSrcRange; } - /// \brief True if the step should be subtracted. + /// True if the step should be subtracted. bool shouldSubtractStep() const { return SubtractStep; } - /// \brief Build the expression to calculate the number of iterations. + /// Build the expression to calculate the number of iterations. Expr *buildNumIterations( Scope *S, const bool LimitedType, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const; - /// \brief Build the precondition expression for the loops. + /// Build the precondition expression for the loops. Expr * buildPreCond(Scope *S, Expr *Cond, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const; - /// \brief Build reference expression to the counter be used for codegen. + /// Build reference expression to the counter be used for codegen. DeclRefExpr * buildCounterVar(llvm::MapVector<const Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const; - /// \brief Build reference expression to the private counter be used for + /// Build reference expression to the private counter be used for /// codegen. Expr *buildPrivateCounterVar() const; - /// \brief Build initialization of the counter be used for codegen. + /// Build initialization of the counter be used for codegen. Expr *buildCounterInit() const; - /// \brief Build step of the counter be used for codegen. + /// Build step of the counter be used for codegen. Expr *buildCounterStep() const; - /// \brief Return true if any expression is dependent. + /// Return true if any expression is dependent. bool dependent() const; private: - /// \brief Check the right-hand side of an assignment in the increment + /// Check the right-hand side of an assignment in the increment /// expression. bool checkAndSetIncRHS(Expr *RHS); - /// \brief Helper to set loop counter variable and its initializer. + /// Helper to set loop counter variable and its initializer. bool setLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB); - /// \brief Helper to set upper bound. + /// Helper to set upper bound. bool setUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR, SourceLocation SL); - /// \brief Helper to set loop increment. + /// Helper to set loop increment. bool setStep(Expr *NewStep, bool Subtract); }; @@ -3930,7 +3930,7 @@ bool OpenMPIterationSpaceChecker::checkAndSetInit(Stmt *S, bool EmitDiags) { return true; } -/// \brief Ignore parenthesizes, implicit casts, copy constructor and return the +/// Ignore parenthesizes, implicit casts, copy constructor and return the /// variable (which may be the loop variable) if possible. static const ValueDecl *getInitLCDecl(const Expr *E) { if (!E) @@ -4134,7 +4134,7 @@ tryBuildCapture(Sema &SemaRef, Expr *Capture, return Res; } -/// \brief Build the expression to calculate the number of iterations. +/// Build the expression to calculate the number of iterations. Expr *OpenMPIterationSpaceChecker::buildNumIterations( Scope *S, const bool LimitedType, llvm::MapVector<const Expr *, DeclRefExpr *> &Captures) const { @@ -4260,7 +4260,7 @@ Expr *OpenMPIterationSpaceChecker::buildPreCond( return CondExpr.isUsable() ? CondExpr.get() : Cond; } -/// \brief Build reference expression to the counter be used for codegen. +/// Build reference expression to the counter be used for codegen. DeclRefExpr *OpenMPIterationSpaceChecker::buildCounterVar( llvm::MapVector<const Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const { auto *VD = dyn_cast<VarDecl>(LCDecl); @@ -4296,35 +4296,35 @@ Expr *OpenMPIterationSpaceChecker::buildPrivateCounterVar() const { return nullptr; } -/// \brief Build initialization of the counter to be used for codegen. +/// Build initialization of the counter to be used for codegen. Expr *OpenMPIterationSpaceChecker::buildCounterInit() const { return LB; } -/// \brief Build step of the counter be used for codegen. +/// Build step of the counter be used for codegen. Expr *OpenMPIterationSpaceChecker::buildCounterStep() const { return Step; } -/// \brief Iteration space of a single for loop. +/// Iteration space of a single for loop. struct LoopIterationSpace final { - /// \brief Condition of the loop. + /// Condition of the loop. Expr *PreCond = nullptr; - /// \brief This expression calculates the number of iterations in the loop. + /// This expression calculates the number of iterations in the loop. /// It is always possible to calculate it before starting the loop. Expr *NumIterations = nullptr; - /// \brief The loop counter variable. + /// The loop counter variable. Expr *CounterVar = nullptr; - /// \brief Private loop counter variable. + /// Private loop counter variable. Expr *PrivateCounterVar = nullptr; - /// \brief This is initializer for the initial value of #CounterVar. + /// This is initializer for the initial value of #CounterVar. Expr *CounterInit = nullptr; - /// \brief This is step for the #CounterVar used to generate its update: + /// This is step for the #CounterVar used to generate its update: /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration. Expr *CounterStep = nullptr; - /// \brief Should step be subtracted? + /// Should step be subtracted? bool Subtract = false; - /// \brief Source range of the loop init. + /// Source range of the loop init. SourceRange InitSrcRange; - /// \brief Source range of the loop condition. + /// Source range of the loop condition. SourceRange CondSrcRange; - /// \brief Source range of the loop increment. + /// Source range of the loop increment. SourceRange IncSrcRange; }; @@ -4356,7 +4356,7 @@ void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) { } } -/// \brief Called on a for stmt to check and extract its iteration space +/// Called on a for stmt to check and extract its iteration space /// for further processing (such as collapsing). static bool checkOpenMPIterationSpace( OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA, @@ -4510,7 +4510,7 @@ static bool checkOpenMPIterationSpace( return HasErrors; } -/// \brief Build 'VarRef = Start. +/// Build 'VarRef = Start. static ExprResult buildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef, ExprResult Start, @@ -4533,7 +4533,7 @@ buildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef, return Init; } -/// \brief Build 'VarRef = Start + Iter * Step'. +/// Build 'VarRef = Start + Iter * Step'. static ExprResult buildCounterUpdate( Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef, ExprResult Start, ExprResult Iter, ExprResult Step, bool Subtract, @@ -4604,7 +4604,7 @@ static ExprResult buildCounterUpdate( return Update; } -/// \brief Convert integer expression \a E to make it have at least \a Bits +/// Convert integer expression \a E to make it have at least \a Bits /// bits. static ExprResult widenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) { if (E == nullptr) @@ -4620,7 +4620,7 @@ static ExprResult widenIterationCount(unsigned Bits, Expr *E, Sema &SemaRef) { true); } -/// \brief Check if the given expression \a E is a constant integer that fits +/// Check if the given expression \a E is a constant integer that fits /// into \a Bits bits. static bool fitsInto(unsigned Bits, bool Signed, const Expr *E, Sema &SemaRef) { if (E == nullptr) @@ -4675,7 +4675,7 @@ static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) { return PostUpdate; } -/// \brief Called on a for stmt to check itself and nested loops (if any). +/// Called on a for stmt to check itself and nested loops (if any). /// \return Returns 0 if one of the collapsed stmts is not canonical for loop, /// number of collapsed loops otherwise. static unsigned @@ -5863,50 +5863,50 @@ StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, } namespace { -/// \brief Helper class for checking expression in 'omp atomic [update]' +/// Helper class for checking expression in 'omp atomic [update]' /// construct. class OpenMPAtomicUpdateChecker { - /// \brief Error results for atomic update expressions. + /// Error results for atomic update expressions. enum ExprAnalysisErrorCode { - /// \brief A statement is not an expression statement. + /// A statement is not an expression statement. NotAnExpression, - /// \brief Expression is not builtin binary or unary operation. + /// Expression is not builtin binary or unary operation. NotABinaryOrUnaryExpression, - /// \brief Unary operation is not post-/pre- increment/decrement operation. + /// Unary operation is not post-/pre- increment/decrement operation. NotAnUnaryIncDecExpression, - /// \brief An expression is not of scalar type. + /// An expression is not of scalar type. NotAScalarType, - /// \brief A binary operation is not an assignment operation. + /// A binary operation is not an assignment operation. NotAnAssignmentOp, - /// \brief RHS part of the binary operation is not a binary expression. + /// RHS part of the binary operation is not a binary expression. NotABinaryExpression, - /// \brief RHS part is not additive/multiplicative/shift/biwise binary + /// RHS part is not additive/multiplicative/shift/biwise binary /// expression. NotABinaryOperator, - /// \brief RHS binary operation does not have reference to the updated LHS + /// RHS binary operation does not have reference to the updated LHS /// part. NotAnUpdateExpression, - /// \brief No errors is found. + /// No errors is found. NoError }; - /// \brief Reference to Sema. + /// Reference to Sema. Sema &SemaRef; - /// \brief A location for note diagnostics (when error is found). + /// A location for note diagnostics (when error is found). SourceLocation NoteLoc; - /// \brief 'x' lvalue part of the source atomic expression. + /// 'x' lvalue part of the source atomic expression. Expr *X; - /// \brief 'expr' rvalue part of the source atomic expression. + /// 'expr' rvalue part of the source atomic expression. Expr *E; - /// \brief Helper expression of the form + /// Helper expression of the form /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'. Expr *UpdateExpr; - /// \brief Is 'x' a LHS in a RHS part of full update expression. It is + /// Is 'x' a LHS in a RHS part of full update expression. It is /// important for non-associative operations. bool IsXLHSInRHSPart; BinaryOperatorKind Op; SourceLocation OpLoc; - /// \brief true if the source expression is a postfix unary operation, false + /// true if the source expression is a postfix unary operation, false /// if it is a prefix unary operation. bool IsPostfixUpdate; @@ -5914,7 +5914,7 @@ public: OpenMPAtomicUpdateChecker(Sema &SemaRef) : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr), IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {} - /// \brief Check specified statement that it is suitable for 'atomic update' + /// Check specified statement that it is suitable for 'atomic update' /// constructs and extract 'x', 'expr' and Operation from the original /// expression. If DiagId and NoteId == 0, then only check is performed /// without error notification. @@ -5922,19 +5922,19 @@ public: /// \param NoteId Diagnostic note for the main error message. /// \return true if statement is not an update expression, false otherwise. bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0); - /// \brief Return the 'x' lvalue part of the source atomic expression. + /// Return the 'x' lvalue part of the source atomic expression. Expr *getX() const { return X; } - /// \brief Return the 'expr' rvalue part of the source atomic expression. + /// Return the 'expr' rvalue part of the source atomic expression. Expr *getExpr() const { return E; } - /// \brief Return the update expression used in calculation of the updated + /// Return the update expression used in calculation of the updated /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'. Expr *getUpdateExpr() const { return UpdateExpr; } - /// \brief Return true if 'x' is LHS in RHS part of full update expression, + /// Return true if 'x' is LHS in RHS part of full update expression, /// false otherwise. bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; } - /// \brief true if the source expression is a postfix unary operation, false + /// true if the source expression is a postfix unary operation, false /// if it is a prefix unary operation. bool isPostfixUpdate() const { return IsPostfixUpdate; } @@ -11654,7 +11654,7 @@ static bool checkTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef, return true; } -/// \brief Return true if it can be proven that the provided array expression +/// Return true if it can be proven that the provided array expression /// (array section or array subscript) does NOT specify the whole size of the /// array whose base type is \a BaseQTy. static bool checkArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef, 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., '+'). diff --git a/clang/lib/Sema/SemaPseudoObject.cpp b/clang/lib/Sema/SemaPseudoObject.cpp index 988797725dc..4484e9b3513 100644 --- a/clang/lib/Sema/SemaPseudoObject.cpp +++ b/clang/lib/Sema/SemaPseudoObject.cpp @@ -253,7 +253,7 @@ namespace { virtual ExprResult buildGet() = 0; virtual ExprResult buildSet(Expr *, SourceLocation, bool captureSetValueAsResult) = 0; - /// \brief Should the result of an assignment be the formal result of the + /// Should the result of an assignment be the formal result of the /// setter call or the value that was passed to the setter? /// /// Different pseudo-object language features use different language rules diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index d3224b75f45..ccf25ee9ebe 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -121,7 +121,7 @@ void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) { } } -/// \brief Diagnose unused comparisons, both builtin and overloaded operators. +/// Diagnose unused comparisons, both builtin and overloaded operators. /// For '==' and '!=', suggest fixits for '=' or '|='. /// /// Adding a cast to void (or other expression wrappers) will prevent the @@ -2121,7 +2121,7 @@ StmtResult Sema::ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, DS, RParenLoc, Kind); } -/// \brief Create the initialization, compare, and increment steps for +/// Create the initialization, compare, and increment steps for /// the range-based for loop expression. /// This function does not handle array-based for loops, /// which are created in Sema::BuildCXXForRangeStmt. @@ -2851,7 +2851,7 @@ Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { return new (Context) BreakStmt(BreakLoc); } -/// \brief Determine whether the given expression is a candidate for +/// Determine whether the given expression is a candidate for /// copy elision in either a return statement or a throw expression. /// /// \param ReturnType If we're determining the copy elision candidate for @@ -2931,7 +2931,7 @@ bool Sema::isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD, return true; } -/// \brief Try to perform the initialization of a potentially-movable value, +/// Try to perform the initialization of a potentially-movable value, /// which is the operand to a return or throw statement. /// /// This routine implements C++14 [class.copy]p32, which attempts to treat @@ -3019,7 +3019,7 @@ static void TryMoveInitialization(Sema& S, } } -/// \brief Perform the initialization of a potentially-movable value, which +/// Perform the initialization of a potentially-movable value, which /// is the result of return value. /// /// This routine implements C++14 [class.copy]p32, which attempts to treat @@ -3131,7 +3131,7 @@ Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity, return Res; } -/// \brief Determine whether the declared return type of the specified function +/// Determine whether the declared return type of the specified function /// contains 'auto'. static bool hasDeducedReturnType(FunctionDecl *FD) { const FunctionProtoType *FPT = @@ -3303,7 +3303,7 @@ Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) { } namespace { -/// \brief Marks all typedefs in all local classes in a type referenced. +/// Marks all typedefs in all local classes in a type referenced. /// /// In a function like /// auto f() { diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp index cad398a13d9..7e26b71c048 100644 --- a/clang/lib/Sema/SemaStmtAsm.cpp +++ b/clang/lib/Sema/SemaStmtAsm.cpp @@ -109,7 +109,7 @@ static bool CheckNakedParmReference(Expr *E, Sema &S) { return false; } -/// \brief Returns true if given expression is not compatible with inline +/// Returns true if given expression is not compatible with inline /// assembly's memory constraint; false otherwise. static bool checkExprMemoryConstraintCompat(Sema &S, Expr *E, TargetInfo::ConstraintInfo &Info, diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index d5f6b640a70..a4b9086aa4c 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -46,7 +46,7 @@ clang::getTemplateParamsRange(TemplateParameterList const * const *Ps, } namespace clang { -/// \brief [temp.constr.decl]p2: A template's associated constraints are +/// [temp.constr.decl]p2: A template's associated constraints are /// defined as a single constraint-expression derived from the introduced /// constraint-expressions [ ... ]. /// @@ -65,7 +65,7 @@ static Expr *clang::formAssociatedConstraints(TemplateParameterList *Params, return Params->getRequiresClause(); } -/// \brief Determine whether the declaration found is acceptable as the name +/// Determine whether the declaration found is acceptable as the name /// of a template and, if so, return that template declaration. Otherwise, /// returns NULL. static NamedDecl *isAcceptableTemplateName(ASTContext &Context, @@ -765,7 +765,7 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, llvm_unreachable("Unhandled parsed template argument"); } -/// \brief Translates template arguments as provided by the parser +/// Translates template arguments as provided by the parser /// into template arguments used by semantic analysis. void Sema::translateTemplateArguments(const ASTTemplateArgsPtr &TemplateArgsIn, TemplateArgumentListInfo &TemplateArgs) { @@ -904,7 +904,7 @@ NamedDecl *Sema::ActOnTypeParameter(Scope *S, bool Typename, return Param; } -/// \brief Check that the type of a non-type template parameter is +/// Check that the type of a non-type template parameter is /// well-formed. /// /// \returns the (possibly-promoted) parameter type if valid; @@ -1975,7 +1975,7 @@ void Sema::DeclareImplicitDeductionGuides(TemplateDecl *Template, ->setIsCopyDeductionCandidate(); } -/// \brief Diagnose the presence of a default template argument on a +/// Diagnose the presence of a default template argument on a /// template parameter, which is ill-formed in certain contexts. /// /// \returns true if the default template argument should be dropped. @@ -2031,7 +2031,7 @@ static bool DiagnoseDefaultTemplateArgument(Sema &S, llvm_unreachable("Invalid TemplateParamListContext!"); } -/// \brief Check for unexpanded parameter packs within the template parameters +/// Check for unexpanded parameter packs within the template parameters /// of a template template parameter, recursively. static bool DiagnoseUnexpandedParameterPacks(Sema &S, TemplateTemplateParmDecl *TTP) { @@ -2062,7 +2062,7 @@ static bool DiagnoseUnexpandedParameterPacks(Sema &S, return false; } -/// \brief Checks the validity of a template parameter list, possibly +/// Checks the validity of a template parameter list, possibly /// considering the template parameter list from a previous /// declaration. /// @@ -2429,7 +2429,7 @@ static SourceRange getRangeOfTypeInNestedNameSpecifier(ASTContext &Context, return SourceRange(); } -/// \brief Match the given template parameter lists to the given scope +/// Match the given template parameter lists to the given scope /// specifier, returning the template parameter list that applies to the /// name. /// @@ -3804,7 +3804,7 @@ DeclResult Sema::ActOnVarTemplateSpecialization( } namespace { -/// \brief A partial specialization whose template arguments have matched +/// A partial specialization whose template arguments have matched /// a given template-id. struct PartialSpecMatchResult { VarTemplatePartialSpecializationDecl *Partial; @@ -4092,7 +4092,7 @@ Sema::BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS, return BuildTemplateIdExpr(SS, TemplateKWLoc, R, /*ADL*/ false, TemplateArgs); } -/// \brief Form a dependent template name. +/// Form a dependent template name. /// /// This action forms a dependent template name given the template /// name and its (presumably dependent) scope specifier. For @@ -4319,7 +4319,7 @@ bool Sema::CheckTemplateTypeArgument(TemplateTypeParmDecl *Param, return false; } -/// \brief Substitute template arguments into the default template argument for +/// Substitute template arguments into the default template argument for /// the given template type parameter. /// /// \param SemaRef the semantic analysis object for which we are performing @@ -4375,7 +4375,7 @@ SubstDefaultTemplateArgument(Sema &SemaRef, return ArgType; } -/// \brief Substitute template arguments into the default template argument for +/// Substitute template arguments into the default template argument for /// the given non-type template parameter. /// /// \param SemaRef the semantic analysis object for which we are performing @@ -4423,7 +4423,7 @@ SubstDefaultTemplateArgument(Sema &SemaRef, return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists); } -/// \brief Substitute template arguments into the default template argument for +/// Substitute template arguments into the default template argument for /// the given template template parameter. /// /// \param SemaRef the semantic analysis object for which we are performing @@ -4487,7 +4487,7 @@ SubstDefaultTemplateArgument(Sema &SemaRef, TemplateArgLists); } -/// \brief If the given template parameter has a default template +/// If the given template parameter has a default template /// argument, substitute into that default template argument and /// return the corresponding template argument. TemplateArgumentLoc @@ -4588,7 +4588,7 @@ static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(TypeLoc TLoc) { return TemplateArgumentLoc(); } -/// \brief Check that the given template argument corresponds to the given +/// Check that the given template argument corresponds to the given /// template parameter. /// /// \param Param The template parameter against which the argument will be @@ -4850,7 +4850,7 @@ bool Sema::CheckTemplateArgument(NamedDecl *Param, return false; } -/// \brief Diagnose an arity mismatch in the +/// Diagnose an arity mismatch in the static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs) { @@ -4871,7 +4871,7 @@ static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template, return true; } -/// \brief Check whether the template parameter is a pack expansion, and if so, +/// Check whether the template parameter is a pack expansion, and if so, /// determine the number of parameters produced by that expansion. For instance: /// /// \code @@ -4927,7 +4927,7 @@ static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc, return diagnoseArityMismatch(S, TD, Loc, Args); } -/// \brief Check that the given template argument list is well-formed +/// Check that the given template argument list is well-formed /// for specializing the given template. bool Sema::CheckTemplateArgumentList( TemplateDecl *Template, SourceLocation TemplateLoc, @@ -5434,7 +5434,7 @@ bool UnnamedLocalNoLinkageFinder::VisitNestedNameSpecifier( llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); } -/// \brief Check a template argument against its corresponding +/// Check a template argument against its corresponding /// template type parameter. /// /// This routine implements the semantics of C++ [temp.arg.type]. It @@ -5472,7 +5472,7 @@ enum NullPointerValueKind { NPV_Error }; -/// \brief Determine whether the given template argument is a null pointer +/// Determine whether the given template argument is a null pointer /// value of the appropriate type. static NullPointerValueKind isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, @@ -5568,7 +5568,7 @@ isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param, return NPV_NotNullPointer; } -/// \brief Checks whether the given template argument is compatible with its +/// Checks whether the given template argument is compatible with its /// template parameter. static bool CheckTemplateArgumentIsCompatibleWithParameter( Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn, @@ -5625,7 +5625,7 @@ static bool CheckTemplateArgumentIsCompatibleWithParameter( return false; } -/// \brief Checks whether the given template argument is the address +/// Checks whether the given template argument is the address /// of an object or function according to C++ [temp.arg.nontype]p1. static bool CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, @@ -5913,7 +5913,7 @@ CheckTemplateArgumentAddressOfObjectOrFunction(Sema &S, return false; } -/// \brief Checks whether the given template argument is a pointer to +/// Checks whether the given template argument is a pointer to /// member constant according to C++ [temp.arg.nontype]p1. static bool CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param, @@ -6042,7 +6042,7 @@ static bool CheckTemplateArgumentPointerToMember(Sema &S, return true; } -/// \brief Check a template argument against its corresponding +/// Check a template argument against its corresponding /// non-type template parameter. /// /// This routine implements the semantics of C++ [temp.arg.nontype]. @@ -6560,7 +6560,7 @@ static void DiagnoseTemplateParameterListArityMismatch( Sema &S, TemplateParameterList *New, TemplateParameterList *Old, Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc); -/// \brief Check a template argument against its corresponding +/// Check a template argument against its corresponding /// template template parameter. /// /// This routine implements the semantics of C++ [temp.arg.template]. @@ -6627,7 +6627,7 @@ bool Sema::CheckTemplateTemplateArgument(TemplateParameterList *Params, Arg.getLocation()); } -/// \brief Given a non-type template argument that refers to a +/// Given a non-type template argument that refers to a /// declaration and the type of its corresponding non-type template /// parameter, produce an expression that properly refers to that /// declaration. @@ -6750,7 +6750,7 @@ Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg, return BuildDeclRefExpr(VD, T, VK, Loc); } -/// \brief Construct a new expression that refers to the given +/// Construct a new expression that refers to the given /// integral template argument with the given source-location /// information. /// @@ -6810,7 +6810,7 @@ Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg, return E; } -/// \brief Match two template parameters within template parameter lists. +/// Match two template parameters within template parameter lists. static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old, bool Complain, Sema::TemplateParameterListEqualKind Kind, @@ -6913,7 +6913,7 @@ static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old, return true; } -/// \brief Diagnose a known arity mismatch when comparing template argument +/// Diagnose a known arity mismatch when comparing template argument /// lists. static void DiagnoseTemplateParameterListArityMismatch(Sema &S, @@ -6935,7 +6935,7 @@ void DiagnoseTemplateParameterListArityMismatch(Sema &S, << SourceRange(Old->getTemplateLoc(), Old->getRAngleLoc()); } -/// \brief Determine whether the given template parameter lists are +/// Determine whether the given template parameter lists are /// equivalent. /// /// \param New The new template parameter list, typically written in the @@ -7027,7 +7027,7 @@ Sema::TemplateParameterListsAreEqual(TemplateParameterList *New, return true; } -/// \brief Check whether a template can be declared within this scope. +/// Check whether a template can be declared within this scope. /// /// If the template declaration is valid in this scope, returns /// false. Otherwise, issues a diagnostic and returns true. @@ -7076,7 +7076,7 @@ Sema::CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams) { << TemplateParams->getSourceRange(); } -/// \brief Determine what kind of template specialization the given declaration +/// Determine what kind of template specialization the given declaration /// is. static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) { if (!D) @@ -7092,7 +7092,7 @@ static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D) { return TSK_Undeclared; } -/// \brief Check whether a specialization is well-formed in the current +/// Check whether a specialization is well-formed in the current /// context. /// /// This routine determines whether a template specialization can be declared @@ -7208,7 +7208,7 @@ static SourceRange findTemplateParameter(unsigned Depth, TypeLoc TL) { return Checker.MatchLoc; } -/// \brief Subroutine of Sema::CheckTemplatePartialSpecializationArgs +/// Subroutine of Sema::CheckTemplatePartialSpecializationArgs /// that checks non-type template partial specialization arguments. static bool CheckNonTypeTemplatePartialSpecializationArgs( Sema &S, SourceLocation TemplateNameLoc, NonTypeTemplateParmDecl *Param, @@ -7296,7 +7296,7 @@ static bool CheckNonTypeTemplatePartialSpecializationArgs( return false; } -/// \brief Check the non-type template arguments of a class template +/// Check the non-type template arguments of a class template /// partial specialization according to C++ [temp.class.spec]p9. /// /// \param TemplateNameLoc the location of the template name. @@ -7710,7 +7710,7 @@ Decl *Sema::ActOnTemplateDeclarator(Scope *S, return NewDecl; } -/// \brief Strips various properties off an implicit instantiation +/// Strips various properties off an implicit instantiation /// that has just been explicitly specialized. static void StripImplicitInstantiation(NamedDecl *D) { D->dropAttr<DLLImportAttr>(); @@ -7720,7 +7720,7 @@ static void StripImplicitInstantiation(NamedDecl *D) { FD->setInlineSpecified(false); } -/// \brief Compute the diagnostic location for an explicit instantiation +/// Compute the diagnostic location for an explicit instantiation // declaration or definition. static SourceLocation DiagLocForExplicitInstantiation( NamedDecl* D, SourceLocation PointOfInstantiation) { @@ -7737,7 +7737,7 @@ static SourceLocation DiagLocForExplicitInstantiation( return PrevDiagLoc; } -/// \brief Diagnose cases where we have an explicit template specialization +/// Diagnose cases where we have an explicit template specialization /// before/after an explicit template instantiation, producing diagnostics /// for those cases where they are required and determining whether the /// new specialization/instantiation will have any effect. @@ -7922,7 +7922,7 @@ Sema::CheckSpecializationInstantiationRedecl(SourceLocation NewLoc, llvm_unreachable("Missing specialization/instantiation case?"); } -/// \brief Perform semantic analysis for the given dependent function +/// Perform semantic analysis for the given dependent function /// template specialization. /// /// The only possible way to get a dependent function template specialization @@ -7962,7 +7962,7 @@ Sema::CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD, return false; } -/// \brief Perform semantic analysis for the given function template +/// Perform semantic analysis for the given function template /// specialization. /// /// This routine performs all of the semantic analysis required for an @@ -8185,7 +8185,7 @@ bool Sema::CheckFunctionTemplateSpecialization( return false; } -/// \brief Perform semantic analysis for the given non-template member +/// Perform semantic analysis for the given non-template member /// specialization. /// /// This routine performs all of the semantic analysis required for an @@ -8395,7 +8395,7 @@ void Sema::CompleteMemberSpecialization(NamedDecl *Member, llvm_unreachable("unknown member specialization kind"); } -/// \brief Check the scope of an explicit instantiation. +/// Check the scope of an explicit instantiation. /// /// \returns true if a serious error occurs, false otherwise. static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, @@ -8449,7 +8449,7 @@ static bool CheckExplicitInstantiationScope(Sema &S, NamedDecl *D, return false; } -/// \brief Determine whether the given scope specifier has a template-id in it. +/// Determine whether the given scope specifier has a template-id in it. static bool ScopeSpecifierHasTemplateId(const CXXScopeSpec &SS) { if (!SS.isSet()) return false; @@ -9503,7 +9503,7 @@ static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II, return true; } -/// \brief Build the type that describes a C++ typename specifier, +/// Build the type that describes a C++ typename specifier, /// e.g., "typename T::type". QualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, @@ -9678,7 +9678,7 @@ namespace { : TreeTransform<CurrentInstantiationRebuilder>(SemaRef), Loc(Loc), Entity(Entity) { } - /// \brief Determine whether the given type \p T has already been + /// Determine whether the given type \p T has already been /// transformed. /// /// For the purposes of type reconstruction, a type has already been @@ -9687,14 +9687,14 @@ namespace { return T.isNull() || !T->isDependentType(); } - /// \brief Returns the location of the entity whose type is being + /// Returns the location of the entity whose type is being /// rebuilt. SourceLocation getBaseLocation() { return Loc; } - /// \brief Returns the name of the entity whose type is being rebuilt. + /// Returns the name of the entity whose type is being rebuilt. DeclarationName getBaseEntity() { return Entity; } - /// \brief Sets the "base" location and entity when that + /// Sets the "base" location and entity when that /// information is known based on another transformation. void setBase(SourceLocation Loc, DeclarationName Entity) { this->Loc = Loc; @@ -9708,7 +9708,7 @@ namespace { }; } // end anonymous namespace -/// \brief Rebuilds a type within the context of the current instantiation. +/// Rebuilds a type within the context of the current instantiation. /// /// The type \p T is part of the type of an out-of-line member definition of /// a class template (or class template partial specialization) that was parsed @@ -9766,7 +9766,7 @@ bool Sema::RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS) { return false; } -/// \brief Rebuild the template parameters now that we know we're in a current +/// Rebuild the template parameters now that we know we're in a current /// instantiation. bool Sema::RebuildTemplateParamsInCurrentInstantiation( TemplateParameterList *Params) { @@ -9805,7 +9805,7 @@ bool Sema::RebuildTemplateParamsInCurrentInstantiation( return false; } -/// \brief Produces a formatted string that describes the binding of +/// Produces a formatted string that describes the binding of /// template parameters to template arguments. std::string Sema::getTemplateArgumentBindingsText(const TemplateParameterList *Params, @@ -9883,7 +9883,7 @@ bool Sema::IsInsideALocalClassWithinATemplateFunction() { } namespace { -/// \brief Walk the path from which a declaration was instantiated, and check +/// Walk the path from which a declaration was instantiated, and check /// that every explicit specialization along that path is visible. This enforces /// C++ [temp.expl.spec]/6: /// @@ -10019,7 +10019,7 @@ void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) { ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec); } -/// \brief Check whether a template partial specialization that we've discovered +/// Check whether a template partial specialization that we've discovered /// is hidden, and produce suitable diagnostics if so. void Sema::checkPartialSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) { diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index dc3c3a66c06..87968362e03 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -59,39 +59,39 @@ namespace clang { - /// \brief Various flags that control template argument deduction. + /// Various flags that control template argument deduction. /// /// These flags can be bitwise-OR'd together. enum TemplateDeductionFlags { - /// \brief No template argument deduction flags, which indicates the + /// No template argument deduction flags, which indicates the /// strictest results for template argument deduction (as used for, e.g., /// matching class template partial specializations). TDF_None = 0, - /// \brief Within template argument deduction from a function call, we are + /// Within template argument deduction from a function call, we are /// matching with a parameter type for which the original parameter was /// a reference. TDF_ParamWithReferenceType = 0x1, - /// \brief Within template argument deduction from a function call, we + /// Within template argument deduction from a function call, we /// are matching in a case where we ignore cv-qualifiers. TDF_IgnoreQualifiers = 0x02, - /// \brief Within template argument deduction from a function call, + /// Within template argument deduction from a function call, /// we are matching in a case where we can perform template argument /// deduction from a template-id of a derived class of the argument type. TDF_DerivedClass = 0x04, - /// \brief Allow non-dependent types to differ, e.g., when performing + /// Allow non-dependent types to differ, e.g., when performing /// template argument deduction from a function call where conversions /// may apply. TDF_SkipNonDependent = 0x08, - /// \brief Whether we are performing template argument deduction for + /// Whether we are performing template argument deduction for /// parameters and arguments in a top-level template argument TDF_TopLevelParameterTypeList = 0x10, - /// \brief Within template argument deduction from overload resolution per + /// Within template argument deduction from overload resolution per /// C++ [over.over] allow matching function types that are compatible in /// terms of noreturn and default calling convention adjustments, or /// similarly matching a declared template specialization against a @@ -105,7 +105,7 @@ namespace clang { using namespace clang; using namespace sema; -/// \brief Compare two APSInts, extending and switching the sign as +/// Compare two APSInts, extending and switching the sign as /// necessary to compare their values regardless of underlying type. static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { if (Y.getBitWidth() > X.getBitWidth()) @@ -163,7 +163,7 @@ static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, bool OnlyDeduced, unsigned Level, llvm::SmallBitVector &Deduced); -/// \brief If the given expression is of a form that permits the deduction +/// If the given expression is of a form that permits the deduction /// of a non-type template parameter, return the declaration of that /// non-type template parameter. static NonTypeTemplateParmDecl * @@ -188,7 +188,7 @@ getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) { return nullptr; } -/// \brief Determine whether two declaration pointers refer to the same +/// Determine whether two declaration pointers refer to the same /// declaration. static bool isSameDeclaration(Decl *X, Decl *Y) { if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) @@ -199,7 +199,7 @@ static bool isSameDeclaration(Decl *X, Decl *Y) { return X->getCanonicalDecl() == Y->getCanonicalDecl(); } -/// \brief Verify that the given, deduced template arguments are compatible. +/// Verify that the given, deduced template arguments are compatible. /// /// \returns The deduced template argument, or a NULL template argument if /// the deduced template arguments were incompatible. @@ -362,7 +362,7 @@ checkDeducedTemplateArguments(ASTContext &Context, llvm_unreachable("Invalid TemplateArgument Kind!"); } -/// \brief Deduce the value of the given non-type template parameter +/// Deduce the value of the given non-type template parameter /// as the given deduced template argument. All non-type template parameter /// deduction is funneled through here. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( @@ -410,7 +410,7 @@ static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound()); } -/// \brief Deduce the value of the given non-type template parameter +/// Deduce the value of the given non-type template parameter /// from the given integral constant. static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, @@ -424,7 +424,7 @@ static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( ValueType, Info, Deduced); } -/// \brief Deduce the value of the given non-type template parameter +/// Deduce the value of the given non-type template parameter /// from the given null pointer template argument type. static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument( Sema &S, TemplateParameterList *TemplateParams, @@ -441,7 +441,7 @@ static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument( Value->getType(), Info, Deduced); } -/// \brief Deduce the value of the given non-type template parameter +/// Deduce the value of the given non-type template parameter /// from the given type- or value-dependent expression. /// /// \returns true if deduction succeeded, false otherwise. @@ -454,7 +454,7 @@ static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( Value->getType(), Info, Deduced); } -/// \brief Deduce the value of the given non-type template parameter +/// Deduce the value of the given non-type template parameter /// from the given declaration. /// /// \returns true if deduction succeeded, false otherwise. @@ -514,7 +514,7 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_NonDeducedMismatch; } -/// \brief Deduce the template arguments by comparing the template parameter +/// Deduce the template arguments by comparing the template parameter /// type (which is a template-id) with the template argument type. /// /// \param S the Sema @@ -599,7 +599,7 @@ DeduceTemplateArguments(Sema &S, Deduced, /*NumberOfArgumentsMustMatch=*/true); } -/// \brief Determines whether the given type is an opaque type that +/// Determines whether the given type is an opaque type that /// might be more qualified when instantiated. static bool IsPossiblyOpaquelyQualifiedType(QualType T) { switch (T->getTypeClass()) { @@ -623,7 +623,7 @@ static bool IsPossiblyOpaquelyQualifiedType(QualType T) { } } -/// \brief Retrieve the depth and index of a template parameter. +/// Retrieve the depth and index of a template parameter. static std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) @@ -636,7 +636,7 @@ getDepthAndIndex(NamedDecl *ND) { return std::make_pair(TTP->getDepth(), TTP->getIndex()); } -/// \brief Retrieve the depth and index of an unexpanded parameter pack. +/// Retrieve the depth and index of an unexpanded parameter pack. static std::pair<unsigned, unsigned> getDepthAndIndex(UnexpandedParameterPack UPP) { if (const TemplateTypeParmType *TTP @@ -646,7 +646,7 @@ getDepthAndIndex(UnexpandedParameterPack UPP) { return getDepthAndIndex(UPP.first.get<NamedDecl *>()); } -/// \brief Helper function to build a TemplateParameter when we don't +/// Helper function to build a TemplateParameter when we don't /// know its type statically. static TemplateParameter makeTemplateParameter(Decl *D) { if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) @@ -805,7 +805,7 @@ public: ++PackElements; } - /// \brief Finish template argument deduction for a set of argument packs, + /// Finish template argument deduction for a set of argument packs, /// producing the argument packs and checking for consistency with prior /// deductions. Sema::TemplateDeductionResult finish() { @@ -897,7 +897,7 @@ private: } // namespace -/// \brief Deduce the template arguments by comparing the list of parameter +/// Deduce the template arguments by comparing the list of parameter /// types to the list of argument types, as in the parameter-type-lists of /// function types (C++ [temp.deduct.type]p10). /// @@ -1019,7 +1019,7 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_Success; } -/// \brief Determine whether the parameter has qualifiers that are either +/// Determine whether the parameter has qualifiers that are either /// inconsistent with or a superset of the argument's qualifiers. static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType) { @@ -1050,7 +1050,7 @@ static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, == ParamQs.getCVRQualifiers()); } -/// \brief Compare types for equality with respect to possibly compatible +/// Compare types for equality with respect to possibly compatible /// function types (noreturn adjustment, implicit calling conventions). If any /// of parameter and argument is not a function, just perform type comparison. /// @@ -1102,7 +1102,7 @@ static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex) { return false; } -/// \brief Deduce the template arguments by comparing the parameter type and +/// Deduce the template arguments by comparing the parameter type and /// the argument type (C++ [temp.deduct.type]). /// /// \param S the semantic analysis object within which we are deducing @@ -2078,7 +2078,7 @@ DeduceTemplateArguments(Sema &S, llvm_unreachable("Invalid TemplateArgument Kind!"); } -/// \brief Determine whether there is a template argument to be used for +/// Determine whether there is a template argument to be used for /// deduction. /// /// This routine "expands" argument packs in-place, overriding its input @@ -2101,7 +2101,7 @@ static bool hasTemplateArgumentForDeduction(ArrayRef<TemplateArgument> &Args, return ArgIdx < Args.size(); } -/// \brief Determine whether the given set of template arguments has a pack +/// Determine whether the given set of template arguments has a pack /// expansion that is not the last template argument. static bool hasPackExpansionBeforeEnd(ArrayRef<TemplateArgument> Args) { bool FoundPackExpansion = false; @@ -2216,7 +2216,7 @@ DeduceTemplateArguments(Sema &S, /*NumberOfArgumentsMustMatch*/false); } -/// \brief Determine whether two template arguments are the same. +/// Determine whether two template arguments are the same. static bool isSameTemplateArg(ASTContext &Context, TemplateArgument X, const TemplateArgument &Y, @@ -2277,7 +2277,7 @@ static bool isSameTemplateArg(ASTContext &Context, llvm_unreachable("Invalid TemplateArgument Kind!"); } -/// \brief Allocate a TemplateArgumentLoc where all locations have +/// Allocate a TemplateArgumentLoc where all locations have /// been initialized to the given location. /// /// \param Arg The template argument we are producing template argument @@ -2352,7 +2352,7 @@ Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, llvm_unreachable("Invalid TemplateArgument Kind!"); } -/// \brief Convert the given deduced template argument and add it to the set of +/// Convert the given deduced template argument and add it to the set of /// fully-converted template arguments. static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, @@ -2707,7 +2707,7 @@ static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( } -/// \brief Perform template argument deduction to determine whether +/// Perform template argument deduction to determine whether /// the given template arguments match the given class template /// partial specialization per C++ [temp.class.spec.match]. Sema::TemplateDeductionResult @@ -2750,7 +2750,7 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); } -/// \brief Perform template argument deduction to determine whether +/// Perform template argument deduction to determine whether /// the given template arguments match the given variable template /// partial specialization per C++ [temp.class.spec.match]. Sema::TemplateDeductionResult @@ -2791,7 +2791,7 @@ Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info); } -/// \brief Determine whether the given type T is a simple-template-id type. +/// Determine whether the given type T is a simple-template-id type. static bool isSimpleTemplateIdType(QualType T) { if (const TemplateSpecializationType *Spec = T->getAs<TemplateSpecializationType>()) @@ -2811,7 +2811,7 @@ static bool isSimpleTemplateIdType(QualType T) { return false; } -/// \brief Substitute the explicitly-provided template arguments into the +/// Substitute the explicitly-provided template arguments into the /// given function template according to C++ [temp.arg.explicit]. /// /// \param FunctionTemplate the function template into which the explicit @@ -3018,7 +3018,7 @@ Sema::SubstituteExplicitTemplateArguments( return TDK_Success; } -/// \brief Check whether the deduced argument type for a call to a function +/// Check whether the deduced argument type for a call to a function /// template matches the actual argument type per C++ [temp.deduct.call]p4. static Sema::TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, @@ -3164,7 +3164,7 @@ static unsigned getPackIndexForParam(Sema &S, llvm_unreachable("parameter index would not be produced from template"); } -/// \brief Finish template argument deduction for a function template, +/// Finish template argument deduction for a function template, /// checking the deduced template arguments for completeness and forming /// the function template specialization. /// @@ -3436,7 +3436,7 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, return Match; } -/// \brief Perform the adjustments to the parameter and argument types +/// Perform the adjustments to the parameter and argument types /// described in C++ [temp.deduct.call]. /// /// \returns true if the caller should not attempt to perform any template @@ -3543,7 +3543,7 @@ static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF); -/// \brief Attempt template argument deduction from an initializer list +/// Attempt template argument deduction from an initializer list /// deemed to be an argument in a function call. static Sema::TemplateDeductionResult DeduceFromInitializerList( Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, @@ -3604,7 +3604,7 @@ static Sema::TemplateDeductionResult DeduceFromInitializerList( return Sema::TDK_Success; } -/// \brief Perform template argument deduction per [temp.deduct.call] for a +/// Perform template argument deduction per [temp.deduct.call] for a /// single parameter / argument pair. static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, @@ -3637,7 +3637,7 @@ static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument( ArgType, Info, Deduced, TDF); } -/// \brief Perform template argument deduction from a function call +/// Perform template argument deduction from a function call /// (C++ [temp.deduct.call]). /// /// \param FunctionTemplate the function template for which we are performing @@ -3848,7 +3848,7 @@ QualType Sema::adjustCCAndNoReturn(QualType ArgFunctionType, ArgFunctionTypeP->getParamTypes(), EPI); } -/// \brief Deduce template arguments when taking the address of a function +/// Deduce template arguments when taking the address of a function /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to /// a template. /// @@ -3990,7 +3990,7 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( return TDK_Success; } -/// \brief Deduce template arguments for a templated conversion +/// Deduce template arguments for a templated conversion /// function (C++ [temp.deduct.conv]) and, if successful, produce a /// conversion function template specialization. Sema::TemplateDeductionResult @@ -4100,7 +4100,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, return Result; } -/// \brief Deduce template arguments for a function template when there is +/// Deduce template arguments for a function template when there is /// nothing to deduce against (C++0x [temp.arg.explicit]p3). /// /// \param FunctionTemplate the function template for which we are performing @@ -4239,7 +4239,7 @@ static bool diagnoseAutoDeductionFailure(Sema &S, } } -/// \brief Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) +/// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6) /// /// Note that this is done even if the initializer is dependent. (This is /// necessary to support partial ordering of templates using 'auto'.) @@ -4498,7 +4498,7 @@ bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, return StillUndeduced; } -/// \brief If this is a non-static member function, +/// If this is a non-static member function, static void AddImplicitObjectParameterType(ASTContext &Context, CXXMethodDecl *Method, @@ -4520,7 +4520,7 @@ AddImplicitObjectParameterType(ASTContext &Context, ArgTypes.push_back(ArgTy); } -/// \brief Determine whether the function template \p FT1 is at least as +/// Determine whether the function template \p FT1 is at least as /// specialized as \p FT2. static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, @@ -4671,7 +4671,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, return true; } -/// \brief Determine whether this a function template whose parameter-type-list +/// Determine whether this a function template whose parameter-type-list /// ends with a function parameter pack. static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { FunctionDecl *Function = FunTmpl->getTemplatedDecl(); @@ -4692,7 +4692,7 @@ static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) { return true; } -/// \brief Returns the more specialized function template according +/// Returns the more specialized function template according /// to the rules of function template partial ordering (C++ [temp.func.order]). /// /// \param FT1 the first function template @@ -4739,7 +4739,7 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, return nullptr; } -/// \brief Determine if the two templates are equivalent. +/// Determine if the two templates are equivalent. static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { if (T1 == T2) return true; @@ -4750,7 +4750,7 @@ static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) { return T1->getCanonicalDecl() == T2->getCanonicalDecl(); } -/// \brief Retrieve the most specialized of the given function template +/// Retrieve the most specialized of the given function template /// specializations. /// /// \param SpecBegin the start iterator of the function template @@ -4909,7 +4909,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2, return true; } -/// \brief Returns the more specialized class template partial specialization +/// Returns the more specialized class template partial specialization /// according to the rules of partial ordering of class template partial /// specializations (C++ [temp.class.order]). /// @@ -5064,7 +5064,7 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs( return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info); } -/// \brief Mark the template parameters that are used by the given +/// Mark the template parameters that are used by the given /// expression. static void MarkUsedTemplateParameters(ASTContext &Ctx, @@ -5108,7 +5108,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used); } -/// \brief Mark the template parameters that are used by the given +/// Mark the template parameters that are used by the given /// nested name specifier. static void MarkUsedTemplateParameters(ASTContext &Ctx, @@ -5125,7 +5125,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, OnlyDeduced, Depth, Used); } -/// \brief Mark the template parameters that are used by the given +/// Mark the template parameters that are used by the given /// template name. static void MarkUsedTemplateParameters(ASTContext &Ctx, @@ -5150,7 +5150,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, Depth, Used); } -/// \brief Mark the template parameters that are used by the given +/// Mark the template parameters that are used by the given /// type. static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, @@ -5403,7 +5403,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, } } -/// \brief Mark the template parameters that are used by this +/// Mark the template parameters that are used by this /// template argument. static void MarkUsedTemplateParameters(ASTContext &Ctx, @@ -5446,7 +5446,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, } } -/// \brief Mark which template parameters can be deduced from a given +/// Mark which template parameters can be deduced from a given /// template argument list. /// /// \param TemplateArgs the template argument list from which template @@ -5472,7 +5472,7 @@ Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs, Depth, Used); } -/// \brief Marks all of the template parameters that will be deduced by a +/// Marks all of the template parameters that will be deduced by a /// call to the given function template. void Sema::MarkDeducedTemplateParameters( ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate, diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index 5b6eb39e6b0..8e7ebe25153 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -34,7 +34,7 @@ using namespace sema; // Template Instantiation Support //===----------------------------------------------------------------------===/ -/// \brief Retrieve the template argument list(s) that should be used to +/// Retrieve the template argument list(s) that should be used to /// instantiate the definition of the given declaration. /// /// \param D the declaration for which we are computing template instantiation @@ -427,7 +427,7 @@ bool Sema::InstantiatingTemplate::CheckInstantiationDepth( return true; } -/// \brief Prints the current instantiation stack through a series of +/// Prints the current instantiation stack through a series of /// notes. void Sema::PrintInstantiationStack() { // Determine which template instantiations to skip, if any. @@ -708,7 +708,7 @@ Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { return None; } -/// \brief Retrieve the depth and index of a parameter pack. +/// Retrieve the depth and index of a parameter pack. static std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) @@ -740,20 +740,20 @@ namespace { : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc), Entity(Entity) { } - /// \brief Determine whether the given type \p T has already been + /// Determine whether the given type \p T has already been /// transformed. /// /// For the purposes of template instantiation, a type has already been /// transformed if it is NULL or if it is not dependent. bool AlreadyTransformed(QualType T); - /// \brief Returns the location of the entity being instantiated, if known. + /// Returns the location of the entity being instantiated, if known. SourceLocation getBaseLocation() { return Loc; } - /// \brief Returns the name of the entity being instantiated, if any. + /// Returns the name of the entity being instantiated, if any. DeclarationName getBaseEntity() { return Entity; } - /// \brief Sets the "base" location and entity when that + /// Sets the "base" location and entity when that /// information is known based on another transformation. void setBase(SourceLocation Loc, DeclarationName Entity) { this->Loc = Loc; @@ -808,7 +808,7 @@ namespace { } } - /// \brief Transform the given declaration by instantiating a reference to + /// Transform the given declaration by instantiating a reference to /// this declaration. Decl *TransformDecl(SourceLocation Loc, Decl *D); @@ -839,15 +839,15 @@ namespace { SemaRef.PerformDependentDiagnostics(DC, TemplateArgs); } - /// \brief Transform the definition of the given declaration by + /// Transform the definition of the given declaration by /// instantiating it. Decl *TransformDefinition(SourceLocation Loc, Decl *D); - /// \brief Transform the first qualifier within a scope by instantiating the + /// Transform the first qualifier within a scope by instantiating the /// declaration. NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc); - /// \brief Rebuild the exception declaration and register the declaration + /// Rebuild the exception declaration and register the declaration /// as an instantiated local. VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl, TypeSourceInfo *Declarator, @@ -855,12 +855,12 @@ namespace { SourceLocation NameLoc, IdentifierInfo *Name); - /// \brief Rebuild the Objective-C exception declaration and register the + /// Rebuild the Objective-C exception declaration and register the /// declaration as an instantiated local. VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl, TypeSourceInfo *TSInfo, QualType T); - /// \brief Check for tag mismatches when instantiating an + /// Check for tag mismatches when instantiating an /// elaborated type. QualType RebuildElaboratedType(SourceLocation KeywordLoc, ElaboratedTypeKeyword Keyword, @@ -885,14 +885,14 @@ namespace { ExprResult TransformSubstNonTypeTemplateParmPackExpr( SubstNonTypeTemplateParmPackExpr *E); - /// \brief Rebuild a DeclRefExpr for a ParmVarDecl reference. + /// Rebuild a DeclRefExpr for a ParmVarDecl reference. ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc); - /// \brief Transform a reference to a function parameter pack. + /// Transform a reference to a function parameter pack. ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E, ParmVarDecl *PD); - /// \brief Transform a FunctionParmPackExpr which was built when we couldn't + /// Transform a FunctionParmPackExpr which was built when we couldn't /// expand a function parameter pack reference which refers to an expanded /// pack. ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E); @@ -915,12 +915,12 @@ namespace { Optional<unsigned> NumExpansions, bool ExpectParameterPack); - /// \brief Transforms a template type parameter type by performing + /// Transforms a template type parameter type by performing /// substitution of the corresponding template type argument. QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL); - /// \brief Transforms an already-substituted template type parameter pack + /// Transforms an already-substituted template type parameter pack /// into either itself (if we aren't substituting into its pack expansion) /// or the appropriate substituted argument. QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB, @@ -1540,7 +1540,7 @@ TemplateInstantiator::TransformSubstTemplateTypeParmPackType( return Result; } -/// \brief Perform substitution on the type T with a given set of template +/// Perform substitution on the type T with a given set of template /// arguments. /// /// This routine substitutes the given template arguments into the @@ -1835,7 +1835,7 @@ ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, return NewParm; } -/// \brief Substitute the given template arguments into the given set of +/// Substitute the given template arguments into the given set of /// parameters, producing the set of parameter types that would be generated /// from such a substitution. bool Sema::SubstParmTypes( @@ -1855,7 +1855,7 @@ bool Sema::SubstParmTypes( Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos); } -/// \brief Perform substitution on the base class specifiers of the +/// Perform substitution on the base class specifiers of the /// given class template specialization. /// /// Produces a diagnostic and returns true on error, returns false and @@ -1975,7 +1975,7 @@ namespace clang { } } -/// \brief Instantiate the definition of a class from a given pattern. +/// Instantiate the definition of a class from a given pattern. /// /// \param PointOfInstantiation The point of instantiation within the /// source code. @@ -2011,7 +2011,7 @@ Sema::InstantiateClass(SourceLocation PointOfInstantiation, return true; Pattern = PatternDef; - // \brief Record the point of instantiation. + // Record the point of instantiation. if (MemberSpecializationInfo *MSInfo = Instantiation->getMemberSpecializationInfo()) { MSInfo->setTemplateSpecializationKind(TSK); @@ -2215,7 +2215,7 @@ Sema::InstantiateClass(SourceLocation PointOfInstantiation, return Instantiation->isInvalidDecl(); } -/// \brief Instantiate the definition of an enum from a given pattern. +/// Instantiate the definition of an enum from a given pattern. /// /// \param PointOfInstantiation The point of instantiation within the /// source code. @@ -2281,7 +2281,7 @@ bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation, } -/// \brief Instantiate the definition of a field from the given pattern. +/// Instantiate the definition of a field from the given pattern. /// /// \param PointOfInstantiation The point of instantiation within the /// source code. @@ -2359,7 +2359,7 @@ bool Sema::InstantiateInClassInitializer( } namespace { - /// \brief A partial specialization whose template arguments have matched + /// A partial specialization whose template arguments have matched /// a given template-id. struct PartialSpecMatchResult { ClassTemplatePartialSpecializationDecl *Partial; @@ -2544,7 +2544,7 @@ bool Sema::InstantiateClassTemplateSpecialization( Complain); } -/// \brief Instantiates the definitions of all of the member +/// Instantiates the definitions of all of the member /// of the given class, which is an instantiation of a class template /// or a member class of a template. void @@ -2751,7 +2751,7 @@ Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation, } } -/// \brief Instantiate the definitions of all of the members of the +/// Instantiate the definitions of all of the members of the /// given class template specialization, which was named as part of an /// explicit instantiation. void @@ -2827,7 +2827,7 @@ Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, return Instantiator.TransformNestedNameSpecifierLoc(NNS); } -/// \brief Do template substitution on declaration name info. +/// Do template substitution on declaration name info. DeclarationNameInfo Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo, const MultiLevelTemplateArgumentList &TemplateArgs) { diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index a7883c67b80..cd80215d044 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -1556,7 +1556,7 @@ Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { return Record; } -/// \brief Adjust the given function type for an instantiation of the +/// Adjust the given function type for an instantiation of the /// given declaration, to cope with modifications to the function's type that /// aren't reflected in the type-source information. /// @@ -3086,7 +3086,7 @@ Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner, return Instantiator.Visit(D); } -/// \brief Instantiates a nested template parameter list in the current +/// Instantiates a nested template parameter list in the current /// instantiation context. /// /// \param L The parameter list to instantiate @@ -3129,7 +3129,7 @@ Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner, return Instantiator.SubstTemplateParams(Params); } -/// \brief Instantiate the declaration of a class template partial +/// Instantiate the declaration of a class template partial /// specialization. /// /// \param ClassTemplate the (instantiated) class template that is partially @@ -3263,7 +3263,7 @@ TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization( return InstPartialSpec; } -/// \brief Instantiate the declaration of a variable template partial +/// Instantiate the declaration of a variable template partial /// specialization. /// /// \param VarTemplate the (instantiated) variable template that is partially @@ -3605,7 +3605,7 @@ void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation, TemplateArgs); } -/// \brief Initializes the common fields of an instantiation function +/// Initializes the common fields of an instantiation function /// declaration (New) from the corresponding fields of its template (Tmpl). /// /// \returns true if there was an error @@ -3693,7 +3693,7 @@ TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New, return false; } -/// \brief Initializes common fields of an instantiated method +/// Initializes common fields of an instantiated method /// declaration (New) from the corresponding fields of its template /// (Tmpl). /// @@ -3757,7 +3757,7 @@ static void InstantiateDefaultCtorDefaultArgs(Sema &S, } } -/// \brief Instantiate the definition of the given function from its +/// Instantiate the definition of the given function from its /// template. /// /// \param PointOfInstantiation the point at which the instantiation was @@ -4033,7 +4033,7 @@ VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation( VarTemplate, FromVar, InsertPos, TemplateArgsInfo, Converted)); } -/// \brief Instantiates a variable template specialization by completing it +/// Instantiates a variable template specialization by completing it /// with appropriate type information and initializer. VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl( VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl, @@ -4157,7 +4157,7 @@ void Sema::BuildVariableInstantiation( DiagnoseUnusedDecl(NewVar); } -/// \brief Instantiate the initializer of a variable. +/// Instantiate the initializer of a variable. void Sema::InstantiateVariableInitializer( VarDecl *Var, VarDecl *OldVar, const MultiLevelTemplateArgumentList &TemplateArgs) { @@ -4223,7 +4223,7 @@ void Sema::InstantiateVariableInitializer( } } -/// \brief Instantiate the definition of the given variable from its +/// Instantiate the definition of the given variable from its /// template. /// /// \param PointOfInstantiation the point at which the instantiation was @@ -4842,7 +4842,7 @@ static NamedDecl *findInstantiationOf(ASTContext &Ctx, return nullptr; } -/// \brief Finds the instantiation of the given declaration context +/// Finds the instantiation of the given declaration context /// within the current instantiation. /// /// \returns NULL if there was an error @@ -4854,7 +4854,7 @@ DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC, } else return DC; } -/// \brief Find the instantiation of the given declaration within the +/// Find the instantiation of the given declaration within the /// current instantiation. /// /// This routine is intended to be used when \p D is a declaration @@ -5167,7 +5167,7 @@ NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, return D; } -/// \brief Performs template instantiation for all implicit template +/// Performs template instantiation for all implicit template /// instantiations we have seen until this point. void Sema::PerformPendingInstantiations(bool LocalOnly) { while (!PendingLocalImplicitInstantiations.empty() || diff --git a/clang/lib/Sema/SemaTemplateVariadic.cpp b/clang/lib/Sema/SemaTemplateVariadic.cpp index 68a69091f0b..c58e648bb3b 100644 --- a/clang/lib/Sema/SemaTemplateVariadic.cpp +++ b/clang/lib/Sema/SemaTemplateVariadic.cpp @@ -26,7 +26,7 @@ using namespace clang; // Visitor that collects unexpanded parameter packs //---------------------------------------------------------------------------- -/// \brief Retrieve the depth and index of a parameter pack. +/// Retrieve the depth and index of a parameter pack. static std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) { if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND)) @@ -40,7 +40,7 @@ getDepthAndIndex(NamedDecl *ND) { } namespace { - /// \brief A class that collects unexpanded parameter packs. + /// A class that collects unexpanded parameter packs. class CollectUnexpandedParameterPacksVisitor : public RecursiveASTVisitor<CollectUnexpandedParameterPacksVisitor> { @@ -83,14 +83,14 @@ namespace { // Recording occurrences of (unexpanded) parameter packs. //------------------------------------------------------------------------ - /// \brief Record occurrences of template type parameter packs. + /// Record occurrences of template type parameter packs. bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { if (TL.getTypePtr()->isParameterPack()) addUnexpanded(TL.getTypePtr(), TL.getNameLoc()); return true; } - /// \brief Record occurrences of template type parameter packs + /// Record occurrences of template type parameter packs /// when we don't have proper source-location information for /// them. /// @@ -102,7 +102,7 @@ namespace { return true; } - /// \brief Record occurrences of function and non-type template + /// Record occurrences of function and non-type template /// parameter packs in an expression. bool VisitDeclRefExpr(DeclRefExpr *E) { if (E->getDecl()->isParameterPack()) @@ -111,7 +111,7 @@ namespace { return true; } - /// \brief Record occurrences of template template parameter packs. + /// Record occurrences of template template parameter packs. bool TraverseTemplateName(TemplateName Template) { if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>( Template.getAsTemplateDecl())) { @@ -122,7 +122,7 @@ namespace { return inherited::TraverseTemplateName(Template); } - /// \brief Suppress traversal into Objective-C container literal + /// Suppress traversal into Objective-C container literal /// elements that are pack expansions. bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { if (!E->containsUnexpandedParameterPack()) @@ -142,7 +142,7 @@ namespace { // Pruning the search for unexpanded parameter packs. //------------------------------------------------------------------------ - /// \brief Suppress traversal into statements and expressions that + /// Suppress traversal into statements and expressions that /// do not contain unexpanded parameter packs. bool TraverseStmt(Stmt *S) { Expr *E = dyn_cast_or_null<Expr>(S); @@ -152,7 +152,7 @@ namespace { return true; } - /// \brief Suppress traversal into types that do not contain + /// Suppress traversal into types that do not contain /// unexpanded parameter packs. bool TraverseType(QualType T) { if ((!T.isNull() && T->containsUnexpandedParameterPack()) || InLambda) @@ -161,7 +161,7 @@ namespace { return true; } - /// \brief Suppress traversal into types with location information + /// Suppress traversal into types with location information /// that do not contain unexpanded parameter packs. bool TraverseTypeLoc(TypeLoc TL) { if ((!TL.getType().isNull() && @@ -172,7 +172,7 @@ namespace { return true; } - /// \brief Suppress traversal of parameter packs. + /// Suppress traversal of parameter packs. bool TraverseDecl(Decl *D) { // A function parameter pack is a pack expansion, so cannot contain // an unexpanded parameter pack. Likewise for a template parameter @@ -183,7 +183,7 @@ namespace { return inherited::TraverseDecl(D); } - /// \brief Suppress traversal of pack-expanded attributes. + /// Suppress traversal of pack-expanded attributes. bool TraverseAttr(Attr *A) { if (A->isPackExpansion()) return true; @@ -191,7 +191,7 @@ namespace { return inherited::TraverseAttr(A); } - /// \brief Suppress traversal of pack expansion expressions and types. + /// Suppress traversal of pack expansion expressions and types. ///@{ bool TraversePackExpansionType(PackExpansionType *T) { return true; } bool TraversePackExpansionTypeLoc(PackExpansionTypeLoc TL) { return true; } @@ -200,7 +200,7 @@ namespace { ///@} - /// \brief Suppress traversal of using-declaration pack expansion. + /// Suppress traversal of using-declaration pack expansion. bool TraverseUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { if (D->isPackExpansion()) return true; @@ -208,7 +208,7 @@ namespace { return inherited::TraverseUnresolvedUsingValueDecl(D); } - /// \brief Suppress traversal of using-declaration pack expansion. + /// Suppress traversal of using-declaration pack expansion. bool TraverseUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { if (D->isPackExpansion()) return true; @@ -216,7 +216,7 @@ namespace { return inherited::TraverseUnresolvedUsingTypenameDecl(D); } - /// \brief Suppress traversal of template argument pack expansions. + /// Suppress traversal of template argument pack expansions. bool TraverseTemplateArgument(const TemplateArgument &Arg) { if (Arg.isPackExpansion()) return true; @@ -224,7 +224,7 @@ namespace { return inherited::TraverseTemplateArgument(Arg); } - /// \brief Suppress traversal of template argument pack expansions. + /// Suppress traversal of template argument pack expansions. bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) { if (ArgLoc.getArgument().isPackExpansion()) return true; @@ -232,7 +232,7 @@ namespace { return inherited::TraverseTemplateArgumentLoc(ArgLoc); } - /// \brief Suppress traversal of base specifier pack expansions. + /// Suppress traversal of base specifier pack expansions. bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base) { if (Base.isPackExpansion()) return true; @@ -240,7 +240,7 @@ namespace { return inherited::TraverseCXXBaseSpecifier(Base); } - /// \brief Suppress traversal of mem-initializer pack expansions. + /// Suppress traversal of mem-initializer pack expansions. bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { if (Init->isPackExpansion()) return true; @@ -248,7 +248,7 @@ namespace { return inherited::TraverseConstructorInitializer(Init); } - /// \brief Note whether we're traversing a lambda containing an unexpanded + /// Note whether we're traversing a lambda containing an unexpanded /// parameter pack. In this case, the unexpanded pack can occur anywhere, /// including all the places where we normally wouldn't look. Within a /// lambda, we don't propagate the 'contains unexpanded parameter pack' bit @@ -284,7 +284,7 @@ namespace { }; } -/// \brief Determine whether it's possible for an unexpanded parameter pack to +/// Determine whether it's possible for an unexpanded parameter pack to /// be valid in this location. This only happens when we're in a declaration /// that is nested within an expression that could be expanded, such as a /// lambda-expression within a function call. @@ -298,7 +298,7 @@ bool Sema::isUnexpandedParameterPackPermitted() { return false; } -/// \brief Diagnose all of the unexpanded parameter packs in the given +/// Diagnose all of the unexpanded parameter packs in the given /// vector. bool Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc, @@ -917,7 +917,7 @@ class ParameterPackValidatorCCC : public CorrectionCandidateCallback { } -/// \brief Called when an expression computing the size of a parameter pack +/// Called when an expression computing the size of a parameter pack /// is parsed. /// /// \code diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 80ab5dc6b41..38a06c02078 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -615,7 +615,7 @@ distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, state.addIgnoredTypeAttr(attr); } -/// \brief Given that there are attributes written on the declarator +/// Given that there are attributes written on the declarator /// itself, try to distribute any type attributes to the appropriate /// declarator chunk. /// @@ -1225,7 +1225,7 @@ static OpenCLAccessAttr::Spelling getImageAccess(const AttributeList *Attrs) { return OpenCLAccessAttr::Keyword_read_only; } -/// \brief Convert the specified declspec to the appropriate type +/// Convert the specified declspec to the appropriate type /// object. /// \param state Specifies the declarator containing the declaration specifier /// to be converted, along with other associated processing state. @@ -1755,7 +1755,7 @@ QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, return BuildQualifiedType(T, Loc, Q, DS); } -/// \brief Build a paren type including \p T. +/// Build a paren type including \p T. QualType Sema::BuildParenType(QualType T) { return Context.getParenType(T); } @@ -1865,7 +1865,7 @@ static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, return true; } -/// \brief Build a pointer type. +/// Build a pointer type. /// /// \param T The type to which we'll be building a pointer. /// @@ -1905,7 +1905,7 @@ QualType Sema::BuildPointerType(QualType T, return Context.getPointerType(T); } -/// \brief Build a reference type. +/// Build a reference type. /// /// \param T The type to which we'll be building a reference. /// @@ -1967,7 +1967,7 @@ QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, return Context.getRValueReferenceType(T); } -/// \brief Build a Read-only Pipe type. +/// Build a Read-only Pipe type. /// /// \param T The type to which we'll be building a Pipe. /// @@ -1979,7 +1979,7 @@ QualType Sema::BuildReadPipeType(QualType T, SourceLocation Loc) { return Context.getReadPipeType(T); } -/// \brief Build a Write-only Pipe type. +/// Build a Write-only Pipe type. /// /// \param T The type to which we'll be building a Pipe. /// @@ -2013,7 +2013,7 @@ static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) { S.LangOpts.OpenCL).isInvalid(); } -/// \brief Build an array type. +/// Build an array type. /// /// \param T The type of each element in the array. /// @@ -2238,7 +2238,7 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, return T; } -/// \brief Build an ext-vector type. +/// Build an ext-vector type. /// /// Run the required checks for the extended vector type. QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, @@ -2409,7 +2409,7 @@ QualType Sema::BuildFunctionType(QualType T, return Context.getFunctionType(T, ParamTypes, EPI); } -/// \brief Build a member pointer type \c T Class::*. +/// Build a member pointer type \c T Class::*. /// /// \param T the type to which the member pointer refers. /// \param Class the class type into which the member pointer points. @@ -2458,7 +2458,7 @@ QualType Sema::BuildMemberPointerType(QualType T, QualType Class, return Context.getMemberPointerType(T, Class.getTypePtr()); } -/// \brief Build a block pointer type. +/// Build a block pointer type. /// /// \param T The type to which we'll be building a block pointer. /// @@ -5064,7 +5064,7 @@ static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, // TODO: mark whether we did this inference? } -/// \brief Used for transferring ownership in casts resulting in l-values. +/// Used for transferring ownership in casts resulting in l-values. static void transferARCOwnership(TypeProcessingState &state, QualType &declSpecTy, Qualifiers::ObjCLifetime ownership) { @@ -5571,7 +5571,7 @@ static void fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL, DASTL.setAttrOperandParensRange(SourceRange()); } -/// \brief Create and instantiate a TypeSourceInfo with type source information. +/// Create and instantiate a TypeSourceInfo with type source information. /// /// \param T QualType referring to the type as written in source code. /// @@ -5633,7 +5633,7 @@ Sema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, return TInfo; } -/// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo. +/// Create a LocInfoType to hold the given QualType and TypeSourceInfo. ParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) { // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser // and Sema during declaration parsing. Try deallocating/caching them when @@ -6907,7 +6907,7 @@ static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr, VectorType::GenericVector); } -/// \brief Process the OpenCL-like ext_vector_type attribute when it occurs on +/// Process the OpenCL-like ext_vector_type attribute when it occurs on /// a type. static void HandleExtVectorTypeAttr(QualType &CurType, const AttributeList &Attr, @@ -7390,7 +7390,7 @@ void Sema::completeExprArrayBound(Expr *E) { } } -/// \brief Ensure that the type of the given expression is complete. +/// Ensure that the type of the given expression is complete. /// /// This routine checks whether the expression \p E has a complete type. If the /// expression refers to an instantiable construct, that instantiation is @@ -7427,7 +7427,7 @@ bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) { return RequireCompleteExprType(E, Diagnoser); } -/// @brief Ensure that the type T is a complete type. +/// Ensure that the type T is a complete type. /// /// This routine checks whether the type @p T is complete in any /// context where a complete type is required. If @p T is a complete @@ -7471,7 +7471,7 @@ bool Sema::hasStructuralCompatLayout(Decl *D, Decl *Suggested) { return Ctx.IsStructurallyEquivalent(D, Suggested); } -/// \brief Determine whether there is any declaration of \p D that was ever a +/// Determine whether there is any declaration of \p D that was ever a /// definition (perhaps before module merging) and is currently visible. /// \param D The definition of the entity. /// \param Suggested Filled in with the declaration that should be made visible @@ -7571,7 +7571,7 @@ static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) { } } -/// \brief The implementation of RequireCompleteType +/// The implementation of RequireCompleteType bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, TypeDiagnoser *Diagnoser) { // FIXME: Add this assertion to make sure we always get instantiation points. @@ -7750,7 +7750,7 @@ bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, return RequireCompleteType(Loc, T, Diagnoser); } -/// \brief Get diagnostic %select index for tag kind for +/// Get diagnostic %select index for tag kind for /// literal type diagnostic message. /// WARNING: Indexes apply to particular diagnostics only! /// @@ -7764,7 +7764,7 @@ static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) { } } -/// @brief Ensure that the type T is a literal type. +/// Ensure that the type T is a literal type. /// /// This routine checks whether the type @p T is a literal type. If @p T is an /// incomplete type, an attempt is made to complete it. If @p T is a literal @@ -7863,7 +7863,7 @@ bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) { return RequireLiteralType(Loc, T, Diagnoser); } -/// \brief Retrieve a version of the type 'T' that is elaborated by Keyword +/// Retrieve a version of the type 'T' that is elaborated by Keyword /// and qualified by the nested-name-specifier contained in SS. QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword, const CXXScopeSpec &SS, QualType T) { diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index ee38278b5a8..938a966dbc5 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -41,7 +41,7 @@ namespace clang { using namespace sema; -/// \brief A semantic tree transformation that allows one to transform one +/// A semantic tree transformation that allows one to transform one /// abstract syntax tree into another. /// /// A new tree transformation is defined by creating a new subclass \c X of @@ -94,7 +94,7 @@ using namespace sema; /// (\c getBaseLocation(), \c getBaseEntity()). template<typename Derived> class TreeTransform { - /// \brief Private RAII object that helps us forget and then re-remember + /// Private RAII object that helps us forget and then re-remember /// the template argument corresponding to a partially-substituted parameter /// pack. class ForgetPartiallySubstitutedPackRAII { @@ -114,19 +114,19 @@ class TreeTransform { protected: Sema &SemaRef; - /// \brief The set of local declarations that have been transformed, for + /// The set of local declarations that have been transformed, for /// cases where we are forced to build new declarations within the transformer /// rather than in the subclass (e.g., lambda closure types). llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls; public: - /// \brief Initializes a new tree transformer. + /// Initializes a new tree transformer. TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { } - /// \brief Retrieves a reference to the derived class. + /// Retrieves a reference to the derived class. Derived &getDerived() { return static_cast<Derived&>(*this); } - /// \brief Retrieves a reference to the derived class. + /// Retrieves a reference to the derived class. const Derived &getDerived() const { return static_cast<const Derived&>(*this); } @@ -134,11 +134,11 @@ public: static inline ExprResult Owned(Expr *E) { return E; } static inline StmtResult Owned(Stmt *S) { return S; } - /// \brief Retrieves a reference to the semantic analysis object used for + /// Retrieves a reference to the semantic analysis object used for /// this tree transform. Sema &getSema() const { return SemaRef; } - /// \brief Whether the transformation should always rebuild AST nodes, even + /// Whether the transformation should always rebuild AST nodes, even /// if none of the children have changed. /// /// Subclasses may override this function to specify when the transformation @@ -149,7 +149,7 @@ public: /// statement node appears at most once in its containing declaration. bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; } - /// \brief Returns the location of the entity being transformed, if that + /// Returns the location of the entity being transformed, if that /// information was not available elsewhere in the AST. /// /// By default, returns no source-location information. Subclasses can @@ -157,21 +157,21 @@ public: /// information. SourceLocation getBaseLocation() { return SourceLocation(); } - /// \brief Returns the name of the entity being transformed, if that + /// Returns the name of the entity being transformed, if that /// information was not available elsewhere in the AST. /// /// By default, returns an empty name. Subclasses can provide an alternative /// implementation with a more precise name. DeclarationName getBaseEntity() { return DeclarationName(); } - /// \brief Sets the "base" location and entity when that + /// Sets the "base" location and entity when that /// information is known based on another transformation. /// /// By default, the source location and entity are ignored. Subclasses can /// override this function to provide a customized implementation. void setBase(SourceLocation Loc, DeclarationName Entity) { } - /// \brief RAII object that temporarily sets the base location and entity + /// RAII object that temporarily sets the base location and entity /// used for reporting diagnostics in types. class TemporaryBase { TreeTransform &Self; @@ -193,7 +193,7 @@ public: } }; - /// \brief Determine whether the given type \p T has already been + /// Determine whether the given type \p T has already been /// transformed. /// /// Subclasses can provide an alternative implementation of this routine @@ -204,7 +204,7 @@ public: return T.isNull(); } - /// \brief Determine whether the given call argument should be dropped, e.g., + /// Determine whether the given call argument should be dropped, e.g., /// because it is a default argument. /// /// Subclasses can provide an alternative implementation of this routine to @@ -214,7 +214,7 @@ public: return E->isDefaultArgument(); } - /// \brief Determine whether we should expand a pack expansion with the + /// Determine whether we should expand a pack expansion with the /// given set of parameter packs into separate arguments by repeatedly /// transforming the pattern. /// @@ -261,7 +261,7 @@ public: return false; } - /// \brief "Forget" about the partially-substituted pack template argument, + /// "Forget" about the partially-substituted pack template argument, /// when performing an instantiation that must preserve the parameter pack /// use. /// @@ -270,18 +270,18 @@ public: return TemplateArgument(); } - /// \brief "Remember" the partially-substituted pack template argument + /// "Remember" the partially-substituted pack template argument /// after performing an instantiation that must preserve the parameter pack /// use. /// /// This routine is meant to be overridden by the template instantiator. void RememberPartiallySubstitutedPack(TemplateArgument Arg) { } - /// \brief Note to the derived class when a function parameter pack is + /// Note to the derived class when a function parameter pack is /// being expanded. void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { } - /// \brief Transforms the given type into another type. + /// Transforms the given type into another type. /// /// By default, this routine transforms a type by creating a /// TypeSourceInfo for it and delegating to the appropriate @@ -292,7 +292,7 @@ public: /// \returns the transformed type. QualType TransformType(QualType T); - /// \brief Transforms the given type-with-location into a new + /// Transforms the given type-with-location into a new /// type-with-location. /// /// By default, this routine transforms a type by delegating to the @@ -302,13 +302,13 @@ public: /// to alter the transformation. TypeSourceInfo *TransformType(TypeSourceInfo *DI); - /// \brief Transform the given type-with-location into a new + /// Transform the given type-with-location into a new /// type, collecting location information in the given builder /// as necessary. /// QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL); - /// \brief Transform a type that is permitted to produce a + /// Transform a type that is permitted to produce a /// DeducedTemplateSpecializationType. /// /// This is used in the (relatively rare) contexts where it is acceptable @@ -319,7 +319,7 @@ public: TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *DI); /// @} - /// \brief Transform the given statement. + /// Transform the given statement. /// /// By default, this routine transforms a statement by delegating to the /// appropriate TransformXXXStmt function to transform a specific kind of @@ -330,7 +330,7 @@ public: /// \returns the transformed statement. StmtResult TransformStmt(Stmt *S); - /// \brief Transform the given statement. + /// Transform the given statement. /// /// By default, this routine transforms a statement by delegating to the /// appropriate TransformOMPXXXClause function to transform a specific kind @@ -340,7 +340,7 @@ public: /// \returns the transformed OpenMP clause. OMPClause *TransformOMPClause(OMPClause *S); - /// \brief Transform the given attribute. + /// Transform the given attribute. /// /// By default, this routine transforms a statement by delegating to the /// appropriate TransformXXXAttr function to transform a specific kind @@ -350,7 +350,7 @@ public: /// \returns the transformed attribute const Attr *TransformAttr(const Attr *S); -/// \brief Transform the specified attribute. +/// Transform the specified attribute. /// /// Subclasses should override the transformation of attributes with a pragma /// spelling to transform expressions stored within the attribute. @@ -361,7 +361,7 @@ public: const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; } #include "clang/Basic/AttrList.inc" - /// \brief Transform the given expression. + /// Transform the given expression. /// /// By default, this routine transforms an expression by delegating to the /// appropriate TransformXXXExpr function to build a new expression. @@ -371,7 +371,7 @@ public: /// \returns the transformed expression. ExprResult TransformExpr(Expr *E); - /// \brief Transform the given initializer. + /// Transform the given initializer. /// /// By default, this routine transforms an initializer by stripping off the /// semantic nodes added by initialization, then passing the result to @@ -380,7 +380,7 @@ public: /// \returns the transformed initializer. ExprResult TransformInitializer(Expr *Init, bool NotCopyInit); - /// \brief Transform the given list of expressions. + /// Transform the given list of expressions. /// /// This routine transforms a list of expressions by invoking /// \c TransformExpr() for each subexpression. However, it also provides @@ -407,7 +407,7 @@ public: SmallVectorImpl<Expr *> &Outputs, bool *ArgChanged = nullptr); - /// \brief Transform the given declaration, which is referenced from a type + /// Transform the given declaration, which is referenced from a type /// or expression. /// /// By default, acts as the identity function on declarations, unless the @@ -422,7 +422,7 @@ public: return D; } - /// \brief Transform the specified condition. + /// Transform the specified condition. /// /// By default, this transforms the variable and expression and rebuilds /// the condition. @@ -430,14 +430,14 @@ public: Expr *Expr, Sema::ConditionKind Kind); - /// \brief Transform the attributes associated with the given declaration and + /// Transform the attributes associated with the given declaration and /// place them on the new declaration. /// /// By default, this operation does nothing. Subclasses may override this /// behavior to transform attributes. void transformAttrs(Decl *Old, Decl *New) { } - /// \brief Note that a local declaration has been transformed by this + /// Note that a local declaration has been transformed by this /// transformer. /// /// Local declarations are typically transformed via a call to @@ -448,7 +448,7 @@ public: TransformedLocalDecls[Old] = New; } - /// \brief Transform the definition of the given declaration. + /// Transform the definition of the given declaration. /// /// By default, invokes TransformDecl() to transform the declaration. /// Subclasses may override this function to provide alternate behavior. @@ -456,7 +456,7 @@ public: return getDerived().TransformDecl(Loc, D); } - /// \brief Transform the given declaration, which was the first part of a + /// Transform the given declaration, which was the first part of a /// nested-name-specifier in a member access expression. /// /// This specific declaration transformation only applies to the first @@ -473,7 +473,7 @@ public: bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL, LookupResult &R); - /// \brief Transform the given nested-name-specifier with source-location + /// Transform the given nested-name-specifier with source-location /// information. /// /// By default, transforms all of the types and declarations within the @@ -484,7 +484,7 @@ public: QualType ObjectType = QualType(), NamedDecl *FirstQualifierInScope = nullptr); - /// \brief Transform the given declaration name. + /// Transform the given declaration name. /// /// By default, transforms the types of conversion function, constructor, /// and destructor names and then (if needed) rebuilds the declaration name. @@ -493,7 +493,7 @@ public: DeclarationNameInfo TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); - /// \brief Transform the given template name. + /// Transform the given template name. /// /// \param SS The nested-name-specifier that qualifies the template /// name. This nested-name-specifier must already have been transformed. @@ -520,7 +520,7 @@ public: NamedDecl *FirstQualifierInScope = nullptr, bool AllowInjectedClassName = false); - /// \brief Transform the given template argument. + /// Transform the given template argument. /// /// By default, this operation transforms the type, expression, or /// declaration stored within the template argument and constructs a @@ -532,7 +532,7 @@ public: TemplateArgumentLoc &Output, bool Uneval = false); - /// \brief Transform the given set of template arguments. + /// Transform the given set of template arguments. /// /// By default, this operation transforms all of the template arguments /// in the input set using \c TransformTemplateArgument(), and appends @@ -558,7 +558,7 @@ public: Uneval); } - /// \brief Transform the given set of template arguments. + /// Transform the given set of template arguments. /// /// By default, this operation transforms all of the template arguments /// in the input set using \c TransformTemplateArgument(), and appends @@ -578,11 +578,11 @@ public: TemplateArgumentListInfo &Outputs, bool Uneval = false); - /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument. + /// Fakes up a TemplateArgumentLoc for a given TemplateArgument. void InventTemplateArgumentLoc(const TemplateArgument &Arg, TemplateArgumentLoc &ArgLoc); - /// \brief Fakes up a TypeSourceInfo for a type. + /// Fakes up a TypeSourceInfo for a type. TypeSourceInfo *InventTypeSourceInfo(QualType T) { return SemaRef.Context.getTrivialTypeSourceInfo(T, getDerived().getBaseLocation()); @@ -622,7 +622,7 @@ public: TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL, NestedNameSpecifierLoc QualifierLoc); - /// \brief Transforms the parameters of a function type into the + /// Transforms the parameters of a function type into the /// given vectors. /// /// The result vectors should be kept in sync; null entries in the @@ -636,7 +636,7 @@ public: SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars, Sema::ExtParameterInfoBuilder &PInfos); - /// \brief Transforms a single function-type parameter. Return null + /// Transforms a single function-type parameter. Return null /// on error. /// /// \param indexAdjustment - A number to add to the parameter's @@ -684,7 +684,7 @@ public: OMPClause *Transform ## Class(Class *S); #include "clang/Basic/OpenMPKinds.def" - /// \brief Build a new qualified type given its unqualified type and type + /// Build a new qualified type given its unqualified type and type /// qualifiers. /// /// By default, this routine adds type qualifiers only to types that can @@ -694,19 +694,19 @@ public: QualType RebuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Quals); - /// \brief Build a new pointer type given its pointee type. + /// Build a new pointer type given its pointee type. /// /// By default, performs semantic analysis when building the pointer type. /// Subclasses may override this routine to provide different behavior. QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil); - /// \brief Build a new block pointer type given its pointee type. + /// Build a new block pointer type given its pointee type. /// /// By default, performs semantic analysis when building the block pointer /// type. Subclasses may override this routine to provide different behavior. QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil); - /// \brief Build a new reference type given the type it references. + /// Build a new reference type given the type it references. /// /// By default, performs semantic analysis when building the /// reference type. Subclasses may override this routine to provide @@ -718,7 +718,7 @@ public: bool LValue, SourceLocation Sigil); - /// \brief Build a new member pointer type given the pointee type and the + /// Build a new member pointer type given the pointee type and the /// class type it refers into. /// /// By default, performs semantic analysis when building the member pointer @@ -732,7 +732,7 @@ public: ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc); - /// \brief Build an Objective-C object type. + /// Build an Objective-C object type. /// /// By default, performs semantic analysis when building the object type. /// Subclasses may override this routine to provide different behavior. @@ -746,14 +746,14 @@ public: ArrayRef<SourceLocation> ProtocolLocs, SourceLocation ProtocolRAngleLoc); - /// \brief Build a new Objective-C object pointer type given the pointee type. + /// Build a new Objective-C object pointer type given the pointee type. /// /// By default, directly builds the pointer type, with no additional semantic /// analysis. QualType RebuildObjCObjectPointerType(QualType PointeeType, SourceLocation Star); - /// \brief Build a new array type given the element type, size + /// Build a new array type given the element type, size /// modifier, size of the array (if known), size expression, and index type /// qualifiers. /// @@ -767,7 +767,7 @@ public: unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new constant array type given the element type, size + /// Build a new constant array type given the element type, size /// modifier, (known) size of the array, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. @@ -778,7 +778,7 @@ public: unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new incomplete array type given the element type, size + /// Build a new incomplete array type given the element type, size /// modifier, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. @@ -788,7 +788,7 @@ public: unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new variable-length array type given the element type, + /// Build a new variable-length array type given the element type, /// size modifier, size expression, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. @@ -799,7 +799,7 @@ public: unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new dependent-sized array type given the element type, + /// Build a new dependent-sized array type given the element type, /// size modifier, size expression, and index type qualifiers. /// /// By default, performs semantic analysis when building the array type. @@ -810,7 +810,7 @@ public: unsigned IndexTypeQuals, SourceRange BracketsRange); - /// \brief Build a new vector type given the element type and + /// Build a new vector type given the element type and /// number of elements. /// /// By default, performs semantic analysis when building the vector type. @@ -818,7 +818,7 @@ public: QualType RebuildVectorType(QualType ElementType, unsigned NumElements, VectorType::VectorKind VecKind); - /// \brief Build a new extended vector type given the element type and + /// Build a new extended vector type given the element type and /// number of elements. /// /// By default, performs semantic analysis when building the vector type. @@ -826,7 +826,7 @@ public: QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements, SourceLocation AttributeLoc); - /// \brief Build a new potentially dependently-sized extended vector type + /// Build a new potentially dependently-sized extended vector type /// given the element type and number of elements. /// /// By default, performs semantic analysis when building the vector type. @@ -835,7 +835,7 @@ public: Expr *SizeExpr, SourceLocation AttributeLoc); - /// \brief Build a new DependentAddressSpaceType or return the pointee + /// Build a new DependentAddressSpaceType or return the pointee /// type variable with the correct address space (retrieved from /// AddrSpaceExpr) applied to it. The former will be returned in cases /// where the address space remains dependent. @@ -847,7 +847,7 @@ public: Expr *AddrSpaceExpr, SourceLocation AttributeLoc); - /// \brief Build a new function type. + /// Build a new function type. /// /// By default, performs semantic analysis when building the function type. /// Subclasses may override this routine to provide different behavior. @@ -855,51 +855,51 @@ public: MutableArrayRef<QualType> ParamTypes, const FunctionProtoType::ExtProtoInfo &EPI); - /// \brief Build a new unprototyped function type. + /// Build a new unprototyped function type. QualType RebuildFunctionNoProtoType(QualType ResultType); - /// \brief Rebuild an unresolved typename type, given the decl that + /// Rebuild an unresolved typename type, given the decl that /// the UnresolvedUsingTypenameDecl was transformed to. QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D); - /// \brief Build a new typedef type. + /// Build a new typedef type. QualType RebuildTypedefType(TypedefNameDecl *Typedef) { return SemaRef.Context.getTypeDeclType(Typedef); } - /// \brief Build a new class/struct/union type. + /// Build a new class/struct/union type. QualType RebuildRecordType(RecordDecl *Record) { return SemaRef.Context.getTypeDeclType(Record); } - /// \brief Build a new Enum type. + /// Build a new Enum type. QualType RebuildEnumType(EnumDecl *Enum) { return SemaRef.Context.getTypeDeclType(Enum); } - /// \brief Build a new typeof(expr) type. + /// Build a new typeof(expr) type. /// /// By default, performs semantic analysis when building the typeof type. /// Subclasses may override this routine to provide different behavior. QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc); - /// \brief Build a new typeof(type) type. + /// Build a new typeof(type) type. /// /// By default, builds a new TypeOfType with the given underlying type. QualType RebuildTypeOfType(QualType Underlying); - /// \brief Build a new unary transform type. + /// Build a new unary transform type. QualType RebuildUnaryTransformType(QualType BaseType, UnaryTransformType::UTTKind UKind, SourceLocation Loc); - /// \brief Build a new C++11 decltype type. + /// Build a new C++11 decltype type. /// /// By default, performs semantic analysis when building the decltype type. /// Subclasses may override this routine to provide different behavior. QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc); - /// \brief Build a new C++11 auto type. + /// Build a new C++11 auto type. /// /// By default, builds a new AutoType with the given deduced type. QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) { @@ -918,7 +918,7 @@ public: Template, Deduced, /*IsDependent*/ false); } - /// \brief Build a new template specialization type. + /// Build a new template specialization type. /// /// By default, performs semantic analysis when building the template /// specialization type. Subclasses may override this routine to provide @@ -927,7 +927,7 @@ public: SourceLocation TemplateLoc, TemplateArgumentListInfo &Args); - /// \brief Build a new parenthesized type. + /// Build a new parenthesized type. /// /// By default, builds a new ParenType type from the inner type. /// Subclasses may override this routine to provide different behavior. @@ -935,7 +935,7 @@ public: return SemaRef.BuildParenType(InnerType); } - /// \brief Build a new qualified name type. + /// Build a new qualified name type. /// /// By default, builds a new ElaboratedType type from the keyword, /// the nested-name-specifier and the named type. @@ -949,7 +949,7 @@ public: Named); } - /// \brief Build a new typename type that refers to a template-id. + /// Build a new typename type that refers to a template-id. /// /// By default, builds a new DependentNameType type from the /// nested-name-specifier and the given type. Subclasses may override @@ -993,7 +993,7 @@ public: T); } - /// \brief Build a new typename type that refers to an identifier. + /// Build a new typename type that refers to an identifier. /// /// By default, performs semantic analysis when building the typename type /// (or elaborated type). Subclasses may override this routine to provide @@ -1106,7 +1106,7 @@ public: T); } - /// \brief Build a new pack expansion type. + /// Build a new pack expansion type. /// /// By default, builds a new PackExpansionType type from the given pattern. /// Subclasses may override this routine to provide different behavior. @@ -1118,17 +1118,17 @@ public: NumExpansions); } - /// \brief Build a new atomic type given its value type. + /// Build a new atomic type given its value type. /// /// By default, performs semantic analysis when building the atomic type. /// Subclasses may override this routine to provide different behavior. QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc); - /// \brief Build a new pipe type given its value type. + /// Build a new pipe type given its value type. QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc, bool isReadPipe); - /// \brief Build a new template name given a nested name specifier, a flag + /// Build a new template name given a nested name specifier, a flag /// indicating whether the "template" keyword was provided, and the template /// that the template name refers to. /// @@ -1138,7 +1138,7 @@ public: bool TemplateKW, TemplateDecl *Template); - /// \brief Build a new template name given a nested name specifier and the + /// Build a new template name given a nested name specifier and the /// name that is referred to as a template. /// /// By default, performs semantic analysis to determine whether the name can @@ -1152,7 +1152,7 @@ public: NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName); - /// \brief Build a new template name given a nested name specifier and the + /// Build a new template name given a nested name specifier and the /// overloaded operator name that is referred to as a template. /// /// By default, performs semantic analysis to determine whether the name can @@ -1165,7 +1165,7 @@ public: QualType ObjectType, bool AllowInjectedClassName); - /// \brief Build a new template name given a template template parameter pack + /// Build a new template name given a template template parameter pack /// and the /// /// By default, performs semantic analysis to determine whether the name can @@ -1177,7 +1177,7 @@ public: return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack); } - /// \brief Build a new compound statement. + /// Build a new compound statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1189,7 +1189,7 @@ public: IsStmtExpr); } - /// \brief Build a new case statement. + /// Build a new case statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1202,7 +1202,7 @@ public: ColonLoc); } - /// \brief Attach the body to a new case statement. + /// Attach the body to a new case statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1211,7 +1211,7 @@ public: return S; } - /// \brief Build a new default statement. + /// Build a new default statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1222,7 +1222,7 @@ public: /*CurScope=*/nullptr); } - /// \brief Build a new label statement. + /// Build a new label statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1231,7 +1231,7 @@ public: return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt); } - /// \brief Build a new label statement. + /// Build a new label statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1241,7 +1241,7 @@ public: return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt); } - /// \brief Build a new "if" statement. + /// Build a new "if" statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1252,7 +1252,7 @@ public: ElseLoc, Else); } - /// \brief Start building a new switch statement. + /// Start building a new switch statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1261,7 +1261,7 @@ public: return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond); } - /// \brief Attach the body to the switch statement. + /// Attach the body to the switch statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1270,7 +1270,7 @@ public: return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body); } - /// \brief Build a new while statement. + /// Build a new while statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1279,7 +1279,7 @@ public: return getSema().ActOnWhileStmt(WhileLoc, Cond, Body); } - /// \brief Build a new do-while statement. + /// Build a new do-while statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1290,7 +1290,7 @@ public: Cond, RParenLoc); } - /// \brief Build a new for statement. + /// Build a new for statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1302,7 +1302,7 @@ public: Inc, RParenLoc, Body); } - /// \brief Build a new goto statement. + /// Build a new goto statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1311,7 +1311,7 @@ public: return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label); } - /// \brief Build a new indirect goto statement. + /// Build a new indirect goto statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1321,7 +1321,7 @@ public: return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target); } - /// \brief Build a new return statement. + /// Build a new return statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1329,7 +1329,7 @@ public: return getSema().BuildReturnStmt(ReturnLoc, Result); } - /// \brief Build a new declaration statement. + /// Build a new declaration statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1339,7 +1339,7 @@ public: return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc); } - /// \brief Build a new inline asm statement. + /// Build a new inline asm statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1354,7 +1354,7 @@ public: AsmString, Clobbers, RParenLoc); } - /// \brief Build a new MS style inline asm statement. + /// Build a new MS style inline asm statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1371,7 +1371,7 @@ public: Constraints, Clobbers, Exprs, EndLoc); } - /// \brief Build a new co_return statement. + /// Build a new co_return statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1380,7 +1380,7 @@ public: return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit); } - /// \brief Build a new co_await expression. + /// Build a new co_await expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -1389,7 +1389,7 @@ public: return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit); } - /// \brief Build a new co_await expression. + /// Build a new co_await expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -1399,7 +1399,7 @@ public: return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup); } - /// \brief Build a new co_yield expression. + /// Build a new co_yield expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -1411,7 +1411,7 @@ public: return getSema().BuildCoroutineBodyStmt(Args); } - /// \brief Build a new Objective-C \@try statement. + /// Build a new Objective-C \@try statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1423,7 +1423,7 @@ public: Finally); } - /// \brief Rebuild an Objective-C exception declaration. + /// Rebuild an Objective-C exception declaration. /// /// By default, performs semantic analysis to build the new declaration. /// Subclasses may override this routine to provide different behavior. @@ -1435,7 +1435,7 @@ public: ExceptionDecl->getIdentifier()); } - /// \brief Build a new Objective-C \@catch statement. + /// Build a new Objective-C \@catch statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1447,7 +1447,7 @@ public: Var, Body); } - /// \brief Build a new Objective-C \@finally statement. + /// Build a new Objective-C \@finally statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1456,7 +1456,7 @@ public: return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body); } - /// \brief Build a new Objective-C \@throw statement. + /// Build a new Objective-C \@throw statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1465,7 +1465,7 @@ public: return getSema().BuildObjCAtThrowStmt(AtLoc, Operand); } - /// \brief Build a new OpenMP executable directive. + /// Build a new OpenMP executable directive. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1479,7 +1479,7 @@ public: Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc); } - /// \brief Build a new OpenMP 'if' clause. + /// Build a new OpenMP 'if' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1494,7 +1494,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'final' clause. + /// Build a new OpenMP 'final' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1505,7 +1505,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'num_threads' clause. + /// Build a new OpenMP 'num_threads' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1517,7 +1517,7 @@ public: LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'safelen' clause. + /// Build a new OpenMP 'safelen' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1527,7 +1527,7 @@ public: return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'simdlen' clause. + /// Build a new OpenMP 'simdlen' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1537,7 +1537,7 @@ public: return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'collapse' clause. + /// Build a new OpenMP 'collapse' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1548,7 +1548,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'default' clause. + /// Build a new OpenMP 'default' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1561,7 +1561,7 @@ public: StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'proc_bind' clause. + /// Build a new OpenMP 'proc_bind' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1574,7 +1574,7 @@ public: StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'schedule' clause. + /// Build a new OpenMP 'schedule' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1588,7 +1588,7 @@ public: CommaLoc, EndLoc); } - /// \brief Build a new OpenMP 'ordered' clause. + /// Build a new OpenMP 'ordered' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1598,7 +1598,7 @@ public: return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num); } - /// \brief Build a new OpenMP 'private' clause. + /// Build a new OpenMP 'private' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1610,7 +1610,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'firstprivate' clause. + /// Build a new OpenMP 'firstprivate' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1622,7 +1622,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'lastprivate' clause. + /// Build a new OpenMP 'lastprivate' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1634,7 +1634,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'shared' clause. + /// Build a new OpenMP 'shared' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1646,7 +1646,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'reduction' clause. + /// Build a new OpenMP 'reduction' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1694,7 +1694,7 @@ public: ReductionId, UnresolvedReductions); } - /// \brief Build a new OpenMP 'linear' clause. + /// Build a new OpenMP 'linear' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1710,7 +1710,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'aligned' clause. + /// Build a new OpenMP 'aligned' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1723,7 +1723,7 @@ public: LParenLoc, ColonLoc, EndLoc); } - /// \brief Build a new OpenMP 'copyin' clause. + /// Build a new OpenMP 'copyin' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1735,7 +1735,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'copyprivate' clause. + /// Build a new OpenMP 'copyprivate' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1747,7 +1747,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'flush' pseudo clause. + /// Build a new OpenMP 'flush' pseudo clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1759,7 +1759,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'depend' pseudo clause. + /// Build a new OpenMP 'depend' pseudo clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1772,7 +1772,7 @@ public: StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'device' clause. + /// Build a new OpenMP 'device' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1783,7 +1783,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'map' clause. + /// Build a new OpenMP 'map' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1798,7 +1798,7 @@ public: VarList, StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'num_teams' clause. + /// Build a new OpenMP 'num_teams' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1809,7 +1809,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'thread_limit' clause. + /// Build a new OpenMP 'thread_limit' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1821,7 +1821,7 @@ public: LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'priority' clause. + /// Build a new OpenMP 'priority' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1832,7 +1832,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'grainsize' clause. + /// Build a new OpenMP 'grainsize' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1843,7 +1843,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'num_tasks' clause. + /// Build a new OpenMP 'num_tasks' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1854,7 +1854,7 @@ public: EndLoc); } - /// \brief Build a new OpenMP 'hint' clause. + /// Build a new OpenMP 'hint' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1864,7 +1864,7 @@ public: return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'dist_schedule' clause. + /// Build a new OpenMP 'dist_schedule' clause. /// /// By default, performs semantic analysis to build the new OpenMP clause. /// Subclasses may override this routine to provide different behavior. @@ -1877,7 +1877,7 @@ public: Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc); } - /// \brief Build a new OpenMP 'to' clause. + /// Build a new OpenMP 'to' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1888,7 +1888,7 @@ public: return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc); } - /// \brief Build a new OpenMP 'from' clause. + /// Build a new OpenMP 'from' clause. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1924,7 +1924,7 @@ public: EndLoc); } - /// \brief Rebuild the operand to an Objective-C \@synchronized statement. + /// Rebuild the operand to an Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1933,7 +1933,7 @@ public: return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object); } - /// \brief Build a new Objective-C \@synchronized statement. + /// Build a new Objective-C \@synchronized statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1942,7 +1942,7 @@ public: return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body); } - /// \brief Build a new Objective-C \@autoreleasepool statement. + /// Build a new Objective-C \@autoreleasepool statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1951,7 +1951,7 @@ public: return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body); } - /// \brief Build a new Objective-C fast enumeration statement. + /// Build a new Objective-C fast enumeration statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1970,7 +1970,7 @@ public: return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body); } - /// \brief Build a new C++ exception declaration. + /// Build a new C++ exception declaration. /// /// By default, performs semantic analysis to build the new decaration. /// Subclasses may override this routine to provide different behavior. @@ -1986,7 +1986,7 @@ public: return Var; } - /// \brief Build a new C++ catch statement. + /// Build a new C++ catch statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -1997,7 +1997,7 @@ public: Handler)); } - /// \brief Build a new C++ try statement. + /// Build a new C++ try statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -2006,7 +2006,7 @@ public: return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers); } - /// \brief Build a new C++0x range-based for statement. + /// Build a new C++0x range-based for statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -2040,7 +2040,7 @@ public: Sema::BFRK_Rebuild); } - /// \brief Build a new C++0x range-based for statement. + /// Build a new C++0x range-based for statement. /// /// By default, performs semantic analysis to build the new statement. /// Subclasses may override this routine to provide different behavior. @@ -2053,7 +2053,7 @@ public: QualifierLoc, NameInfo, Nested); } - /// \brief Attach body to a C++0x range-based for statement. + /// Attach body to a C++0x range-based for statement. /// /// By default, performs semantic analysis to finish the new statement. /// Subclasses may override this routine to provide different behavior. @@ -2075,7 +2075,7 @@ public: return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block); } - /// \brief Build a new predefined expression. + /// Build a new predefined expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2084,7 +2084,7 @@ public: return getSema().BuildPredefinedExpr(Loc, IT); } - /// \brief Build a new expression that references a declaration. + /// Build a new expression that references a declaration. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2095,7 +2095,7 @@ public: } - /// \brief Build a new expression that references a declaration. + /// Build a new expression that references a declaration. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2111,7 +2111,7 @@ public: return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD); } - /// \brief Build a new expression in parentheses. + /// Build a new expression in parentheses. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2120,7 +2120,7 @@ public: return getSema().ActOnParenExpr(LParen, RParen, SubExpr); } - /// \brief Build a new pseudo-destructor expression. + /// Build a new pseudo-destructor expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2133,7 +2133,7 @@ public: SourceLocation TildeLoc, PseudoDestructorTypeStorage Destroyed); - /// \brief Build a new unary operator expression. + /// Build a new unary operator expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2143,7 +2143,7 @@ public: return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr); } - /// \brief Build a new builtin offsetof expression. + /// Build a new builtin offsetof expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2155,7 +2155,7 @@ public: RParenLoc); } - /// \brief Build a new sizeof, alignof or vec_step expression with a + /// Build a new sizeof, alignof or vec_step expression with a /// type argument. /// /// By default, performs semantic analysis to build the new expression. @@ -2167,7 +2167,7 @@ public: return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R); } - /// \brief Build a new sizeof, alignof or vec step expression with an + /// Build a new sizeof, alignof or vec step expression with an /// expression argument. /// /// By default, performs semantic analysis to build the new expression. @@ -2183,7 +2183,7 @@ public: return Result; } - /// \brief Build a new array subscript expression. + /// Build a new array subscript expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2196,7 +2196,7 @@ public: RBracketLoc); } - /// \brief Build a new array section expression. + /// Build a new array section expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2208,7 +2208,7 @@ public: ColonLoc, Length, RBracketLoc); } - /// \brief Build a new call expression. + /// Build a new call expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2220,7 +2220,7 @@ public: Args, RParenLoc, ExecConfig); } - /// \brief Build a new member access expression. + /// Build a new member access expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2278,7 +2278,7 @@ public: /*S*/nullptr); } - /// \brief Build a new binary operator expression. + /// Build a new binary operator expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2288,7 +2288,7 @@ public: return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS); } - /// \brief Build a new conditional operator expression. + /// Build a new conditional operator expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2301,7 +2301,7 @@ public: LHS, RHS); } - /// \brief Build a new C-style cast expression. + /// Build a new C-style cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2313,7 +2313,7 @@ public: SubExpr); } - /// \brief Build a new compound literal expression. + /// Build a new compound literal expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2325,7 +2325,7 @@ public: Init); } - /// \brief Build a new extended vector element access expression. + /// Build a new extended vector element access expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2345,7 +2345,7 @@ public: /*S*/ nullptr); } - /// \brief Build a new initializer list expression. + /// Build a new initializer list expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2355,7 +2355,7 @@ public: return SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc); } - /// \brief Build a new designated initializer expression. + /// Build a new designated initializer expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2373,7 +2373,7 @@ public: return Result; } - /// \brief Build a new value-initialized expression. + /// Build a new value-initialized expression. /// /// By default, builds the implicit value initialization without performing /// any semantic analysis. Subclasses may override this routine to provide @@ -2382,7 +2382,7 @@ public: return new (SemaRef.Context) ImplicitValueInitExpr(T); } - /// \brief Build a new \c va_arg expression. + /// Build a new \c va_arg expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2394,7 +2394,7 @@ public: RParenLoc); } - /// \brief Build a new expression list in parentheses. + /// Build a new expression list in parentheses. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2404,7 +2404,7 @@ public: return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs); } - /// \brief Build a new address-of-label expression. + /// Build a new address-of-label expression. /// /// By default, performs semantic analysis, using the name of the label /// rather than attempting to map the label statement itself. @@ -2414,7 +2414,7 @@ public: return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label); } - /// \brief Build a new GNU statement expression. + /// Build a new GNU statement expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2424,7 +2424,7 @@ public: return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc); } - /// \brief Build a new __builtin_choose_expr expression. + /// Build a new __builtin_choose_expr expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2436,7 +2436,7 @@ public: RParenLoc); } - /// \brief Build a new generic selection expression. + /// Build a new generic selection expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2450,7 +2450,7 @@ public: ControllingExpr, Types, Exprs); } - /// \brief Build a new overloaded operator call expression. + /// Build a new overloaded operator call expression. /// /// By default, performs semantic analysis to build the new expression. /// The semantic analysis provides the behavior of template instantiation, @@ -2464,7 +2464,7 @@ public: Expr *First, Expr *Second); - /// \brief Build a new C++ "named" cast expression, such as static_cast or + /// Build a new C++ "named" cast expression, such as static_cast or /// reinterpret_cast. /// /// By default, this routine dispatches to one of the more-specific routines @@ -2505,7 +2505,7 @@ public: } } - /// \brief Build a new C++ static_cast expression. + /// Build a new C++ static_cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2522,7 +2522,7 @@ public: SourceRange(LParenLoc, RParenLoc)); } - /// \brief Build a new C++ dynamic_cast expression. + /// Build a new C++ dynamic_cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2539,7 +2539,7 @@ public: SourceRange(LParenLoc, RParenLoc)); } - /// \brief Build a new C++ reinterpret_cast expression. + /// Build a new C++ reinterpret_cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2556,7 +2556,7 @@ public: SourceRange(LParenLoc, RParenLoc)); } - /// \brief Build a new C++ const_cast expression. + /// Build a new C++ const_cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2573,7 +2573,7 @@ public: SourceRange(LParenLoc, RParenLoc)); } - /// \brief Build a new C++ functional-style cast expression. + /// Build a new C++ functional-style cast expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2587,7 +2587,7 @@ public: ListInitialization); } - /// \brief Build a new C++ typeid(type) expression. + /// Build a new C++ typeid(type) expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2600,7 +2600,7 @@ public: } - /// \brief Build a new C++ typeid(expr) expression. + /// Build a new C++ typeid(expr) expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2612,7 +2612,7 @@ public: RParenLoc); } - /// \brief Build a new C++ __uuidof(type) expression. + /// Build a new C++ __uuidof(type) expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2624,7 +2624,7 @@ public: RParenLoc); } - /// \brief Build a new C++ __uuidof(expr) expression. + /// Build a new C++ __uuidof(expr) expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2636,7 +2636,7 @@ public: RParenLoc); } - /// \brief Build a new C++ "this" expression. + /// Build a new C++ "this" expression. /// /// By default, builds a new "this" expression without performing any /// semantic analysis. Subclasses may override this routine to provide @@ -2648,7 +2648,7 @@ public: return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit); } - /// \brief Build a new C++ throw expression. + /// Build a new C++ throw expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2657,7 +2657,7 @@ public: return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope); } - /// \brief Build a new C++ default-argument expression. + /// Build a new C++ default-argument expression. /// /// By default, builds a new default-argument expression, which does not /// require any semantic analysis. Subclasses may override this routine to @@ -2667,7 +2667,7 @@ public: return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param); } - /// \brief Build a new C++11 default-initialization expression. + /// Build a new C++11 default-initialization expression. /// /// By default, builds a new default field initialization expression, which /// does not require any semantic analysis. Subclasses may override this @@ -2677,7 +2677,7 @@ public: return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field); } - /// \brief Build a new C++ zero-initialization expression. + /// Build a new C++ zero-initialization expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2688,7 +2688,7 @@ public: TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false); } - /// \brief Build a new C++ "new" expression. + /// Build a new C++ "new" expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2715,7 +2715,7 @@ public: Initializer); } - /// \brief Build a new C++ "delete" expression. + /// Build a new C++ "delete" expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2727,7 +2727,7 @@ public: Operand); } - /// \brief Build a new type trait expression. + /// Build a new type trait expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2738,7 +2738,7 @@ public: return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc); } - /// \brief Build a new array type trait expression. + /// Build a new array type trait expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2750,7 +2750,7 @@ public: return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc); } - /// \brief Build a new expression trait expression. + /// Build a new expression trait expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2761,7 +2761,7 @@ public: return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc); } - /// \brief Build a new (previously unresolved) declaration reference + /// Build a new (previously unresolved) declaration reference /// expression. /// /// By default, performs semantic analysis to build the new expression. @@ -2784,7 +2784,7 @@ public: SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI); } - /// \brief Build a new template-id expression. + /// Build a new template-id expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2797,7 +2797,7 @@ public: TemplateArgs); } - /// \brief Build a new object-construction expression. + /// Build a new object-construction expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2827,7 +2827,7 @@ public: ParenRange); } - /// \brief Build a new implicit construction via inherited constructor + /// Build a new implicit construction via inherited constructor /// expression. ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc, CXXConstructorDecl *Constructor, @@ -2837,7 +2837,7 @@ public: Loc, T, Constructor, ConstructsVBase, InheritedFromVBase); } - /// \brief Build a new object-construction expression. + /// Build a new object-construction expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2850,7 +2850,7 @@ public: TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization); } - /// \brief Build a new object-construction expression. + /// Build a new object-construction expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2863,7 +2863,7 @@ public: RParenLoc, ListInitialization); } - /// \brief Build a new member reference expression. + /// Build a new member reference expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2887,7 +2887,7 @@ public: TemplateArgs, /*S*/nullptr); } - /// \brief Build a new member reference expression. + /// Build a new member reference expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2909,7 +2909,7 @@ public: R, TemplateArgs, /*S*/nullptr); } - /// \brief Build a new noexcept expression. + /// Build a new noexcept expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2917,7 +2917,7 @@ public: return SemaRef.BuildCXXNoexceptExpr(Range.getBegin(), Arg, Range.getEnd()); } - /// \brief Build a new expression to compute the length of a parameter pack. + /// Build a new expression to compute the length of a parameter pack. ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, @@ -2928,7 +2928,7 @@ public: RParenLoc, Length, PartialArgs); } - /// \brief Build a new Objective-C boxed expression. + /// Build a new Objective-C boxed expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2936,7 +2936,7 @@ public: return getSema().BuildObjCBoxedExpr(SR, ValueExpr); } - /// \brief Build a new Objective-C array literal. + /// Build a new Objective-C array literal. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2954,7 +2954,7 @@ public: getterMethod, setterMethod); } - /// \brief Build a new Objective-C dictionary literal. + /// Build a new Objective-C dictionary literal. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2963,7 +2963,7 @@ public: return getSema().BuildObjCDictionaryLiteral(Range, Elements); } - /// \brief Build a new Objective-C \@encode expression. + /// Build a new Objective-C \@encode expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -2973,7 +2973,7 @@ public: return SemaRef.BuildObjCEncodeExpression(AtLoc, EncodeTypeInfo, RParenLoc); } - /// \brief Build a new Objective-C class message. + /// Build a new Objective-C class message. ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, @@ -2988,7 +2988,7 @@ public: RBracLoc, Args); } - /// \brief Build a new Objective-C instance message. + /// Build a new Objective-C instance message. ExprResult RebuildObjCMessageExpr(Expr *Receiver, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, @@ -3003,7 +3003,7 @@ public: RBracLoc, Args); } - /// \brief Build a new Objective-C instance/class message to 'super'. + /// Build a new Objective-C instance/class message to 'super'. ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, @@ -3026,7 +3026,7 @@ public: } - /// \brief Build a new Objective-C ivar reference expression. + /// Build a new Objective-C ivar reference expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3046,7 +3046,7 @@ public: return Result; } - /// \brief Build a new Objective-C property reference expression. + /// Build a new Objective-C property reference expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3065,7 +3065,7 @@ public: /*S=*/nullptr); } - /// \brief Build a new Objective-C property reference expression. + /// Build a new Objective-C property reference expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3081,7 +3081,7 @@ public: PropertyLoc, Base)); } - /// \brief Build a new Objective-C "isa" expression. + /// Build a new Objective-C "isa" expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3098,7 +3098,7 @@ public: /*S=*/nullptr); } - /// \brief Build a new shuffle vector expression. + /// Build a new shuffle vector expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3130,7 +3130,7 @@ public: return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get())); } - /// \brief Build a new convert vector expression. + /// Build a new convert vector expression. ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc, Expr *SrcExpr, TypeSourceInfo *DstTInfo, SourceLocation RParenLoc) { @@ -3138,7 +3138,7 @@ public: BuiltinLoc, RParenLoc); } - /// \brief Build a new template argument pack expansion. + /// Build a new template argument pack expansion. /// /// By default, performs semantic analysis to build a new pack expansion /// for a template argument. Subclasses may override this routine to provide @@ -3186,7 +3186,7 @@ public: return TemplateArgumentLoc(); } - /// \brief Build a new expression pack expansion. + /// Build a new expression pack expansion. /// /// By default, performs semantic analysis to build a new pack expansion /// for an expression. Subclasses may override this routine to provide @@ -3196,7 +3196,7 @@ public: return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } - /// \brief Build a new C++1z fold-expression. + /// Build a new C++1z fold-expression. /// /// By default, performs semantic analysis in order to build a new fold /// expression. @@ -3208,7 +3208,7 @@ public: RHS, RParenLoc); } - /// \brief Build an empty C++1z fold-expression with the given operator. + /// Build an empty C++1z fold-expression with the given operator. /// /// By default, produces the fallback value for the fold-expression, or /// produce an error if there is no fallback value. @@ -3217,7 +3217,7 @@ public: return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator); } - /// \brief Build a new atomic operation expression. + /// Build a new atomic operation expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -3920,7 +3920,7 @@ bool TreeTransform<Derived>::TransformTemplateArgument( return true; } -/// \brief Iterator adaptor that invents template argument location information +/// Iterator adaptor that invents template argument location information /// for each of the template arguments in its underlying iterator. template<typename Derived, typename InputIterator> class TemplateArgumentLocInventIterator { @@ -5758,7 +5758,7 @@ QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB, return Result; } - /// \brief Simple iterator that traverses the template arguments in a + /// Simple iterator that traverses the template arguments in a /// container that provides a \c getArgLoc() member function. /// /// This iterator is intended to be used with the iterator form of @@ -8962,7 +8962,7 @@ TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) { E->getRParen()); } -/// \brief The operand of a unary address-of operator has special rules: it's +/// The operand of a unary address-of operator has special rules: it's /// allowed to refer to a non-static member of a class even if there's no 'this' /// object available. template<typename Derived> @@ -9661,7 +9661,7 @@ TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) { E->getRParenLoc()); } -/// \brief Transform an address-of-label expression. +/// Transform an address-of-label expression. /// /// By default, the transformation of an address-of-label expression always /// rebuilds the expression, so that the label identifier can be resolved to @@ -10791,7 +10791,7 @@ ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr( E->constructsVBase(), E->inheritedFromVBase()); } -/// \brief Transform a C++ temporary-binding expression. +/// Transform a C++ temporary-binding expression. /// /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just /// transform the subexpression and return that. @@ -10801,7 +10801,7 @@ TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { return getDerived().TransformExpr(E->getSubExpr()); } -/// \brief Transform a C++ expression that contains cleanups that should +/// Transform a C++ expression that contains cleanups that should /// be run after the expression is evaluated. /// /// Since ExprWithCleanups nodes are implicitly generated, we diff --git a/clang/lib/Sema/TypeLocBuilder.h b/clang/lib/Sema/TypeLocBuilder.h index 9c77045d2e1..a088fe9de66 100644 --- a/clang/lib/Sema/TypeLocBuilder.h +++ b/clang/lib/Sema/TypeLocBuilder.h @@ -83,7 +83,7 @@ class TypeLocBuilder { NumBytesAtAlign4 = NumBytesAtAlign8 = 0; } - /// \brief Tell the TypeLocBuilder that the type it is storing has been + /// Tell the TypeLocBuilder that the type it is storing has been /// modified in some safe way that doesn't affect type-location information. void TypeWasModifiedSafely(QualType T) { #ifndef NDEBUG @@ -112,7 +112,7 @@ class TypeLocBuilder { return DI; } - /// \brief Copies the type-location information to the given AST context and + /// Copies the type-location information to the given AST context and /// returns a \c TypeLoc referring into the AST context. TypeLoc getTypeLocInContext(ASTContext &Context, QualType T) { #ifndef NDEBUG @@ -132,7 +132,7 @@ private: /// Grow to the given capacity. void grow(size_t NewCapacity); - /// \brief Retrieve a temporary TypeLoc that refers into this \c TypeLocBuilder + /// Retrieve a temporary TypeLoc that refers into this \c TypeLocBuilder /// object. /// /// The resulting \c TypeLoc should only be used so long as the |
