Author: Nico Weber Date: 2021-09-20T19:42:49-04:00 New Revision: bde305baf631004b8d00081f11e62b33e1665e45
URL: https://github.com/llvm/llvm-project/commit/bde305baf631004b8d00081f11e62b33e1665e45 DIFF: https://github.com/llvm/llvm-project/commit/bde305baf631004b8d00081f11e62b33e1665e45.diff LOG: [clang] Fix a few comment more typos to cycle bots Added: Modified: clang/lib/Sema/SemaCXXScopeSpec.cpp clang/lib/Sema/SemaChecking.cpp clang/lib/Sema/SemaCodeComplete.cpp clang/lib/Sema/SemaConcept.cpp clang/lib/Sema/SemaDeclAttr.cpp clang/lib/Sema/SemaDeclCXX.cpp clang/lib/Sema/SemaDeclObjC.cpp clang/lib/Sema/SemaInit.cpp clang/lib/Sema/SemaLookup.cpp clang/lib/Sema/SemaOpenMP.cpp clang/lib/Sema/SemaStmt.cpp clang/lib/Sema/SemaTemplate.cpp clang/lib/Sema/SemaTemplateDeduction.cpp clang/lib/Sema/SemaTemplateInstantiateDecl.cpp clang/lib/Sema/SemaType.cpp clang/lib/Sema/TreeTransform.h Removed: ################################################################################ diff --git a/clang/lib/Sema/SemaCXXScopeSpec.cpp b/clang/lib/Sema/SemaCXXScopeSpec.cpp index 1c8f6329bd67..7f8d03008159 100644 --- a/clang/lib/Sema/SemaCXXScopeSpec.cpp +++ b/clang/lib/Sema/SemaCXXScopeSpec.cpp @@ -442,7 +442,7 @@ bool Sema::isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, namespace { // Callback to only accept typo corrections that can be a valid C++ member -// intializer: either a non-static field member or a base class. +// initializer: either a non-static field member or a base class. class NestedNameSpecifierValidatorCCC final : public CorrectionCandidateCallback { public: diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 0c47fb040d60..986230632532 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -773,7 +773,7 @@ void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, StringRef FunctionName = getASTContext().BuiltinInfo.getName(BuiltinID); // Skim off the details of whichever builtin was called to produce a better - // diagnostic, as it's unlikley that the user wrote the __builtin explicitly. + // diagnostic, as it's unlikely that the user wrote the __builtin explicitly. if (IsChkVariant) { FunctionName = FunctionName.drop_front(std::strlen("__builtin___")); FunctionName = FunctionName.drop_back(std::strlen("_chk")); @@ -3527,7 +3527,7 @@ bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, << ArgExpr->getType(); auto Ord = ArgResult.Val.getInt().getZExtValue(); - // Check valididty of memory ordering as per C11 / C++11's memody model. + // Check validity of memory ordering as per C11 / C++11's memody model. // Only fence needs check. Atomic dec/inc allow all memory orders. if (!llvm::isValidAtomicOrderingCABI(Ord)) return Diag(ArgExpr->getBeginLoc(), @@ -11279,7 +11279,7 @@ static QualType GetExprType(const Expr *E) { /// /// \param MaxWidth The width to which the value will be truncated. /// \param Approximate If \c true, return a likely range for the result: in -/// particular, assume that aritmetic on narrower types doesn't leave +/// particular, assume that arithmetic on narrower types doesn't leave /// those types. If \c false, return a range including all possible /// result values. static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, @@ -16677,7 +16677,7 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall, return CallResult; } - // Check row and column dimenions. + // Check row and column dimensions. llvm::Optional<unsigned> MaybeRows; if (RowsExpr) MaybeRows = getAndVerifyMatrixDimension(RowsExpr, "row", *this); diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp index 8c551a798b32..610c64d1521b 100644 --- a/clang/lib/Sema/SemaCodeComplete.cpp +++ b/clang/lib/Sema/SemaCodeComplete.cpp @@ -2823,7 +2823,7 @@ FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param, bool SuppressName = false, bool SuppressBlock = false, Optional<ArrayRef<QualType>> ObjCSubsts = None) { // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid. - // It would be better to pass in the param Type, which is usually avaliable. + // It would be better to pass in the param Type, which is usually available. // But this case is rare, so just pretend we fell back to int as elsewhere. if (!Param) return "int"; diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp index 2932335f3ad4..466e37831f66 100644 --- a/clang/lib/Sema/SemaConcept.cpp +++ b/clang/lib/Sema/SemaConcept.cpp @@ -234,7 +234,7 @@ static bool calculateConstraintSatisfaction( // ...If substitution results in an invalid type or expression, the // constraint is not satisfied. if (!Trap.hasErrorOccurred()) - // A non-SFINAE error has occured as a result of this + // A non-SFINAE error has occurred as a result of this // substitution. return ExprError(); @@ -980,8 +980,8 @@ bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, // Not the same source level expression - are the expressions // identical? llvm::FoldingSetNodeID IDA, IDB; - EA->Profile(IDA, Context, /*Cannonical=*/true); - EB->Profile(IDB, Context, /*Cannonical=*/true); + EA->Profile(IDA, Context, /*Canonical=*/true); + EB->Profile(IDB, Context, /*Canonical=*/true); if (IDA != IDB) return false; diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index 8092aeb21ada..dd13324f4d18 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -4775,7 +4775,7 @@ static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) { } // To check if earlier decl attributes do not conflict the newly parsed ones - // we always add (and check) the attribute to the cannonical decl. We need + // we always add (and check) the attribute to the canonical decl. We need // to repeat the check for attribute mutual exclusion because we're attaching // all of the attributes to the canonical declaration rather than the current // declaration. @@ -7500,7 +7500,7 @@ static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D, // index rather than incorrectly assume the index for NoSanitizeSpecificAttr // has the same spellings as the index for NoSanitizeAttr. We don't have a // general way to "translate" between the two, so this hack attempts to work - // around the issue with hard-coded indicies. This is critical for calling + // around the issue with hard-coded indices. This is critical for calling // getSpelling() or prettyPrint() on the resulting semantic attribute object // without failing assertions. unsigned TranslatedSpellingIndex = 0; diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index ecafab99424f..c3fbcc42fbfd 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -4114,7 +4114,7 @@ Sema::ActOnMemInitializer(Decl *ConstructorD, namespace { // Callback to only accept typo corrections that can be a valid C++ member -// intializer: either a non-static field member or a base class. +// initializer: either a non-static field member or a base class. class MemInitializerValidatorCCC final : public CorrectionCandidateCallback { public: explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl) @@ -9823,7 +9823,7 @@ struct FindHiddenVirtualMethod { }; } // end anonymous namespace -/// Add the most overriden methods from MD to Methods +/// Add the most overridden methods from MD to Methods static void AddMostOverridenMethods(const CXXMethodDecl *MD, llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) { if (MD->size_overridden_methods() == 0) @@ -15451,7 +15451,7 @@ ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) { void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) { if (VD->isInvalidDecl()) return; // If initializing the variable failed, don't also diagnose problems with - // the desctructor, they're likely related. + // the destructor, they're likely related. if (VD->getInit() && VD->getInit()->containsErrors()) return; diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp index f19a041fa487..51ac96f6b289 100644 --- a/clang/lib/Sema/SemaDeclObjC.cpp +++ b/clang/lib/Sema/SemaDeclObjC.cpp @@ -2614,7 +2614,7 @@ void Sema::WarnExactTypedMethods(ObjCMethodDecl *ImpMethodDecl, if (MethodDecl->getImplementationControl() == ObjCMethodDecl::Optional) return; // don't issue warning when primary class's method is - // depecated/unavailable. + // deprecated/unavailable. if (MethodDecl->hasAttr<UnavailableAttr>() || MethodDecl->hasAttr<DeprecatedAttr>()) return; @@ -4834,7 +4834,7 @@ Decl *Sema::ActOnMethodDeclaration( // If this method overrides a previous @synthesize declaration, // register it with the property. Linear search through all // properties here, because the autosynthesized stub hasn't been - // made visible yet, so it can be overriden by a later + // made visible yet, so it can be overridden by a later // user-specified implementation. for (ObjCPropertyImplDecl *PropertyImpl : ImpDecl->property_impls()) { if (auto *Setter = PropertyImpl->getSetterMethodDecl()) diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 111d93b1e7a4..40563083b438 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -2041,7 +2041,7 @@ void InitListChecker::CheckStructUnionTypes( RecordDecl *structDecl = DeclType->castAs<RecordType>()->getDecl(); // If the record is invalid, some of it's members are invalid. To avoid - // confusion, we forgo checking the intializer for the entire record. + // confusion, we forgo checking the initializer for the entire record. if (structDecl->isInvalidDecl()) { // Assume it was supposed to consume a single initializer. ++Index; @@ -8252,7 +8252,7 @@ ExprResult InitializationSequence::Perform(Sema &S, // When this is an incomplete array type (such as when this is // initializing an array of unknown bounds from an init list), use THAT - // type instead so that we propogate the array bounds. + // type instead so that we propagate the array bounds. if (MTETy->isIncompleteArrayType() && !CurInit.get()->getType()->isIncompleteArrayType() && S.Context.hasSameType( diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index a88bf52b4d8b..f0ab50f0acdd 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -3846,7 +3846,7 @@ class LookupVisibleHelper { : Ctx->noload_lookups(/*PreserveInternalState=*/false)) { for (auto *D : R) { if (auto *ND = Result.getAcceptableDecl(D)) { - // Rather than visit immediatelly, we put ND into a vector and visit + // Rather than visit immediately, we put ND into a vector and visit // all decls, in order, outside of this loop. The reason is that // Consumer.FoundDecl() may invalidate the iterators used in the two // loops above. diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index 1c81104520f9..3a1249b7a7ff 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -5735,7 +5735,7 @@ processImplicitMapsWithDefaultMappers(Sema &S, DSAStackTy *Stack, SubExprs.push_back(BaseExpr); continue; } - // Check for the "default" mapper for data memebers. + // Check for the "default" mapper for data members. bool FirstIter = true; for (FieldDecl *FD : RD->fields()) { if (!FD) @@ -6698,7 +6698,7 @@ void Sema::ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D) { FD = cast<FunctionDecl>(D); assert(FD && "Expected a function declaration!"); - // If we are intantiating templates we do *not* apply scoped assumptions but + // If we are instantiating templates we do *not* apply scoped assumptions but // only global ones. We apply scoped assumption to the template definition // though. if (!inTemplateInstantiation()) { diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index 32809a0884cd..2945e2b0cf24 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -3453,7 +3453,7 @@ const VarDecl *Sema::getCopyElisionCandidate(NamedReturnInfo &Info, /// Verify that the initialization sequence that was picked for the /// first overload resolution is permissible under C++98. /// -/// Reject (possibly converting) contructors not taking an rvalue reference, +/// Reject (possibly converting) constructors not taking an rvalue reference, /// or user conversion operators which are not ref-qualified. static bool VerifyInitializationSequenceCXX98(const Sema &S, @@ -3885,7 +3885,7 @@ StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) { if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp)) return StmtError(); - // HACK: We supress simpler implicit move here in msvc compatibility mode + // HACK: We suppress simpler implicit move here in msvc compatibility mode // just as a temporary work around, as the MSVC STL has issues with // this change. bool SupressSimplerImplicitMoves = diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index bfe69a45f595..00fe811860e5 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -1206,7 +1206,7 @@ static ExprResult formImmediatelyDeclaredConstraint( } /// Attach a type-constraint to a template parameter. -/// \returns true if an error occured. This can happen if the +/// \returns true if an error occurred. This can happen if the /// immediately-declared constraint could not be formed (e.g. incorrect number /// of arguments for the named concept). bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS, @@ -8708,7 +8708,7 @@ static SourceLocation DiagLocForExplicitInstantiation( /// /// \param PrevTSK the kind of the old explicit specialization or instantiatin. /// -/// \param PrevPointOfInstantiation if valid, indicates where the previus +/// \param PrevPointOfInstantiation if valid, indicates where the previous /// declaration was instantiated (either implicitly or explicitly). /// /// \param HasNoEffect will be set to true to indicate that the new diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index f0a9e820c028..826abbd8c362 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -1297,12 +1297,12 @@ static Sema::TemplateDeductionResult DeduceTemplateBases( AddBases(Match.first); // We can give up once we have a single item (or have run out of things to - // search) since cyclical inheritence isn't valid. + // search) since cyclical inheritance isn't valid. while (Matches.size() > 1 && !ToVisit.empty()) { const RecordType *NextT = ToVisit.pop_back_val(); Matches.erase(NextT); - // Always add all bases, since the inheritence tree can contain + // Always add all bases, since the inheritance tree can contain // disqualifications for multiple matches. AddBases(NextT); } diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 54ba12e0e644..79fd065a7b69 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -579,7 +579,7 @@ static void instantiateDependentSYCLKernelAttr( New->addAttr(Attr.clone(S.getASTContext())); } -/// Determine whether the attribute A might be relevent to the declaration D. +/// Determine whether the attribute A might be relevant to the declaration D. /// If not, we can skip instantiating it. The attribute may or may not have /// been instantiated yet. static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A) { @@ -5986,11 +5986,11 @@ NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, bool FindingInstantiatedContext) { DeclContext *ParentDC = D->getDeclContext(); - // Determine whether our parent context depends on any of the tempalte + // Determine whether our parent context depends on any of the template // arguments we're currently substituting. bool ParentDependsOnArgs = isDependentContextAtLevel( ParentDC, TemplateArgs.getNumRetainedOuterLevels()); - // FIXME: Parmeters of pointer to functions (y below) that are themselves + // FIXME: Parameters of pointer to functions (y below) that are themselves // parameters (p below) can have their ParentDC set to the translation-unit // - thus we can not consistently check if the ParentDC of such a parameter // is Dependent or/and a FunctionOrMethod. diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 53e41f01f83d..fcc2cf055be9 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -5523,7 +5523,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, break; case DeclaratorChunk::Function: { const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; - // We supress the warning when there's no LParen location, as this + // We suppress the warning when there's no LParen location, as this // indicates the declaration was an implicit declaration, which gets // warned about separately via -Wimplicit-function-declaration. if (FTI.NumParams == 0 && !FTI.isVariadic && FTI.getLParenLoc().isValid()) @@ -5908,7 +5908,7 @@ namespace { void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { TL.setNameLoc(DS.getTypeSpecTypeLoc()); // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires - // addition field. What we have is good enough for dispay of location + // addition field. What we have is good enough for display of location // of 'fixit' on interface name. TL.setNameEndLoc(DS.getEndLoc()); } diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index b4089def5d9c..0aee33a51633 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -161,7 +161,7 @@ class TreeTransform { /// Wether CXXConstructExpr can be skipped when they are implicit. /// They will be reconstructed when used if needed. - /// This is usefull when the user that cause rebuilding of the + /// This is useful when the user that cause rebuilding of the /// CXXConstructExpr is outside of the expression at which the TreeTransform /// started. bool AllowSkippingCXXConstructExpr() { return true; } @@ -522,7 +522,7 @@ class TreeTransform { /// /// By default, transforms the types of conversion function, constructor, /// and destructor names and then (if needed) rebuilds the declaration name. - /// Identifiers and selectors are returned unmodified. Sublcasses may + /// Identifiers and selectors are returned unmodified. Subclasses may /// override this function to provide alternate behavior. DeclarationNameInfo TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
