[clang-tidy] Fix lint warnings in clang-tidy source code (NFC)

[salman-javed-nz]

Summary

Run clang-tidy on all source files under clang-tools-extra/clang-tidy
with -header-filter=clang-tidy.* and make suggested corrections.

[salman-javed-nz]

No functional change is intended.

The majority of clang-tidy check infractions were

• readability-identifier-naming
• llvm-qualified-auto
• llvm-namespace-comment

I have also fixed obvious typos wherever I noticed them.

[carlosgalvezp]

Looks great, thanks for fixing! I'm surprised we don't have a CI bot running these checks post-merge?

Since this is my first review it's probably good to wait for other reviewers before merging in case I missed something.

[salman-javed-nz]

In D112864#3098351, @carlosgalvezp wrote:

Looks great, thanks for fixing! I'm surprised we don't have a CI bot running these checks post-merge?

You would think so, but it looks like automatic checking during CI was disabled in this commit:
https://github.com/google/llvm-premerge-checks/commit/b69eb6f3647ecb67ff85e551323b3445acde684b

Anyway, even if you run clang-tidy manually, you could miss many issues. A number of warnings are in the header files, and they only get revealed if you set --header-filter properly to look at them.

I will leave this review open for a few days in case other people have comments to add. This patch isn't urgent.

clang-tools-extra/clang-tidy/ClangTidy.h

 class ClangTidyASTConsumerFactory {
 public:
   ClangTidyASTConsumerFactory(
       ClangTidyContext &Context,
       IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> OverlayFS = nullptr);
 
   /// Returns an ASTConsumer that runs the specified clang-tidy checks.
   std::unique_ptr<clang::ASTConsumer>
-  CreateASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
+  createASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
 
   /// Get the list of enabled checks.
   std::vector<std::string> getCheckNames();
 
   /// Get the union of options from all checks.
   ClangTidyOptions::OptionMap getCheckOptions();
 
 private:

clang-tools-extra/clang-tidy/ClangTidy.cpp

if (CheckName.startswith("core") ||
       List.emplace_back(std::string(CheckName), true);
     }
   }
   return List;
 }
 #endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
 
 std::unique_ptr<clang::ASTConsumer>
-ClangTidyASTConsumerFactory::CreateASTConsumer(
+ClangTidyASTConsumerFactory::createASTConsumer(
     clang::CompilerInstance &Compiler, StringRef File) {
   // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
   // modify Compiler.
   SourceManager *SM = &Compiler.getSourceManager();
   Context.setSourceManager(SM);
   Context.setCurrentFile(File);
   Context.setASTContext(&Compiler.getASTContext());
 
public:
     }
 
   private:
     class Action : public ASTFrontendAction {
     public:
       Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
       std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                      StringRef File) override {
-        return Factory->CreateASTConsumer(Compiler, File);
+        return Factory->createASTConsumer(Compiler, File);
       }
 
     private:
       ClangTidyASTConsumerFactory *Factory;
     };
 
     ClangTidyASTConsumerFactory ConsumerFactory;
   };

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
 class SourceManager;
 namespace ast_matchers {
 class MatchFinder;
-}
+} // namespace ast_matchers
 namespace tooling {
 class CompilationDatabase;
-}
+} // namespace tooling
 
 namespace tidy {
 
 /// A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
     if (Message.endswith(CheckNameInMessage))
       Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
 
     auto TidyMessage =
         Loc.isValid()
             ? tooling::DiagnosticMessage(Message, Loc.getManager(), Loc)
             : tooling::DiagnosticMessage(Message);
 
-    // Make sure that if a TokenRange is receieved from the check it is unfurled
+    // Make sure that if a TokenRange is received from the check it is unfurled
     // into a real CharRange for the diagnostic printer later.
     // Whatever we store here gets decoupled from the current SourceManager, so
     // we **have to** know the exact position and length of the highlight.
     auto ToCharRange = [this, &Loc](const CharSourceRange &SourceRange) {
       if (SourceRange.isCharRange())
         return SourceRange;
       assert(SourceRange.isTokenRange());
       SourceLocation End = Lexer::getLocForEndOfToken(

clang-tools-extra/clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
   struct ClangTidyValue {
     ClangTidyValue() : Value(), Priority(0) {}
     ClangTidyValue(const char *Value) : Value(Value), Priority(0) {}
     ClangTidyValue(llvm::StringRef Value, unsigned Priority = 0)
         : Value(Value), Priority(Priority) {}
 
     std::string Value;
     /// Priority stores relative precedence of the value loaded from config
-    /// files to disambigute local vs global value from different levels.
+    /// files to disambiguate local vs global value from different levels.
     unsigned Priority;
   };
   typedef std::pair<std::string, std::string> StringPair;
   typedef llvm::StringMap<ClangTidyValue> OptionMap;
 
   /// Key-value mapping used to store check-specific options.
   OptionMap CheckOptions;
 
   typedef std::vector<std::string> ArgList;
 
   /// Add extra compilation arguments to the end of the list.
   llvm::Optional<ArgList> ExtraArgs;
 
   /// Add extra compilation arguments to the start of the list.
   llvm::Optional<ArgList> ExtraArgsBefore;
 
   /// Only used in the FileOptionsProvider and ConfigOptionsProvider. If true
   /// and using a FileOptionsProvider, it will take a configuration file in the
   /// parent directory (if any exists) and apply this config file on top of the
   /// parent one. IF true and using a ConfigOptionsProvider, it will apply this
-  /// config on top of any configuation file it finds in the directory using the
-  /// same logic as FileOptionsProvider. If false or missing, only this
+  /// config on top of any configuration file it finds in the directory using
+  /// the same logic as FileOptionsProvider. If false or missing, only this
   /// configuration file will be used.
   llvm::Optional<bool> InheritParentConfig;
 
   /// Use colors in diagnostics. If missing, it will be auto detected.
   llvm::Optional<bool> UseColor;
 };
 
 /// Abstract interface for retrieving various ClangTidy options.

clang-tools-extra/clang-tidy/abseil/DurationDivisionCheck.h

 // http://clang.llvm.org/extra/clang-tidy/checks/abseil-duration-division.html
 
 class DurationDivisionCheck : public ClangTidyCheck {
 public:
   using ClangTidyCheck::ClangTidyCheck;
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
-  void registerMatchers(ast_matchers::MatchFinder *finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &result) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_

clang-tools-extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp

if (Call->getExprLoc().isMacroID())
     return;
 
   const Expr *Arg = Call->getArg(0)->IgnoreParenImpCasts();
   // Arguments which are macros are ignored.
   if (Arg->getBeginLoc().isMacroID())
     return;
 
   // We first handle the cases of literal zero (both float and integer).
-  if (IsLiteralZero(Result, *Arg)) {
+  if (isLiteralZero(Result, *Arg)) {
     diag(Call->getBeginLoc(),
          "use ZeroDuration() for zero-length time intervals")
         << FixItHint::CreateReplacement(Call->getSourceRange(),
                                         "absl::ZeroDuration()");
     return;
   }
 
   const auto *CallDecl = Result.Nodes.getNodeAs<FunctionDecl>("call_decl");

clang-tools-extra/clang-tidy/abseil/DurationRewriter.h

 };
 
 /// Given a `Scale`, return the appropriate factory function call for
 /// constructing a `Duration` for that scale.
 llvm::StringRef getDurationFactoryForScale(DurationScale Scale);
 
 /// Given a 'Scale', return the appropriate factory function call for
 /// constructing a `Time` for that scale.
-llvm::StringRef getTimeFactoryForScale(DurationScale scale);
+llvm::StringRef getTimeFactoryForScale(DurationScale Scale);
 
 // Determine if `Node` represents a literal floating point or integral zero.
-bool IsLiteralZero(const ast_matchers::MatchFinder::MatchResult &Result,
+bool isLiteralZero(const ast_matchers::MatchFinder::MatchResult &Result,
                    const Expr &Node);
 
 /// Possibly strip a floating point cast expression.
 ///
 /// If `Node` represents an explicit cast to a floating point type, return
 /// the textual context of the cast argument, otherwise `None`.
 llvm::Optional<std::string>
 stripFloatCast(const ast_matchers::MatchFinder::MatchResult &Result,

 
 /// Given a `Scale` return the fully qualified inverse functions for it.
 /// The first returned value is the inverse for `double`, and the second
 /// returned value is the inverse for `int64`.
 const std::pair<llvm::StringRef, llvm::StringRef> &
 getDurationInverseForScale(DurationScale Scale);
 
 /// Returns the Time inverse function name for a given `Scale`.
-llvm::StringRef getTimeInverseForScale(DurationScale scale);
+llvm::StringRef getTimeInverseForScale(DurationScale Scale);
 
 /// Assuming `Node` has type `double` or `int` representing a time interval of
 /// `Scale`, return the expression to make it a suitable `Duration`.
 std::string rewriteExprFromNumberToDuration(
     const ast_matchers::MatchFinder::MatchResult &Result, DurationScale Scale,
     const Expr *Node);
 
 /// Assuming `Node` has a type `int` representing a time instant of `Scale`

clang-tools-extra/clang-tidy/abseil/DurationRewriter.cpp

case DurationScale::Microseconds:
     return "absl::ToUnixMicros";
   case DurationScale::Nanoseconds:
     return "absl::ToUnixNanos";
   }
   llvm_unreachable("unknown scaling factor");
 }
 
 /// Returns `true` if `Node` is a value which evaluates to a literal `0`.
-bool IsLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) {
+bool isLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) {
   auto ZeroMatcher =
       anyOf(integerLiteral(equals(0)), floatLiteral(equals(0.0)));
 
   // Check to see if we're using a zero directly.
   if (selectFirst<const clang::Expr>(
           "val", match(expr(ignoringImpCasts(ZeroMatcher)).bind("val"), Node,
                        *Result.Context)) != nullptr)
     return true;
std::string rewriteExprFromNumberToDuration(
     const Expr *Node) {
   const Expr &RootNode = *Node->IgnoreParenImpCasts();
 
   // First check to see if we can undo a complimentary function call.
   if (llvm::Optional<std::string> MaybeRewrite =
           rewriteInverseDurationCall(Result, Scale, RootNode))
     return *MaybeRewrite;
 
-  if (IsLiteralZero(Result, RootNode))
+  if (isLiteralZero(Result, RootNode))
     return std::string("absl::ZeroDuration()");
 
   return (llvm::Twine(getDurationFactoryForScale(Scale)) + "(" +
           simplifyDurationFactoryArg(Result, RootNode) + ")")
       .str();
 }
 
 std::string rewriteExprFromNumberToTime(
     const ast_matchers::MatchFinder::MatchResult &Result, DurationScale Scale,
     const Expr *Node) {
   const Expr &RootNode = *Node->IgnoreParenImpCasts();
 
   // First check to see if we can undo a complimentary function call.
   if (llvm::Optional<std::string> MaybeRewrite =
           rewriteInverseTimeCall(Result, Scale, RootNode))
     return *MaybeRewrite;
 
-  if (IsLiteralZero(Result, RootNode))
+  if (isLiteralZero(Result, RootNode))
     return std::string("absl::UnixEpoch()");
 
   return (llvm::Twine(getTimeFactoryForScale(Scale)) + "(" +
           tooling::fixit::getText(RootNode, *Result.Context) + ")")
       .str();
 }
 
 bool isInMacro(const MatchFinder::MatchResult &Result, const Expr *E) {

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

auto Diagnostic = diag(ComparisonExpr->getBeginLoc(),
                     << Neg;
 
   Diagnostic << FixItHint::CreateReplacement(
       ComparisonExpr->getSourceRange(),
       ((Neg ? "!absl::StartsWith(" : "absl::StartsWith(") + HaystackExprCode +
        ", " + NeedleExprCode + ")")
           .str());
 
-  // Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks
+  // Create a preprocessor #include FixIt hint (createIncludeInsertion checks
   // whether this already exists).
   Diagnostic << IncludeInserter.createIncludeInsertion(
       Source.getFileID(ComparisonExpr->getBeginLoc()),
       AbseilStringsMatchHeader);
 }
 
 void StringFindStartswithCheck::registerPPCallbacks(
     const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {

clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.cpp

bool UnrollLoopsCheck::extractValue(int &Value, const BinaryOperator *Op,
   const Expr *LHS = Op->getLHS();
   const Expr *RHS = Op->getRHS();
   Expr::EvalResult Result;
   if (LHS->isEvaluatable(*Context))
     LHS->EvaluateAsRValue(Result, *Context);
   else if (RHS->isEvaluatable(*Context))
     RHS->EvaluateAsRValue(Result, *Context);
   else
-    return false; // Cannot evalue either side.
+    return false; // Cannot evaluate either side.
   if (!Result.Val.isInt())
     return false; // Cannot check number of iterations, return false to be
                   // safe.
   Value = Result.Val.getInt().getExtValue();
   return true;
 }
 
 bool UnrollLoopsCheck::exprHasLargeNumIterations(const Expr *Expression,

clang-tools-extra/clang-tidy/bugprone/BranchCloneCheck.cpp

static bool areSwitchBranchesIdentical(const SwitchBranch LHS,
                                        const SwitchBranch RHS,
                                        const ASTContext &Context) {
   if (LHS.size() != RHS.size())
     return false;
 
   for (size_t I = 0, Size = LHS.size(); I < Size; I++) {
     // NOTE: We strip goto labels and annotations in addition to stripping
     // the `case X:` or `default:` labels, but it is very unlikely that this
-    // would casue false positives in real-world code.
+    // would cause false positives in real-world code.
     if (!areStatementsIdentical(LHS[I]->stripLabelLikeStatements(),
                                 RHS[I]->stripLabelLikeStatements(), Context)) {
       return false;
     }
   }
 
   return true;
 }
for (const Stmt *S : Body->body()) {
       // There may be code before the first branch (which can be dead code
       // and can be code reached either through goto or through case labels
       // that are embedded inside e.g. inner compound statements); we do not
       // store those statements in branches.
       if (!Branches.empty())
         Branches.back().push_back(S);
     }
 
-    auto End = Branches.end();
-    auto BeginCurrent = Branches.begin();
+    auto *End = Branches.end();
+    auto *BeginCurrent = Branches.begin();
     while (BeginCurrent < End) {
-      auto EndCurrent = BeginCurrent + 1;
+      auto *EndCurrent = BeginCurrent + 1;
       while (EndCurrent < End &&
              areSwitchBranchesIdentical(*BeginCurrent, *EndCurrent, Context)) {
         ++EndCurrent;
       }
       // At this point the iterator range {BeginCurrent, EndCurrent} contains a
       // complete family of consecutive identical branches.
       if (EndCurrent > BeginCurrent + 1) {
         diag(BeginCurrent->front()->getBeginLoc(),

clang-tools-extra/clang-tidy/bugprone/CopyConstructorInitCheck.h

CopyConstructorInitCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

public:
 
   /// Adds the conversion between the two types for the given function into
   /// the possible implicit conversion set. FromType and ToType is either:
   ///   * the result of a standard sequence and a converting ctor parameter
   ///   * the return type of a conversion operator and the expected target of
   ///     an implicit conversion.
   void addConversion(const CXXMethodDecl *ConvFun, QualType FromType,
                      QualType ToType) {
-    // Try to go from the FromType to the ToType wiht only a single implicit
+    // Try to go from the FromType to the ToType with only a single implicit
     // conversion, to see if the conversion function is applicable.
     MixData Mix = calculateMixability(
         Check, FromType, ToType, ConvFun->getASTContext(),
         ImplicitConversionModellingMode::OneWaySingleStandardOnly);
     Mix.sanitize();
     if (!Mix.indicatesMixability())
       return;
 
if (llvm::any_of(Check.IgnoredParameterTypeSuffixes,
       return true;
     }
   }
 
   return false;
 }
 
 /// This namespace contains the implementations for the suppression of
-/// diagnostics from similaly used ("related") parameters.
+/// diagnostics from similarly-used ("related") parameters.
 namespace relatedness_heuristic {
 
 static constexpr std::size_t SmallDataStructureSize = 4;
 
 template <typename T, std::size_t N = SmallDataStructureSize>
 using ParamToSmallSetMap =
     llvm::DenseMap<const ParmVarDecl *, llvm::SmallSet<T, N>>;
 

clang-tools-extra/clang-tidy/bugprone/ForwardingReferenceOverloadCheck.cpp

void ForwardingReferenceOverloadCheck::check(
   // template as the function parameter of that type. (This implies that type
   // deduction will happen on the type.)
   const TemplateParameterList *Params = FuncTemplate->getTemplateParameters();
   if (!llvm::is_contained(*Params, TypeParmDecl))
     return;
 
   // Every parameter after the first must have a default value.
   const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-  for (auto Iter = Ctor->param_begin() + 1; Iter != Ctor->param_end(); ++Iter) {
+  for (auto *Iter = Ctor->param_begin() + 1; Iter != Ctor->param_end();
+       ++Iter) {
     if (!(*Iter)->hasDefaultArg())
       return;
   }
   bool EnabledCopy = false, DisabledCopy = false, EnabledMove = false,
        DisabledMove = false;
   for (const auto *OtherCtor : Ctor->getParent()->ctors()) {
     if (OtherCtor->isCopyOrMoveConstructor()) {
       if (OtherCtor->isDeleted() || OtherCtor->getAccess() == AS_private)

clang-tools-extra/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp

if (Prev == S)
       return Child;
     Prev = Child;
   }
   return nextStmt(Result, Parent);
 }
 
 using ExpansionRanges = std::vector<SourceRange>;
 
-/// \bried Get all the macro expansion ranges related to `Loc`.
+/// \brief Get all the macro expansion ranges related to `Loc`.
 ///
 /// The result is ordered from most inner to most outer.
 ExpansionRanges getExpansionRanges(SourceLocation Loc,
                                    const MatchFinder::MatchResult &Result) {
   ExpansionRanges Locs;
   while (Loc.isMacroID()) {
     Locs.push_back(
         Result.SourceManager->getImmediateExpansionRange(Loc).getAsRange());

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.h

 
 public:
   ReservedIdentifierCheck(StringRef Name, ClangTidyContext *Context);
 
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   llvm::Optional<FailureInfo>
-  GetDeclFailureInfo(const NamedDecl *Decl,
+  getDeclFailureInfo(const NamedDecl *Decl,
                      const SourceManager &SM) const override;
   llvm::Optional<FailureInfo>
-  GetMacroFailureInfo(const Token &MacroNameTok,
+  getMacroFailureInfo(const Token &MacroNameTok,
                       const SourceManager &SM) const override;
-  DiagInfo GetDiagInfo(const NamingCheckId &ID,
+  DiagInfo getDiagInfo(const NamingCheckId &ID,
                        const NamingCheckFailure &Failure) const override;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_RESERVEDIDENTIFIERCHECK_H

clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.cpp

getFailureInfoImpl(StringRef Name, bool IsInGlobalNamespace,
   if (!(hasReservedDoubleUnderscore(Name, LangOpts) ||
         startsWithUnderscoreCapital(Name) ||
         startsWithUnderscoreInGlobalNamespace(Name, IsInGlobalNamespace)))
     return FailureInfo{NonReservedTag, getNonReservedFixup(std::string(Name))};
   return None;
 }
 
 Optional<RenamerClangTidyCheck::FailureInfo>
-ReservedIdentifierCheck::GetDeclFailureInfo(const NamedDecl *Decl,
+ReservedIdentifierCheck::getDeclFailureInfo(const NamedDecl *Decl,
                                             const SourceManager &) const {
   assert(Decl && Decl->getIdentifier() && !Decl->getName().empty() &&
          !Decl->isImplicit() &&
          "Decl must be an explicit identifier with a name.");
   return getFailureInfoImpl(Decl->getName(),
                             isa<TranslationUnitDecl>(Decl->getDeclContext()),
                             getLangOpts(), Invert, AllowedIdentifiers);
 }
 
 Optional<RenamerClangTidyCheck::FailureInfo>
-ReservedIdentifierCheck::GetMacroFailureInfo(const Token &MacroNameTok,
+ReservedIdentifierCheck::getMacroFailureInfo(const Token &MacroNameTok,
                                              const SourceManager &) const {
   return getFailureInfoImpl(MacroNameTok.getIdentifierInfo()->getName(), true,
                             getLangOpts(), Invert, AllowedIdentifiers);
 }
 
 RenamerClangTidyCheck::DiagInfo
-ReservedIdentifierCheck::GetDiagInfo(const NamingCheckId &ID,
+ReservedIdentifierCheck::getDiagInfo(const NamingCheckId &ID,
                                      const NamingCheckFailure &Failure) const {
   return DiagInfo{Message, [&](DiagnosticBuilder &Diag) {
                     Diag << ID.second
                          << getMessageSelectIndex(Failure.Info.KindName);
                   }};
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(expr(anyOf(sizeOfExpr(has(ignoringParenImpCasts(anyOf(
                                     ArrayCastExpr, PointerToArrayExpr,
                                     StructAddrOfExpr, PointerToStructExpr)))),
                                 sizeOfExpr(has(PointerToStructType))),
                           unless(ArrayLengthExprDenom))
                          .bind("sizeof-pointer-to-aggregate"),
                      this);
 
-  // Detect expression like: sizeof(epxr) <= k for a suspicious constant 'k'.
+  // Detect expression like: sizeof(expr) <= k for a suspicious constant 'k'.
   if (WarnOnSizeOfCompareToConstant) {
     Finder->addMatcher(
         binaryOperator(matchers::isRelationalOperator(),
                        hasOperands(ignoringParenImpCasts(SizeOfExpr),
                                    ignoringParenImpCasts(integerLiteral(anyOf(
                                        equals(0), isBiggerThan(0x80000))))))
             .bind("sizeof-compare-constant"),
         this);

clang-tools-extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp

if (WarnOnLogicalNotComparison) {
     //     'if (!strcmp())'  ->  'if (strcmp() == 0)'
     Finder->addMatcher(unaryOperator(hasOperatorName("!"),
                                      hasUnaryOperand(ignoringParenImpCasts(
                                          StringCompareCallExpr)))
                            .bind("logical-not-comparison"),
                        this);
   }
 
-  // Detect suspicious cast to an inconsistant type (i.e. not integer type).
+  // Detect suspicious cast to an inconsistent type (i.e. not integer type).
   Finder->addMatcher(
       traverse(TK_AsIs,
                implicitCastExpr(unless(hasType(isInteger())),
                                 hasSourceExpression(StringCompareCallExpr))
                    .bind("invalid-conversion")),
       this);
 
   // Detect suspicious operator with string compare function as operand.

clang-tools-extra/clang-tidy/bugprone/UnusedRaiiCheck.cpp

void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Node = dyn_cast<CXXConstructExpr>(E))
     reportDiagnostic(D, Node, Node->getParenOrBraceRange(),
                      Node->getNumArgs() == 0 ||
                          isa<CXXDefaultArgExpr>(Node->getArg(0)));
   if (const auto *Node = dyn_cast<CXXUnresolvedConstructExpr>(E)) {
     auto SR = SourceRange(Node->getLParenLoc(), Node->getRParenLoc());
     auto DefaultConstruction = Node->getNumArgs() == 0;
     if (!DefaultConstruction) {
-      auto FirstArg = Node->getArg(0);
+      auto *FirstArg = Node->getArg(0);
       DefaultConstruction = isa<CXXDefaultArgExpr>(FirstArg);
-      if (auto ILE = dyn_cast<InitListExpr>(FirstArg)) {
+      if (auto *ILE = dyn_cast<InitListExpr>(FirstArg)) {
         DefaultConstruction = ILE->getNumInits() == 0;
         SR = SourceRange(ILE->getLBraceLoc(), ILE->getRBraceLoc());
       }
     }
     reportDiagnostic(D, Node, SR, DefaultConstruction);
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

const auto LegacyConsumerFunctions =
       hasAnyListedName(LegacyResourceConsumers);
 
   // Legacy functions that are use for resource management but cannot be
   // updated to use `gsl::owner<>`, like standard C memory management.
   const auto CreatesLegacyOwner =
       callExpr(callee(functionDecl(LegacyCreatorFunctions)));
   // C-style functions like `::malloc()` sometimes create owners as void*
   // which is expected to be cast to the correct type in C++. This case
-  // must be catched explicitly.
+  // must be caught explicitly.
   const auto LegacyOwnerCast =
       castExpr(hasSourceExpression(CreatesLegacyOwner));
   // Functions that do manual resource management but cannot be updated to use
   // owner. Best example is `::free()`.
   const auto LegacyOwnerConsumers = functionDecl(LegacyConsumerFunctions);
 
   const auto CreatesOwner =
       anyOf(cxxNewExpr(),

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

enum class InitializerPlacement {
   // the constructor's body creating a new initializer list including the ':'.
   New
 };
 
 // An InitializerInsertion contains a list of fields and/or base classes to
 // insert into the initializer list of a constructor. We use this to ensure
 // proper absolute ordering according to the class declaration relative to the
 // (perhaps improper) ordering in the existing initializer list, if any.
-struct IntializerInsertion {
-  IntializerInsertion(InitializerPlacement Placement,
+struct InitializerInsertion {
+  InitializerInsertion(InitializerPlacement Placement,
                        const CXXCtorInitializer *Where)
       : Placement(Placement), Where(Where) {}
 
   SourceLocation getLocation(const ASTContext &Context,
                              const CXXConstructorDecl &Constructor) const {
     assert((Where != nullptr || Placement == InitializerPlacement::New) &&
            "Location should be relative to an existing initializer or this "
            "insertion represents a new initializer list.");
     SourceLocation Location;

 // Convenience utility to get a RecordDecl from a QualType.
 const RecordDecl *getCanonicalRecordDecl(const QualType &Type) {
   if (const auto *RT = Type.getCanonicalType()->getAs<RecordType>())
     return RT->getDecl();
   return nullptr;
 }
 
 template <typename R, typename T>
-SmallVector<IntializerInsertion, 16>
+SmallVector<InitializerInsertion, 16>
 computeInsertions(const CXXConstructorDecl::init_const_range &Inits,
                   const R &OrderedDecls,
                   const SmallPtrSetImpl<const T *> &DeclsToInit) {
-  SmallVector<IntializerInsertion, 16> Insertions;
+  SmallVector<InitializerInsertion, 16> Insertions;
   Insertions.emplace_back(InitializerPlacement::New, nullptr);
 
   typename R::const_iterator Decl = std::begin(OrderedDecls);
   for (const CXXCtorInitializer *Init : Inits) {
     if (Init->isWritten()) {
       if (Insertions.size() == 1)
         Insertions.emplace_back(InitializerPlacement::Before, Init);
 

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.h

 class SlicingCheck : public ClangTidyCheck {
 public:
   SlicingCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  void DiagnoseSlicedOverriddenMethods(const Expr &call,
+  void diagnoseSlicedOverriddenMethods(const Expr &Call,
                                        const CXXRecordDecl &DerivedDecl,
                                        const CXXRecordDecl &BaseDecl);
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp

Finder->addMatcher(traverse(TK_AsIs, expr(anyOf(SlicesObjectInAssignment,
                                                   SlicesObjectInCtor))
                                            .bind("Call")),
                      this);
 }
 
 /// Warns on methods overridden in DerivedDecl with respect to BaseDecl.
 /// FIXME: this warns on all overrides outside of the sliced path in case of
 /// multiple inheritance.
-void SlicingCheck::DiagnoseSlicedOverriddenMethods(
+void SlicingCheck::diagnoseSlicedOverriddenMethods(
     const Expr &Call, const CXXRecordDecl &DerivedDecl,
     const CXXRecordDecl &BaseDecl) {
   if (DerivedDecl.getCanonicalDecl() == BaseDecl.getCanonicalDecl())
     return;
   for (const auto *Method : DerivedDecl.methods()) {
     // Virtual destructors are OK. We're ignoring constructors since they are
     // tagged as overrides.
     if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
       continue;
     if (Method->size_overridden_methods() > 0) {
       diag(Call.getExprLoc(),
            "slicing object from type %0 to %1 discards override %2")
           << &DerivedDecl << &BaseDecl << Method;
     }
   }
   // Recursively process bases.
   for (const auto &Base : DerivedDecl.bases()) {
     if (const auto *BaseRecordType = Base.getType()->getAs<RecordType>()) {
       if (const auto *BaseRecord = cast_or_null<CXXRecordDecl>(
               BaseRecordType->getDecl()->getDefinition()))
-        DiagnoseSlicedOverriddenMethods(Call, *BaseRecord, BaseDecl);
+        diagnoseSlicedOverriddenMethods(Call, *BaseRecord, BaseDecl);
     }
   }
 }
 
 void SlicingCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *BaseDecl = Result.Nodes.getNodeAs<CXXRecordDecl>("BaseDecl");
   const auto *DerivedDecl =
       Result.Nodes.getNodeAs<CXXRecordDecl>("DerivedDecl");
   const auto *Call = Result.Nodes.getNodeAs<Expr>("Call");
   assert(BaseDecl != nullptr);
   assert(DerivedDecl != nullptr);
   assert(Call != nullptr);
 
   // Warn when slicing the vtable.
   // We're looking through all the methods in the derived class and see if they
   // override some methods in the base class.
   // It's not enough to just test whether the class is polymorphic because we
   // would be fine slicing B to A if no method in B (or its bases) overrides
   // anything in A:
   //   class A { virtual void f(); };
   //   class B : public A {};
   // because in that case calling A::f is the same as calling B::f.
-  DiagnoseSlicedOverriddenMethods(*Call, *DerivedDecl, *BaseDecl);
+  diagnoseSlicedOverriddenMethods(*Call, *DerivedDecl, *BaseDecl);
 
   // Warn when slicing member variables.
   const auto &BaseLayout =
       BaseDecl->getASTContext().getASTRecordLayout(BaseDecl);
   const auto &DerivedLayout =
       DerivedDecl->getASTContext().getASTRecordLayout(DerivedDecl);
   const CharUnits StateSize =
       DerivedLayout.getDataSize() - BaseLayout.getDataSize();

clang-tools-extra/clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.h

private:
   ClassDefiningSpecialMembersMap ClassWithSpecialMembers;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 namespace llvm {
-/// Specialisation of DenseMapInfo to allow ClassDefId objects in DenseMaps
+/// Specialization of DenseMapInfo to allow ClassDefId objects in DenseMaps
 /// FIXME: Move this to the corresponding cpp file as is done for
 /// clang-tidy/readability/IdentifierNamingCheck.cpp.
 template <>
 struct DenseMapInfo<
     clang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::ClassDefId> {
   using ClassDefId =
       clang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::ClassDefId;
 

clang-tools-extra/clang-tidy/fuchsia/MultipleInheritanceCheck.h

bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
   void onEndOfTranslationUnit() override { InterfaceMap.clear(); }
 
 private:
-  void addNodeToInterfaceMap(const CXXRecordDecl *Node, bool isInterface);
-  bool getInterfaceStatus(const CXXRecordDecl *Node, bool &isInterface) const;
+  void addNodeToInterfaceMap(const CXXRecordDecl *Node, bool IsInterface);
+  bool getInterfaceStatus(const CXXRecordDecl *Node, bool &IsInterface) const;
   bool isCurrentClassInterface(const CXXRecordDecl *Node) const;
   bool isInterface(const CXXRecordDecl *Node);
 
   // Contains the identity of each named CXXRecord as an interface.  This is
   // used to memoize lookup speeds and improve performance from O(N^2) to O(N),
   // where N is the number of classes.
   llvm::StringMap<bool> InterfaceMap;
 };
 
 } // namespace fuchsia
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H

clang-tools-extra/clang-tidy/llvm/HeaderGuardCheck.cpp

if (PosInclude != StringRef::npos)
     Guard = Guard.substr(PosInclude + std::strlen("include/"));
 
   // For clang we drop the _TOOLS_.
   size_t PosToolsClang = Guard.rfind("tools/clang/");
   if (PosToolsClang != StringRef::npos)
     Guard = Guard.substr(PosToolsClang + std::strlen("tools/"));
 
   // Unlike LLVM svn, LLVM git monorepo is named llvm-project, so we replace
-  // "/llvm-project/" with the cannonical "/llvm/".
+  // "/llvm-project/" with the canonical "/llvm/".
   const static StringRef LLVMProject = "/llvm-project/";
   size_t PosLLVMProject = Guard.rfind(std::string(LLVMProject));
   if (PosLLVMProject != StringRef::npos)
     Guard = Guard.replace(PosLLVMProject, LLVMProject.size(), "/llvm/");
 
   // The remainder is LLVM_FULL_PATH_TO_HEADER_H
   size_t PosLLVM = Guard.rfind("llvm/");
   if (PosLLVM != StringRef::npos)

clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp

CallStackTy pathfindSomeCycle(ArrayRef<CallGraphNode *> SCC) {
   auto NodeIsPartOfSCC = [&SCCElts](CallGraphNode *N) {
     return SCCElts.count(N) != 0;
   };
 
   // Track the call stack that will cause a cycle.
   SmartSmallSetVector<CallGraphNode::CallRecord, SmallCallStackSize>
       CallStackSet;
 
-  // Arbitrairly take the first element of SCC as entry point.
+  // Arbitrarily take the first element of SCC as entry point.
   CallGraphNode::CallRecord EntryNode(SCC.front(), /*CallExpr=*/nullptr);
   // Continue recursing into subsequent callees that are part of this SCC,
   // and are thus known to be part of the call graph loop, until loop forms.
   CallGraphNode::CallRecord *Node = &EntryNode;
   while (true) {
     // Did we see this node before?
     if (!CallStackSet.insert(*Node))
       break; // Cycle completed! Note that didn't insert the node into stack!

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp

static bool isSameRawIdentifierToken(const Token &T1, const Token &T2,
   return StringRef(SM.getCharacterData(T1.getLocation()), T1.getLength()) ==
          StringRef(SM.getCharacterData(T2.getLocation()), T2.getLength());
 }
 
 bool isTokAtEndOfExpr(SourceRange ExprSR, Token T, const SourceManager &SM) {
   return SM.getExpansionLoc(ExprSR.getEnd()) == T.getLocation();
 }
 
-/// Returns true if both LhsEpxr and RhsExpr are
+/// Returns true if both LhsExpr and RhsExpr are
 /// macro expressions and they are expanded
 /// from different macros.
 static bool areExprsFromDifferentMacros(const Expr *LhsExpr,
                                         const Expr *RhsExpr,
                                         const ASTContext *AstCtx) {
   if (!LhsExpr || !RhsExpr)
     return false;
   SourceRange Lsr = LhsExpr->getSourceRange();
Finder->addMatcher(
                      // Filter noisy false positives.
                      unless(isInTemplateInstantiation()),
                      unless(binaryOperatorIsInMacro()),
                      // TODO: if the banned macros are themselves duplicated
                      unless(hasDescendant(BannedIntegerLiteral)))
           .bind("nested-duplicates"),
       this);
 
-  // Conditional (trenary) operator with equivalent operands, like (Y ? X : X).
+  // Conditional (ternary) operator with equivalent operands, like (Y ? X : X).
   Finder->addMatcher(
       traverse(TK_AsIs,
                conditionalOperator(expressionsAreEquivalent(),
                                    // Filter noisy false positives.
                                    unless(conditionalOperatorIsInMacro()),
                                    unless(isInTemplateInstantiation()))
                    .bind("cond")),
       this);

clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  void diagnoseThrowLocations(const CXXThrowExpr *throwExpr);
-  void diagnoseCatchLocations(const CXXCatchStmt *catchStmt,
-                              ASTContext &context);
-  bool isFunctionParameter(const DeclRefExpr *declRefExpr);
-  bool isCatchVariable(const DeclRefExpr *declRefExpr);
-  bool isFunctionOrCatchVar(const DeclRefExpr *declRefExpr);
+  void diagnoseThrowLocations(const CXXThrowExpr *ThrowExpr);
+  void diagnoseCatchLocations(const CXXCatchStmt *CatchStmt,
+                              ASTContext &Context);
+  bool isFunctionParameter(const DeclRefExpr *DeclRefExpr);
+  bool isCatchVariable(const DeclRefExpr *DeclRefExpr);
+  bool isFunctionOrCatchVar(const DeclRefExpr *DeclRefExpr);
   const bool CheckAnonymousTemporaries;
   const bool WarnOnLargeObject;
   const uint64_t MaxSizeOptions; // The raw value read from the options.
   uint64_t MaxSize; // No `const` because we have to set it in two steps.
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H

clang-tools-extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

 void ThrowByValueCatchByReferenceCheck::check(
     const MatchFinder::MatchResult &Result) {
   diagnoseThrowLocations(Result.Nodes.getNodeAs<CXXThrowExpr>("throw"));
   diagnoseCatchLocations(Result.Nodes.getNodeAs<CXXCatchStmt>("catch"),
                          *Result.Context);
 }
 
 bool ThrowByValueCatchByReferenceCheck::isFunctionParameter(
-    const DeclRefExpr *declRefExpr) {
-  return isa<ParmVarDecl>(declRefExpr->getDecl());
+    const DeclRefExpr *DeclRefExpr) {
+  return isa<ParmVarDecl>(DeclRefExpr->getDecl());
 }
 
 bool ThrowByValueCatchByReferenceCheck::isCatchVariable(
-    const DeclRefExpr *declRefExpr) {
-  auto *valueDecl = declRefExpr->getDecl();
-  if (auto *varDecl = dyn_cast<VarDecl>(valueDecl))
-    return varDecl->isExceptionVariable();
+    const DeclRefExpr *DeclRefExpr) {
+  auto *ValueDecl = DeclRefExpr->getDecl();
+  if (auto *VarDecl = dyn_cast<clang::VarDecl>(ValueDecl))
+    return VarDecl->isExceptionVariable();
   return false;
 }
 
 bool ThrowByValueCatchByReferenceCheck::isFunctionOrCatchVar(
-    const DeclRefExpr *declRefExpr) {
-  return isFunctionParameter(declRefExpr) || isCatchVariable(declRefExpr);
+    const DeclRefExpr *DeclRefExpr) {
+  return isFunctionParameter(DeclRefExpr) || isCatchVariable(DeclRefExpr);
 }
 
 void ThrowByValueCatchByReferenceCheck::diagnoseThrowLocations(
-    const CXXThrowExpr *throwExpr) {
-  if (!throwExpr)
+    const CXXThrowExpr *ThrowExpr) {
+  if (!ThrowExpr)
     return;
-  auto *subExpr = throwExpr->getSubExpr();
-  if (!subExpr)
+  auto *SubExpr = ThrowExpr->getSubExpr();
+  if (!SubExpr)
     return;
-  auto qualType = subExpr->getType();
-  if (qualType->isPointerType()) {
+  auto QualType = SubExpr->getType();
+  if (QualType->isPointerType()) {
     // The code is throwing a pointer.
-    // In case it is strng literal, it is safe and we return.
-    auto *inner = subExpr->IgnoreParenImpCasts();
-    if (isa<StringLiteral>(inner))
+    // In case it is string literal, it is safe and we return.
+    auto *Inner = SubExpr->IgnoreParenImpCasts();
+    if (isa<StringLiteral>(Inner))
       return;
     // If it's a variable from a catch statement, we return as well.
-    auto *declRef = dyn_cast<DeclRefExpr>(inner);
-    if (declRef && isCatchVariable(declRef)) {
+    auto *DeclRef = dyn_cast<DeclRefExpr>(Inner);
+    if (DeclRef && isCatchVariable(DeclRef)) {
       return;
     }
-    diag(subExpr->getBeginLoc(), "throw expression throws a pointer; it should "
+    diag(SubExpr->getBeginLoc(), "throw expression throws a pointer; it should "
                                  "throw a non-pointer value instead");
   }
   // If the throw statement does not throw by pointer then it throws by value
   // which is ok.
   // There are addition checks that emit diagnosis messages if the thrown value
   // is not an RValue. See:
   // https://www.securecoding.cert.org/confluence/display/cplusplus/ERR09-CPP.+Throw+anonymous+temporaries
   // This behavior can be influenced by an option.
 
   // If we encounter a CXXThrowExpr, we move through all casts until you either
   // encounter a DeclRefExpr or a CXXConstructExpr.
   // If it's a DeclRefExpr, we emit a message if the referenced variable is not
   // a catch variable or function parameter.
   // When encountering a CopyOrMoveConstructor: emit message if after casts,
   // the expression is a LValue
   if (CheckAnonymousTemporaries) {
-    bool emit = false;
-    auto *currentSubExpr = subExpr->IgnoreImpCasts();
-    const auto *variableReference = dyn_cast<DeclRefExpr>(currentSubExpr);
-    const auto *constructorCall = dyn_cast<CXXConstructExpr>(currentSubExpr);
+    bool Emit = false;
+    auto *CurrentSubExpr = SubExpr->IgnoreImpCasts();
+    const auto *VariableReference = dyn_cast<DeclRefExpr>(CurrentSubExpr);
+    const auto *ConstructorCall = dyn_cast<CXXConstructExpr>(CurrentSubExpr);
     // If we have a DeclRefExpr, we flag for emitting a diagnosis message in
     // case the referenced variable is neither a function parameter nor a
     // variable declared in the catch statement.
-    if (variableReference)
-      emit = !isFunctionOrCatchVar(variableReference);
-    else if (constructorCall &&
-             constructorCall->getConstructor()->isCopyOrMoveConstructor()) {
+    if (VariableReference)
+      Emit = !isFunctionOrCatchVar(VariableReference);
+    else if (ConstructorCall &&
+             ConstructorCall->getConstructor()->isCopyOrMoveConstructor()) {
       // If we have a copy / move construction, we emit a diagnosis message if
       // the object that we copy construct from is neither a function parameter
       // nor a variable declared in a catch statement
-      auto argIter =
-          constructorCall
+      auto ArgIter =
+          ConstructorCall
               ->arg_begin(); // there's only one for copy constructors
-      auto *currentSubExpr = (*argIter)->IgnoreImpCasts();
-      if (currentSubExpr->isLValue()) {
-        if (auto *tmp = dyn_cast<DeclRefExpr>(currentSubExpr))
-          emit = !isFunctionOrCatchVar(tmp);
-        else if (isa<CallExpr>(currentSubExpr))
-          emit = true;
+      auto *CurrentSubExpr = (*ArgIter)->IgnoreImpCasts();
+      if (CurrentSubExpr->isLValue()) {
+        if (auto *Tmp = dyn_cast<DeclRefExpr>(CurrentSubExpr))
+          Emit = !isFunctionOrCatchVar(Tmp);
+        else if (isa<CallExpr>(CurrentSubExpr))
+          Emit = true;
       }
     }
-    if (emit)
-      diag(subExpr->getBeginLoc(),
+    if (Emit)
+      diag(SubExpr->getBeginLoc(),
            "throw expression should throw anonymous temporary values instead");
   }
 }
 
 void ThrowByValueCatchByReferenceCheck::diagnoseCatchLocations(
-    const CXXCatchStmt *catchStmt, ASTContext &context) {
-  if (!catchStmt)
+    const CXXCatchStmt *CatchStmt, ASTContext &Context) {
+  if (!CatchStmt)
     return;
-  auto caughtType = catchStmt->getCaughtType();
-  if (caughtType.isNull())
+  auto CaughtType = CatchStmt->getCaughtType();
+  if (CaughtType.isNull())
     return;
-  auto *varDecl = catchStmt->getExceptionDecl();
-  if (const auto *PT = caughtType.getCanonicalType()->getAs<PointerType>()) {
-    const char *diagMsgCatchReference = "catch handler catches a pointer value; "
-                                        "should throw a non-pointer value and "
-                                        "catch by reference instead";
+  auto *VarDecl = CatchStmt->getExceptionDecl();
+  if (const auto *PT = CaughtType.getCanonicalType()->getAs<PointerType>()) {
+    const char *DiagMsgCatchReference =
+        "catch handler catches a pointer value; "
     // We do not diagnose when catching pointer to strings since we also allow
     // throwing string literals.
     if (!PT->getPointeeType()->isAnyCharacterType())
-      diag(varDecl->getBeginLoc(), diagMsgCatchReference);
-  } else if (!caughtType->isReferenceType()) {
-    const char *diagMsgCatchReference = "catch handler catches by value; "
+      diag(VarDecl->getBeginLoc(), DiagMsgCatchReference);
+  } else if (!CaughtType->isReferenceType()) {
+    const char *DiagMsgCatchReference = "catch handler catches by value; "
                                         "should catch by reference instead";
     // If it's not a pointer and not a reference then it must be caught "by
     // value". In this case we should emit a diagnosis message unless the type
     // is trivial.
-    if (!caughtType.isTrivialType(context)) {
-      diag(varDecl->getBeginLoc(), diagMsgCatchReference);
+    if (!CaughtType.isTrivialType(Context)) {
+      diag(VarDecl->getBeginLoc(), DiagMsgCatchReference);
     } else if (WarnOnLargeObject) {
       // If the type is trivial, then catching it by reference is not dangerous.
       // However, catching large objects by value decreases the performance.
 
       // We can now access `ASTContext` so if `MaxSize` is an extremal value
       // then set it to the size of `size_t`.
       if (MaxSize == std::numeric_limits<uint64_t>::max())
-        MaxSize = context.getTypeSize(context.getSizeType());
-      if (context.getTypeSize(caughtType) > MaxSize)
-        diag(varDecl->getBeginLoc(), diagMsgCatchReference);
+        MaxSize = Context.getTypeSize(Context.getSizeType());
+      if (Context.getTypeSize(CaughtType) > MaxSize)
+        diag(VarDecl->getBeginLoc(), DiagMsgCatchReference);
     }
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/modernize/AvoidBindCheck.cpp

 }
 
 static void addPlaceholderArgs(const LambdaProperties &LP,
                                llvm::raw_ostream &Stream,
                                bool PermissiveParameterList) {
 
   ArrayRef<BindArgument> Args = LP.BindArguments;
 
-  auto MaxPlaceholderIt =
+  const auto *MaxPlaceholderIt =
       std::max_element(Args.begin(), Args.end(),
                        [](const BindArgument &B1, const BindArgument &B2) {
                          return B1.PlaceHolderIndex < B2.PlaceHolderIndex;
                        });
 
   // Placeholders (if present) have index 1 or greater.
   if (!PermissiveParameterList && (MaxPlaceholderIt == Args.end() ||
                                    MaxPlaceholderIt->PlaceHolderIndex == 0))

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

const auto *Initializer =
       Result.Nodes.getNodeAs<CXXCtorInitializer>("Initializer");
   SourceManager &SM = *Result.SourceManager;
 
   // If the parameter is used or anything other than the copy, do not apply
   // the changes.
   if (!paramReferredExactlyOnce(Ctor, ParamDecl))
     return;
 
-  // If the parameter is trivial to copy, don't move it. Moving a trivivally
+  // If the parameter is trivial to copy, don't move it. Moving a trivially
   // copyable type will cause a problem with performance-move-const-arg
   if (ParamDecl->getType().getNonReferenceType().isTriviallyCopyableType(
           *Result.Context))
     return;
 
   auto Diag = diag(ParamDecl->getBeginLoc(), "pass by value and use std::move");
 
   // Iterate over all declarations of the constructor.

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.h

 /// Transforms the deprecated `std::auto_ptr` into the C++11 `std::unique_ptr`.
 ///
 /// Note that both the `std::auto_ptr` type and the transfer of ownership are
 /// transformed. `std::auto_ptr` provides two ways to transfer the ownership,
 /// the copy-constructor and the assignment operator. Unlike most classes these
 /// operations do not 'copy' the resource but they 'steal' it.
 /// `std::unique_ptr` uses move semantics instead, which makes the intent of
 /// transferring the resource explicit. This difference between the two smart
-/// pointers requeres to wrap the copy-ctor and assign-operator with
+/// pointers requires wrapping the copy-ctor and assign-operator with
 /// `std::move()`.
 ///
 /// For example, given:
 ///
 /// \code
 ///   std::auto_ptr<int> i, j;
 ///   i = j;
 /// \endcode

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.cpp

public:
 
   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override {
     IdentifierInfo *Info = MacroNameTok.getIdentifierInfo();
     if (!Info || !Args || Args->getNumMacroArguments() != 1)
       return;
     if (Info->getName() != Check.getMacroName())
       return;
-    // The first argument to the DISALLOW_COPY_AND_ASSIGN macro is exptected to
+    // The first argument to the DISALLOW_COPY_AND_ASSIGN macro is expected to
     // be the class name.
     const Token *ClassNameTok = Args->getUnexpArgument(0);
     if (Args->ArgNeedsPreexpansion(ClassNameTok, PP))
       // For now we only support simple argument that don't need to be
       // pre-expanded.
       return;
     clang::IdentifierInfo *ClassIdent = ClassNameTok->getIdentifierInfo();
     if (!ClassIdent)

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.h

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class UseNullptrCheck : public ClangTidyCheck {
 public:
   UseNullptrCheck(StringRef Name, ClangTidyContext *Context);
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
-    // FIXME this should be CPlusCplus11 but that causes test cases to
+    // FIXME this should be CPlusPlus11 but that causes test cases to
     // erroneously fail.
     return LangOpts.CPlusPlus;
   }
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

if (!HasFinal && !HasOverride) {
 
     if (InsertLoc.isInvalid() && Method->doesThisDeclarationHaveABody() &&
         Method->getBody() && !Method->isDefaulted()) {
       // For methods with inline definition, add the override keyword at the
       // end of the declaration of the function, but prefer to put it on the
       // same line as the declaration if the beginning brace for the start of
       // the body falls on the next line.
       ReplacementText = " " + OverrideSpelling;
-      auto LastTokenIter = std::prev(Tokens.end());
+      auto *LastTokenIter = std::prev(Tokens.end());
       // When try statement is used instead of compound statement as
       // method body - insert override keyword before it.
       if (LastTokenIter->is(tok::kw_try))
         LastTokenIter = std::prev(LastTokenIter);
       InsertLoc = LastTokenIter->getEndLoc();
     }
 
     if (!InsertLoc.isValid()) {

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h

 #include "clang/Lex/Token.h"
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 struct ClassifiedToken {
   Token T;
-  bool isQualifier;
-  bool isSpecifier;
+  bool IsQualifier;
+  bool IsSpecifier;
 };
 
 /// Rewrites function signatures to use a trailing return type.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-trailing-type-return.html
 class UseTrailingReturnTypeCheck : public ClangTidyCheck {
 public:

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

if (!Elaborated) {
       default:
         break;
       }
     }
 
     return RecursiveASTVisitor<UnqualNameVisitor>::TraverseTypeLoc(TL);
   }
 
-  // Replace the base method in order to call ower own
+  // Replace the base method in order to call our own
   // TraverseTypeLoc().
   bool TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) {
     return TraverseTypeLoc(TL.getUnqualifiedLoc());
   }
 
   // Replace the base version to inform TraverseTypeLoc that the type is
   // elaborated.
   bool TraverseElaboratedTypeLoc(ElaboratedTypeLoc TL) {
static bool isSpecifier(Token T) {
   return T.isOneOf(tok::kw_constexpr, tok::kw_inline, tok::kw_extern,
                    tok::kw_static, tok::kw_friend, tok::kw_virtual);
 }
 
 static llvm::Optional<ClassifiedToken>
 classifyToken(const FunctionDecl &F, Preprocessor &PP, Token Tok) {
   ClassifiedToken CT;
   CT.T = Tok;
-  CT.isQualifier = true;
-  CT.isSpecifier = true;
+  CT.IsQualifier = true;
+  CT.IsSpecifier = true;
   bool ContainsQualifiers = false;
   bool ContainsSpecifiers = false;
   bool ContainsSomethingElse = false;
 
   Token End;
   End.startToken();
   End.setKind(tok::eof);
   SmallVector<Token, 2> Stream{Tok, End};
 
   // FIXME: do not report these token to Preprocessor.TokenWatcher.
   PP.EnterTokenStream(Stream, false, /*IsReinject=*/false);
   while (true) {
     Token T;
     PP.Lex(T);
     if (T.is(tok::eof))
       break;
 
     bool Qual = isCvr(T);
     bool Spec = isSpecifier(T);
-    CT.isQualifier &= Qual;
-    CT.isSpecifier &= Spec;
+    CT.IsQualifier &= Qual;
+    CT.IsSpecifier &= Spec;
     ContainsQualifiers |= Qual;
     ContainsSpecifiers |= Spec;
     ContainsSomethingElse |= !Qual && !Spec;
   }
 
   // If the Token/Macro contains more than one type of tokens, we would need
   // to split the macro in order to move parts to the trailing return type.
   if (ContainsQualifiers + ContainsSpecifiers + ContainsSomethingElse > 1)
SourceRange UseTrailingReturnTypeCheck::findReturnTypeAndCVSourceRange(
   bool ExtendedLeft = false;
   for (size_t I = 0; I < Tokens.size(); I++) {
     // If we found the beginning of the return type, include left qualifiers.
     if (!SM.isBeforeInTranslationUnit(Tokens[I].T.getLocation(),
                                       ReturnTypeRange.getBegin()) &&
         !ExtendedLeft) {
       assert(I <= size_t(std::numeric_limits<int>::max()) &&
              "Integer overflow detected");
-      for (int J = static_cast<int>(I) - 1; J >= 0 && Tokens[J].isQualifier;
+      for (int J = static_cast<int>(I) - 1; J >= 0 && Tokens[J].IsQualifier;
            J--)
         ReturnTypeRange.setBegin(Tokens[J].T.getLocation());
       ExtendedLeft = true;
     }
     // If we found the end of the return type, include right qualifiers.
     if (SM.isBeforeInTranslationUnit(ReturnTypeRange.getEnd(),
                                      Tokens[I].T.getLocation())) {
-      for (size_t J = I; J < Tokens.size() && Tokens[J].isQualifier; J++)
+      for (size_t J = I; J < Tokens.size() && Tokens[J].IsQualifier; J++)
         ReturnTypeRange.setEnd(Tokens[J].T.getLocation());
       break;
     }
   }
 
   assert(!ReturnTypeRange.getBegin().isMacroID() &&
          "Return type source range begin must not be a macro");
   assert(!ReturnTypeRange.getEnd().isMacroID() &&
void UseTrailingReturnTypeCheck::keepSpecifiers(
   size_t InitialAutoLength = Auto.size();
   unsigned int DeletedChars = 0;
   for (ClassifiedToken CT : *MaybeTokens) {
     if (SM.isBeforeInTranslationUnit(CT.T.getLocation(),
                                      ReturnTypeCVRange.getBegin()) ||
         SM.isBeforeInTranslationUnit(ReturnTypeCVRange.getEnd(),
                                      CT.T.getLocation()))
       continue;
-    if (!CT.isSpecifier)
+    if (!CT.IsSpecifier)
       continue;
 
     // Add the token to 'auto' and remove it from the return type, including
     // any whitespace following the token.
     unsigned int TOffset = SM.getDecomposedLoc(CT.T.getLocation()).second;
     assert(TOffset >= ReturnTypeBeginOffset &&
            "Token location must be after the beginning of the return type");
     unsigned int TOffsetInRT = TOffset - ReturnTypeBeginOffset - DeletedChars;

clang-tools-extra/clang-tidy/performance/ImplicitConversionInLoopCheck.h

ImplicitConversionInLoopCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
       bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
         return LangOpts.CPlusPlus11;
       }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
-  void ReportAndFix(const ASTContext *Context, const VarDecl *VD,
+  void reportAndFix(const ASTContext *Context, const VarDecl *VD,
                     const Expr *OperatorCall);
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_IMPLICIT_CONVERSION_IN_LOOP_CHECK_H_

clang-tools-extra/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 // Checks if the stmt is a ImplicitCastExpr with a CastKind that is not a NoOp.
-// The subtelty is that in some cases (user defined conversions), we can
+// The subtlety is that in some cases (user defined conversions), we can
 // get to ImplicitCastExpr inside each other, with the outer one a NoOp. In this
 // case we skip the first cast expr.
 static bool isNonTrivialImplicitCast(const Stmt *ST) {
   if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) {
     return (ICE->getCastKind() != CK_NoOp) ||
            isNonTrivialImplicitCast(ICE->getSubExpr());
   }
   return false;
void ImplicitConversionInLoopCheck::check(
   if (!Materialized)
     return;
 
   // We ignore NoOp casts. Those are generated if the * operator on the
   // iterator returns a value instead of a reference, and the loop variable
   // is a reference. This situation is fine (it probably produces the same
   // code at the end).
   if (isNonTrivialImplicitCast(Materialized->getSubExpr()))
-    ReportAndFix(Result.Context, VD, OperatorCall);
+    reportAndFix(Result.Context, VD, OperatorCall);
 }
 
-void ImplicitConversionInLoopCheck::ReportAndFix(
-    const ASTContext *Context, const VarDecl *VD,
+void ImplicitConversionInLoopCheck::reportAndFix(const ASTContext *Context,
+                                                 const VarDecl *VD,
                                                  const Expr *OperatorCall) {
   // We only match on const ref, so we should print a const ref version of the
   // type.
   QualType ConstType = OperatorCall->getType().withConst();
   QualType ConstRefType = Context->getLValueReferenceType(ConstType);
   const char Message[] =
       "the type of the loop variable %0 is different from the one returned "
       "by the iterator and generates an implicit conversion; you can either "
       "change the type to the matching one (%1 but 'const auto&' is always a "
       "valid option) or remove the reference to make it explicit that you are "
       "creating a new value";
   diag(VD->getBeginLoc(), Message) << VD << ConstRefType;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.h

public:
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override{
     return LangOpts.CPlusPlus;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
-  void AddMatcher(const ast_matchers::DeclarationMatcher &TargetRecordDecl,
+  void addMatcher(const ast_matchers::DeclarationMatcher &TargetRecordDecl,
                   StringRef VarDeclName, StringRef VarDeclStmtName,
                   const ast_matchers::DeclarationMatcher &AppendMethodDecl,
                   StringRef AppendCallName, ast_matchers::MatchFinder *Finder);
   const std::vector<std::string> VectorLikeClasses;
 
   // If true, also check inefficient operations for proto repeated fields.
   bool EnableProto;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENT_VECTOR_OPERATION_H

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

 
 void InefficientVectorOperationCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "VectorLikeClasses",
                 utils::options::serializeStringList(VectorLikeClasses));
   Options.store(Opts, "EnableProto", EnableProto);
 }
 
-void InefficientVectorOperationCheck::AddMatcher(
+void InefficientVectorOperationCheck::addMatcher(
     const DeclarationMatcher &TargetRecordDecl, StringRef VarDeclName,
     StringRef VarDeclStmtName, const DeclarationMatcher &AppendMethodDecl,
     StringRef AppendCallName, MatchFinder *Finder) {
   const auto DefaultConstructorCall = cxxConstructExpr(
       hasType(TargetRecordDecl),
       hasDeclaration(cxxConstructorDecl(isDefaultConstructor())));
   const auto TargetVarDecl =
       varDecl(hasInitializer(DefaultConstructorCall)).bind(VarDeclName);
Finder->addMatcher(
       this);
 }
 
 void InefficientVectorOperationCheck::registerMatchers(MatchFinder *Finder) {
   const auto VectorDecl = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 5>(
       VectorLikeClasses.begin(), VectorLikeClasses.end())));
   const auto AppendMethodDecl =
       cxxMethodDecl(hasAnyName("push_back", "emplace_back"));
-  AddMatcher(VectorDecl, VectorVarDeclName, VectorVarDeclStmtName,
+  addMatcher(VectorDecl, VectorVarDeclName, VectorVarDeclStmtName,
              AppendMethodDecl, PushBackOrEmplaceBackCallName, Finder);
 
   if (EnableProto) {
     const auto ProtoDecl =
         cxxRecordDecl(isDerivedFrom("::proto2::MessageLite"));
 
     // A method's name starts with "add_" might not mean it's an add field
     // call; it could be the getter for a proto field of which the name starts
     // with "add_". So we exclude const methods.
     const auto AddFieldMethodDecl =
         cxxMethodDecl(matchesName("::add_"), unless(isConst()));
-    AddMatcher(ProtoDecl, ProtoVarDeclName, ProtoVarDeclStmtName,
+    addMatcher(ProtoDecl, ProtoVarDeclName, ProtoVarDeclStmtName,
                AddFieldMethodDecl, ProtoAddFieldCallName, Finder);
   }
 }
 
 void InefficientVectorOperationCheck::check(
     const MatchFinder::MatchResult &Result) {
   auto* Context = Result.Context;
   if (Context->getDiagnostics().hasUncompilableErrorOccurred())

clang-tools-extra/clang-tidy/plugin/ClangTidyPlugin.cpp

auto *DiagConsumer =
         new ClangTidyDiagnosticConsumer(*Context, &Compiler.getDiagnostics());
     auto DiagEngine = std::make_unique<DiagnosticsEngine>(
         new DiagnosticIDs, new DiagnosticOptions, DiagConsumer);
     Context->setDiagnosticsEngine(DiagEngine.get());
 
     // Create the AST consumer.
     ClangTidyASTConsumerFactory Factory(*Context);
     std::vector<std::unique_ptr<ASTConsumer>> Vec;
-    Vec.push_back(Factory.CreateASTConsumer(Compiler, File));
+    Vec.push_back(Factory.createASTConsumer(Compiler, File));
 
     return std::make_unique<WrapConsumer>(
         std::move(Context), std::move(DiagEngine), std::move(Vec));
   }
 
   bool ParseArgs(const CompilerInstance &,
                  const std::vector<std::string> &Args) override {
     ClangTidyGlobalOptions GlobalOptions;

clang-tools-extra/clang-tidy/readability/ConstReturnTypeCheck.h

 /// For any function whose return type is const-qualified, suggests removal of
 /// the `const` qualifier from that return type.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-const-return-type.html
 class ConstReturnTypeCheck : public ClangTidyCheck {
  public:
   using ClangTidyCheck::ClangTidyCheck;
-  void registerMatchers(ast_matchers::MatchFinder* finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult& result) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONSTRETURNTYPECHECK_H

clang-tools-extra/clang-tidy/readability/ContainerDataPointerCheck.h

 namespace tidy {
 namespace readability {
 /// Checks whether a call to `operator[]` and `&` can be replaced with a call to
 /// `data()`.
 ///
 /// This only replaces the case where the offset being accessed through the
 /// subscript operation is a known constant 0.  This avoids a potential invalid
 /// memory access when the container is empty.  Cases where the constant is not
-/// explictly zero can be addressed through the clang static analyzer, and those
-/// which cannot be statically identified can be caught using UBSan.
+/// explicitly zero can be addressed through the clang static analyzer, and
+/// those which cannot be statically identified can be caught using UBSan.
 class ContainerDataPointerCheck : public ClangTidyCheck {
 public:
   ContainerDataPointerCheck(StringRef Name, ClangTidyContext *Context);
 
   bool isLanguageVersionSupported(const LangOptions &LO) const override {
     return LO.CPlusPlus11;
   }
 

clang-tools-extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

 }
 AST_MATCHER(CXXConstructExpr, isDefaultConstruction) {
   return Node.getConstructor()->isDefaultConstructor();
 }
 } // namespace ast_matchers
 namespace tidy {
 namespace readability {
 
-using utils::IsBinaryOrTernary;
+using utils::isBinaryOrTernary;
 
 ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
                                                  ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {}
 
 void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
   const auto ValidContainerRecord = cxxRecordDecl(isSameOrDerivedFrom(
       namedDecl(
void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E =
       MemberCallObject
           ? MemberCallObject
           : (Pointee ? Pointee : Result.Nodes.getNodeAs<Expr>("STLObject"));
   FixItHint Hint;
   std::string ReplacementText = std::string(
       Lexer::getSourceText(CharSourceRange::getTokenRange(E->getSourceRange()),
                            *Result.SourceManager, getLangOpts()));
-  if (IsBinaryOrTernary(E) || isa<UnaryOperator>(E)) {
+  if (isBinaryOrTernary(E) || isa<UnaryOperator>(E)) {
     ReplacementText = "(" + ReplacementText + ")";
   }
   if (E->getType()->isPointerType())
     ReplacementText += "->empty()";
   else
     ReplacementText += ".empty()";
 
   if (BinCmp) {

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

enum Criteria : uint8_t {
     // * WhileStmt, DoStmt
     // * CXXCatchStmt
     PenalizeNesting = 1U << 2,
 
     All = Increment | PenalizeNesting | IncrementNesting,
   };
 
   // The helper struct used to record one increment occurrence, with all the
-  // details nessesary.
+  // details necessary.
   struct Detail {
     const SourceLocation Loc;     // What caused the increment?
     const unsigned short Nesting; // How deeply nested is Loc located?
     const Criteria C;             // The criteria of the increment
 
     Detail(SourceLocation SLoc, unsigned short CurrentNesting, Criteria Crit)
         : Loc(SLoc), Nesting(CurrentNesting), C(Crit) {}
 

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

llvm::Optional<RenamerClangTidyCheck::FailureInfo> getFailureInfo(
       const IdentifierNamingCheck::HungarianNotationOption &HNOption,
       StyleKind SK, const SourceManager &SM, bool IgnoreFailedSplit) const;
 
   bool isParamInMainLikeFunction(const ParmVarDecl &ParmDecl,
                                  bool IncludeMainLike) const;
 
 private:
   llvm::Optional<FailureInfo>
-  GetDeclFailureInfo(const NamedDecl *Decl,
+  getDeclFailureInfo(const NamedDecl *Decl,
                      const SourceManager &SM) const override;
   llvm::Optional<FailureInfo>
-  GetMacroFailureInfo(const Token &MacroNameTok,
+  getMacroFailureInfo(const Token &MacroNameTok,
                       const SourceManager &SM) const override;
-  DiagInfo GetDiagInfo(const NamingCheckId &ID,
+  DiagInfo getDiagInfo(const NamingCheckId &ID,
                        const NamingCheckFailure &Failure) const override;
 
   const FileStyle &getStyleForFile(StringRef FileName) const;
 
   /// Stores the style options as a vector, indexed by the specified \ref
   /// StyleKind, for a given directory.
   mutable llvm::StringMap<FileStyle> NamingStylesCache;
   FileStyle *MainFileStyle;

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

if (StringRef(Fixup).equals(Name)) {
     }
     return None;
   }
   return RenamerClangTidyCheck::FailureInfo{std::move(KindName),
                                             std::move(Fixup)};
 }
 
 llvm::Optional<RenamerClangTidyCheck::FailureInfo>
-IdentifierNamingCheck::GetDeclFailureInfo(const NamedDecl *Decl,
+IdentifierNamingCheck::getDeclFailureInfo(const NamedDecl *Decl,
                                           const SourceManager &SM) const {
   SourceLocation Loc = Decl->getLocation();
   const FileStyle &FileStyle = getStyleForFile(SM.getFilename(Loc));
   if (!FileStyle.isActive())
     return llvm::None;
 
   return getFailureInfo(HungarianNotation.getDeclTypeName(Decl),
                         Decl->getName(), Decl, Loc, FileStyle.getStyles(),
                         FileStyle.getHNOption(),
                         findStyleKind(Decl, FileStyle.getStyles(),
                                       FileStyle.isIgnoringMainLikeFunction()),
                         SM, IgnoreFailedSplit);
 }
 
 llvm::Optional<RenamerClangTidyCheck::FailureInfo>
-IdentifierNamingCheck::GetMacroFailureInfo(const Token &MacroNameTok,
+IdentifierNamingCheck::getMacroFailureInfo(const Token &MacroNameTok,
                                            const SourceManager &SM) const {
   SourceLocation Loc = MacroNameTok.getLocation();
   const FileStyle &Style = getStyleForFile(SM.getFilename(Loc));
   if (!Style.isActive())
     return llvm::None;
 
   return getFailureInfo("", MacroNameTok.getIdentifierInfo()->getName(), NULL,
                         Loc, Style.getStyles(), Style.getHNOption(),
                         SK_MacroDefinition, SM, IgnoreFailedSplit);
 }
 
 RenamerClangTidyCheck::DiagInfo
-IdentifierNamingCheck::GetDiagInfo(const NamingCheckId &ID,
+IdentifierNamingCheck::getDiagInfo(const NamingCheckId &ID,
                                    const NamingCheckFailure &Failure) const {
   return DiagInfo{"invalid case style for %0 '%1'",
                   [&](DiagnosticBuilder &Diag) {
                     Diag << Failure.Info.KindName << ID.second;
                   }};
 }
 
 const IdentifierNamingCheck::FileStyle &

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

 
 DifferingParamsContainer
 findDifferingParamsInDeclaration(const FunctionDecl *ParameterSourceDeclaration,
                                  const FunctionDecl *OtherDeclaration,
                                  const FunctionDecl *OriginalDeclaration,
                                  bool Strict) {
   DifferingParamsContainer DifferingParams;
 
-  auto SourceParamIt = ParameterSourceDeclaration->param_begin();
-  auto OtherParamIt = OtherDeclaration->param_begin();
+  const auto *SourceParamIt = ParameterSourceDeclaration->param_begin();
+  const auto *OtherParamIt = OtherDeclaration->param_begin();
 
   while (SourceParamIt != ParameterSourceDeclaration->param_end() &&
          OtherParamIt != OtherDeclaration->param_end()) {
     auto SourceParamName = (*SourceParamIt)->getName();
     auto OtherParamName = (*OtherParamIt)->getName();
 
     // FIXME: Provide a way to extract commented out parameter name from comment
     // next to it.

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto")) {
 
     Diag << FixItHint::CreateReplacement(FixItRange, ReplStr);
     return;
   }
   if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ptr")) {
     if (!isPointerConst(Var->getType()))
       return; // Pointer isn't const, no need to add const qualifier.
     if (!isAutoPointerConst(Var->getType()))
-      return; // Const isnt wrapped in the auto type, so must be declared
+      return; // Const isn't wrapped in the auto type, so must be declared
               // explicitly.
 
     if (Var->getType().isLocalConstQualified()) {
       llvm::Optional<Token> Token =
           findQualToken(Var, Qualifier::Const, Result);
       if (!Token || Token->getLocation().isMacroID())
         return;
     }
if (llvm::Optional<SourceRange> TypeSpec =
           << FixItHint::CreateInsertion(InsertPos, "const ");
     }
     return;
   }
   if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ref")) {
     if (!isPointerConst(Var->getType()))
       return; // Pointer isn't const, no need to add const qualifier.
     if (!isAutoPointerConst(Var->getType()))
-      // Const isnt wrapped in the auto type, so must be declared explicitly.
+      // Const isn't wrapped in the auto type, so must be declared explicitly.
       return;
 
     if (llvm::Optional<SourceRange> TypeSpec =
             getTypeSpecifierLocation(Var, Result)) {
       if (TypeSpec->isInvalid() || TypeSpec->getBegin().isMacroID() ||
           TypeSpec->getEnd().isMacroID())
         return;
       SourceLocation InsertPos = TypeSpec->getBegin();

clang-tools-extra/clang-tidy/utils/ASTUtils.h

 
 namespace clang {
 namespace tidy {
 namespace utils {
 // Returns the (closest) Function declaration surrounding |Statement| or NULL.
 const FunctionDecl *getSurroundingFunction(ASTContext &Context,
                                            const Stmt &Statement);
 // Determine whether Expr is a Binary or Ternary expression.
-bool IsBinaryOrTernary(const Expr *E);
+bool isBinaryOrTernary(const Expr *E);
 
 /// Checks whether a macro flag is present in the given argument. Only considers
 /// cases of single match or match in a binary OR expression. For example,
 /// <needed-flag> or <flag> | <needed-flag> | ...
 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
                                 const LangOptions &LangOpts,
                                 StringRef FlagName);
 

clang-tools-extra/clang-tidy/utils/ASTUtils.cpp

 
 const FunctionDecl *getSurroundingFunction(ASTContext &Context,
                                            const Stmt &Statement) {
   return selectFirst<const FunctionDecl>(
       "function", match(stmt(hasAncestor(functionDecl().bind("function"))),
                         Statement, Context));
 }
 
-bool IsBinaryOrTernary(const Expr *E) {
+bool isBinaryOrTernary(const Expr *E) {
   const Expr *EBase = E->IgnoreImpCasts();
   if (isa<BinaryOperator>(EBase) || isa<ConditionalOperator>(EBase)) {
     return true;
   }
 
   if (const auto *Operator = dyn_cast<CXXOperatorCallExpr>(EBase)) {
     return Operator->isInfixBinaryOp();
   }

clang-tools-extra/clang-tidy/utils/DeclRefExprUtils.cpp

 // is the a const reference or value argument to a CallExpr or CXXConstructExpr.
 SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt,
                            ASTContext &Context) {
   auto DeclRefToVar =
       declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef");
   auto ConstMethodCallee = callee(cxxMethodDecl(isConst()));
   // Match method call expressions where the variable is referenced as the this
-  // implicit object argument and opertor call expression for member operators
+  // implicit object argument and operator call expression for member operators
   // where the variable is the 0-th argument.
   auto Matches = match(
       findAll(expr(anyOf(cxxMemberCallExpr(ConstMethodCallee, on(DeclRefToVar)),
                          cxxOperatorCallExpr(ConstMethodCallee,
                                              hasArgument(0, DeclRefToVar))))),
       Stmt, Context);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);

clang-tools-extra/clang-tidy/utils/IncludeInserter.cpp

 namespace clang {
 namespace tidy {
 namespace utils {
 
 class IncludeInserterCallback : public PPCallbacks {
 public:
   explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
-  // Implements PPCallbacks::InclusionDerective(). Records the names and source
+  // Implements PPCallbacks::InclusionDirective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
                           const Token &IncludeToken, StringRef FileNameRef,
                           bool IsAngled, CharSourceRange FileNameRange,
                           const FileEntry * /*IncludedFile*/,
                           StringRef /*SearchPath*/, StringRef /*RelativePath*/,
                           const Module * /*ImportedModule*/,
                           SrcMgr::CharacteristicKind /*FileType*/) override {
IncludeInserter::createIncludeInsertion(FileID FileID, llvm::StringRef Header) {
   bool IsAngled = Header.consume_front("<");
   if (IsAngled != Header.consume_back(">"))
     return llvm::None;
   // We assume the same Header will never be included both angled and not
   // angled.
   if (!InsertedHeaders[FileID].insert(Header).second)
     return llvm::None;
 
-  return getOrCreate(FileID).CreateIncludeInsertion(Header, IsAngled);
+  return getOrCreate(FileID).createIncludeInsertion(Header, IsAngled);
 }
 
 llvm::Optional<FixItHint>
 IncludeInserter::createMainFileIncludeInsertion(StringRef Header) {
   assert(SourceMgr && "SourceMgr shouldn't be null; did you remember to call "
                       "registerPreprocessor()?");
   return createIncludeInsertion(SourceMgr->getMainFileID(), Header);
 }
 
 void IncludeInserter::addInclude(StringRef FileName, bool IsAngled,
                                  SourceLocation HashLocation,
                                  SourceLocation EndLocation) {
   assert(SourceMgr && "SourceMgr shouldn't be null; did you remember to call "
                       "registerPreprocessor()?");
   FileID FileID = SourceMgr->getFileID(HashLocation);
-  getOrCreate(FileID).AddInclude(FileName, IsAngled, HashLocation, EndLocation);
+  getOrCreate(FileID).addInclude(FileName, IsAngled, HashLocation, EndLocation);
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/utils/IncludeSorter.h

public:
   };
 
   /// ``IncludeSorter`` constructor; takes the FileID and name of the file to be
   /// processed by the sorter.
   IncludeSorter(const SourceManager *SourceMgr, const FileID FileID,
                 StringRef FileName, IncludeStyle Style);
 
   /// Adds the given include directive to the sorter.
-  void AddInclude(StringRef FileName, bool IsAngled,
+  void addInclude(StringRef FileName, bool IsAngled,
                   SourceLocation HashLocation, SourceLocation EndLocation);
 
   /// Creates a quoted inclusion directive in the right sort order. Returns None
   /// on error or if header inclusion directive for header already exists.
-  Optional<FixItHint> CreateIncludeInsertion(StringRef FileName, bool IsAngled);
+  Optional<FixItHint> createIncludeInsertion(StringRef FileName, bool IsAngled);
 
 private:
   typedef SmallVector<SourceRange, 1> SourceRangeVector;
 
   const SourceManager *SourceMgr;
   const IncludeStyle Style;
   FileID CurrentFileID;
   /// The file name stripped of common suffixes.

clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp

 } // namespace
 
 IncludeSorter::IncludeSorter(const SourceManager *SourceMgr,
                              const FileID FileID, StringRef FileName,
                              IncludeStyle Style)
     : SourceMgr(SourceMgr), Style(Style), CurrentFileID(FileID),
       CanonicalFile(makeCanonicalName(FileName, Style)) {}
 
-void IncludeSorter::AddInclude(StringRef FileName, bool IsAngled,
+void IncludeSorter::addInclude(StringRef FileName, bool IsAngled,
                                SourceLocation HashLocation,
                                SourceLocation EndLocation) {
   int Offset = findNextLine(SourceMgr->getCharacterData(EndLocation));
 
   // Record the relevant location information for this inclusion directive.
   IncludeLocations[FileName].push_back(
       SourceRange(HashLocation, EndLocation.getLocWithOffset(Offset)));
   SourceLocations.push_back(IncludeLocations[FileName].back());
 
   // Stop if this inclusion is a duplicate.
   if (IncludeLocations[FileName].size() > 1)
     return;
 
   // Add the included file's name to the appropriate bucket.
   IncludeKinds Kind =
       determineIncludeKind(CanonicalFile, FileName, IsAngled, Style);
   if (Kind != IK_InvalidInclude)
     IncludeBucket[Kind].push_back(FileName.str());
 }
 
-Optional<FixItHint> IncludeSorter::CreateIncludeInsertion(StringRef FileName,
+Optional<FixItHint> IncludeSorter::createIncludeInsertion(StringRef FileName,
                                                           bool IsAngled) {
   std::string IncludeStmt;
   if (Style == IncludeStyle::IS_Google_ObjC) {
     IncludeStmt = IsAngled
                       ? llvm::Twine("#import <" + FileName + ">\n").str()
                       : llvm::Twine("#import \"" + FileName + "\"\n").str();
   } else {
     IncludeStmt = IsAngled

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

if (EndLoc.isMacroID()) {
     const SourceLocation SpellingLoc = SM.getSpellingLoc(EndLoc);
     Optional<Token> NextTok =
         findNextTokenSkippingComments(SpellingLoc, SM, LangOpts);
 
     // Was the next token found successfully?
     // All macro issues are simply resolved by ensuring it's a semicolon.
     if (NextTok && NextTok->is(tok::TokenKind::semi)) {
       // Ideally this would return `F` with spelling location `;` (NextTok)
-      // following the examle above. For now simply return NextTok location.
+      // following the example above. For now simply return NextTok location.
       return NextTok->getLocation();
     }
 
     // Fallthrough to 'normal handling'.
     //  F     (      foo()              ) ;
     //  ^ EndLoc         ^ SpellingLoc  ) ^ next token of EndLoc
   }
 

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.h

-//===--- RenamderClangTidyCheck.h - clang-tidy ------------------*- C++ -*-===//
+//===--- RenamerClangTidyCheck.h - clang-tidy -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_RENAMERCLANGTIDYCHECK_H

 /// macros for renaming based on customizable criteria.
 class RenamerClangTidyCheck : public ClangTidyCheck {
 public:
   RenamerClangTidyCheck(StringRef CheckName, ClangTidyContext *Context);
   ~RenamerClangTidyCheck();
 
   /// Derived classes should not implement any matching logic themselves; this
   /// class will do the matching and call the derived class'
-  /// GetDeclFailureInfo() and GetMacroFailureInfo() for determining whether a
+  /// getDeclFailureInfo() and getMacroFailureInfo() for determining whether a
   /// given identifier passes or fails the check.
   void registerMatchers(ast_matchers::MatchFinder *Finder) override final;
   void
   check(const ast_matchers::MatchFinder::MatchResult &Result) override final;
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override final;
   void onEndOfTranslationUnit() override final;
 
public:
   /// identifier usages.
   struct NamingCheckFailure {
     FailureInfo Info;
 
     /// Whether the failure should be fixed or not.
     ///
     /// e.g.: if the identifier was used or declared within a macro we won't
     /// offer a fixup for safety reasons.
-    bool ShouldFix() const {
+    bool shouldFix() const {
       return FixStatus == ShouldFixStatus::ShouldFix && !Info.Fixup.empty();
     }
 
-    bool ShouldNotify() const {
+    bool shouldNotify() const {
       return FixStatus < ShouldFixStatus::IgnoreFailureThreshold;
     }
 
     ShouldFixStatus FixStatus = ShouldFixStatus::ShouldFix;
 
     /// A set of all the identifier usages starting SourceLocation.
     llvm::DenseSet<SourceLocation> RawUsageLocs;
 
     NamingCheckFailure() = default;
   };
 
   using NamingCheckId = std::pair<SourceLocation, std::string>;
 
   using NamingCheckFailureMap =
       llvm::DenseMap<NamingCheckId, NamingCheckFailure>;
 
   /// Check Macros for style violations.
-  void checkMacro(SourceManager &sourceMgr, const Token &MacroNameTok,
+  void checkMacro(SourceManager &SourceMgr, const Token &MacroNameTok,
                   const MacroInfo *MI);
 
   /// Add a usage of a macro if it already has a violation.
   void expandMacro(const Token &MacroNameTok, const MacroInfo *MI);
 
   void addUsage(const RenamerClangTidyCheck::NamingCheckId &Decl,
                 SourceRange Range, SourceManager *SourceMgr = nullptr);
 
   /// Convenience method when the usage to be added is a NamedDecl.
   void addUsage(const NamedDecl *Decl, SourceRange Range,
                 SourceManager *SourceMgr = nullptr);
 
 protected:
   /// Overridden by derived classes, returns information about if and how a Decl
   /// failed the check. A 'None' result means the Decl did not fail the check.
   virtual llvm::Optional<FailureInfo>
-  GetDeclFailureInfo(const NamedDecl *Decl, const SourceManager &SM) const = 0;
+  getDeclFailureInfo(const NamedDecl *Decl, const SourceManager &SM) const = 0;
 
   /// Overridden by derived classes, returns information about if and how a
   /// macro failed the check. A 'None' result means the macro did not fail the
   /// check.
   virtual llvm::Optional<FailureInfo>
-  GetMacroFailureInfo(const Token &MacroNameTok,
+  getMacroFailureInfo(const Token &MacroNameTok,
                       const SourceManager &SM) const = 0;
 
   /// Represents customized diagnostic text and how arguments should be applied.
   /// Example usage:
   ///
   /// return DiagInfo{"my %1 very %2 special %3 text",
   ///                  [=](DiagnosticBuilder &diag) {
   ///                    diag << arg1 << arg2 << arg3;
   ///                  }};
   struct DiagInfo {
     std::string Text;
     llvm::unique_function<void(DiagnosticBuilder &)> ApplyArgs;
   };
 
   /// Overridden by derived classes, returns a description of the diagnostic
   /// that should be emitted for the given failure. The base class will then
   /// further customize the diagnostic by adding info about whether the fix-it
   /// can be automatically applied or not.
-  virtual DiagInfo GetDiagInfo(const NamingCheckId &ID,
+  virtual DiagInfo getDiagInfo(const NamingCheckId &ID,
                                const NamingCheckFailure &Failure) const = 0;
 
 private:
   NamingCheckFailureMap NamingCheckFailures;
   const bool AggressiveDependentMemberLookup;
 };
 
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_RENAMERCLANGTIDYCHECK_H

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

 #include "llvm/ADT/PointerIntPair.h"
 
 #define DEBUG_TYPE "clang-tidy"
 
 using namespace clang::ast_matchers;
 
 namespace llvm {
 
-/// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps
+/// Specialization of DenseMapInfo to allow NamingCheckId objects in DenseMaps
 template <>
 struct DenseMapInfo<clang::tidy::RenamerClangTidyCheck::NamingCheckId> {
   using NamingCheckId = clang::tidy::RenamerClangTidyCheck::NamingCheckId;
 
   static inline NamingCheckId getEmptyKey() {
     return NamingCheckId(DenseMapInfo<clang::SourceLocation>::getEmptyKey(),
                          "EMPTY");
   }
void RenamerClangTidyCheck::addUsage(
 
   // Try to insert the identifier location in the Usages map, and bail out if it
   // is already in there
   RenamerClangTidyCheck::NamingCheckFailure &Failure =
       NamingCheckFailures[Decl];
   if (!Failure.RawUsageLocs.insert(FixLocation).second)
     return;
 
-  if (!Failure.ShouldFix())
+  if (!Failure.shouldFix())
     return;
 
   if (SourceMgr && SourceMgr->isWrittenInScratchSpace(FixLocation))
     Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
 
   if (!utils::rangeCanBeFixed(Range, SourceMgr))
     Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
 }
if (auto Search =
           return NameLookup(
               llvm::None); // Multiple decls found in different base classes.
         Found = *Search;
         continue;
       }
     } else
       return NameLookup(llvm::None); // Propagate multiple resolution back up.
   }
-  return NameLookup(Found); // If nullptr, decl wasnt found.
+  return NameLookup(Found); // If nullptr, decl wasn't found.
 }
 
 void RenamerClangTidyCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Decl =
           Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
 
     addUsage(Decl->getParent(), Decl->getNameInfo().getSourceRange(),
              Result.SourceManager);
if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
     }
 
     // Ignore ClassTemplateSpecializationDecl which are creating duplicate
     // replacements with CXXRecordDecl.
     if (isa<ClassTemplateSpecializationDecl>(Decl))
       return;
 
     Optional<FailureInfo> MaybeFailure =
-        GetDeclFailureInfo(Decl, *Result.SourceManager);
+        getDeclFailureInfo(Decl, *Result.SourceManager);
     if (!MaybeFailure)
       return;
     FailureInfo &Info = *MaybeFailure;
     NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
         Decl->getLocation(), Decl->getNameAsString())];
     SourceRange Range =
         DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
             .getSourceRange();
if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
     addUsage(Decl, Range);
   }
 }
 
 void RenamerClangTidyCheck::checkMacro(SourceManager &SourceMgr,
                                        const Token &MacroNameTok,
                                        const MacroInfo *MI) {
   Optional<FailureInfo> MaybeFailure =
-      GetMacroFailureInfo(MacroNameTok, SourceMgr);
+      getMacroFailureInfo(MacroNameTok, SourceMgr);
   if (!MaybeFailure)
     return;
   FailureInfo &Info = *MaybeFailure;
   StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
   NamingCheckId ID(MI->getDefinitionLoc(), std::string(Name));
   NamingCheckFailure &Failure = NamingCheckFailures[ID];
   SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
 

 void RenamerClangTidyCheck::onEndOfTranslationUnit() {
   for (const auto &Pair : NamingCheckFailures) {
     const NamingCheckId &Decl = Pair.first;
     const NamingCheckFailure &Failure = Pair.second;
 
     if (Failure.Info.KindName.empty())
       continue;
 
-    if (Failure.ShouldNotify()) {
-      auto DiagInfo = GetDiagInfo(Decl, Failure);
+    if (Failure.shouldNotify()) {
+      auto DiagInfo = getDiagInfo(Decl, Failure);
       auto Diag = diag(Decl.first,
                        DiagInfo.Text + getDiagnosticSuffix(Failure.FixStatus,
                                                            Failure.Info.Fixup));
       DiagInfo.ApplyArgs(Diag);
 
-      if (Failure.ShouldFix()) {
+      if (Failure.shouldFix()) {
         for (const auto &Loc : Failure.RawUsageLocs) {
           // We assume that the identifier name is made of one token only. This
           // is always the case as we ignore usages in macros that could build
           // identifier names by combining multiple tokens.
           //
           // For destructors, we already take care of it by remembering the
           // location of the start of the identifier and not the start of the
           // tilde.

clang-tools-extra/clang-tidy/utils/TypeTraits.h

 bool isTriviallyDestructible(QualType Type);
 
 /// Returns true if `Type` has a non-trivial move constructor.
 bool hasNonTrivialMoveConstructor(QualType Type);
 
 /// Return true if `Type` has a non-trivial move assignment operator.
 bool hasNonTrivialMoveAssignment(QualType Type);
 
-} // type_traits
+} // namespace type_traits
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPETRAITS_H