[clang-tidy] Applied clang-tidy fixes. NFC

[alexfh]

Summary

Applied fixes enabled by the LLVM's .clang-tidy configs. Reverted files where
fixes introduced compile errors:

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

$ clang-tools-extra/clang-tidy/tool/run-clang-tidy.py -fix clang-tools-extra/clang-tidy/
Enabled checks:

llvm-else-after-return
llvm-header-guard
llvm-include-order
llvm-namespace-comment
llvm-prefer-isa-or-dyn-cast-in-conditionals
llvm-prefer-register-over-unsigned
llvm-qualified-auto
llvm-twine-local
misc-definitions-in-headers
misc-misplaced-const
misc-new-delete-overloads
misc-no-recursion
misc-non-copyable-objects
misc-redundant-expression
misc-static-assert
misc-throw-by-value-catch-by-reference
misc-unconventional-assign-operator
misc-uniqueptr-reset-release
misc-unused-alias-decls
misc-unused-using-decls
readability-identifier-naming

[aaron.ballman]

LGTM, thank you for the cleanup!

[alexfh]

Manually cleaned up suboptimal fixes.

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

96

Changing this to const char *.

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

283

Changing this to FunctionDecl *.

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

192–194

This comes from llvm-qualified-auto. Iterator being a pointer is an implementation detail, thus the fix is not helpful. Reverting it.

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

113

Removed this manually.

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

109–110

This comes from llvm-qualified-auto. Iterator being a pointer is an implementation detail, thus the fix is not helpful. Reverting it.

For the context:
using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
...
param_iterator param_begin() ...

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

923

Removing this const, since it doesn't bring anything here.

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

42–43

Removing this one too. The check outputs just one diagnostic per if - else if - else if chain for some reason.

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

87–88

Removing this one too. The llvm-else-after-return check outputs just one diagnostic per if - else if - else if chain for some reason.

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

337 ↗

(On Diff #319854)

Iterator being a pointer is an implementation detail. Reverting.

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

62

Changing to const char *.

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

389–390

Fixing indentation.

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

175

Reverting this (iterator doesn't have to be a pointer).

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

61–65

Removed the use of auto here.

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

72

Changing to const char *.

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

41–42

Removed this variable.

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

108–109 ↗

(On Diff #319854)

Reverting.

[alexfh]

Trying to upload complete patch.

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

 #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
 static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
 
 class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
 public:
   AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
 
   void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
-                            FilesMade *filesMade) override {
+                            FilesMade *FilesMade) override {
     for (const ento::PathDiagnostic *PD : Diags) {
       SmallString<64> CheckName(AnalyzerCheckNamePrefix);
       CheckName += PD->getCheckerName();
       Context.diag(CheckName, PD->getLocation().asLocation(),
                    PD->getShortDescription())
           << PD->path.back()->getRanges();
 
       for (const auto &DiagPiece :
void reportDiagnostic(const ClangTidyError &Error) {
     for (auto Fix : FixLocations) {
       Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
                                          : diag::note_fixit_failed);
     }
     for (const auto &Note : Error.Notes)
       reportNote(Note);
   }
 
-  void Finish() {
+  void finish() {
     if (ApplyFixes && TotalFixes > 0) {
       Rewriter Rewrite(SourceMgr, LangOpts);
       for (const auto &FileAndReplacements : FileReplacements) {
         StringRef File = FileAndReplacements.first();
         llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
             SourceMgr.getFileManager().getBufferForFile(File);
         if (!Buffer) {
           llvm::errs() << "Can't get buffer for file " << File << ": "
if (!Error.BuildDirectory.empty()) {
       //
       // Change the directory to the one used during the analysis.
       FileSystem.setCurrentWorkingDirectory(Error.BuildDirectory);
     }
     Reporter.reportDiagnostic(Error);
     // Return to the initial directory to correctly resolve next Error.
     FileSystem.setCurrentWorkingDirectory(InitialWorkingDir.get());
   }
-  Reporter.Finish();
+  Reporter.finish();
   WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
 }
 
 void exportReplacements(const llvm::StringRef MainFilePath,
                         const std::vector<ClangTidyError> &Errors,
                         raw_ostream &OS) {
   TranslationUnitDiagnostics TUD;
   TUD.MainSourceFile = std::string(MainFilePath);

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

template <> struct SequenceTraits<FileFilter::LineRange> {
   }
 };
 
 template <> struct MappingTraits<FileFilter> {
   static void mapping(IO &IO, FileFilter &File) {
     IO.mapRequired("name", File.Name);
     IO.mapOptional("lines", File.LineRanges);
   }
-  static std::string validate(IO &io, FileFilter &File) {
+  static std::string validate(IO &Io, FileFilter &File) {
     if (File.Name.empty())
       return "No file name specified";
     for (const FileFilter::LineRange &Range : File.LineRanges) {
       if (Range.first <= 0 || Range.second <= 0)
         return "Invalid line range";
     }
     return "";
   }

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

void ExpandModularHeadersPPCallbacks::handleModuleFile(
   // Visit all the input files of this module and mark them to record their
   // contents later.
   Compiler.getASTReader()->visitInputFiles(
       *MF, true, false,
       [this](const serialization::InputFile &IF, bool /*IsSystem*/) {
         Recorder->addNecessaryFile(IF.getFile());
       });
   // Recursively handle all transitively imported modules.
-  for (auto Import : MF->Imports)
+  for (auto *Import : MF->Imports)
     handleModuleFile(Import);
 }
 
 void ExpandModularHeadersPPCallbacks::parseToLocation(SourceLocation Loc) {
   // Load all source locations present in the external sources.
   for (unsigned I = 0, N = Sources.loaded_sloc_entry_size(); I != N; ++I) {
     Sources.getLoadedSLocEntry(I, nullptr);
   }

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

 //===--- tools/extra/clang-tidy/GlobList.cpp ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "GlobList.h"
 #include "llvm/ADT/SmallString.h"
 
 using namespace clang;
 using namespace tidy;
 
 // Returns true if GlobList starts with the negative indicator ('-'), removes it
 // from the GlobList.
-static bool ConsumeNegativeIndicator(StringRef &GlobList) {
+static bool consumeNegativeIndicator(StringRef &GlobList) {
   GlobList = GlobList.trim(" \r\n");
   if (GlobList.startswith("-")) {
     GlobList = GlobList.substr(1);
     return true;
   }
   return false;
 }
 
 // Converts first glob from the comma-separated list of globs to Regex and
 // removes it and the trailing comma from the GlobList.
-static llvm::Regex ConsumeGlob(StringRef &GlobList) {
+static llvm::Regex consumeGlob(StringRef &GlobList) {
   StringRef UntrimmedGlob = GlobList.substr(0, GlobList.find(','));
   StringRef Glob = UntrimmedGlob.trim(' ');
   GlobList = GlobList.substr(UntrimmedGlob.size() + 1);
   SmallString<128> RegexText("^");
   StringRef MetaChars("()^$|*+?.[]\\{}");
   for (char C : Glob) {
     if (C == '*')
       RegexText.push_back('.');
     else if (MetaChars.contains(C))
       RegexText.push_back('\\');
     RegexText.push_back(C);
   }
   RegexText.push_back('$');
   return llvm::Regex(RegexText);
 }
 
 GlobList::GlobList(StringRef Globs) {
   Items.reserve(Globs.count(',') + 1);
   do {
     GlobListItem Item;
-    Item.IsPositive = !ConsumeNegativeIndicator(Globs);
-    Item.Regex = ConsumeGlob(Globs);
+    Item.IsPositive = !consumeNegativeIndicator(Globs);
+    Item.Regex = consumeGlob(Globs);
     Items.push_back(std::move(Item));
   } while (!Globs.empty());
 }
 
 bool GlobList::contains(StringRef S) const {
   // Iterating the container backwards as the last match determins if S is in
   // the list.
   for (const GlobListItem &Item : llvm::reverse(Items)) {
     if (Item.Regex.match(S))
       return Item.IsPositive;
   }
   return false;
 }

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

 #include "clang/Lex/Lexer.h"
 
 namespace clang {
 namespace tidy {
 namespace abseil {
 
 using namespace clang::ast_matchers;
 
-void DurationDivisionCheck::registerMatchers(MatchFinder *finder) {
+void DurationDivisionCheck::registerMatchers(MatchFinder *Finder) {
   const auto DurationExpr =
       expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))));
-  finder->addMatcher(
+  Finder->addMatcher(
       traverse(TK_AsIs,
                implicitCastExpr(
                    hasSourceExpression(ignoringParenCasts(
                        cxxOperatorCallExpr(hasOverloadedOperatorName("/"),
                                            hasArgument(0, DurationExpr),
                                            hasArgument(1, DurationExpr))
                            .bind("OpCall"))),
                    hasImplicitDestinationType(qualType(unless(isInteger()))),
                    unless(hasParent(cxxStaticCastExpr())),
                    unless(hasParent(cStyleCastExpr())),
                    unless(isInTemplateInstantiation()))),
       this);
 }
 
-void DurationDivisionCheck::check(const MatchFinder::MatchResult &result) {
-  const auto *OpCall = result.Nodes.getNodeAs<CXXOperatorCallExpr>("OpCall");
+void DurationDivisionCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *OpCall = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("OpCall");
   diag(OpCall->getOperatorLoc(),
        "operator/ on absl::Duration objects performs integer division; "
        "did you mean to use FDivDuration()?")
       << FixItHint::CreateInsertion(OpCall->getBeginLoc(),
                                     "absl::FDivDuration(")
       << FixItHint::CreateReplacement(
              SourceRange(OpCall->getOperatorLoc(), OpCall->getOperatorLoc()),
              ", ")
       << FixItHint::CreateInsertion(
              Lexer::getLocForEndOfToken(
-                 result.SourceManager->getSpellingLoc(OpCall->getEndLoc()), 0,
-                 *result.SourceManager, result.Context->getLangOpts()),
+                 Result.SourceManager->getSpellingLoc(OpCall->getEndLoc()), 0,
+                 *Result.SourceManager, Result.Context->getLangOpts()),
              ")");
 }
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace abseil {
 
 // Returns `true` if `Range` is inside a macro definition.
-static bool InsideMacroDefinition(const MatchFinder::MatchResult &Result,
+static bool insideMacroDefinition(const MatchFinder::MatchResult &Result,
                                   SourceRange Range) {
   return !clang::Lexer::makeFileCharRange(
               clang::CharSourceRange::getCharRange(Range),
               *Result.SourceManager, Result.Context->getLangOpts())
               .isValid();
 }
 
 void DurationFactoryFloatCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
           .bind("call"),
       this);
 }
 
 void DurationFactoryFloatCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>("call");
 
   // Don't try and replace things inside of macro definitions.
-  if (InsideMacroDefinition(Result, MatchedCall->getSourceRange()))
+  if (insideMacroDefinition(Result, MatchedCall->getSourceRange()))
     return;
 
   const Expr *Arg = MatchedCall->getArg(0)->IgnoreImpCasts();
   // Arguments which are macros are ignored.
   if (Arg->getBeginLoc().isMacroID())
     return;
 
   llvm::Optional<std::string> SimpleArg = stripFloatCast(Result, *Arg);

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

return llvm::StringSwitch<llvm::Optional<DurationScale>>(FactoryName)
       .Case("Seconds", DurationScale::Seconds)
       .Case("Minutes", DurationScale::Minutes)
       .Case("Hours", DurationScale::Hours)
       .Default(llvm::None);
 }
 
 // Given either an integer or float literal, return its value.
 // One and only one of `IntLit` and `FloatLit` should be provided.
-static double GetValue(const IntegerLiteral *IntLit,
+static double getValue(const IntegerLiteral *IntLit,
                        const FloatingLiteral *FloatLit) {
   if (IntLit)
     return IntLit->getValue().getLimitedValue();
 
   assert(FloatLit != nullptr && "Neither IntLit nor FloatLit set");
   return FloatLit->getValueAsApproximateDouble();
 }
 
 // Given the scale of a duration and a `Multiplier`, determine if `Multiplier`
 // would produce a new scale.  If so, return a tuple containing the new scale
 // and a suitable Multiplier for that scale, otherwise `None`.
 static llvm::Optional<std::tuple<DurationScale, double>>
-GetNewScaleSingleStep(DurationScale OldScale, double Multiplier) {
+getNewScaleSingleStep(DurationScale OldScale, double Multiplier) {
   switch (OldScale) {
   case DurationScale::Hours:
     if (Multiplier <= 1.0 / 60.0)
       return std::make_tuple(DurationScale::Minutes, Multiplier * 60.0);
     break;
 
   case DurationScale::Minutes:
     if (Multiplier >= 60.0)
case DurationScale::Nanoseconds:
     break;
   }
 
   return llvm::None;
 }
 
 // Given the scale of a duration and a `Multiplier`, determine if `Multiplier`
 // would produce a new scale.  If so, return it, otherwise `None`.
-static llvm::Optional<DurationScale> GetNewScale(DurationScale OldScale,
+static llvm::Optional<DurationScale> getNewScale(DurationScale OldScale,
                                                  double Multiplier) {
   while (Multiplier != 1.0) {
-    llvm::Optional<std::tuple<DurationScale, double>> result =
-        GetNewScaleSingleStep(OldScale, Multiplier);
-    if (!result)
-      break;
-    if (std::get<1>(*result) == 1.0)
-      return std::get<0>(*result);
-    Multiplier = std::get<1>(*result);
-    OldScale = std::get<0>(*result);
+    llvm::Optional<std::tuple<DurationScale, double>> Result =
+        getNewScaleSingleStep(OldScale, Multiplier);
+    if (!Result)
+      break;
+    if (std::get<1>(*Result) == 1.0)
+      return std::get<0>(*Result);
+    Multiplier = std::get<1>(*Result);
+    OldScale = std::get<0>(*Result);
   }
 
   return llvm::None;
 }
 
 void DurationFactoryScaleCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       callExpr(
if (const auto *MultBinOp =
           Result.Nodes.getNodeAs<BinaryOperator>("mult_binop")) {
     // For multiplication, we need to look at both operands, and consider the
     // cases where a user is multiplying by something such as 1e-3.
 
     // First check the LHS
     const auto *IntLit = llvm::dyn_cast<IntegerLiteral>(MultBinOp->getLHS());
     const auto *FloatLit = llvm::dyn_cast<FloatingLiteral>(MultBinOp->getLHS());
     if (IntLit || FloatLit) {
-      NewScale = GetNewScale(Scale, GetValue(IntLit, FloatLit));
+      NewScale = getNewScale(Scale, getValue(IntLit, FloatLit));
       if (NewScale)
         Remainder = MultBinOp->getRHS();
     }
 
     // If we weren't able to scale based on the LHS, check the RHS
     if (!NewScale) {
       IntLit = llvm::dyn_cast<IntegerLiteral>(MultBinOp->getRHS());
       FloatLit = llvm::dyn_cast<FloatingLiteral>(MultBinOp->getRHS());
       if (IntLit || FloatLit) {
-        NewScale = GetNewScale(Scale, GetValue(IntLit, FloatLit));
+        NewScale = getNewScale(Scale, getValue(IntLit, FloatLit));
         if (NewScale)
           Remainder = MultBinOp->getLHS();
       }
     }
   } else if (const auto *DivBinOp =
                  Result.Nodes.getNodeAs<BinaryOperator>("div_binop")) {
     // We next handle division.
     // For division, we only check the RHS.
     const auto *FloatLit = llvm::dyn_cast<FloatingLiteral>(DivBinOp->getRHS());
 
     llvm::Optional<DurationScale> NewScale =
-        GetNewScale(Scale, 1.0 / FloatLit->getValueAsApproximateDouble());
+        getNewScale(Scale, 1.0 / FloatLit->getValueAsApproximateDouble());
     if (NewScale) {
       const Expr *Remainder = DivBinOp->getLHS();
 
       // We've found an appropriate scaling factor and the new scale, so output
       // the relevant fix.
       diag(Call->getBeginLoc(), "internal duration scaling can be removed")
           << FixItHint::CreateReplacement(
                  Call->getSourceRange(),

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

case DurationScale::Microseconds:
     return "absl::FromUnixMicros";
   case DurationScale::Nanoseconds:
     return "absl::FromUnixNanos";
   }
   llvm_unreachable("unknown scaling factor");
 }
 
 /// Returns the Time factory function name for a given `Scale`.
-llvm::StringRef getTimeInverseForScale(DurationScale scale) {
-  switch (scale) {
+llvm::StringRef getTimeInverseForScale(DurationScale Scale) {
+  switch (Scale) {
   case DurationScale::Hours:
     return "absl::ToUnixHours";
   case DurationScale::Minutes:
     return "absl::ToUnixMinutes";
   case DurationScale::Seconds:
     return "absl::ToUnixSeconds";
   case DurationScale::Milliseconds:
     return "absl::ToUnixMillis";

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

for (const auto &Scale : {"Hours", "Minutes", "Seconds", "Milliseconds",
     std::string DurationFactory = (llvm::Twine("::absl::") + Scale).str();
     std::string FloatConversion =
         (llvm::Twine("::absl::ToDouble") + Scale).str();
     std::string IntegerConversion =
         (llvm::Twine("::absl::ToInt64") + Scale).str();
 
     // Matcher which matches the current scale's factory with a `1` argument,
     // e.g. `absl::Seconds(1)`.
-    auto factory_matcher = ignoringElidableConstructorCall(
+    auto FactoryMatcher = ignoringElidableConstructorCall(
         callExpr(callee(functionDecl(hasName(DurationFactory))),
                  hasArgument(0, ignoringImpCasts(integerLiteral(equals(1))))));
 
     // Matcher which matches either inverse function and binds its argument,
     // e.g. `absl::ToDoubleSeconds(dur)`.
-    auto inverse_function_matcher = callExpr(
+    auto InverseFunctionMatcher = callExpr(
         callee(functionDecl(hasAnyName(FloatConversion, IntegerConversion))),
         hasArgument(0, expr().bind("arg")));
 
     // Matcher which matches a duration divided by the factory_matcher above,
     // e.g. `dur / absl::Seconds(1)`.
-    auto division_operator_matcher = cxxOperatorCallExpr(
+    auto DivisionOperatorMatcher = cxxOperatorCallExpr(
         hasOverloadedOperatorName("/"), hasArgument(0, expr().bind("arg")),
-        hasArgument(1, factory_matcher));
+        hasArgument(1, FactoryMatcher));
 
     // Matcher which matches a duration argument to `FDivDuration`,
     // e.g. `absl::FDivDuration(dur, absl::Seconds(1))`
-    auto fdiv_matcher = callExpr(
+    auto FdivMatcher = callExpr(
         callee(functionDecl(hasName("::absl::FDivDuration"))),
-        hasArgument(0, expr().bind("arg")), hasArgument(1, factory_matcher));
+        hasArgument(0, expr().bind("arg")), hasArgument(1, FactoryMatcher));
 
     // Matcher which matches a duration argument being scaled,
     // e.g. `absl::ToDoubleSeconds(dur) * 2`
-    auto scalar_matcher = ignoringImpCasts(
+    auto ScalarMatcher = ignoringImpCasts(
         binaryOperator(hasOperatorName("*"),
                        hasEitherOperand(expr(ignoringParenImpCasts(
                            callExpr(callee(functionDecl(hasAnyName(
                                         FloatConversion, IntegerConversion))),
                                     hasArgument(0, expr().bind("arg")))
                                .bind("inner_call")))))
             .bind("binop"));
 
     Finder->addMatcher(
         callExpr(callee(functionDecl(hasName(DurationFactory))),
-                 hasArgument(0, anyOf(inverse_function_matcher,
-                                      division_operator_matcher, fdiv_matcher,
-                                      scalar_matcher)))
+                 hasArgument(0, anyOf(InverseFunctionMatcher,
+                                      DivisionOperatorMatcher, FdivMatcher,
+                                      ScalarMatcher)))
             .bind("call"),
         this);
   }
 }
 
 void DurationUnnecessaryConversionCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *OuterCall = Result.Nodes.getNodeAs<Expr>("call");

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

 void NoNamespaceCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       namespaceDecl(hasName("::absl"), unless(isInAbseilFile()))
           .bind("abslNamespace"),
       this);
 }
 
 void NoNamespaceCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *abslNamespaceDecl =
+  const auto *AbslNamespaceDecl =
       Result.Nodes.getNodeAs<NamespaceDecl>("abslNamespace");
 
-  diag(abslNamespaceDecl->getLocation(),
+  diag(AbslNamespaceDecl->getLocation(),
        "namespace 'absl' is reserved for implementation of the Abseil library "
        "and should not be opened in user code");
 }
 
 } // namespace abseil
 } // namespace tidy
 } // namespace clang

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

 
 namespace {
 
 struct StrCatCheckResult {
   int NumCalls = 0;
   std::vector<FixItHint> Hints;
 };
 
-void RemoveCallLeaveArgs(const CallExpr* Call, StrCatCheckResult* CheckResult) {
+void removeCallLeaveArgs(const CallExpr *Call, StrCatCheckResult *CheckResult) {
   if (Call->getNumArgs() == 0)
     return;
   // Remove 'Foo('
   CheckResult->Hints.push_back(
       FixItHint::CreateRemoval(CharSourceRange::getCharRange(
           Call->getBeginLoc(), Call->getArg(0)->getBeginLoc())));
   // Remove the ')'
   CheckResult->Hints.push_back(
       FixItHint::CreateRemoval(CharSourceRange::getCharRange(
           Call->getRParenLoc(), Call->getEndLoc().getLocWithOffset(1))));
 }
 
-const clang::CallExpr* ProcessArgument(const Expr* Arg,
-                                       const MatchFinder::MatchResult& Result,
-                                       StrCatCheckResult* CheckResult) {
+const clang::CallExpr *processArgument(const Expr *Arg,
+                                       const MatchFinder::MatchResult &Result,
+                                       StrCatCheckResult *CheckResult) {
   const auto IsAlphanum = hasDeclaration(cxxMethodDecl(hasName("AlphaNum")));
   static const auto* const Strcat = new auto(hasName("::absl::StrCat"));
   const auto IsStrcat = cxxBindTemporaryExpr(
       has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat")));
   if (const auto *SubStrcatCall = selectFirst<const CallExpr>(
           "StrCat",
           match(stmt(traverse(TK_AsIs,
                               anyOf(cxxConstructExpr(IsAlphanum,
                                                      hasArgument(0, IsStrcat)),
                                     IsStrcat))),
                 *Arg->IgnoreParenImpCasts(), *Result.Context))) {
-    RemoveCallLeaveArgs(SubStrcatCall, CheckResult);
+    removeCallLeaveArgs(SubStrcatCall, CheckResult);
     return SubStrcatCall;
   }
   return nullptr;
 }
 
-StrCatCheckResult ProcessCall(const CallExpr* RootCall, bool IsAppend,
-                              const MatchFinder::MatchResult& Result) {
+StrCatCheckResult processCall(const CallExpr *RootCall, bool IsAppend,
+                              const MatchFinder::MatchResult &Result) {
   StrCatCheckResult CheckResult;
   std::deque<const CallExpr*> CallsToProcess = {RootCall};
 
   while (!CallsToProcess.empty()) {
     ++CheckResult.NumCalls;
 
     const CallExpr* CallExpr = CallsToProcess.front();
     CallsToProcess.pop_front();
 
     int StartArg = CallExpr == RootCall && IsAppend;
     for (const auto *Arg : CallExpr->arguments()) {
       if (StartArg-- > 0) 
         continue;
-      if (const clang::CallExpr* Sub =
-              ProcessArgument(Arg, Result, &CheckResult)) {
+      if (const clang::CallExpr *Sub =
+              processArgument(Arg, Result, &CheckResult)) {
         CallsToProcess.push_back(Sub);
       }
     }
   }
   return CheckResult;
 }
 }  // namespace
 
void RedundantStrcatCallsCheck::check(const MatchFinder::MatchResult& Result) {
   if (RootCall->getBeginLoc().isMacroID()) {
     // Ignore calls within macros.
     // In many cases the outer StrCat part of the macro and the inner StrCat is
     // a macro argument. Removing the inner StrCat() converts one macro
     // argument into many.
     return;
   }
 
-  const StrCatCheckResult CheckResult =
-      ProcessCall(RootCall, IsAppend, Result);
+  const StrCatCheckResult CheckResult = processCall(RootCall, IsAppend, Result);
   if (CheckResult.NumCalls == 1) {
     // Just one call, so nothing to fix.
     return;
   }
 
   diag(RootCall->getBeginLoc(), 
        "multiple calls to 'absl::StrCat' can be flattened into a single call")
       << CheckResult.Hints;
 }
 
 }  // namespace abseil
 }  // namespace tidy
 }  // namespace clang

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

auto StringFind = cxxMemberCallExpr(
           hasParameter(
               0, parmVarDecl(anyOf(hasType(StringType), hasType(CharStarType),
                                    hasType(CharType)))))),
       on(hasType(StringType)), hasArgument(0, expr().bind("parameter_to_find")),
       anyOf(hasArgument(1, integerLiteral(equals(0))),
             hasArgument(1, cxxDefaultArgExpr())),
       onImplicitObjectArgument(expr().bind("string_being_searched")));
 
-  RewriteRule rule = applyFirst(
+  RewriteRule Rule = applyFirst(
       {makeRule(
            binaryOperator(hasOperatorName("=="),
                           hasOperands(ignoringParenImpCasts(StringNpos),
                                       ignoringParenImpCasts(StringFind))),
            {changeTo(cat("!absl::StrContains(", node("string_being_searched"),
                          ", ", node("parameter_to_find"), ")")),
             addInclude(AbseilStringsMatchHeader)},
            cat("use !absl::StrContains instead of find() == npos")),
        makeRule(
            binaryOperator(hasOperatorName("!="),
                           hasOperands(ignoringParenImpCasts(StringNpos),
                                       ignoringParenImpCasts(StringFind))),
            {changeTo(cat("absl::StrContains(", node("string_being_searched"),
                          ", ", node("parameter_to_find"), ")")),
             addInclude(AbseilStringsMatchHeader)},
            cat("use absl::StrContains instead "
                "of find() != npos"))});
-  return rule;
+  return Rule;
 }
 
 StringFindStrContainsCheck::StringFindStrContainsCheck(
     StringRef Name, ClangTidyContext *Context)
     : TransformerClangTidyCheck(Name, Context),
       StringLikeClassesOption(utils::options::parseStringList(
           Options.get("StringLikeClasses", DefaultStringLikeClasses))),
       AbseilStringsMatchHeaderOption(Options.get(

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace abseil {
 
 // Returns `true` if `Range` is inside a macro definition.
-static bool InsideMacroDefinition(const MatchFinder::MatchResult &Result,
+static bool insideMacroDefinition(const MatchFinder::MatchResult &Result,
                                   SourceRange Range) {
   return !clang::Lexer::makeFileCharRange(
               clang::CharSourceRange::getCharRange(Range),
               *Result.SourceManager, Result.Context->getLangOpts())
               .isValid();
 }
 
 static bool isConstructorAssignment(const MatchFinder::MatchResult &Result,

 
 void TimeSubtractionCheck::emitDiagnostic(const Expr *Node,
                                           llvm::StringRef Replacement) {
   diag(Node->getBeginLoc(), "perform subtraction in the time domain")
       << FixItHint::CreateReplacement(Node->getSourceRange(), Replacement);
 }
 
 void TimeSubtractionCheck::registerMatchers(MatchFinder *Finder) {
-  for (auto ScaleName :
+  for (const char *ScaleName :
        {"Hours", "Minutes", "Seconds", "Millis", "Micros", "Nanos"}) {
     std::string TimeInverse = (llvm::Twine("ToUnix") + ScaleName).str();
     llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(TimeInverse);
     assert(Scale && "Unknown scale encountered");
 
     auto TimeInverseMatcher = callExpr(callee(
         functionDecl(hasName((llvm::Twine("::absl::") + TimeInverse).str()))
             .bind("func_decl")));
for (const char *ScaleName :
     Finder->addMatcher(OperandMatcher, this);
   }
 }
 
 void TimeSubtractionCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("binop");
   std::string InverseName =
       Result.Nodes.getNodeAs<FunctionDecl>("func_decl")->getNameAsString();
-  if (InsideMacroDefinition(Result, BinOp->getSourceRange()))
+  if (insideMacroDefinition(Result, BinOp->getSourceRange()))
     return;
 
   llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(InverseName);
   if (!Scale)
     return;
 
   const auto *OuterCall = Result.Nodes.getNodeAs<CallExpr>("outer_call");
   if (OuterCall) {
-    if (InsideMacroDefinition(Result, OuterCall->getSourceRange()))
+    if (insideMacroDefinition(Result, OuterCall->getSourceRange()))
       return;
 
     // We're working with the first case of matcher, and need to replace the
     // entire 'Duration' factory call. (Which also means being careful about
     // our order-of-operations and optionally putting in some parenthesis.
     bool NeedParens = parensRequired(Result, OuterCall);
 
     emitDiagnostic(
if (OuterCall) {
     // latter case (addressed first), we also need to worry about parenthesis.
     const auto *MaybeCallArg = selectFirst<const CallExpr>(
         "arg", match(expr(hasAncestor(
                          callExpr(callee(functionDecl(hasName(
                                       getDurationFactoryForScale(*Scale)))))
                              .bind("arg"))),
                      *BinOp, *Result.Context));
     if (MaybeCallArg && MaybeCallArg->getArg(0)->IgnoreImpCasts() == BinOp &&
-        !InsideMacroDefinition(Result, MaybeCallArg->getSourceRange())) {
+        !insideMacroDefinition(Result, MaybeCallArg->getSourceRange())) {
       // Handle the case where the matched expression is inside a call which
       // converts it from the inverse to a Duration.  In this case, we replace
       // the outer with just the subtraction expression, which gives the right
       // type and scale, taking care again about parenthesis.
       bool NeedParens = parensRequired(Result, MaybeCallArg);
 
       emitDiagnostic(
           MaybeCallArg,

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

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           const Module *Imported,
                           SrcMgr::CharacteristicKind FileType) override;
 
   void EndOfMainFile() override;
 
 private:
   /// Returns true if the name of the file with path FilePath is 'kernel.cl',
   /// 'verilog.cl', or 'vhdl.cl'. The file name check is case insensitive.
-  bool FileNameIsRestricted(StringRef FilePath);
+  bool fileNameIsRestricted(StringRef FilePath);
 
   struct IncludeDirective {
     SourceLocation Loc; // Location in the include directive.
     StringRef FileName; // Filename as a string.
   };
 
   std::vector<IncludeDirective> IncludeDirectives;
   ClangTidyCheck &Check;

 void KernelNameRestrictionPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &, StringRef FileName, bool,
     CharSourceRange, const FileEntry *, StringRef, StringRef, const Module *,
     SrcMgr::CharacteristicKind) {
   IncludeDirective ID = {HashLoc, FileName};
   IncludeDirectives.push_back(std::move(ID));
 }
 
-bool KernelNameRestrictionPPCallbacks::FileNameIsRestricted(
+bool KernelNameRestrictionPPCallbacks::fileNameIsRestricted(
     StringRef FileName) {
   return FileName.equals_lower("kernel.cl") ||
          FileName.equals_lower("verilog.cl") ||
          FileName.equals_lower("vhdl.cl");
 }
 
 void KernelNameRestrictionPPCallbacks::EndOfMainFile() {
 
   // Check main file for restricted names.
   const FileEntry *Entry = SM.getFileEntryForID(SM.getMainFileID());
   StringRef FileName = llvm::sys::path::filename(Entry->getName());
-  if (FileNameIsRestricted(FileName))
+  if (fileNameIsRestricted(FileName))
     Check.diag(SM.getLocForStartOfFile(SM.getMainFileID()),
                "compiling '%0' may cause additional compilation errors due "
                "to the name of the kernel source file; consider renaming the "
                "included kernel source file")
         << FileName;
 
   if (IncludeDirectives.empty())
     return;
 
   // Check included files for restricted names.
   for (const IncludeDirective &ID : IncludeDirectives) {
     StringRef FileName = llvm::sys::path::filename(ID.FileName);
-    if (FileNameIsRestricted(FileName))
+    if (fileNameIsRestricted(FileName))
       Check.diag(ID.Loc,
                  "including '%0' may cause additional compilation errors due "
                  "to the name of the kernel source file; consider renaming the "
                  "included kernel source file")
           << FileName;
   }
 }
 
 } // namespace altera
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/android/AndroidTidyModule.cpp

 #include "CloexecDupCheck.h"
 #include "CloexecEpollCreate1Check.h"
 #include "CloexecEpollCreateCheck.h"
 #include "CloexecFopenCheck.h"
 #include "CloexecInotifyInit1Check.h"
 #include "CloexecInotifyInitCheck.h"
 #include "CloexecMemfdCreateCheck.h"
 #include "CloexecOpenCheck.h"
-#include "CloexecPipeCheck.h"
 #include "CloexecPipe2Check.h"
+#include "CloexecPipeCheck.h"
 #include "CloexecSocketCheck.h"
 #include "ComparisonInTempFailureRetryCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace android {

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

return Lexer::makeFileCharRange(CharSourceRange::getCharRange(Begin, End),
                                     Ctx->getLangOpts());
   };
 
   for (unsigned I = 0; I < NumArgs; ++I) {
     const ParmVarDecl *PVD = Callee->getParamDecl(I);
     IdentifierInfo *II = PVD->getIdentifier();
     if (!II)
       continue;
-    if (auto Template = Callee->getTemplateInstantiationPattern()) {
+    if (FunctionDecl *Template = Callee->getTemplateInstantiationPattern()) {
       // Don't warn on arguments for parameters instantiated from template
       // parameter packs. If we find more arguments than the template
       // definition has, it also means that they correspond to a parameter
       // pack.
       if (Template->getNumParams() <= I ||
           Template->getParamDecl(I)->isParameterPack()) {
         continue;
       }

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

const auto *MatchedIntLiteral =
       Result.Nodes.getNodeAs<IntegerLiteral>("integer-literal");
   if (MatchedIntLiteral->getValue() == *SigtermValue) {
     diag(MatchedExpr->getBeginLoc(),
          "thread should not be terminated by raising the 'SIGTERM' signal");
   }
 }
 
 void BadSignalToKillThreadCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *pp, Preprocessor *ModuleExpanderPP) {
-  PP = pp;
+    const SourceManager &SM, Preprocessor *Pp, Preprocessor *ModuleExpanderPP) {
+  PP = Pp;
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

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

 /// clones of each other. This function only examines the body of the branch
 /// and ignores the `case X:` or `default:` at the start of the branch.
 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++) {
+  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.
-    if (!areStatementsIdentical(LHS[i]->stripLabelLikeStatements(),
-                                RHS[i]->stripLabelLikeStatements(), Context)) {
+    if (!areStatementsIdentical(LHS[I]->stripLabelLikeStatements(),
+                                RHS[I]->stripLabelLikeStatements(), Context)) {
       return false;
     }
   }
 
   return true;
 }
 
 namespace clang {
while (true) {
         Branches.push_back(Else);
         break;
       }
     }
 
     size_t N = Branches.size();
     llvm::BitVector KnownAsClone(N);
 
-    for (size_t i = 0; i + 1 < N; i++) {
+    for (size_t I = 0; I + 1 < N; I++) {
       // We have already seen Branches[i] as a clone of an earlier branch.
-      if (KnownAsClone[i])
+      if (KnownAsClone[I])
         continue;
 
       int NumCopies = 1;
 
-      for (size_t j = i + 1; j < N; j++) {
-        if (KnownAsClone[j] ||
-            !areStatementsIdentical(Branches[i]->IgnoreContainers(),
-                                    Branches[j]->IgnoreContainers(), Context))
+      for (size_t J = I + 1; J < N; J++) {
+        if (KnownAsClone[J] ||
+            !areStatementsIdentical(Branches[I]->IgnoreContainers(),
+                                    Branches[J]->IgnoreContainers(), Context))
           continue;
 
         NumCopies++;
-        KnownAsClone[j] = true;
+        KnownAsClone[J] = true;
 
         if (NumCopies == 2) {
           // We report the first occurrence only when we find the second one.
-          diag(Branches[i]->getBeginLoc(),
+          diag(Branches[I]->getBeginLoc(),
                "repeated branch in conditional chain");
           SourceLocation End =
-              Lexer::getLocForEndOfToken(Branches[i]->getEndLoc(), 0,
+              Lexer::getLocForEndOfToken(Branches[I]->getEndLoc(), 0,
                                          *Result.SourceManager, getLangOpts());
           if (End.isValid()) {
             diag(End, "end of the original", DiagnosticIDs::Note);
           }
         }
 
-        diag(Branches[j]->getBeginLoc(), "clone %0 starts here",
+        diag(Branches[J]->getBeginLoc(), "clone %0 starts here",
              DiagnosticIDs::Note)
             << (NumCopies - 1);
       }
     }
     return;
   }
 
   if (const auto *CO = Result.Nodes.getNodeAs<ConditionalOperator>("condOp")) {
for (const Stmt *S : Body->body()) {
       // 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();
     while (BeginCurrent < End) {
       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.cpp

void CopyConstructorInitCheck::check(const MatchFinder::MatchResult &Result) {
   } else {
     // We apply the missing ctors at the beginning of the initialization list.
     FixItLoc = (*Ctor->init_begin())->getSourceLocation();
     FixItMsg += ',';
   }
   FixItMsg += ' ';
 
   Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg);
-} // namespace misc
+}
 
-} // namespace misc
+} // namespace bugprone
 } // namespace tidy
 } // namespace clang

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

while (BaseType->isPointerType() || BaseType->isReferenceType()) {
     BaseType = BaseType->getPointeeType().getTypePtr();
   }
   // Case: type parameter dependent (enable_if<is_integral<T>>).
   if (const auto *Dependent = BaseType->getAs<DependentNameType>()) {
     BaseType = Dependent->getQualifier()->getAsType();
   }
   if (!BaseType)
     return false;
-  if (CheckTemplate(BaseType->getAs<TemplateSpecializationType>())) {
+  if (CheckTemplate(BaseType->getAs<TemplateSpecializationType>()))
     return true; // Case: enable_if_t< >.
-  } else if (const auto *Elaborated = BaseType->getAs<ElaboratedType>()) {
+  if (const auto *Elaborated = BaseType->getAs<ElaboratedType>()) {
     if (const auto *Qualifier = Elaborated->getQualifier()->getAsType()) {
       if (CheckTemplate(Qualifier->getAs<TemplateSpecializationType>())) {
         return true; // Case: enable_if< >::type.
       }
     }
   }
   return false;
 }
 AST_MATCHER_P(TemplateTypeParmDecl, hasDefaultArgument,
               clang::ast_matchers::internal::Matcher<QualType>, TypeMatcher) {
   return Node.hasDefaultArgument() &&
          TypeMatcher.matches(Node.getDefaultArgument(), Finder, Builder);
 }
 } // namespace
 
 void ForwardingReferenceOverloadCheck::registerMatchers(MatchFinder *Finder) {
   auto ForwardingRefParm =
       parmVarDecl(
           hasType(qualType(rValueReferenceType(),
                            references(templateTypeParmType(hasDeclaration(
                                templateTypeParmDecl().bind("type-parm-decl")))),
                            unless(references(isConstQualified())))))
           .bind("parm-var");
 
-  DeclarationMatcher findOverload =
+  DeclarationMatcher FindOverload =
       cxxConstructorDecl(
           hasParameter(0, ForwardingRefParm),
           unless(hasAnyParameter(
               // No warning: enable_if as constructor parameter.
               parmVarDecl(hasType(isEnableIf())))),
           unless(hasParent(functionTemplateDecl(has(templateTypeParmDecl(
               // No warning: enable_if as type parameter.
               hasDefaultArgument(isEnableIf())))))))
           .bind("ctor");
-  Finder->addMatcher(findOverload, this);
+  Finder->addMatcher(FindOverload, this);
 }
 
 void ForwardingReferenceOverloadCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *ParmVar = Result.Nodes.getNodeAs<ParmVarDecl>("parm-var");
   const auto *TypeParmDecl =
       Result.Nodes.getNodeAs<TemplateTypeParmDecl>("type-parm-decl");
 
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) {
     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)
         (OtherCtor->isCopyConstructor() ? DisabledCopy : DisabledMove) = true;

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 namespace {
 AST_MATCHER(FloatingLiteral, floatHalf) {
-  const auto &literal = Node.getValue();
+  const auto &Literal = Node.getValue();
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
-    return literal.convertToFloat() == 0.5f;
+    return Literal.convertToFloat() == 0.5f;
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
-    return literal.convertToDouble() == 0.5;
+    return Literal.convertToDouble() == 0.5;
   return false;
 }
 } // namespace
 
 void IncorrectRoundingsCheck::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 

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

 //===--- InfiniteLoopCheck.cpp - clang-tidy -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "InfiniteLoopCheck.h"
+#include "../utils/Aliasing.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
-#include "../utils/Aliasing.h"
 
 using namespace clang::ast_matchers;
 using clang::tidy::utils::hasPtrOrReferenceInFunc;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 

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

 public:
   explicit MacroExpansionsWithFileAndLine(
       LambdaFunctionNameCheck::SourceRangeSet *SME)
       : SuppressMacroExpansions(SME) {}
 
   void MacroExpands(const Token &MacroNameTok,
                     const MacroDefinition &MD, SourceRange Range,
                     const MacroArgs *Args) override {
-    bool has_file = false;
-    bool has_line = false;
+    bool HasFile = false;
+    bool HasLine = false;
     for (const auto& T : MD.getMacroInfo()->tokens()) {
       if (T.is(tok::identifier)) {
         StringRef IdentName = T.getIdentifierInfo()->getName();
         if (IdentName == "__FILE__") {
-          has_file = true;
+          HasFile = true;
         } else if (IdentName == "__LINE__") {
-          has_line = true;
+          HasLine = true;
         }
       }
     }
-    if (has_file && has_line) {
+    if (HasFile && HasLine) {
       SuppressMacroExpansions->insert(Range);
     }
   }
 
 private:
   LambdaFunctionNameCheck::SourceRangeSet* SuppressMacroExpansions;
 };
 

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

isGivenLengthEqualToSrcLength(const MatchFinder::MatchResult &Result) {
 
   int GivenLength = getGivenLength(Result);
   int SrcLength = getLength(Result.Nodes.getNodeAs<Expr>(SrcExprName), Result);
 
   if (GivenLength != 0 && SrcLength != 0 && GivenLength == SrcLength)
     return true;
 
   if (const auto *LengthExpr = Result.Nodes.getNodeAs<Expr>(LengthExprName))
-    if (dyn_cast<BinaryOperator>(LengthExpr->IgnoreParenImpCasts()))
+    if (isa<BinaryOperator>(LengthExpr->IgnoreParenImpCasts()))
       return false;
 
   // Check the strlen()'s argument's 'VarDecl' is equal to the source 'VarDecl'.
   if (const CallExpr *StrlenCE = getStrlenExpr(Result))
     if (const auto *ArgDRE =
             dyn_cast<DeclRefExpr>(StrlenCE->getArg(0)->IgnoreImpCasts()))
       if (const auto *SrcVD = Result.Nodes.getNodeAs<VarDecl>(SrcVarDeclName))
         return dyn_cast<VarDecl>(ArgDRE->getDecl()) == SrcVD;
: ClangTidyCheck(Name, Context),
       WantToUseSafeFunctions(Options.get("WantToUseSafeFunctions", true)) {}
 
 void NotNullTerminatedResultCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "WantToUseSafeFunctions", WantToUseSafeFunctions);
 }
 
 void NotNullTerminatedResultCheck::registerPPCallbacks(
-    const SourceManager &SM, Preprocessor *pp, Preprocessor *ModuleExpanderPP) {
-  PP = pp;
+    const SourceManager &SM, Preprocessor *Pp, Preprocessor *ModuleExpanderPP) {
+  PP = Pp;
 }
 
 namespace {
 AST_MATCHER_P(Expr, hasDefinition, ast_matchers::internal::Matcher<Expr>,
               InnerMatcher) {
   const Expr *SimpleNode = &Node;
   SimpleNode = SimpleNode->IgnoreParenImpCasts();
 
auto Match = [=](CallContext CC) {
 
     llvm_unreachable("Unhandled match");
   };
 
   // void *memcpy(void *dest, const void *src, size_t count)
   auto Memcpy = Match({"memcpy", 0, 1, 2, false});
 
   // errno_t memcpy_s(void *dest, size_t ds, const void *src, size_t count)
-  auto Memcpy_s = Match({"memcpy_s", 0, 2, 3, false});
+  auto MemcpyS = Match({"memcpy_s", 0, 2, 3, false});
 
   // void *memchr(const void *src, int c, size_t count)
   auto Memchr = Match({"memchr", None, 0, 2, false});
 
   // void *memmove(void *dest, const void *src, size_t count)
   auto Memmove = Match({"memmove", 0, 1, 2, false});
 
   // errno_t memmove_s(void *dest, size_t ds, const void *src, size_t count)
-  auto Memmove_s = Match({"memmove_s", 0, 2, 3, false});
+  auto MemmoveS = Match({"memmove_s", 0, 2, 3, false});
 
   // int strncmp(const char *str1, const char *str2, size_t count);
   auto StrncmpRHS = Match({"strncmp", None, 1, 2, true});
   auto StrncmpLHS = Match({"strncmp", None, 0, 2, true});
 
   // size_t strxfrm(char *dest, const char *src, size_t count);
   auto Strxfrm = Match({"strxfrm", 0, 1, 2, false});
 
   // errno_t strerror_s(char *buffer, size_t bufferSize, int errnum);
-  auto Strerror_s = Match({"strerror_s", 0, None, 1, false});
+  auto StrerrorS = Match({"strerror_s", 0, None, 1, false});
 
-  auto AnyOfMatchers = anyOf(Memcpy, Memcpy_s, Memmove, Memmove_s, StrncmpRHS,
-                             StrncmpLHS, Strxfrm, Strerror_s);
+  auto AnyOfMatchers = anyOf(Memcpy, MemcpyS, Memmove, MemmoveS, StrncmpRHS,
+                             StrncmpLHS, Strxfrm, StrerrorS);
 
   Finder->addMatcher(callExpr(AnyOfMatchers).bind(FunctionExprName), this);
 
   // Need to remove the CastExpr from 'memchr()' as 'strchr()' returns 'char *'.
   Finder->addMatcher(
       callExpr(Memchr,
                unless(hasAncestor(castExpr(unless(implicitCastExpr())))))
           .bind(FunctionExprName),
void NotNullTerminatedResultCheck::memcpy_sFix(
 
   if (!IsCopy && !IsSafe)
     insertNullTerminatorExpr(Name, Result, Diag);
 }
 
 void NotNullTerminatedResultCheck::memchrFix(
     StringRef Name, const MatchFinder::MatchResult &Result) {
   const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
-  if (const auto GivenCL = dyn_cast<CharacterLiteral>(FunctionExpr->getArg(1)))
+  if (const auto *GivenCL = dyn_cast<CharacterLiteral>(FunctionExpr->getArg(1)))
     if (GivenCL->getValue() != 0)
       return;
 
   auto Diag = diag(FunctionExpr->getArg(2)->IgnoreParenCasts()->getBeginLoc(),
                    "the length is too short to include the null terminator");
 
   if (const auto *CastExpr = Result.Nodes.getNodeAs<Expr>(CastExprName)) {
     const auto CastRemoveFix = FixItHint::CreateRemoval(

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

ReservedIdentifierCheck::GetMacroFailureInfo(const Token &MacroNameTok,
                                              const SourceManager &) const {
   return getFailureInfoImpl(MacroNameTok.getIdentifierInfo()->getName(), true,
                             getLangOpts(), Invert, AllowedIdentifiers);
 }
 
 RenamerClangTidyCheck::DiagInfo
 ReservedIdentifierCheck::GetDiagInfo(const NamingCheckId &ID,
                                      const NamingCheckFailure &Failure) const {
-  return DiagInfo{Message, [&](DiagnosticBuilder &diag) {
-                    diag << ID.second
+  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

AST_MATCHER_P2(Expr, hasSizeOfDescendant, int, Depth,
 
   const Expr *E = Node.IgnoreParenImpCasts();
   if (InnerMatcher.matches(*E, Finder, Builder))
     return true;
 
   if (const auto *CE = dyn_cast<CastExpr>(E)) {
     const auto M = hasSizeOfDescendant(Depth - 1, InnerMatcher);
     return M.matches(*CE->getSubExpr(), Finder, Builder);
-  } else if (const auto *UE = dyn_cast<UnaryOperator>(E)) {
+  }
+  if (const auto *UE = dyn_cast<UnaryOperator>(E)) {
     const auto M = hasSizeOfDescendant(Depth - 1, InnerMatcher);
     return M.matches(*UE->getSubExpr(), Finder, Builder);
-  } else if (const auto *BE = dyn_cast<BinaryOperator>(E)) {
+  }
+  if (const auto *BE = dyn_cast<BinaryOperator>(E)) {
     const auto LHS = hasSizeOfDescendant(Depth - 1, InnerMatcher);
     const auto RHS = hasSizeOfDescendant(Depth - 1, InnerMatcher);
     return LHS.matches(*BE->getLHS(), Finder, Builder) ||
            RHS.matches(*BE->getRHS(), Finder, Builder);
   }
 
   return false;
 }

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 void SpuriouslyWakeUpFunctionsCheck::registerMatchers(MatchFinder *Finder) {
 
-  auto hasUniqueLock = hasDescendant(declRefExpr(
+  auto HasUniqueLock = hasDescendant(declRefExpr(
       hasDeclaration(varDecl(hasType(recordDecl(classTemplateSpecializationDecl(
           hasName("::std::unique_lock"),
           hasTemplateArgument(
               0, templateArgument(refersToType(qualType(hasDeclaration(
                      cxxRecordDecl(hasName("::std::mutex"))))))))))))));
 
-  auto hasWaitDescendantCPP = hasDescendant(
+  auto HasWaitDescendantCpp = hasDescendant(
       cxxMemberCallExpr(
           anyOf(
               allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
                         allOf(hasName("::std::condition_variable::wait"),
                               parameterCountIs(1)))))),
                     onImplicitObjectArgument(
                         declRefExpr(to(varDecl(hasType(references(recordDecl(
                             hasName("::std::condition_variable")))))))),
-                    hasUniqueLock),
+                    HasUniqueLock),
               allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
                         allOf(hasName("::std::condition_variable::wait_for"),
                               parameterCountIs(2)))))),
                     onImplicitObjectArgument(
                         declRefExpr(to(varDecl(hasType(references(recordDecl(
                             hasName("::std::condition_variable")))))))),
-                    hasUniqueLock),
+                    HasUniqueLock),
               allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
                         allOf(hasName("::std::condition_variable::wait_until"),
                               parameterCountIs(2)))))),
                     onImplicitObjectArgument(
                         declRefExpr(to(varDecl(hasType(references(recordDecl(
                             hasName("::std::condition_variable")))))))),
-                    hasUniqueLock)
+                    HasUniqueLock)
 
                   ))
           .bind("wait"));
 
-  auto hasWaitDescendantC = hasDescendant(
+  auto HasWaitDescendantC = hasDescendant(
       callExpr(callee(functionDecl(hasAnyName("cnd_wait", "cnd_timedwait"))))
           .bind("wait"));
   if (getLangOpts().CPlusPlus) {
     // Check for `CON54-CPP`
     Finder->addMatcher(
         ifStmt(
-
-            allOf(hasWaitDescendantCPP,
-                  unless(anyOf(hasDescendant(ifStmt(hasWaitDescendantCPP)),
-                               hasDescendant(whileStmt(hasWaitDescendantCPP)),
-                               hasDescendant(forStmt(hasWaitDescendantCPP)),
-                               hasDescendant(doStmt(hasWaitDescendantCPP)))))
+            allOf(HasWaitDescendantCpp,
+                  unless(anyOf(hasDescendant(ifStmt(HasWaitDescendantCpp)),
+                               hasDescendant(whileStmt(HasWaitDescendantCpp)),
+                               hasDescendant(forStmt(HasWaitDescendantCpp)),
+                               hasDescendant(doStmt(HasWaitDescendantCpp)))))
 
                 ),
         this);
   } else {
     // Check for `CON36-C`
     Finder->addMatcher(
-
         ifStmt(
-            allOf(hasWaitDescendantC,
-                  unless(anyOf(hasDescendant(ifStmt(hasWaitDescendantC)),
-                               hasDescendant(whileStmt(hasWaitDescendantC)),
-                               hasDescendant(forStmt(hasWaitDescendantC)),
-                               hasDescendant(doStmt(hasWaitDescendantC)),
+            allOf(HasWaitDescendantC,
+                  unless(anyOf(hasDescendant(ifStmt(HasWaitDescendantC)),
+                               hasDescendant(whileStmt(HasWaitDescendantC)),
+                               hasDescendant(forStmt(HasWaitDescendantC)),
+                               hasDescendant(doStmt(HasWaitDescendantC)),
                                hasParent(whileStmt()),
                                hasParent(compoundStmt(hasParent(whileStmt()))),
                                hasParent(forStmt()),
                                hasParent(compoundStmt(hasParent(forStmt()))),
                                hasParent(doStmt()),
                                hasParent(compoundStmt(hasParent(doStmt())))))
 
                       ))

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 namespace {
 AST_MATCHER(StringLiteral, containsNul) {
-  for (size_t i = 0; i < Node.getLength(); ++i)
-    if (Node.getCodeUnit(i) == '\0')
+  for (size_t I = 0; I < Node.getLength(); ++I)
+    if (Node.getCodeUnit(I) == '\0')
       return true;
   return false;
 }
 } // namespace
 
 void StringLiteralWithEmbeddedNulCheck::registerMatchers(MatchFinder *Finder) {
   // Match a string that contains embedded NUL character. Extra-checks are
   // applied in |check| to find incorrectly escaped characters.

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

SuspiciousEnumUsageCheck::SuspiciousEnumUsageCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}
 
 void SuspiciousEnumUsageCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
 }
 
 void SuspiciousEnumUsageCheck::registerMatchers(MatchFinder *Finder) {
-  const auto enumExpr = [](StringRef RefName, StringRef DeclName) {
+  const auto EnumExpr = [](StringRef RefName, StringRef DeclName) {
     return expr(ignoringImpCasts(expr().bind(RefName)),
                 ignoringImpCasts(hasType(enumDecl().bind(DeclName))));
   };
 
   Finder->addMatcher(
-      binaryOperator(hasOperatorName("|"), hasLHS(enumExpr("", "enumDecl")),
-                     hasRHS(expr(enumExpr("", "otherEnumDecl"),
+      binaryOperator(hasOperatorName("|"), hasLHS(EnumExpr("", "enumDecl")),
+                     hasRHS(expr(EnumExpr("", "otherEnumDecl"),
                                  ignoringImpCasts(hasType(enumDecl(
                                      unless(equalsBoundNode("enumDecl"))))))))
           .bind("diffEnumOp"),
       this);
 
   Finder->addMatcher(
       binaryOperator(hasAnyOperatorName("+", "|"),
-                     hasLHS(enumExpr("lhsExpr", "enumDecl")),
-                     hasRHS(expr(enumExpr("rhsExpr", ""),
+                     hasLHS(EnumExpr("lhsExpr", "enumDecl")),
+                     hasRHS(expr(EnumExpr("rhsExpr", ""),
                                  ignoringImpCasts(hasType(
                                      enumDecl(equalsBoundNode("enumDecl"))))))),
       this);
 
   Finder->addMatcher(
       binaryOperator(
           hasAnyOperatorName("+", "|"),
-          hasOperands(expr(hasType(isInteger()), unless(enumExpr("", ""))),
-                      enumExpr("enumExpr", "enumDecl"))),
+          hasOperands(expr(hasType(isInteger()), unless(EnumExpr("", ""))),
+                      EnumExpr("enumExpr", "enumDecl"))),
       this);
 
   Finder->addMatcher(binaryOperator(hasAnyOperatorName("|=", "+="),
-                                    hasRHS(enumExpr("enumExpr", "enumDecl"))),
+                                    hasRHS(EnumExpr("enumExpr", "enumDecl"))),
                      this);
 }
 
 void SuspiciousEnumUsageCheck::checkSuspiciousBitmaskUsage(
     const Expr *NodeExpr, const EnumDecl *EnumDec) {
   const auto *EnumExpr = dyn_cast<DeclRefExpr>(NodeExpr);
   const auto *EnumConst =
       EnumExpr ? dyn_cast<EnumConstantDecl>(EnumExpr->getDecl()) : nullptr;

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

void SuspiciousMissingCommaCheck::check(
 
   // Skip small arrays as they often generate false-positive.
   unsigned int Size = InitializerList->getNumInits();
   if (Size < SizeThreshold)
     return;
 
   // Count the number of occurrence of concatenated string literal.
   unsigned int Count = 0;
-  for (unsigned int i = 0; i < Size; ++i) {
-    const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
+  for (unsigned int I = 0; I < Size; ++I) {
+    const Expr *Child = InitializerList->getInit(I)->IgnoreImpCasts();
     if (const auto *Literal = dyn_cast<StringLiteral>(Child)) {
       if (Literal->getNumConcatenated() > 1)
         ++Count;
     }
   }
 
   // Warn only when concatenation is not common in this initializer list.
   // The current threshold is set to less than 1/5 of the string literals.

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) {
-  const auto doWithFalse =
+  const auto DoWithFalse =
       doStmt(hasCondition(ignoringImpCasts(
                  anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),
                        cxxNullPtrLiteralExpr(), gnuNullExpr()))),
              equalsBoundNode("closestLoop"));
 
   Finder->addMatcher(
       continueStmt(hasAncestor(stmt(anyOf(forStmt(), whileStmt(),
                                           cxxForRangeStmt(), doStmt()))
                                    .bind("closestLoop")),
-                   hasAncestor(doWithFalse))
+                   hasAncestor(DoWithFalse))
           .bind("continue"),
       this);
 }
 
 void TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue");
 
   auto Diag =
       diag(ContStmt->getBeginLoc(),
            "'continue' in loop with false condition is equivalent to 'break'")
       << tooling::fixit::createReplacement(*ContStmt, "break");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

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

void UseAfterMoveFinder::getDeclRefs(
     const CFGBlock *Block, const Decl *MovedVariable,
     llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) {
   DeclRefs->clear();
   for (const auto &Elem : *Block) {
     Optional<CFGStmt> S = Elem.getAs<CFGStmt>();
     if (!S)
       continue;
 
-    auto addDeclRefs = [this, Block,
+    auto AddDeclRefs = [this, Block,
                         DeclRefs](const ArrayRef<BoundNodes> Matches) {
       for (const auto &Match : Matches) {
         const auto *DeclRef = Match.getNodeAs<DeclRefExpr>("declref");
         const auto *Operator = Match.getNodeAs<CXXOperatorCallExpr>("operator");
         if (DeclRef && BlockMap->blockContainingStmt(DeclRef) == Block) {
           // Ignore uses of a standard smart pointer that don't dereference the
           // pointer.
           if (Operator || !isStandardSmartPointer(DeclRef->getDecl())) {
             DeclRefs->insert(DeclRef);
           }
         }
       }
     };
 
     auto DeclRefMatcher = declRefExpr(hasDeclaration(equalsNode(MovedVariable)),
                                       unless(inDecltypeOrTemplateArg()))
                               .bind("declref");
 
-    addDeclRefs(match(traverse(TK_AsIs, findAll(DeclRefMatcher)), *S->getStmt(),
+    AddDeclRefs(match(traverse(TK_AsIs, findAll(DeclRefMatcher)), *S->getStmt(),
                       *Context));
-    addDeclRefs(match(findAll(cxxOperatorCallExpr(
+    AddDeclRefs(match(findAll(cxxOperatorCallExpr(
                                   hasAnyOverloadedOperatorName("*", "->", "[]"),
                                   hasArgument(0, DeclRefMatcher))
                                   .bind("operator")),
                       *S->getStmt(), *Context));
   }
 }
 
 void UseAfterMoveFinder::getReinits(
void UseAfterMoveCheck::check(const MatchFinder::MatchResult &Result) {
   else
     return;
 
   // Ignore the std::move if the variable that was passed to it isn't a local
   // variable.
   if (!Arg->getDecl()->getDeclContext()->isFunctionOrMethod())
     return;
 
-  UseAfterMoveFinder finder(Result.Context);
+  UseAfterMoveFinder Finder(Result.Context);
   UseAfterMove Use;
-  if (finder.find(FunctionBody, MovingCall, Arg->getDecl(), &Use))
+  if (Finder.find(FunctionBody, MovingCall, Arg->getDecl(), &Use))
     emitDiagnostic(MovingCall, Arg, Use, this, Result.Context);
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/cert/LimitedRandomnessCheck.cpp

 void LimitedRandomnessCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(callExpr(callee(functionDecl(namedDecl(hasName("::rand")),
                                                   parameterCountIs(0))))
                          .bind("randomGenerator"),
                      this);
 }
 
 void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) {
-  std::string msg = "";
+  std::string Msg = "";
   if (getLangOpts().CPlusPlus)
-    msg = "; use C++11 random library instead";
+    Msg = "; use C++11 random library instead";
 
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
-  diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + msg);
+  diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + Msg);
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/cert/StrToNumCheck.cpp

 //===-- StrToNumCheck.cpp - clang-tidy ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "StrToNumCheck.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/AST/FormatString.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <cassert>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cert {
enum class ConversionKind {
   ToLongUInt,
   ToIntMax,
   ToUIntMax,
   ToFloat,
   ToDouble,
   ToLongDouble
 };
 
-ConversionKind ClassifyConversionFunc(const FunctionDecl *FD) {
+ConversionKind classifyConversionFunc(const FunctionDecl *FD) {
   return llvm::StringSwitch<ConversionKind>(FD->getName())
       .Cases("atoi", "atol", ConversionKind::ToInt)
       .Case("atoll", ConversionKind::ToLongInt)
       .Case("atof", ConversionKind::ToDouble)
       .Default(ConversionKind::None);
 }
 
-ConversionKind ClassifyFormatString(StringRef Fmt, const LangOptions &LO,
+ConversionKind classifyFormatString(StringRef Fmt, const LangOptions &LO,
                                     const TargetInfo &TI) {
   // Scan the format string for the first problematic format specifier, then
   // report that as the conversion type. This will miss additional conversion
   // specifiers, but that is acceptable behavior.
 
   class Handler : public analyze_format_string::FormatStringHandler {
     ConversionKind CK;
 
     bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS,
-                              const char *startSpecifier,
-                              unsigned specifierLen) override {
+                              const char *StartSpecifier,
+                              unsigned SpecifierLen) override {
       // If we just consume the argument without assignment, we don't care
       // about it having conversion errors.
       if (!FS.consumesDataArgument())
         return true;
 
       // Get the conversion specifier and use it to determine the conversion
       // kind.
       analyze_scanf::ScanfConversionSpecifier SCS = FS.getConversionSpecifier();
ConversionKind classifyFormatString(StringRef Fmt, const LangOptions &LO,
   };
 
   Handler H;
   analyze_format_string::ParseScanfString(H, Fmt.begin(), Fmt.end(), LO, TI);
 
   return H.get();
 }
 
-StringRef ClassifyConversionType(ConversionKind K) {
+StringRef classifyConversionType(ConversionKind K) {
   switch (K) {
   case ConversionKind::None:
     llvm_unreachable("Unexpected conversion kind");
   case ConversionKind::ToInt:
   case ConversionKind::ToLongInt:
   case ConversionKind::ToIntMax:
     return "an integer value";
   case ConversionKind::ToUInt:
   case ConversionKind::ToLongUInt:
   case ConversionKind::ToUIntMax:
     return "an unsigned integer value";
   case ConversionKind::ToFloat:
   case ConversionKind::ToDouble:
   case ConversionKind::ToLongDouble:
     return "a floating-point value";
   }
   llvm_unreachable("Unknown conversion kind");
 }
 
-StringRef ClassifyReplacement(ConversionKind K) {
+StringRef classifyReplacement(ConversionKind K) {
   switch (K) {
   case ConversionKind::None:
     llvm_unreachable("Unexpected conversion kind");
   case ConversionKind::ToInt:
     return "strtol";
   case ConversionKind::ToUInt:
     return "strtoul";
   case ConversionKind::ToIntMax:
void StrToNumCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("expr");
   const FunctionDecl *FuncDecl = nullptr;
   ConversionKind Conversion;
 
   if (const auto *ConverterFunc =
           Result.Nodes.getNodeAs<FunctionDecl>("converter")) {
     // Converter functions are always incorrect to use.
     FuncDecl = ConverterFunc;
-    Conversion = ClassifyConversionFunc(ConverterFunc);
+    Conversion = classifyConversionFunc(ConverterFunc);
   } else if (const auto *FFD =
                  Result.Nodes.getNodeAs<FunctionDecl>("formatted")) {
     StringRef FmtStr;
     // The format string comes from the call expression and depends on which
     // flavor of scanf is called.
     // Index 0: scanf, vscanf, Index 1: fscanf, sscanf, vfscanf, vsscanf.
     unsigned Idx =
         (FFD->getName() == "scanf" || FFD->getName() == "vscanf") ? 0 : 1;
if (const auto *ConverterFunc =
     }
 
     // If we could not get the format string, bail out.
     if (FmtStr.empty())
       return;
 
     // Formatted input functions need further checking of the format string to
     // determine whether a problematic conversion may be happening.
-    Conversion = ClassifyFormatString(FmtStr, getLangOpts(),
+    Conversion = classifyFormatString(FmtStr, getLangOpts(),
                                       Result.Context->getTargetInfo());
     if (Conversion != ConversionKind::None)
       FuncDecl = FFD;
   }
 
   if (!FuncDecl)
     return;
 
   diag(Call->getExprLoc(),
        "%0 used to convert a string to %1, but function will not report "
        "conversion errors; consider using '%2' instead")
-      << FuncDecl << ClassifyConversionType(Conversion)
-      << ClassifyReplacement(Conversion);
+      << FuncDecl << classifyConversionType(Conversion)
+      << classifyReplacement(Conversion);
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/concurrency/MtUnsafeCheck.cpp

static constexpr std::pair<concurrency::MtUnsafeCheck::FunctionSet,
                      {concurrency::MtUnsafeCheck::FunctionSet::Any, "any"}};
     return makeArrayRef(Mapping);
   }
 };
 
 namespace concurrency {
 
 static ast_matchers::internal::Matcher<clang::NamedDecl>
-hasAnyMtUnsafeNames(MtUnsafeCheck::FunctionSet libc) {
-  switch (libc) {
+hasAnyMtUnsafeNames(MtUnsafeCheck::FunctionSet Libc) {
+  switch (Libc) {
   case MtUnsafeCheck::FunctionSet::Posix:
     return hasAnyName(PosixFunctions);
   case MtUnsafeCheck::FunctionSet::Glibc:
     return hasAnyName(GlibcFunctions);
   case MtUnsafeCheck::FunctionSet::Any:
     return anyOf(hasAnyName(PosixFunctions), hasAnyName(GlibcFunctions));
   }
   llvm_unreachable("invalid FunctionSet");

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

 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 namespace {
 
 bool isCapsOnly(StringRef Name) {
-  return std::all_of(Name.begin(), Name.end(), [](const char c) {
-    if (std::isupper(c) || std::isdigit(c) || c == '_')
+  return std::all_of(Name.begin(), Name.end(), [](const char C) {
+    if (std::isupper(C) || std::isdigit(C) || C == '_')
       return true;
     return false;
   });
 }
 
 class MacroUsageCallbacks : public PPCallbacks {
 public:
   MacroUsageCallbacks(MacroUsageCheck *Check, const SourceManager &SM,

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

if (!Constant.isFloat())
     return false;
   Value = Constant.getFloat();
   return true;
 }
 
 namespace {
 
 struct IntegerRange {
-  bool Contains(const IntegerRange &From) const {
+  bool contains(const IntegerRange &From) const {
     return llvm::APSInt::compareValues(Lower, From.Lower) <= 0 &&
            llvm::APSInt::compareValues(Upper, From.Upper) >= 0;
   }
 
-  bool Contains(const llvm::APSInt &Value) const {
+  bool contains(const llvm::APSInt &Value) const {
     return llvm::APSInt::compareValues(Lower, Value) <= 0 &&
            llvm::APSInt::compareValues(Upper, Value) >= 0;
   }
 
   llvm::APSInt Lower;
   llvm::APSInt Upper;
 };
 
return {llvm::APSInt::getMinValue(TypeSize, IsUnsignedInteger),
           llvm::APSInt::getMaxValue(TypeSize, IsUnsignedInteger)};
 }
 
 static bool isWideEnoughToHold(const ASTContext &Context,
                                const BuiltinType &FromType,
                                const BuiltinType &ToType) {
   IntegerRange FromIntegerRange = createFromType(Context, FromType);
   IntegerRange ToIntegerRange = createFromType(Context, ToType);
-  return ToIntegerRange.Contains(FromIntegerRange);
+  return ToIntegerRange.contains(FromIntegerRange);
 }
 
 static bool isWideEnoughToHold(const ASTContext &Context,
                                const llvm::APSInt &IntegerConstant,
                                const BuiltinType &ToType) {
   IntegerRange ToIntegerRange = createFromType(Context, ToType);
-  return ToIntegerRange.Contains(IntegerConstant);
+  return ToIntegerRange.contains(IntegerConstant);
 }
 
 static llvm::SmallString<64> getValueAsString(const llvm::APSInt &Value,
                                               uint64_t HexBits) {
   llvm::SmallString<64> Str;
   Value.toString(Str, 10);
   if (HexBits > 0) {
     Str.append(" (0x");

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

if (SourceDecl->isPolymorphic()) {
       // getTypeAsWritten().getAsString() which would spell enum types 'enum
       // X').
       StringRef DestTypeString = Lexer::getSourceText(
           CharSourceRange::getTokenRange(
               MatchedCast->getLParenLoc().getLocWithOffset(1),
               MatchedCast->getRParenLoc().getLocWithOffset(-1)),
           *Result.SourceManager, getLangOpts());
 
-      auto diag_builder = diag(
+      auto DiagBuilder = diag(
           MatchedCast->getBeginLoc(),
           "do not use C-style cast to downcast from a base to a derived class; "
           "use dynamic_cast instead");
 
       const Expr *SubExpr =
           MatchedCast->getSubExprAsWritten()->IgnoreImpCasts();
       std::string CastText = ("dynamic_cast<" + DestTypeString + ">").str();
       if (!isa<ParenExpr>(SubExpr)) {
         CastText.push_back('(');
-        diag_builder << FixItHint::CreateInsertion(
+        DiagBuilder << FixItHint::CreateInsertion(
             Lexer::getLocForEndOfToken(SubExpr->getEndLoc(), 0,
                                        *Result.SourceManager, getLangOpts()),
             ")");
       }
       auto ParenRange = CharSourceRange::getTokenRange(
           MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
-      diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
+      DiagBuilder << FixItHint::CreateReplacement(ParenRange, CastText);
     } else {
       diag(
           MatchedCast->getBeginLoc(),
           "do not use C-style cast to downcast from a base to a derived class");
     }
     return;
   }
 

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

SourceLocation getLocation(const ASTContext &Context,
     }
     return getLocationForEndOfToken(Context, Location);
   }
 
   std::string codeToInsert() const {
     assert(!Initializers.empty() && "No initializers to insert");
     std::string Code;
     llvm::raw_string_ostream Stream(Code);
-    std::string joined =
+    std::string Joined =
         llvm::join(Initializers.begin(), Initializers.end(), "(), ");
     switch (Placement) {
     case InitializerPlacement::New:
-      Stream << " : " << joined << "()";
+      Stream << " : " << Joined << "()";
       break;
     case InitializerPlacement::Before:
-      Stream << " " << joined << "(),";
+      Stream << " " << Joined << "(),";
       break;
     case InitializerPlacement::After:
-      Stream << ", " << joined << "()";
+      Stream << ", " << Joined << "()";
       break;
     }
     return Stream.str();
   }
 
   InitializerPlacement Placement;
   const CXXCtorInitializer *Where;
   SmallVector<std::string, 4> Initializers;

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

 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> vAArgExpr;
+const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> VAArgExpr;
 
 static constexpr StringRef AllowedVariadics[] = {
     // clang-format off
     "__builtin_isgreater", 
     "__builtin_isgreaterequal", 
     "__builtin_isless",
     "__builtin_islessequal", 
     "__builtin_islessgreater", 

 
 AST_MATCHER_P(AdjustedType, hasOriginalType,
               ast_matchers::internal::Matcher<QualType>, InnerType) {
   return InnerType.matches(Node.getOriginalType(), Finder, Builder);
 }
 } // namespace
 
 void ProTypeVarargCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(vAArgExpr().bind("va_use"), this);
+  Finder->addMatcher(VAArgExpr().bind("va_use"), this);
 
   Finder->addMatcher(
       callExpr(callee(functionDecl(isVariadic(),
                                    unless(hasAnyName(AllowedVariadics)))))
           .bind("callvararg"),
       this);
 
   Finder->addMatcher(

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

join(ArrayRef<SpecialMemberFunctionsCheck::SpecialMemberFunctionKind> SMFS,
 
   assert(!SMFS.empty() &&
          "List of defined or undefined members should never be empty.");
   std::string Buffer;
   llvm::raw_string_ostream Stream(Buffer);
 
   Stream << toString(SMFS[0]);
   size_t LastIndex = SMFS.size() - 1;
-  for (size_t i = 1; i < LastIndex; ++i) {
-    Stream << ", " << toString(SMFS[i]);
+  for (size_t I = 1; I < LastIndex; ++I) {
+    Stream << ", " << toString(SMFS[I]);
   }
   if (LastIndex != 0) {
     Stream << AndOr << toString(SMFS[LastIndex]);
   }
   return Stream.str();
 }
 
 void SpecialMemberFunctionsCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXRecordDecl>("class-def");
   if (!MatchedDecl)
     return;
 
   ClassDefId ID(MatchedDecl->getLocation(), std::string(MatchedDecl->getName()));
 
-  auto StoreMember = [this, &ID](SpecialMemberFunctionData data) {
+  auto StoreMember = [this, &ID](SpecialMemberFunctionData Data) {
     llvm::SmallVectorImpl<SpecialMemberFunctionData> &Members =
         ClassWithSpecialMembers[ID];
-    if (!llvm::is_contained(Members, data))
-      Members.push_back(std::move(data));
+    if (!llvm::is_contained(Members, Data))
+      Members.push_back(std::move(Data));
   };
 
   if (const auto *Dtor = Result.Nodes.getNodeAs<CXXMethodDecl>("dtor")) {
     StoreMember({Dtor->isDefaulted()
                      ? SpecialMemberFunctionKind::DefaultDestructor
                      : SpecialMemberFunctionKind::NonDefaultDestructor,
                  Dtor->isDeleted()});
   }

 }
 
 void SpecialMemberFunctionsCheck::checkForMissingMembers(
     const ClassDefId &ID,
     llvm::ArrayRef<SpecialMemberFunctionData> DefinedMembers) {
   llvm::SmallVector<SpecialMemberFunctionKind, 5> MissingMembers;
 
   auto HasMember = [&](SpecialMemberFunctionKind Kind) {
-    return llvm::any_of(DefinedMembers, [Kind](const auto &data) {
-      return data.FunctionKind == Kind;
+    return llvm::any_of(DefinedMembers, [Kind](const auto &Data) {
+      return Data.FunctionKind == Kind;
     });
   };
 
   auto IsDeleted = [&](SpecialMemberFunctionKind Kind) {
-    return llvm::any_of(DefinedMembers, [Kind](const auto &data) {
-      return data.FunctionKind == Kind && data.IsDeleted;
+    return llvm::any_of(DefinedMembers, [Kind](const auto &Data) {
+      return Data.FunctionKind == Kind && Data.IsDeleted;
     });
   };
 
   auto RequireMember = [&](SpecialMemberFunctionKind Kind) {
     if (!HasMember(Kind))
       MissingMembers.push_back(Kind);
   };
 
if (RequireFive &&
     assert(RequireThree);
     RequireMember(SpecialMemberFunctionKind::MoveConstructor);
     RequireMember(SpecialMemberFunctionKind::MoveAssignment);
   }
 
   if (!MissingMembers.empty()) {
     llvm::SmallVector<SpecialMemberFunctionKind, 5> DefinedMemberKinds;
     llvm::transform(DefinedMembers, std::back_inserter(DefinedMemberKinds),
-                    [](const auto &data) { return data.FunctionKind; });
+                    [](const auto &Data) { return Data.FunctionKind; });
     diag(ID.first, "class '%0' defines %1 but does not define %2")
         << ID.second << cppcoreguidelines::join(DefinedMemberKinds, " and ")
         << cppcoreguidelines::join(MissingMembers, " or ");
   }
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

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

if (Node.hasDefinition())
     return Node.getNumBases() > 0;
   return false;
 }
 } // namespace
 
 // Adds a node (by name) to the interface map, if it was not present in the map
 // previously.
 void MultipleInheritanceCheck::addNodeToInterfaceMap(const CXXRecordDecl *Node,
-                                                     bool isInterface) {
+                                                     bool IsInterface) {
   assert(Node->getIdentifier());
   StringRef Name = Node->getIdentifier()->getName();
-  InterfaceMap.insert(std::make_pair(Name, isInterface));
+  InterfaceMap.insert(std::make_pair(Name, IsInterface));
 }
 
 // Returns "true" if the boolean "isInterface" has been set to the
 // interface status of the current Node. Return "false" if the
 // interface status for the current node is not yet known.
 bool MultipleInheritanceCheck::getInterfaceStatus(const CXXRecordDecl *Node,
-                                                  bool &isInterface) const {
+                                                  bool &IsInterface) const {
   assert(Node->getIdentifier());
   StringRef Name = Node->getIdentifier()->getName();
   llvm::StringMapConstIterator<bool> Pair = InterfaceMap.find(Name);
   if (Pair == InterfaceMap.end())
     return false;
-  isInterface = Pair->second;
+  IsInterface = Pair->second;
   return true;
 }
 
 bool MultipleInheritanceCheck::isCurrentClassInterface(
     const CXXRecordDecl *Node) const {
   // Interfaces should have no fields.
   if (!Node->field_empty()) return false;
 

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp

void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   if (CastExpr->getExprLoc().isMacroID())
     return;
 
   // Casting to void is an idiomatic way to mute "unused variable" and similar
   // warnings.
   if (CastExpr->getCastKind() == CK_ToVoid)
     return;
 
-  auto isFunction = [](QualType T) {
+  auto IsFunction = [](QualType T) {
     T = T.getCanonicalType().getNonReferenceType();
     return T->isFunctionType() || T->isFunctionPointerType() ||
            T->isMemberFunctionPointerType();
   };
 
   const QualType DestTypeAsWritten =
       CastExpr->getTypeAsWritten().getUnqualifiedType();
   const QualType SourceTypeAsWritten =
       CastExpr->getSubExprAsWritten()->getType().getUnqualifiedType();
   const QualType SourceType = SourceTypeAsWritten.getCanonicalType();
   const QualType DestType = DestTypeAsWritten.getCanonicalType();
 
   auto ReplaceRange = CharSourceRange::getCharRange(
       CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getBeginLoc());
 
   bool FnToFnCast =
-      isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten);
+      IsFunction(SourceTypeAsWritten) && IsFunction(DestTypeAsWritten);
 
   const bool ConstructorCast = !CastExpr->getTypeAsWritten().hasQualifiers() &&
       DestTypeAsWritten->isRecordType() &&
       !DestTypeAsWritten->isElaboratedTypeSpecifier();
 
   if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) {
     // Function pointer/reference casts may be needed to resolve ambiguities in
     // case of overloaded functions, so detection of redundant casts is trickier

clang-tools-extra/clang-tidy/google/AvoidUnderscoreInGoogletestNameCheck.cpp

 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace readability {
 
-constexpr llvm::StringLiteral kDisabledTestPrefix = "DISABLED_";
+constexpr llvm::StringLiteral KDisabledTestPrefix = "DISABLED_";
 
 // Determines whether the macro is a Googletest test macro.
 static bool isGoogletestTestMacro(StringRef MacroName) {
   static const llvm::StringSet<> MacroNames = {"TEST", "TEST_F", "TEST_P",
                                                "TYPED_TEST", "TYPED_TEST_P"};
   return MacroNames.find(MacroName) != MacroNames.end();
 }
 
void MacroExpands(const Token &MacroNameToken,
     if (TestCaseName.find('_') != std::string::npos)
       Check->diag(TestCaseNameToken->getLocation(),
                   "avoid using \"_\" in test case name \"%0\" according to "
                   "Googletest FAQ")
           << TestCaseName;
 
     std::string TestNameMaybeDisabled = PP->getSpelling(*TestNameToken);
     StringRef TestName = TestNameMaybeDisabled;
-    TestName.consume_front(kDisabledTestPrefix);
+    TestName.consume_front(KDisabledTestPrefix);
     if (TestName.contains('_'))
       Check->diag(TestNameToken->getLocation(),
                   "avoid using \"_\" in test name \"%0\" according to "
                   "Googletest FAQ")
           << TestName;
   }
 
 private:

clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.cpp

Finder->addMatcher(
                                      isDeleted(), isInstantiated())))
 
           .bind("conversion"),
       this);
 }
 
 // Looks for the token matching the predicate and returns the range of the found
 // token including trailing whitespace.
-static SourceRange FindToken(const SourceManager &Sources,
+static SourceRange findToken(const SourceManager &Sources,
                              const LangOptions &LangOpts,
                              SourceLocation StartLoc, SourceLocation EndLoc,
                              bool (*Pred)(const Token &)) {
   if (StartLoc.isMacroID() || EndLoc.isMacroID())
     return SourceRange();
   FileID File = Sources.getFileID(Sources.getSpellingLoc(StartLoc));
   StringRef Buf = Sources.getBufferData(File);
   const char *StartChar = Sources.getCharacterData(StartLoc);
if (const auto *Conversion =
     return;
   }
 
   const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
   if (Ctor->isOutOfLine() || Ctor->getNumParams() == 0 ||
       Ctor->getMinRequiredArguments() > 1)
     return;
 
-  bool takesInitializerList = isStdInitializerList(
+  bool TakesInitializerList = isStdInitializerList(
       Ctor->getParamDecl(0)->getType().getNonReferenceType());
   if (Ctor->isExplicit() &&
-      (Ctor->isCopyOrMoveConstructor() || takesInitializerList)) {
-    auto isKWExplicit = [](const Token &Tok) {
+      (Ctor->isCopyOrMoveConstructor() || TakesInitializerList)) {
+    auto IsKwExplicit = [](const Token &Tok) {
       return Tok.is(tok::raw_identifier) &&
              Tok.getRawIdentifier() == "explicit";
     };
     SourceRange ExplicitTokenRange =
-        FindToken(*Result.SourceManager, getLangOpts(),
-                  Ctor->getOuterLocStart(), Ctor->getEndLoc(), isKWExplicit);
+        findToken(*Result.SourceManager, getLangOpts(),
+                  Ctor->getOuterLocStart(), Ctor->getEndLoc(), IsKwExplicit);
     StringRef ConstructorDescription;
     if (Ctor->isMoveConstructor())
       ConstructorDescription = "move";
     else if (Ctor->isCopyConstructor())
       ConstructorDescription = "copy";
     else
       ConstructorDescription = "initializer-list";
 
     auto Diag = diag(Ctor->getLocation(),
                      "%0 constructor should not be declared explicit")
                 << ConstructorDescription;
     if (ExplicitTokenRange.isValid()) {
       Diag << FixItHint::CreateRemoval(
           CharSourceRange::getCharRange(ExplicitTokenRange));
     }
     return;
   }
 
   if (Ctor->isExplicit() || Ctor->isCopyOrMoveConstructor() ||
-      takesInitializerList)
+      TakesInitializerList)
     return;
 
   bool SingleArgument =
       Ctor->getNumParams() == 1 && !Ctor->getParamDecl(0)->isParameterPack();
   SourceLocation Loc = Ctor->getLocation();
   diag(Loc, WarningMessage)
       << (SingleArgument
               ? "single-argument constructors"
               : "constructors that are callable with a single argument")
       << FixItHint::CreateInsertion(Loc, "explicit ");
 }
 
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/google/FunctionNamingCheck.cpp

if (Decl->getStorageClass() != SC_Static)
     return FixItHint();
 
   StringRef Name = Decl->getName();
   std::string NewName = Decl->getName().str();
 
   size_t Index = 0;
   bool AtWordBoundary = true;
   while (Index < NewName.size()) {
-    char ch = NewName[Index];
-    if (isalnum(ch)) {
+    char Ch = NewName[Index];
+    if (isalnum(Ch)) {
       // Capitalize the first letter after every word boundary.
       if (AtWordBoundary) {
         NewName[Index] = toupper(NewName[Index]);
         AtWordBoundary = false;
       }
 
       // Advance the index after every alphanumeric character.
       Index++;

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

 ///         - numeric_limits<std::size_t>::max() when overflow appeared due to
 ///           more than 64 bits type size.
 static std::size_t getNumberOfPossibleValues(QualType T,
                                              const ASTContext &Context) {
   // `isBooleanType` must come first because `bool` is an integral type as well
   // and would not return 2 as result.
   if (T->isBooleanType())
     return 2;
-  else if (T->isIntegralType(Context))
+  if (T->isIntegralType(Context))
     return twoPow(Context.getTypeSize(T));
-  else
-    return 1;
 }
 
 void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *ElseIfWithoutElse =
           Result.Nodes.getNodeAs<IfStmt>("else-if")) {
     diag(ElseIfWithoutElse->getBeginLoc(),
          "potentially uncovered codepath; add an ending else statement");
     return;

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

bool setInsert(const T &V) {
     assert(SetInsertionSucceeded && "We did check that no such value existed");
     return true;
   }
 
 public:
   /// Insert a new element into the SmartSmallSetVector.
   /// \returns true if the element was inserted into the SmartSmallSetVector.
   bool insert(const T &X) {
-    bool result = setInsert(X);
-    if (result)
+    bool Result = setInsert(X);
+    if (Result)
       Vector.push_back(X);
-    return result;
+    return Result;
   }
 
   /// Clear the SmartSmallSetVector and return the underlying vector.
   decltype(Vector) takeVector() {
     Set.clear();
     return std::move(Vector);
   }
 };
 
 constexpr unsigned SmallCallStackSize = 16;
 constexpr unsigned SmallSCCSize = 32;
 
 using CallStackTy =
     llvm::SmallVector<CallGraphNode::CallRecord, SmallCallStackSize>;
 
 // In given SCC, find *some* call stack that will be cyclic.
 // This will only find *one* such stack, it might not be the smallest one,
 // and there may be other loops.
-CallStackTy PathfindSomeCycle(ArrayRef<CallGraphNode *> SCC) {
+CallStackTy pathfindSomeCycle(ArrayRef<CallGraphNode *> SCC) {
   // We'll need to be able to performantly look up whether some CallGraphNode
   // is in SCC or not, so cache all the SCC elements in a set.
   const ImmutableSmallSet<CallGraphNode *, SmallSCCSize> SCCElts(SCC);
 
   // Is node N part if the current SCC?
   auto NodeIsPartOfSCC = [&SCCElts](CallGraphNode *N) {
     return SCCElts.count(N) != 0;
   };
for (CallGraphNode *N : SCC) {
     FunctionDecl *D = N->getDefinition();
     diag(D->getLocation(), "function %0 is within a recursive call chain") << D;
   }
 
   // Now, SCC only tells us about strongly connected function declarations in
   // the call graph. It doesn't *really* tell us about the cycles they form.
   // And there may be more than one cycle in SCC.
   // So let's form a call stack that eventually exposes *some* cycle.
-  const CallStackTy EventuallyCyclicCallStack = PathfindSomeCycle(SCC);
+  const CallStackTy EventuallyCyclicCallStack = pathfindSomeCycle(SCC);
   assert(!EventuallyCyclicCallStack.empty() && "We should've found the cycle");
 
   // While last node of the call stack does cause a loop, due to the way we
   // pathfind the cycle, the loop does not necessarily begin at the first node
   // of the call stack, so drop front nodes of the call stack until it does.
   const auto CyclicCallStack =
       ArrayRef<CallGraphNode::CallRecord>(EventuallyCyclicCallStack)
           .drop_until([LastNode = EventuallyCyclicCallStack.back()](

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

static bool areEquivalentExpr(const Expr *Left, const Expr *Right) {
   case Stmt::UnaryExprOrTypeTraitExprClass:
     const auto *LeftUnaryExpr =
         cast<UnaryExprOrTypeTraitExpr>(Left);
     const auto *RightUnaryExpr =
         cast<UnaryExprOrTypeTraitExpr>(Right);
     if (LeftUnaryExpr->isArgumentType() && RightUnaryExpr->isArgumentType())
       return LeftUnaryExpr->getArgumentType() ==
              RightUnaryExpr->getArgumentType();
-    else if (!LeftUnaryExpr->isArgumentType() &&
-             !RightUnaryExpr->isArgumentType())
+    if (!LeftUnaryExpr->isArgumentType() && !RightUnaryExpr->isArgumentType())
       return areEquivalentExpr(LeftUnaryExpr->getArgumentExpr(),
                                RightUnaryExpr->getArgumentExpr());
 
     return false;
   }
 }
 
 // For a given expression 'x', returns whether the ranges covered by the
 // relational operators are equivalent (i.e.  x <= 4 is equivalent to x < 5).
 static bool areEquivalentRanges(BinaryOperatorKind OpcodeLHS,
                                 const APSInt &ValueLHS,
                                 BinaryOperatorKind OpcodeRHS,
                                 const APSInt &ValueRHS) {
   assert(APSInt::compareValues(ValueLHS, ValueRHS) <= 0 &&
          "Values must be ordered");
   // Handle the case where constants are the same: x <= 4  <==>  x <= 4.
   if (APSInt::compareValues(ValueLHS, ValueRHS) == 0)
     return OpcodeLHS == OpcodeRHS;
 
   // Handle the case where constants are off by one: x <= 4  <==>  x < 5.
-  APSInt ValueLHS_plus1;
+  APSInt ValueLhsPlus1;
   return ((OpcodeLHS == BO_LE && OpcodeRHS == BO_LT) ||
           (OpcodeLHS == BO_GT && OpcodeRHS == BO_GE)) &&
-         incrementWithoutOverflow(ValueLHS, ValueLHS_plus1) &&
-         APSInt::compareValues(ValueLHS_plus1, ValueRHS) == 0;
+         incrementWithoutOverflow(ValueLHS, ValueLhsPlus1) &&
+         APSInt::compareValues(ValueLhsPlus1, ValueRHS) == 0;
 }
 
 // For a given expression 'x', returns whether the ranges covered by the
 // relational operators are fully disjoint (i.e. x < 4  and  x > 7).
 static bool areExclusiveRanges(BinaryOperatorKind OpcodeLHS,
                                const APSInt &ValueLHS,
                                BinaryOperatorKind OpcodeRHS,
                                const APSInt &ValueRHS) {
static bool areExclusiveRanges(BinaryOperatorKind OpcodeLHS,
   }
 
   // Handle cases where the constants are different.
   if ((OpcodeLHS == BO_EQ || OpcodeLHS == BO_LT || OpcodeLHS == BO_LE) &&
       (OpcodeRHS == BO_EQ || OpcodeRHS == BO_GT || OpcodeRHS == BO_GE))
     return true;
 
   // Handle the case where constants are off by one: x > 5 && x < 6.
-  APSInt ValueLHS_plus1;
+  APSInt ValueLhsPlus1;
   if (OpcodeLHS == BO_GT && OpcodeRHS == BO_LT &&
-      incrementWithoutOverflow(ValueLHS, ValueLHS_plus1) &&
-      APSInt::compareValues(ValueLHS_plus1, ValueRHS) == 0)
+      incrementWithoutOverflow(ValueLHS, ValueLhsPlus1) &&
+      APSInt::compareValues(ValueLhsPlus1, ValueRHS) == 0)
     return true;
 
   return false;
 }
 
 // Returns whether the ranges covered by the union of both relational
 // expressions cover the whole domain (i.e. x < 10  and  x > 0).
 static bool rangesFullyCoverDomain(BinaryOperatorKind OpcodeLHS,
if (APSInt::compareValues(ValueLHS, ValueRHS) == 0) {
     case BO_GT:
       return OpcodeRHS == BO_LE;
     default:
       return false;
     }
   }
 
   // Handle the case where constants are off by one: x <= 4 || x >= 5.
-  APSInt ValueLHS_plus1;
+  APSInt ValueLhsPlus1;
   if (OpcodeLHS == BO_LE && OpcodeRHS == BO_GE &&
-      incrementWithoutOverflow(ValueLHS, ValueLHS_plus1) &&
-      APSInt::compareValues(ValueLHS_plus1, ValueRHS) == 0)
+      incrementWithoutOverflow(ValueLHS, ValueLhsPlus1) &&
+      APSInt::compareValues(ValueLhsPlus1, ValueRHS) == 0)
     return true;
 
   // Handle cases where the constants are different: x > 4 || x <= 7.
   if ((OpcodeLHS == BO_GT || OpcodeLHS == BO_GE) &&
       (OpcodeRHS == BO_LT || OpcodeRHS == BO_LE))
     return true;
 
   // Handle cases where constants are different but both ops are !=, like:

 // Checks whether the arguments of an overloaded operator can be modified in the
 // function.
 // For operators that take an instance and a constant as arguments, only the
 // first argument (the instance) needs to be checked, since the constant itself
 // is a temporary expression. Whether the second parameter is checked is
 // controlled by the parameter `ParamsToCheckCount`.
 static bool
 canOverloadedOperatorArgsBeModified(const CXXOperatorCallExpr *OperatorCall,
-                                    bool checkSecondParam) {
+                                    bool CheckSecondParam) {
   const auto *OperatorDecl =
       dyn_cast_or_null<FunctionDecl>(OperatorCall->getCalleeDecl());
   // if we can't find the declaration, conservatively assume it can modify
   // arguments
   if (!OperatorDecl)
     return true;
 
   unsigned ParamCount = OperatorDecl->getNumParams();
 
   // Overloaded operators declared inside a class have only one param.
   // These functions must be declared const in order to not be able to modify
   // the instance of the class they are called through.
   if (ParamCount == 1 &&
       !OperatorDecl->getType()->castAs<FunctionType>()->isConst())
     return true;
 
   if (isNonConstReferenceType(OperatorDecl->getParamDecl(0)->getType()))
     return true;
 
-  return checkSecondParam && ParamCount == 2 &&
+  return CheckSecondParam && ParamCount == 2 &&
          isNonConstReferenceType(OperatorDecl->getParamDecl(1)->getType());
 }
 
 // Retrieves sub-expressions matched by 'matchRelationalIntegerConstantExpr'
 // with name 'Id'.
 static bool retrieveRelationalIntegerConstantExpr(
     const MatchFinder::MatchResult &Result, StringRef Id,
     const Expr *&OperandExpr, BinaryOperatorKind &Opcode, const Expr *&Symbol,

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

 
 void UnusedParametersCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("function");
   if (!Function->hasWrittenPrototype() || Function->isTemplateInstantiation())
     return;
   if (const auto *Method = dyn_cast<CXXMethodDecl>(Function))
     if (Method->isLambdaStaticInvoker())
       return;
-  for (unsigned i = 0, e = Function->getNumParams(); i != e; ++i) {
-    const auto *Param = Function->getParamDecl(i);
+  for (unsigned I = 0, E = Function->getNumParams(); I != E; ++I) {
+    const auto *Param = Function->getParamDecl(I);
     if (Param->isUsed() || Param->isReferenced() || !Param->getDeclName() ||
         Param->hasAttr<UnusedAttr>())
       continue;
 
     // In non-strict mode ignore function definitions with empty bodies
     // (constructor initializer counts for non-empty body).
     if (StrictMode ||
         (Function->getBody()->child_begin() !=
          Function->getBody()->child_end()) ||
         (isa<CXXConstructorDecl>(Function) &&
          cast<CXXConstructorDecl>(Function)->getNumCtorInitializers() > 0))
-      warnOnUnusedParameter(Result, Function, i);
+      warnOnUnusedParameter(Result, Function, I);
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

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

if (const auto *TD = Node.getTemplateName().getAsTemplateDecl())
     return DeclMatcher.matches(*TD, Finder, Builder);
   return false;
 }
 } // namespace
 
 // A function that helps to tell whether a TargetDecl in a UsingDecl will be
 // checked. Only variable, function, function template, class template, class,
 // enum declaration and enum constant declaration are considered.
-static bool ShouldCheckDecl(const Decl *TargetDecl) {
+static bool shouldCheckDecl(const Decl *TargetDecl) {
   return isa<RecordDecl>(TargetDecl) || isa<ClassTemplateDecl>(TargetDecl) ||
          isa<FunctionDecl>(TargetDecl) || isa<VarDecl>(TargetDecl) ||
          isa<FunctionTemplateDecl>(TargetDecl) || isa<EnumDecl>(TargetDecl) ||
          isa<EnumConstantDecl>(TargetDecl);
 }
 
 void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     UsingDeclContext Context(Using);
     Context.UsingDeclRange = CharSourceRange::getCharRange(
         Using->getBeginLoc(),
         Lexer::findLocationAfterToken(
             Using->getEndLoc(), tok::semi, *Result.SourceManager, getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     for (const auto *UsingShadow : Using->shadows()) {
       const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
-      if (ShouldCheckDecl(TargetDecl))
+      if (shouldCheckDecl(TargetDecl))
         Context.UsingTargetDecls.insert(TargetDecl);
     }
     if (!Context.UsingTargetDecls.empty())
       Contexts.push_back(Context);
     return;
   }
 
   // Mark a corresponding using declaration as used.

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

void DeprecatedIosBaseAliasesCheck::check(
   if (IoStateLoc.isMacroID()) {
     IoStateLoc = SM.getSpellingLoc(IoStateLoc);
     Fix = false;
   }
 
   SourceLocation EndLoc = IoStateLoc.getLocWithOffset(TypeName.size() - 1);
 
   if (Replacement) {
-    auto FixName = *Replacement;
+    const char *FixName = *Replacement;
     auto Builder = diag(IoStateLoc, "'std::ios_base::%0' is deprecated; use "
                                     "'std::ios_base::%1' instead")
                    << TypeName << FixName;
 
     if (Fix)
       Builder << FixItHint::CreateReplacement(SourceRange(IoStateLoc, EndLoc),
                                               FixName);
   } else
     diag(IoStateLoc, "'std::ios_base::%0' is deprecated") << TypeName;
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

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

 static const char InitVarName[] = "initVar";
 static const char BeginCallName[] = "beginCall";
 static const char EndCallName[] = "endCall";
 static const char ConditionEndVarName[] = "conditionEndVar";
 static const char EndVarName[] = "endVar";
 static const char DerefByValueResultName[] = "derefByValueResult";
 static const char DerefByRefResultName[] = "derefByRefResult";
 // shared matchers
-static const TypeMatcher AnyType() { return anything(); }
+static const TypeMatcher anyType() { return anything(); }
 
-static const StatementMatcher IntegerComparisonMatcher() {
+static const StatementMatcher integerComparisonMatcher() {
   return expr(ignoringParenImpCasts(
       declRefExpr(to(varDecl(hasType(isInteger())).bind(ConditionVarName)))));
 }
 
-static const DeclarationMatcher InitToZeroMatcher() {
+static const DeclarationMatcher initToZeroMatcher() {
   return varDecl(
              hasInitializer(ignoringParenImpCasts(integerLiteral(equals(0)))))
       .bind(InitVarName);
 }
 
-static const StatementMatcher IncrementVarMatcher() {
+static const StatementMatcher incrementVarMatcher() {
   return declRefExpr(to(varDecl(hasType(isInteger())).bind(IncrementVarName)));
 }
 
 /// The matcher for loops over arrays.
 ///
 /// In this general example, assuming 'j' and 'k' are of integral type:
 /// \code
 ///   for (int i = 0; j < 3 + 2; ++k) { ... }

 ///   - The index variable is only used as an array index.
 ///   - All arrays indexed by the loop are the same.
 StatementMatcher makeArrayLoopMatcher() {
   StatementMatcher ArrayBoundMatcher =
       expr(hasType(isInteger())).bind(ConditionBoundName);
 
   return forStmt(
              unless(isInTemplateInstantiation()),
-             hasLoopInit(declStmt(hasSingleDecl(InitToZeroMatcher()))),
+             hasLoopInit(declStmt(hasSingleDecl(initToZeroMatcher()))),
              hasCondition(anyOf(
                  binaryOperator(hasOperatorName("<"),
-                                hasLHS(IntegerComparisonMatcher()),
+                                hasLHS(integerComparisonMatcher()),
                                 hasRHS(ArrayBoundMatcher)),
                  binaryOperator(hasOperatorName(">"), hasLHS(ArrayBoundMatcher),
-                                hasRHS(IntegerComparisonMatcher())))),
-             hasIncrement(unaryOperator(hasOperatorName("++"),
-                                        hasUnaryOperand(IncrementVarMatcher()))))
+                                hasRHS(integerComparisonMatcher())))),
+             hasIncrement(
+                 unaryOperator(hasOperatorName("++"),
+                               hasUnaryOperand(incrementVarMatcher()))))
       .bind(LoopNameArray);
 }
 
 /// The matcher used for iterator-based for loops.
 ///
 /// This matcher is more flexible than array-based loops. It will match
 /// catch loops of the following textual forms (regardless of whether the
 /// iterator type is actually a pointer type or a class type):
return forStmt(
                                       hasRHS(IteratorBoundMatcher)),
                        binaryOperator(hasOperatorName("!="),
                                       hasLHS(IteratorBoundMatcher),
                                       hasRHS(IteratorComparisonMatcher)),
                        OverloadedNEQMatcher)),
              hasIncrement(anyOf(
                  unaryOperator(hasOperatorName("++"),
                                hasUnaryOperand(declRefExpr(
-                                   to(varDecl(hasType(pointsTo(AnyType())))
+                                   to(varDecl(hasType(pointsTo(anyType())))
                                           .bind(IncrementVarName))))),
                  cxxOperatorCallExpr(
                      hasOverloadedOperatorName("++"),
                      hasArgument(
                          0, declRefExpr(to(varDecl(TestDerefReturnsByValue)
                                                .bind(IncrementVarName))))))))
       .bind(IsReverse ? LoopNameReverseIterator : LoopNameIterator);
 }
StatementMatcher IndexBoundMatcher =
       expr(anyOf(ignoringParenImpCasts(declRefExpr(to(
                      varDecl(hasType(isInteger())).bind(ConditionEndVarName)))),
                  EndInitMatcher));
 
   return forStmt(
              unless(isInTemplateInstantiation()),
              hasLoopInit(
                  anyOf(declStmt(declCountIs(2),
-                                containsDeclaration(0, InitToZeroMatcher()),
+                                containsDeclaration(0, initToZeroMatcher()),
                                 containsDeclaration(1, EndDeclMatcher)),
-                       declStmt(hasSingleDecl(InitToZeroMatcher())))),
+                       declStmt(hasSingleDecl(initToZeroMatcher())))),
              hasCondition(anyOf(
                  binaryOperator(hasOperatorName("<"),
-                                hasLHS(IntegerComparisonMatcher()),
+                                hasLHS(integerComparisonMatcher()),
                                 hasRHS(IndexBoundMatcher)),
                  binaryOperator(hasOperatorName(">"), hasLHS(IndexBoundMatcher),
-                                hasRHS(IntegerComparisonMatcher())))),
-             hasIncrement(unaryOperator(hasOperatorName("++"),
-                                        hasUnaryOperand(IncrementVarMatcher()))))
+                                hasRHS(integerComparisonMatcher())))),
+             hasIncrement(
+                 unaryOperator(hasOperatorName("++"),
+                               hasUnaryOperand(incrementVarMatcher()))))
       .bind(LoopNamePseudoArray);
 }
 
 /// Determine whether Init appears to be an initializing an iterator.
 ///
 /// If it is, returns the object whose begin() or end() method is called, and
 /// the output parameter isArrow is set to indicate whether the initialization
 /// is called via . or ->.

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

 //===--- LoopConvertUtils.cpp - clang-tidy --------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "LoopConvertUtils.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/Lambda.h"
-#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <cassert>

 }
 
 /// Keep track of the DeclStmt associated with each VarDecl.
 ///
 /// Combined with StmtAncestors, this provides roughly the same information as
 /// Scope, as we can map a VarDecl to its DeclStmt, then walk up the parent tree
 /// using StmtAncestors.
 bool StmtAncestorASTVisitor::VisitDeclStmt(DeclStmt *Decls) {
-  for (const auto *decl : Decls->decls()) {
-    if (const auto *V = dyn_cast<VarDecl>(decl))
+  for (const auto *Decl : Decls->decls()) {
+    if (const auto *V = dyn_cast<VarDecl>(Decl))
       DeclParents.insert(std::make_pair(V, Decls));
   }
   return true;
 }
 
 /// record the DeclRefExpr as part of the parent expression.
 bool ComponentFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *E) {
   Components.push_back(E);
static bool isAliasDecl(ASTContext *Context, const Decl *TheDecl,
   const auto *VDecl = dyn_cast<VarDecl>(TheDecl);
   if (!VDecl)
     return false;
   if (!VDecl->hasInit())
     return false;
 
   bool OnlyCasts = true;
   const Expr *Init = VDecl->getInit()->IgnoreParenImpCasts();
-  if (Init && isa<CXXConstructExpr>(Init)) {
+  if (isa_and_nonnull<CXXConstructExpr>(Init)) {
     Init = digThroughConstructors(Init);
     OnlyCasts = false;
   }
   if (!Init)
     return false;
 
   // Check that the declared type is the same as (or a reference to) the
   // container type.

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

 namespace modernize {
 
 namespace {
 
 constexpr char ConstructorCall[] = "constructorCall";
 constexpr char ResetCall[] = "resetCall";
 constexpr char NewExpression[] = "newExpression";
 
-std::string GetNewExprName(const CXXNewExpr *NewExpr,
-                           const SourceManager &SM,
+std::string getNewExprName(const CXXNewExpr *NewExpr, const SourceManager &SM,
                            const LangOptions &Lang) {
   StringRef WrittenName = Lexer::getSourceText(
       CharSourceRange::getTokenRange(
           NewExpr->getAllocatedTypeSourceInfo()->getTypeLoc().getSourceRange()),
       SM, Lang);
   if (NewExpr->isArray()) {
     return (WrittenName + "[]").str();
   }
void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,
   // Find the location of the template's left angle.
   size_t LAngle = ExprStr.find('<');
   SourceLocation ConstructCallEnd;
   if (LAngle == StringRef::npos) {
     // If the template argument is missing (because it is part of the alias)
     // we have to add it back.
     ConstructCallEnd = ConstructCallStart.getLocWithOffset(ExprStr.size());
     Diag << FixItHint::CreateInsertion(
-        ConstructCallEnd,
-        "<" + GetNewExprName(New, SM, getLangOpts()) + ">");
+        ConstructCallEnd, "<" + getNewExprName(New, SM, getLangOpts()) + ">");
   } else {
     ConstructCallEnd = ConstructCallStart.getLocWithOffset(LAngle);
   }
 
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(ConstructCallStart, ConstructCallEnd),
       MakeSmartPtrFunctionName);
 
void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
 
   if (!replaceNew(Diag, New, SM, Ctx)) {
     return;
   }
 
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
       (llvm::Twine(" = ") + MakeSmartPtrFunctionName + "<" +
-       GetNewExprName(New, SM, getLangOpts()) + ">")
+       getNewExprName(New, SM, getLangOpts()) + ">")
           .str());
 
   if (Expr->isArrow())
     Diag << FixItHint::CreateInsertion(ExprStart, "*");
 
   insertHeader(Diag, SM.getFileID(OperatorLoc));
 }
 
if (const auto *NewConstruct = New->getConstructExpr()) {
         //   struct S2 { S2(S, int); };
         //   smart_ptr<S>(new S{1, 2, 3});  // C++11 direct list-initialization
         //   smart_ptr<S>(new S{});  // use initializer-list constructor
         //   smart_ptr<S2>()new S2{ {1,2}, 3 }; // have a list-initialized arg
         // The above cases have to be replaced with:
         //   std::make_smart_ptr<S>(std::initializer_list<int>({1, 2, 3}));
         //   std::make_smart_ptr<S>(std::initializer_list<int>({}));
         //   std::make_smart_ptr<S2>(S{1, 2}, 3);
         return false;
-      } else {
-        // Direct initialization with ordinary constructors.
-        //   struct S { S(int x); S(); };
-        //   smart_ptr<S>(new S{5});
-        //   smart_ptr<S>(new S{}); // use default constructor
-        // The arguments in the initialization list are going to be forwarded to
-        // the constructor, so this has to be replaced with:
-        //   std::make_smart_ptr<S>(5);
-        //   std::make_smart_ptr<S>();
-        InitRange = SourceRange(
-            NewConstruct->getParenOrBraceRange().getBegin().getLocWithOffset(1),
-            NewConstruct->getParenOrBraceRange().getEnd().getLocWithOffset(-1));
-      }
+      }
     } else {
       // Aggregate initialization.
       //   smart_ptr<Pair>(new Pair{first, second});
       // Has to be replaced with:
       //   smart_ptr<Pair>(Pair{first, second});
       //
       // The fix (std::make_unique) needs to see copy/move constructor of
       // Pair. If we found any invisible or deleted copy/move constructor, we

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

 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
 
 // Determine if the given QualType is a nullary function or pointer to same.
 bool protoTypeHasNoParms(QualType QT) {
-  if (auto PT = QT->getAs<PointerType>()) {
+  if (const auto *PT = QT->getAs<PointerType>()) {
     QT = PT->getPointeeType();
   }
   if (auto *MPT = QT->getAs<MemberPointerType>()) {
     QT = MPT->getPointeeType();
   }
-  if (auto FP = QT->getAs<FunctionProtoType>()) {
+  if (const auto *FP = QT->getAs<FunctionProtoType>()) {
     return FP->getNumParams() == 0;
   }
   return false;
 }
 
 const char FunctionId[] = "function";
 const char TypedefId[] = "typedef";
 const char FieldId[] = "field";

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

if (MatchedCallExpr->getNumArgs() == 3) {
       auto DiagL =
           diag(MatchedCallExpr->getBeginLoc(),
                "'std::random_shuffle' has been removed in C++17; use "
                "'std::shuffle' and an alternative random mechanism instead");
       DiagL << FixItHint::CreateReplacement(
           MatchedArgumentThree->getSourceRange(),
           "std::mt19937(std::random_device()())");
       return DiagL;
-    } else {
-      auto DiagL = diag(MatchedCallExpr->getBeginLoc(),
-                        "'std::random_shuffle' has been removed in C++17; use "
-                        "'std::shuffle' instead");
-      DiagL << FixItHint::CreateInsertion(
-          MatchedCallExpr->getRParenLoc(),
-          ", std::mt19937(std::random_device()())");
-      return DiagL;
-    }
+    }
   }();
 
   std::string NewName = "shuffle";
   StringRef ContainerText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(MatchedDecl->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   if (ContainerText.startswith("std::"))
     NewName = "std::" + NewName;

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

 namespace modernize {
 namespace {
 
 const char IteratorDeclStmtId[] = "iterator_decl";
 const char DeclWithNewId[] = "decl_new";
 const char DeclWithCastId[] = "decl_cast";
 const char DeclWithTemplateCastId[] = "decl_template";
 
-size_t GetTypeNameLength(bool RemoveStars, StringRef Text) {
+size_t getTypeNameLength(bool RemoveStars, StringRef Text) {
   enum CharType { Space, Alpha, Punctuation };
   CharType LastChar = Space, BeforeSpace = Punctuation;
   size_t NumChars = 0;
   int TemplateTypenameCntr = 0;
   for (const unsigned char C : Text) {
     if (C == '<')
       ++TemplateTypenameCntr;
     else if (C == '>')
void UseAutoCheck::replaceExpr(
   while (Loc.getTypeLocClass() == TypeLoc::LValueReference ||
          Loc.getTypeLocClass() == TypeLoc::RValueReference ||
          Loc.getTypeLocClass() == TypeLoc::Qualified) {
     Loc = Loc.getNextTypeLoc();
   }
   SourceRange Range(Loc.getSourceRange());
 
   if (MinTypeNameLength != 0 &&
-      GetTypeNameLength(RemoveStars,
+      getTypeNameLength(RemoveStars,
                         tooling::fixit::getText(Loc.getSourceRange(),
                                                 FirstDecl->getASTContext())) <
           MinTypeNameLength)
     return;
 
   auto Diag = diag(Range.getBegin(), Message);
 
   // Space after 'auto' to handle cases where the '*' in the pointer type is

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

 //===--- UseEqualsDefaultCheck.cpp - clang-tidy----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "UseEqualsDefaultCheck.h"
+#include "../utils/LexerUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
-#include "../utils/LexerUtils.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 static const char SpecialFunction[] = "SpecialFunction";

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

 /// explicit casts exist between the found top-most explicit cast and the
 /// possibly more than one nested implicit cast. This visitor finds all cast
 /// sequences with an implicit cast to null within and creates a replacement
 /// leaving the outermost explicit cast unchanged to avoid introducing
 /// ambiguities.
 class CastSequenceVisitor : public RecursiveASTVisitor<CastSequenceVisitor> {
 public:
   CastSequenceVisitor(ASTContext &Context, ArrayRef<StringRef> NullMacros,
-                      ClangTidyCheck &check)
+                      ClangTidyCheck &Check)
       : SM(Context.getSourceManager()), Context(Context),
-        NullMacros(NullMacros), Check(check), FirstSubExpr(nullptr),
+        NullMacros(NullMacros), Check(Check), FirstSubExpr(nullptr),
         PruneSubtree(false) {}
 
   bool TraverseStmt(Stmt *S) {
     // Stop traversing down the tree if requested.
     if (PruneSubtree) {
       PruneSubtree = false;
       return true;
     }

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

Finder->addMatcher(
         this);
   else
     Finder->addMatcher(cxxMethodDecl(isOverride()).bind("method"), this);
 }
 
 // Re-lex the tokens to get precise locations to insert 'override' and remove
 // 'virtual'.
 static SmallVector<Token, 16>
-ParseTokens(CharSourceRange Range, const MatchFinder::MatchResult &Result) {
+parseTokens(CharSourceRange Range, const MatchFinder::MatchResult &Result) {
   const SourceManager &Sources = *Result.SourceManager;
   std::pair<FileID, unsigned> LocInfo =
       Sources.getDecomposedLoc(Range.getBegin());
   StringRef File = Sources.getBufferData(LocInfo.first);
   const char *TokenBegin = File.data() + LocInfo.second;
   Lexer RawLexer(Sources.getLocForStartOfFile(LocInfo.first),
                  Result.Context->getLangOpts(), File.begin(), TokenBegin,
                  File.end());
if (Tok.is(tok::raw_identifier)) {
       Tok.setIdentifierInfo(&Info);
       Tok.setKind(Info.getTokenID());
     }
     Tokens.push_back(Tok);
   }
   return Tokens;
 }
 
-static StringRef GetText(const Token &Tok, const SourceManager &Sources) {
+static StringRef getText(const Token &Tok, const SourceManager &Sources) {
   return StringRef(Sources.getCharacterData(Tok.getLocation()),
                    Tok.getLength());
 }
 
 void UseOverrideCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Method = Result.Nodes.getNodeAs<FunctionDecl>("method");
   const SourceManager &Sources = *Result.SourceManager;
 
CharSourceRange FileRange = Lexer::makeFileCharRange(
       getLangOpts());
 
   if (!FileRange.isValid())
     return;
 
   // FIXME: Instead of re-lexing and looking for specific macros such as
   // 'ABSTRACT', properly store the location of 'virtual' and '= 0' in each
   // FunctionDecl.
-  SmallVector<Token, 16> Tokens = ParseTokens(FileRange, Result);
+  SmallVector<Token, 16> Tokens = parseTokens(FileRange, Result);
 
   // Add 'override' on inline declarations that don't already have it.
   if (!HasFinal && !HasOverride) {
     SourceLocation InsertLoc;
     std::string ReplacementText = OverrideSpelling + " ";
     SourceLocation MethodLoc = Method->getLocation();
 
     for (Token T : Tokens) {
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());
       // 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()) {
       // For declarations marked with "= 0" or "= [default|delete]", the end
       // location will point until after those markings. Therefore, the override
       // keyword shouldn't be inserted at the end, but before the '='.
       if (Tokens.size() > 2 &&
-          (GetText(Tokens.back(), Sources) == "0" ||
+          (getText(Tokens.back(), Sources) == "0" ||
            Tokens.back().is(tok::kw_default) ||
            Tokens.back().is(tok::kw_delete)) &&
-          GetText(Tokens[Tokens.size() - 2], Sources) == "=") {
+          getText(Tokens[Tokens.size() - 2], Sources) == "=") {
         InsertLoc = Tokens[Tokens.size() - 2].getLocation();
         // Check if we need to insert a space.
         if ((Tokens[Tokens.size() - 2].getFlags() & Token::LeadingSpace) == 0)
           ReplacementText = " " + OverrideSpelling + " ";
-      } else if (GetText(Tokens.back(), Sources) == "ABSTRACT")
+      } else if (getText(Tokens.back(), Sources) == "ABSTRACT")
         InsertLoc = Tokens.back().getLocation();
     }
 
     if (!InsertLoc.isValid()) {
       InsertLoc = FileRange.getEnd();
       ReplacementText = " " + OverrideSpelling;
     }
 

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

 struct UnqualNameVisitor : public RecursiveASTVisitor<UnqualNameVisitor> {
 public:
   UnqualNameVisitor(const FunctionDecl &F) : F(F) {}
 
   bool Collision = false;
 
   bool shouldWalkTypesOfTypeLocs() const { return false; }
 
-  bool VisitUnqualName(StringRef UnqualName) {
+  bool visitUnqualName(StringRef UnqualName) {
     // Check for collisions with function arguments.
     for (ParmVarDecl *Param : F.parameters())
       if (const IdentifierInfo *Ident = Param->getIdentifier())
         if (Ident->getName() == UnqualName) {
           Collision = true;
           return true;
         }
     return false;
   }
 
   bool TraverseTypeLoc(TypeLoc TL, bool Elaborated = false) {
     if (TL.isNull())
       return true;
 
     if (!Elaborated) {
       switch (TL.getTypeLocClass()) {
       case TypeLoc::Record:
-        if (VisitUnqualName(
+        if (visitUnqualName(
                 TL.getAs<RecordTypeLoc>().getTypePtr()->getDecl()->getName()))
           return false;
         break;
       case TypeLoc::Enum:
-        if (VisitUnqualName(
+        if (visitUnqualName(
                 TL.getAs<EnumTypeLoc>().getTypePtr()->getDecl()->getName()))
           return false;
         break;
       case TypeLoc::TemplateSpecialization:
-        if (VisitUnqualName(TL.getAs<TemplateSpecializationTypeLoc>()
+        if (visitUnqualName(TL.getAs<TemplateSpecializationTypeLoc>()
                                 .getTypePtr()
                                 ->getTemplateName()
                                 .getAsTemplateDecl()
                                 ->getName()))
           return false;
         break;
       case TypeLoc::Typedef:
-        if (VisitUnqualName(
+        if (visitUnqualName(
                 TL.getAs<TypedefTypeLoc>().getTypePtr()->getDecl()->getName()))
           return false;
         break;
       default:
         break;
       }
     }
 
if (TL.getQualifierLoc() &&
         !TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()))
       return false;
     return TraverseTypeLoc(TL.getNamedTypeLoc(), true);
   }
 
   bool VisitDeclRefExpr(DeclRefExpr *S) {
     DeclarationName Name = S->getNameInfo().getName();
     return S->getQualifierLoc() || !Name.isIdentifier() ||
-           !VisitUnqualName(Name.getAsIdentifierInfo()->getName());
+           !visitUnqualName(Name.getAsIdentifierInfo()->getName());
   }
 
 private:
   const FunctionDecl &F;
 };
 } // namespace
 
 constexpr llvm::StringLiteral Message =
if (T.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
       Result = T.getEndLoc();
       continue;
     }
     break;
   }
   return Result;
 }
 
-static bool IsCVR(Token T) {
+static bool isCvr(Token T) {
   return T.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict);
 }
 
-static bool IsSpecifier(Token T) {
+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;
classifyToken(const FunctionDecl &F, Preprocessor &PP, Token Tok) {
   // 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);
+    bool Qual = isCvr(T);
+    bool Spec = isSpecifier(T);
     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

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

void UseUsingCheck::check(const MatchFinder::MatchResult &Result) {
   static const char *UseUsingWarning = "use 'using' instead of 'typedef'";
 
   // Warn at StartLoc but do not fix if there is macro or array.
   if (MatchedDecl->getUnderlyingType()->isArrayType() || StartLoc.isMacroID()) {
     diag(StartLoc, UseUsingWarning);
     return;
   }
 
-  auto printPolicy = PrintingPolicy(getLangOpts());
-  printPolicy.SuppressScope = true;
-  printPolicy.ConstantArraySizeAsWritten = true;
-  printPolicy.UseVoidForZeroParams = false;
-  printPolicy.PrintInjectedClassNameWithArguments = false;
+  PrintingPolicy PrintPolicy(getLangOpts());
+  PrintPolicy.SuppressScope = true;
+  PrintPolicy.ConstantArraySizeAsWritten = true;
+  PrintPolicy.UseVoidForZeroParams = false;
+  PrintPolicy.PrintInjectedClassNameWithArguments = false;
 
-  std::string Type = MatchedDecl->getUnderlyingType().getAsString(printPolicy);
+  std::string Type = MatchedDecl->getUnderlyingType().getAsString(PrintPolicy);
   std::string Name = MatchedDecl->getNameAsString();
   SourceRange ReplaceRange = MatchedDecl->getSourceRange();
 
   // typedefs with multiple comma-separated definitions produce multiple
   // consecutive TypedefDecl nodes whose SourceRanges overlap. Each range starts
   // at the "typedef" and then continues *across* previous definitions through
   // the end of the current TypedefDecl definition.
   // But also we need to check that the ranges belong to the same file because

clang-tools-extra/clang-tidy/mpi/BufferDerefCheck.cpp

if (!Identifier || !FuncClassifier.isMPIType(Identifier))
     return;
 
   // These containers are used, to capture the type and expression of a buffer.
   SmallVector<const Type *, 1> BufferTypes;
   SmallVector<const Expr *, 1> BufferExprs;
 
   // Adds the type and expression of a buffer that is used in the MPI call
   // expression to the captured containers.
-  auto addBuffer = [&CE, &Result, &BufferTypes,
+  auto AddBuffer = [&CE, &Result, &BufferTypes,
                     &BufferExprs](const size_t BufferIdx) {
     // Skip null pointer constants and in place 'operators'.
     if (CE->getArg(BufferIdx)->isNullPointerConstant(
             *Result.Context, Expr::NPC_ValueDependentIsNull) ||
         tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
             "MPI_IN_PLACE")
       return;
 
     const Expr *ArgExpr = CE->getArg(BufferIdx);
     if (!ArgExpr)
       return;
     const Type *ArgType = ArgExpr->IgnoreImpCasts()->getType().getTypePtr();
     if (!ArgType)
       return;
     BufferExprs.push_back(ArgExpr);
     BufferTypes.push_back(ArgType);
   };
 
   // Collect buffer types and argument expressions for all buffers used in the
   // MPI call expression. The number passed to the lambda corresponds to the
   // argument index of the currently verified MPI function call.
   if (FuncClassifier.isPointToPointType(Identifier)) {
-    addBuffer(0);
+    AddBuffer(0);
   } else if (FuncClassifier.isCollectiveType(Identifier)) {
     if (FuncClassifier.isReduceType(Identifier)) {
-      addBuffer(0);
-      addBuffer(1);
+      AddBuffer(0);
+      AddBuffer(1);
     } else if (FuncClassifier.isScatterType(Identifier) ||
                FuncClassifier.isGatherType(Identifier) ||
                FuncClassifier.isAlltoallType(Identifier)) {
-      addBuffer(0);
-      addBuffer(3);
+      AddBuffer(0);
+      AddBuffer(3);
     } else if (FuncClassifier.isBcastType(Identifier)) {
-      addBuffer(0);
+      AddBuffer(0);
     }
   }
 
   checkBuffers(BufferTypes, BufferExprs);
 }
 
 void BufferDerefCheck::checkBuffers(ArrayRef<const Type *> BufferTypes,
                                     ArrayRef<const Expr *> BufferExprs) {
-  for (size_t i = 0; i < BufferTypes.size(); ++i) {
+  for (size_t I = 0; I < BufferTypes.size(); ++I) {
     unsigned IndirectionCount = 0;
-    const Type *BufferType = BufferTypes[i];
+    const Type *BufferType = BufferTypes[I];
     llvm::SmallVector<IndirectionType, 1> Indirections;
 
     // Capture the depth and types of indirections for the passed buffer.
     while (true) {
       if (BufferType->isPointerType()) {
         BufferType = BufferType->getPointeeType().getTypePtr();
         Indirections.push_back(IndirectionType::Pointer);
       } else if (BufferType->isArrayType()) {
if (IndirectionCount > 1) {
           IndirectionDesc += "->";
         if (*It == IndirectionType::Pointer) {
           IndirectionDesc += "pointer";
         } else {
           IndirectionDesc += "array";
         }
       }
 
-      const auto Loc = BufferExprs[i]->getSourceRange().getBegin();
+      const auto Loc = BufferExprs[I]->getSourceRange().getBegin();
       diag(Loc, "buffer is insufficiently dereferenced: %0") << IndirectionDesc;
     }
   }
 }
 
 } // namespace mpi
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.cpp

static bool isTypedefTypeMatching(const TypedefType *const Typedef,
                                   std::string &BufferTypeName,
                                   const std::string &MPIDatatype) {
   static llvm::StringMap<std::string> FixedWidthMatches = {
       {"int8_t", "MPI_INT8_T"},     {"int16_t", "MPI_INT16_T"},
       {"int32_t", "MPI_INT32_T"},   {"int64_t", "MPI_INT64_T"},
       {"uint8_t", "MPI_UINT8_T"},   {"uint16_t", "MPI_UINT16_T"},
       {"uint32_t", "MPI_UINT32_T"}, {"uint64_t", "MPI_UINT64_T"}};
 
-  const auto it = FixedWidthMatches.find(Typedef->getDecl()->getName());
+  const auto It = FixedWidthMatches.find(Typedef->getDecl()->getName());
   // Check if the typedef is known and not matching the MPI datatype.
-  if (it != FixedWidthMatches.end() && it->getValue() != MPIDatatype) {
+  if (It != FixedWidthMatches.end() && It->getValue() != MPIDatatype) {
     BufferTypeName = std::string(Typedef->getDecl()->getName());
     return false;
   }
   return true;
 }
 
 /// Get the unqualified, dereferenced type of an argument.
 ///
 /// \param CE call expression
 /// \param idx argument index
 ///
 /// \returns type of the argument
-static const Type *argumentType(const CallExpr *const CE, const size_t idx) {
-  const QualType QT = CE->getArg(idx)->IgnoreImpCasts()->getType();
+static const Type *argumentType(const CallExpr *const CE, const size_t Idx) {
+  const QualType QT = CE->getArg(Idx)->IgnoreImpCasts()->getType();
   return QT.getTypePtr()->getPointeeOrArrayElementType();
 }
 
 void TypeMismatchCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(callExpr().bind("CE"), this);
 }
 
 void TypeMismatchCheck::check(const MatchFinder::MatchResult &Result) {
   static ento::mpi::MPIFunctionClassifier FuncClassifier(*Result.Context);
   const auto *const CE = Result.Nodes.getNodeAs<CallExpr>("CE");
   if (!CE->getDirectCallee())
     return;
 
   const IdentifierInfo *Identifier = CE->getDirectCallee()->getIdentifier();
   if (!Identifier || !FuncClassifier.isMPIType(Identifier))
     return;
 
   // These containers are used, to capture buffer, MPI datatype pairs.
   SmallVector<const Type *, 1> BufferTypes;
   SmallVector<const Expr *, 1> BufferExprs;
   SmallVector<StringRef, 1> MPIDatatypes;
 
   // Adds a buffer, MPI datatype pair of an MPI call expression to the
   // containers. For buffers, the type and expression is captured.
-  auto addPair = [&CE, &Result, &BufferTypes, &BufferExprs, &MPIDatatypes](
+  auto AddPair = [&CE, &Result, &BufferTypes, &BufferExprs, &MPIDatatypes](
                      const size_t BufferIdx, const size_t DatatypeIdx) {
     // Skip null pointer constants and in place 'operators'.
     if (CE->getArg(BufferIdx)->isNullPointerConstant(
             *Result.Context, Expr::NPC_ValueDependentIsNull) ||
         tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
             "MPI_IN_PLACE")
       return;
 
     StringRef MPIDatatype =
         tooling::fixit::getText(*CE->getArg(DatatypeIdx), *Result.Context);
 
     const Type *ArgType = argumentType(CE, BufferIdx);
     // Skip unknown MPI datatypes and void pointers.
     if (!isStandardMPIDatatype(std::string(MPIDatatype)) ||
         ArgType->isVoidType())
       return;
 
     BufferTypes.push_back(ArgType);
     BufferExprs.push_back(CE->getArg(BufferIdx));
     MPIDatatypes.push_back(MPIDatatype);
   };
 
   // Collect all buffer, MPI datatype pairs for the inspected call expression.
   if (FuncClassifier.isPointToPointType(Identifier)) {
-    addPair(0, 2);
+    AddPair(0, 2);
   } else if (FuncClassifier.isCollectiveType(Identifier)) {
     if (FuncClassifier.isReduceType(Identifier)) {
-      addPair(0, 3);
-      addPair(1, 3);
+      AddPair(0, 3);
+      AddPair(1, 3);
     } else if (FuncClassifier.isScatterType(Identifier) ||
                FuncClassifier.isGatherType(Identifier) ||
                FuncClassifier.isAlltoallType(Identifier)) {
-      addPair(0, 2);
-      addPair(3, 5);
+      AddPair(0, 2);
+      AddPair(3, 5);
     } else if (FuncClassifier.isBcastType(Identifier)) {
-      addPair(0, 2);
+      AddPair(0, 2);
     }
   }
   checkArguments(BufferTypes, BufferExprs, MPIDatatypes, getLangOpts());
 }
 
 void TypeMismatchCheck::checkArguments(ArrayRef<const Type *> BufferTypes,
                                        ArrayRef<const Expr *> BufferExprs,
                                        ArrayRef<StringRef> MPIDatatypes,
                                        const LangOptions &LO) {
   std::string BufferTypeName;
 
-  for (size_t i = 0; i < MPIDatatypes.size(); ++i) {
-    const Type *const BT = BufferTypes[i];
+  for (size_t I = 0; I < MPIDatatypes.size(); ++I) {
+    const Type *const BT = BufferTypes[I];
     bool Error = false;
 
     if (const auto *Typedef = BT->getAs<TypedefType>()) {
       Error = !isTypedefTypeMatching(Typedef, BufferTypeName,
-                                     std::string(MPIDatatypes[i]));
+                                     std::string(MPIDatatypes[I]));
     } else if (const auto *Complex = BT->getAs<ComplexType>()) {
       Error = !isCComplexTypeMatching(Complex, BufferTypeName,
-                                      std::string(MPIDatatypes[i]), LO);
+                                      std::string(MPIDatatypes[I]), LO);
     } else if (const auto *Template = BT->getAs<TemplateSpecializationType>()) {
       Error = !isCXXComplexTypeMatching(Template, BufferTypeName,
-                                        std::string(MPIDatatypes[i]), LO);
+                                        std::string(MPIDatatypes[I]), LO);
     } else if (const auto *Builtin = BT->getAs<BuiltinType>()) {
       Error = !isBuiltinTypeMatching(Builtin, BufferTypeName,
-                                     std::string(MPIDatatypes[i]), LO);
+                                     std::string(MPIDatatypes[I]), LO);
     }
 
     if (Error) {
-      const auto Loc = BufferExprs[i]->getSourceRange().getBegin();
+      const auto Loc = BufferExprs[I]->getSourceRange().getBegin();
       diag(Loc, "buffer type '%0' does not match the MPI datatype '%1'")
-          << BufferTypeName << MPIDatatypes[i];
+          << BufferTypeName << MPIDatatypes[I];
     }
   }
 }
 
 } // namespace mpi
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.cpp

 //===--- ForbiddenSubclassingCheck.cpp - clang-tidy -----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ForbiddenSubclassingCheck.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
-#include "../utils/OptionsUtils.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace objc {
 
 namespace {

clang-tools-extra/clang-tidy/objc/PropertyDeclarationCheck.cpp

 //===--- PropertyDeclarationCheck.cpp - clang-tidy-------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "PropertyDeclarationCheck.h"
-#include <algorithm>
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Regex.h"
+#include <algorithm>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace objc {
 
 namespace {

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 namespace {
 
-llvm::Optional<std::string> MakeCharacterLiteral(const StringLiteral *Literal) {
+llvm::Optional<std::string> makeCharacterLiteral(const StringLiteral *Literal) {
   std::string Result;
   {
     llvm::raw_string_ostream OS(Result);
     Literal->outputString(OS);
   }
   // Now replace the " with '.
-  auto pos = Result.find_first_of('"');
-  if (pos == Result.npos)
+  auto Pos = Result.find_first_of('"');
+  if (Pos == Result.npos)
     return llvm::None;
-  Result[pos] = '\'';
-  pos = Result.find_last_of('"');
-  if (pos == Result.npos)
+  Result[Pos] = '\'';
+  Pos = Result.find_last_of('"');
+  if (Pos == Result.npos)
     return llvm::None;
-  Result[pos] = '\'';
+  Result[Pos] = '\'';
   return Result;
 }
 
 AST_MATCHER_FUNCTION(ast_matchers::internal::Matcher<Expr>,
                      hasSubstitutedType) {
   return hasType(qualType(anyOf(substTemplateTypeParmType(),
                                 hasDescendant(substTemplateTypeParmType()))));
 }
Finder->addMatcher(
               unless(hasSubstitutedType())))),
       this);
 }
 
 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
-  auto Replacement = MakeCharacterLiteral(Literal);
+  auto Replacement = makeCharacterLiteral(Literal);
   if (!Replacement)
     return;
 
   diag(Literal->getBeginLoc(), "%0 called with a string literal consisting of "
                                "a single character; consider using the more "
                                "effective overload accepting a character")
       << FindFunc
       << FixItHint::CreateReplacement(
              CharSourceRange::getTokenRange(Literal->getBeginLoc(),
                                             Literal->getEndLoc()),
              *Replacement);
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

 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
 // 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) {
+static bool isNonTrivialImplicitCast(const Stmt *ST) {
   if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) {
     return (ICE->getCastKind() != CK_NoOp) ||
-            IsNonTrivialImplicitCast(ICE->getSubExpr());
+           isNonTrivialImplicitCast(ICE->getSubExpr());
   }
   return false;
 }
 
 void ImplicitConversionInLoopCheck::registerMatchers(MatchFinder *Finder) {
   // We look for const ref loop variables that (optionally inside an
   // ExprWithCleanup) materialize a temporary, and contain a implicit
   // conversion. The check on the implicit conversion is done in check() because
void ImplicitConversionInLoopCheck::check(
   const auto *Materialized = dyn_cast<MaterializeTemporaryExpr>(Init);
   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()))
+  if (isNonTrivialImplicitCast(Materialized->getSubExpr()))
     ReportAndFix(Result.Context, VD, OperatorCall);
 }
 
 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.

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

void InefficientStringConcatenationCheck::registerMatchers(
   }
 }
 
 void InefficientStringConcatenationCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *LhsStr = Result.Nodes.getNodeAs<DeclRefExpr>("lhsStr");
   const auto *PlusOperator =
       Result.Nodes.getNodeAs<CXXOperatorCallExpr>("plusOperator");
-  const auto DiagMsg =
+  const char *DiagMsg =
       "string concatenation results in allocation of unnecessary temporary "
       "strings; consider using 'operator+=' or 'string::append()' instead";
 
   if (LhsStr)
     diag(LhsStr->getExprLoc(), DiagMsg);
   else if (PlusOperator)
     diag(PlusOperator->getExprLoc(), DiagMsg);
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

 //===--- InefficientVectorOperationCheck.cpp - clang-tidy------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "InefficientVectorOperationCheck.h"
+#include "../utils/DeclRefExprUtils.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
-#include "../utils/DeclRefExprUtils.h"
-#include "../utils/OptionsUtils.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 namespace {

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

 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace performance {
 
-static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
+static void replaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
                                const SourceManager &SM,
                                const LangOptions &LangOpts) {
   const Expr *Arg = Call->getArg(0);
 
   CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange(
       CharSourceRange::getCharRange(Call->getBeginLoc(), Arg->getBeginLoc()),
       SM, LangOpts);
   CharSourceRange AfterArgumentsRange = Lexer::makeFileCharRange(
auto Diag = diag(FileMoveRange.getBegin(),
                      "%select{expression|variable %4}1 "
                      "%select{|of the trivially-copyable type %5 }2"
                      "has no effect; remove std::move()"
                      "%select{| or make the variable non-const}3")
                 << IsConstArg << IsVariable << IsTriviallyCopyable
                 << (IsConstArg && IsVariable && !IsTriviallyCopyable) << Var
                 << Arg->getType();
 
-    ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
+    replaceCallWithArg(CallMove, Diag, SM, getLangOpts());
   } else if (ReceivingExpr) {
     auto Diag = diag(FileMoveRange.getBegin(),
                      "passing result of std::move() as a const reference "
                      "argument; no move will actually happen");
 
-    ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
+    replaceCallWithArg(CallMove, Diag, SM, getLangOpts());
   }
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

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

 
 void TypePromotionInMathFnCheck::registerMatchers(MatchFinder *Finder) {
   constexpr BuiltinType::Kind IntTy = BuiltinType::Int;
   constexpr BuiltinType::Kind LongTy = BuiltinType::Long;
   constexpr BuiltinType::Kind FloatTy = BuiltinType::Float;
   constexpr BuiltinType::Kind DoubleTy = BuiltinType::Double;
   constexpr BuiltinType::Kind LongDoubleTy = BuiltinType::LongDouble;
 
-  auto hasBuiltinTyParam = [](int Pos, BuiltinType::Kind Kind) {
+  auto HasBuiltinTyParam = [](int Pos, BuiltinType::Kind Kind) {
     return hasParameter(Pos, hasType(isBuiltinType(Kind)));
   };
-  auto hasBuiltinTyArg = [](int Pos, BuiltinType::Kind Kind) {
+  auto HasBuiltinTyArg = [](int Pos, BuiltinType::Kind Kind) {
     return hasArgument(Pos, hasType(isBuiltinType(Kind)));
   };
 
   // Match calls to foo(double) with a float argument.
   auto OneDoubleArgFns = hasAnyName(
       "::acos", "::acosh", "::asin", "::asinh", "::atan", "::atanh", "::cbrt",
       "::ceil", "::cos", "::cosh", "::erf", "::erfc", "::exp", "::exp2",
       "::expm1", "::fabs", "::floor", "::ilogb", "::lgamma", "::llrint",
       "::log", "::log10", "::log1p", "::log2", "::logb", "::lrint", "::modf",
       "::nearbyint", "::rint", "::round", "::sin", "::sinh", "::sqrt", "::tan",
       "::tanh", "::tgamma", "::trunc", "::llround", "::lround");
   Finder->addMatcher(
       callExpr(callee(functionDecl(OneDoubleArgFns, parameterCountIs(1),
-                                   hasBuiltinTyParam(0, DoubleTy))),
-               hasBuiltinTyArg(0, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy))),
+               HasBuiltinTyArg(0, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to foo(double, double) where both args are floats.
   auto TwoDoubleArgFns = hasAnyName("::atan2", "::copysign", "::fdim", "::fmax",
                                     "::fmin", "::fmod", "::hypot", "::ldexp",
                                     "::nextafter", "::pow", "::remainder");
   Finder->addMatcher(
       callExpr(callee(functionDecl(TwoDoubleArgFns, parameterCountIs(2),
-                                   hasBuiltinTyParam(0, DoubleTy),
-                                   hasBuiltinTyParam(1, DoubleTy))),
-               hasBuiltinTyArg(0, FloatTy), hasBuiltinTyArg(1, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy),
+                                   HasBuiltinTyParam(1, DoubleTy))),
+               HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to fma(double, double, double) where all args are floats.
   Finder->addMatcher(
       callExpr(callee(functionDecl(hasName("::fma"), parameterCountIs(3),
-                                   hasBuiltinTyParam(0, DoubleTy),
-                                   hasBuiltinTyParam(1, DoubleTy),
-                                   hasBuiltinTyParam(2, DoubleTy))),
-               hasBuiltinTyArg(0, FloatTy), hasBuiltinTyArg(1, FloatTy),
-               hasBuiltinTyArg(2, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy),
+                                   HasBuiltinTyParam(1, DoubleTy),
+                                   HasBuiltinTyParam(2, DoubleTy))),
+               HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy),
+               HasBuiltinTyArg(2, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to frexp(double, int*) where the first arg is a float.
   Finder->addMatcher(
       callExpr(callee(functionDecl(
                    hasName("::frexp"), parameterCountIs(2),
-                   hasBuiltinTyParam(0, DoubleTy),
+                   HasBuiltinTyParam(0, DoubleTy),
                    hasParameter(1, parmVarDecl(hasType(pointerType(
                                        pointee(isBuiltinType(IntTy)))))))),
-               hasBuiltinTyArg(0, FloatTy))
+               HasBuiltinTyArg(0, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to nexttoward(double, long double) where the first arg is a
   // float.
   Finder->addMatcher(
       callExpr(callee(functionDecl(hasName("::nexttoward"), parameterCountIs(2),
-                                   hasBuiltinTyParam(0, DoubleTy),
-                                   hasBuiltinTyParam(1, LongDoubleTy))),
-               hasBuiltinTyArg(0, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy),
+                                   HasBuiltinTyParam(1, LongDoubleTy))),
+               HasBuiltinTyArg(0, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to remquo(double, double, int*) where the first two args are
   // floats.
   Finder->addMatcher(
       callExpr(
           callee(functionDecl(
               hasName("::remquo"), parameterCountIs(3),
-              hasBuiltinTyParam(0, DoubleTy), hasBuiltinTyParam(1, DoubleTy),
+              HasBuiltinTyParam(0, DoubleTy), HasBuiltinTyParam(1, DoubleTy),
               hasParameter(2, parmVarDecl(hasType(pointerType(
                                   pointee(isBuiltinType(IntTy)))))))),
-          hasBuiltinTyArg(0, FloatTy), hasBuiltinTyArg(1, FloatTy))
+          HasBuiltinTyArg(0, FloatTy), HasBuiltinTyArg(1, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to scalbln(double, long) where the first arg is a float.
   Finder->addMatcher(
       callExpr(callee(functionDecl(hasName("::scalbln"), parameterCountIs(2),
-                                   hasBuiltinTyParam(0, DoubleTy),
-                                   hasBuiltinTyParam(1, LongTy))),
-               hasBuiltinTyArg(0, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy),
+                                   HasBuiltinTyParam(1, LongTy))),
+               HasBuiltinTyArg(0, FloatTy))
           .bind("call"),
       this);
 
   // Match calls to scalbn(double, int) where the first arg is a float.
   Finder->addMatcher(
       callExpr(callee(functionDecl(hasName("::scalbn"), parameterCountIs(2),
-                                   hasBuiltinTyParam(0, DoubleTy),
-                                   hasBuiltinTyParam(1, IntTy))),
-               hasBuiltinTyArg(0, FloatTy))
+                                   HasBuiltinTyParam(0, DoubleTy),
+                                   HasBuiltinTyParam(1, IntTy))),
+               HasBuiltinTyArg(0, FloatTy))
           .bind("call"),
       this);
 
   // modf(double, double*) is omitted because the second parameter forces the
   // type -- there's no conversion from float* to double*.
 }
 
 void TypePromotionInMathFnCheck::check(const MatchFinder::MatchResult &Result) {

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

 
 UnnecessaryCopyInitialization::UnnecessaryCopyInitialization(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       AllowedTypes(
           utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
 
 void UnnecessaryCopyInitialization::registerMatchers(MatchFinder *Finder) {
-  auto localVarCopiedFrom = [this](const internal::Matcher<Expr> &CopyCtorArg) {
+  auto LocalVarCopiedFrom = [this](const internal::Matcher<Expr> &CopyCtorArg) {
     return compoundStmt(
                forEachDescendant(
                    declStmt(
                        has(varDecl(hasLocalStorage(),
                                    hasType(qualType(
                                        hasCanonicalType(allOf(
                                            matchers::isExpensiveToCopy(),
                                            unless(hasDeclaration(namedDecl(
return compoundStmt(
                                                isCopyConstructor())),
                                            hasArgument(0, CopyCtorArg))
                                            .bind("ctorCall"))))
                                .bind("newVarDecl")))
                        .bind("declStmt")))
         .bind("blockStmt");
   };
 
-  Finder->addMatcher(localVarCopiedFrom(anyOf(isConstRefReturningFunctionCall(),
+  Finder->addMatcher(LocalVarCopiedFrom(anyOf(isConstRefReturningFunctionCall(),
                                               isConstRefReturningMethodCall())),
                      this);
 
-  Finder->addMatcher(localVarCopiedFrom(declRefExpr(
+  Finder->addMatcher(LocalVarCopiedFrom(declRefExpr(
                          to(varDecl(hasLocalStorage()).bind(OldVarDeclId)))),
                      this);
 }
 
 void UnnecessaryCopyInitialization::check(
     const MatchFinder::MatchResult &Result) {
   const auto *NewVar = Result.Nodes.getNodeAs<VarDecl>("newVarDecl");
   const auto *OldVar = Result.Nodes.getNodeAs<VarDecl>(OldVarDeclId);
   const auto *ObjectArg = Result.Nodes.getNodeAs<VarDecl>(ObjectArgId);
   const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt");
   const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctorCall");
 
   TraversalKindScope RAII(*Result.Context, TK_AsIs);
 
   // Do not propose fixes if the DeclStmt has multiple VarDecls or in macros
   // since we cannot place them correctly.
   bool IssueFix =
       Result.Nodes.getNodeAs<DeclStmt>("declStmt")->isSingleDecl() &&
       !NewVar->getLocation().isMacroID();
 
   // A constructor that looks like T(const T& t, bool arg = false) counts as a
   // copy only when it is called with default arguments for the arguments after
   // the first.
-  for (unsigned int i = 1; i < CtorCall->getNumArgs(); ++i)
-    if (!CtorCall->getArg(i)->isDefaultArgument())
+  for (unsigned int I = 1; I < CtorCall->getNumArgs(); ++I)
+    if (!CtorCall->getArg(I)->isDefaultArgument())
       return;
 
   if (OldVar == nullptr) {
     handleCopyFromMethodReturn(*NewVar, *BlockStmt, IssueFix, ObjectArg,
                                *Result.Context);
   } else {
     handleCopyFromLocalVar(*NewVar, *OldVar, *BlockStmt, IssueFix,
                            *Result.Context);

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

WrapConsumer(std::unique_ptr<ClangTidyContext> Context,
                  std::vector<std::unique_ptr<ASTConsumer>> Consumer)
         : MultiplexConsumer(std::move(Consumer)), Context(std::move(Context)),
           DiagEngine(std::move(DiagEngine)) {}
   };
 
 public:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef File) override {
     // Create and set diagnostics engine
-    auto ExternalDiagEngine = &Compiler.getDiagnostics();
-    auto DiagConsumer =
-        new ClangTidyDiagnosticConsumer(*Context, ExternalDiagEngine);
+    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));

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

for (const ParmVarDecl *Parm : Node.parameters()) {
     if (Type->isVectorType())
       IsVector = true;
   }
   return IsVector;
 }
 
 } // namespace
 
-static StringRef TrySuggestPPC(StringRef Name) {
+static StringRef trySuggestPpc(StringRef Name) {
   if (!Name.consume_front("vec_"))
     return {};
 
   return llvm::StringSwitch<StringRef>(Name)
       // [simd.alg]
       .Case("max", "$std::max")
       .Case("min", "$std::min")
       // [simd.binary]
       .Case("add", "operator+ on $simd objects")
       .Case("sub", "operator- on $simd objects")
       .Case("mul", "operator* on $simd objects")
       .Default({});
 }
 
-static StringRef TrySuggestX86(StringRef Name) {
+static StringRef trySuggestX86(StringRef Name) {
   if (!(Name.consume_front("_mm_") || Name.consume_front("_mm256_") ||
         Name.consume_front("_mm512_")))
     return {};
 
   // [simd.alg]
   if (Name.startswith("max_"))
     return "$simd::max";
   if (Name.startswith("min_"))
void SIMDIntrinsicsCheck::check(const MatchFinder::MatchResult &Result) {
   // We warn or suggest if this SIMD intrinsic function has a std::simd
   // replacement.
   switch (Arch) {
   default:
     break;
   case llvm::Triple::ppc:
   case llvm::Triple::ppc64:
   case llvm::Triple::ppc64le:
-    New = TrySuggestPPC(Old);
+    New = trySuggestPpc(Old);
     break;
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
-    New = TrySuggestX86(Old);
+    New = trySuggestX86(Old);
     break;
   }
 
   // We have found a std::simd replacement.
   if (!New.empty()) {
     std::string Message;
     // If Suggest is true, give a P0214 alternative, otherwise point it out it
     // is non-portable.

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

Finder->addMatcher(
                    unless(cxxMethodDecl(ofClass(cxxRecordDecl(anyOf(
                        isLambda(), ast_matchers::isTemplateInstantiation()))))),
                    has(typeLoc(forEach(ConstParamDecl))))
           .bind("func"),
       this);
 }
 
 // Re-lex the tokens to get precise location of last 'const'
-static llvm::Optional<Token> ConstTok(CharSourceRange Range,
+static llvm::Optional<Token> constTok(CharSourceRange Range,
                                       const MatchFinder::MatchResult &Result) {
   const SourceManager &Sources = *Result.SourceManager;
   std::pair<FileID, unsigned> LocInfo =
       Sources.getDecomposedLoc(Range.getBegin());
   StringRef File = Sources.getBufferData(LocInfo.first);
   const char *TokenBegin = File.data() + LocInfo.second;
   Lexer RawLexer(Sources.getLocForStartOfFile(LocInfo.first),
                  Result.Context->getLangOpts(), File.begin(), TokenBegin,
void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
   if (!Param->getType().isLocalConstQualified())
     return;
 
   auto Diag = diag(Param->getBeginLoc(),
                    "parameter %0 is const-qualified in the function "
                    "declaration; const-qualification of parameters only has an "
                    "effect in function definitions");
   if (Param->getName().empty()) {
-    for (unsigned int i = 0; i < Func->getNumParams(); ++i) {
-      if (Param == Func->getParamDecl(i)) {
-        Diag << (i + 1);
+    for (unsigned int I = 0; I < Func->getNumParams(); ++I) {
+      if (Param == Func->getParamDecl(I)) {
+        Diag << (I + 1);
         break;
       }
     }
   } else {
     Diag << Param;
   }
 
   if (Param->getBeginLoc().isMacroID() != Param->getEndLoc().isMacroID()) {
     // Do not offer a suggestion if the part of the variable declaration comes
     // from a macro.
     return;
   }
 
   CharSourceRange FileRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(getTypeRange(*Param)),
       *Result.SourceManager, getLangOpts());
 
   if (!FileRange.isValid())
     return;
 
-  auto Tok = ConstTok(FileRange, Result);
+  auto Tok = constTok(FileRange, Result);
   if (!Tok)
     return;
   Diag << FixItHint::CreateRemoval(
       CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation()));
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

 }
 
 void BracesAroundStatementsCheck::check(
     const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
   const ASTContext *Context = Result.Context;
 
   // Get location of closing parenthesis or 'do' to insert opening brace.
-  if (auto S = Result.Nodes.getNodeAs<ForStmt>("for")) {
+  if (const auto *S = Result.Nodes.getNodeAs<ForStmt>("for")) {
     checkStmt(Result, S->getBody(), S->getRParenLoc());
-  } else if (auto S = Result.Nodes.getNodeAs<CXXForRangeStmt>("for-range")) {
+  } else if (const auto *S =
+                 Result.Nodes.getNodeAs<CXXForRangeStmt>("for-range")) {
     checkStmt(Result, S->getBody(), S->getRParenLoc());
-  } else if (auto S = Result.Nodes.getNodeAs<DoStmt>("do")) {
+  } else if (const auto *S = Result.Nodes.getNodeAs<DoStmt>("do")) {
     checkStmt(Result, S->getBody(), S->getDoLoc(), S->getWhileLoc());
-  } else if (auto S = Result.Nodes.getNodeAs<WhileStmt>("while")) {
+  } else if (const auto *S = Result.Nodes.getNodeAs<WhileStmt>("while")) {
     SourceLocation StartLoc = findRParenLoc(S, SM, Context);
     if (StartLoc.isInvalid())
       return;
     checkStmt(Result, S->getBody(), StartLoc);
-  } else if (auto S = Result.Nodes.getNodeAs<IfStmt>("if")) {
+  } else if (const auto *S = Result.Nodes.getNodeAs<IfStmt>("if")) {
     SourceLocation StartLoc = findRParenLoc(S, SM, Context);
     if (StartLoc.isInvalid())
       return;
     if (ForceBracesStmts.erase(S))
       ForceBracesStmts.insert(S->getThen());
     bool BracedIf = checkStmt(Result, S->getThen(), StartLoc, S->getElseLoc());
     const Stmt *Else = S->getElse();
     if (Else && BracedIf)

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

class FunctionASTVisitor final
 
   // Used to efficiently know the last type of the binary sequence operator
   // that was encountered. It would make sense for the function call to start
   // the new sequence, thus it is a stack.
   using OBO = Optional<BinaryOperator::Opcode>;
   std::stack<OBO, SmallVector<OBO, 4>> BinaryOperatorsStack;
 
 public:
-  bool TraverseStmtWithIncreasedNestingLevel(Stmt *Node) {
+  bool traverseStmtWithIncreasedNestingLevel(Stmt *Node) {
     ++CurrentNestingLevel;
     bool ShouldContinue = Base::TraverseStmt(Node);
     --CurrentNestingLevel;
     return ShouldContinue;
   }
 
-  bool TraverseDeclWithIncreasedNestingLevel(Decl *Node) {
+  bool traverseDeclWithIncreasedNestingLevel(Decl *Node) {
     ++CurrentNestingLevel;
     bool ShouldContinue = Base::TraverseDecl(Node);
     --CurrentNestingLevel;
     return ShouldContinue;
   }
 
   bool TraverseIfStmt(IfStmt *Node, bool InElseIf = false) {
     if (!Node)
bool TraverseIfStmt(IfStmt *Node, bool InElseIf = false) {
 
     if (!InElseIf) {
       if (!TraverseStmt(Node->getInit()))
         return false;
 
       if (!TraverseStmt(Node->getCond()))
         return false;
     } else {
-      if (!TraverseStmtWithIncreasedNestingLevel(Node->getInit()))
+      if (!traverseStmtWithIncreasedNestingLevel(Node->getInit()))
         return false;
 
-      if (!TraverseStmtWithIncreasedNestingLevel(Node->getCond()))
+      if (!traverseStmtWithIncreasedNestingLevel(Node->getCond()))
         return false;
     }
 
     // "Then" always increases nesting level.
-    if (!TraverseStmtWithIncreasedNestingLevel(Node->getThen()))
+    if (!traverseStmtWithIncreasedNestingLevel(Node->getThen()))
       return false;
 
     if (!Node->getElse())
       return true;
 
     if (auto *E = dyn_cast<IfStmt>(Node->getElse()))
       return TraverseIfStmt(E, true);
 
     {
       CognitiveComplexity::Criteria Reasons;
 
       Reasons = CognitiveComplexity::Criteria::None;
 
       // "Else" increases cognitive complexity.
       Reasons |= CognitiveComplexity::Criteria::Increment;
       // "Else" increases nesting level.
       Reasons |= CognitiveComplexity::Criteria::IncrementNesting;
       // "Else" DOES NOT receive a nesting increment commensurate with it's
       // nested depth.
 
       CC.account(Node->getElseLoc(), CurrentNestingLevel, Reasons);
     }
 
     // "Else" always increases nesting level.
-    return TraverseStmtWithIncreasedNestingLevel(Node->getElse());
+    return traverseStmtWithIncreasedNestingLevel(Node->getElse());
   }
 
 // The currently-being-processed stack entry, which is always the top.
 #define CurrentBinaryOperator BinaryOperatorsStack.top()
 
   // In a sequence of binary logical operators, if the new operator is different
   // from the previous one, then the cognitive complexity is increased.
   bool TraverseBinaryOperator(BinaryOperator *Op) {
bool TraverseStmt(Stmt *Node) {
     // If we have found any reasons, let's account it.
     if (Reasons & CognitiveComplexity::Criteria::All)
       CC.account(Location, CurrentNestingLevel, Reasons);
 
     // Did we decide that the nesting level should be increased?
     if (!(Reasons & CognitiveComplexity::Criteria::IncrementNesting))
       return Base::TraverseStmt(Node);
 
-    return TraverseStmtWithIncreasedNestingLevel(Node);
+    return traverseStmtWithIncreasedNestingLevel(Node);
   }
 
   // The parameter MainAnalyzedFunction is needed to differentiate between the
   // cases where TraverseDecl() is the entry point from
   // FunctionCognitiveComplexityCheck::check() and the cases where it was called
   // from the FunctionASTVisitor itself. Explanation: if we get a function
   // definition (e.g. constructor, destructor, method), the Cognitive Complexity
   // specification states that the Nesting level shall be increased. But if this
default:
       // If this is something else, we use early return!
       return Base::TraverseDecl(Node);
       break;
     }
 
     CC.account(Node->getBeginLoc(), CurrentNestingLevel,
                CognitiveComplexity::Criteria::IncrementNesting);
 
-    return TraverseDeclWithIncreasedNestingLevel(Node);
+    return traverseDeclWithIncreasedNestingLevel(Node);
   }
 
   CognitiveComplexity CC;
 };
 
 } // namespace
 
 FunctionCognitiveComplexityCheck::FunctionCognitiveComplexityCheck(

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

if (FDecl->getNumParams() == 3 &&
       IsCharPtrPtr(FDecl->parameters()[2]->getType()) != Type)
     return false;
 
   if (Type == Main) {
     static llvm::Regex Matcher(
         "(^[Mm]ain([_A-Z]|$))|([a-z0-9_]Main([_A-Z]|$))|(_main(_|$))");
     assert(Matcher.isValid() && "Invalid Matcher for main like functions.");
     return Matcher.match(FDecl->getName());
-  } else {
-    static llvm::Regex Matcher("(^((W[Mm])|(wm))ain([_A-Z]|$))|([a-z0-9_]W[Mm]"
-                               "ain([_A-Z]|$))|(_wmain(_|$))");
-    assert(Matcher.isValid() && "Invalid Matcher for wmain like functions.");
-    return Matcher.match(FDecl->getName());
-  }
-}
+  }
 
 static std::string
 fixupWithStyle(StringRef Name,
                const IdentifierNamingCheck::NamingStyle &Style) {
   const std::string Fixed = fixupWithCase(
       Name, Style.Case.getValueOr(IdentifierNamingCheck::CaseType::CT_AnyCase));
   StringRef Mid = StringRef(Fixed).trim("_");
   if (Mid.empty())

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

 
 void ImplicitBoolConversionCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AllowIntegerConditions", AllowIntegerConditions);
   Options.store(Opts, "AllowPointerConditions", AllowPointerConditions);
 }
 
 void ImplicitBoolConversionCheck::registerMatchers(MatchFinder *Finder) {
-  auto exceptionCases =
+  auto ExceptionCases =
       expr(anyOf(allOf(isMacroExpansion(), unless(isNULLMacroExpansion())),
-                 has(ignoringImplicit(memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1)))))),
+                 has(ignoringImplicit(
+                     memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1)))))),
                  hasParent(explicitCastExpr())));
-  auto implicitCastFromBool = implicitCastExpr(
+  auto ImplicitCastFromBool = implicitCastExpr(
       anyOf(hasCastKind(CK_IntegralCast), hasCastKind(CK_IntegralToFloating),
             // Prior to C++11 cast from bool literal to pointer was allowed.
             allOf(anyOf(hasCastKind(CK_NullToPointer),
                         hasCastKind(CK_NullToMemberPointer)),
                   hasSourceExpression(cxxBoolLiteral()))),
       hasSourceExpression(expr(hasType(booleanType()))),
-      unless(exceptionCases));
-  auto boolXor =
-      binaryOperator(hasOperatorName("^"), hasLHS(implicitCastFromBool),
-                     hasRHS(implicitCastFromBool));
+      unless(ExceptionCases));
+  auto BoolXor =
+      binaryOperator(hasOperatorName("^"), hasLHS(ImplicitCastFromBool),
+                     hasRHS(ImplicitCastFromBool));
   Finder->addMatcher(
       traverse(TK_AsIs,
                implicitCastExpr(
                    anyOf(hasCastKind(CK_IntegralToBoolean),
                          hasCastKind(CK_FloatingToBoolean),
                          hasCastKind(CK_PointerToBoolean),
                          hasCastKind(CK_MemberPointerToBoolean)),
                    // Exclude case of using if or while statements with variable
                    // declaration, e.g.:
                    //   if (int var = functionCall()) {}
                    unless(hasParent(
                        stmt(anyOf(ifStmt(), whileStmt()), has(declStmt())))),
                    // Exclude cases common to implicit cast to and from bool.
-                   unless(exceptionCases), unless(has(boolXor)),
+                   unless(ExceptionCases), unless(has(BoolXor)),
                    // Retrieve also parent statement, to check if we need
                    // additional parens in replacement.
                    anyOf(hasParent(stmt().bind("parentStmt")), anything()),
                    unless(isInTemplateInstantiation()),
                    unless(hasAncestor(functionTemplateDecl())))
                    .bind("implicitCastToBool")),
       this);
 
-  auto boolComparison = binaryOperator(hasAnyOperatorName("==", "!="),
-                                       hasLHS(implicitCastFromBool),
-                                       hasRHS(implicitCastFromBool));
-  auto boolOpAssignment = binaryOperator(hasAnyOperatorName("|=", "&="),
+  auto BoolComparison = binaryOperator(hasAnyOperatorName("==", "!="),
+                                       hasLHS(ImplicitCastFromBool),
+                                       hasRHS(ImplicitCastFromBool));
+  auto BoolOpAssignment = binaryOperator(hasAnyOperatorName("|=", "&="),
                                          hasLHS(expr(hasType(booleanType()))));
-  auto bitfieldAssignment = binaryOperator(
+  auto BitfieldAssignment = binaryOperator(
       hasLHS(memberExpr(hasDeclaration(fieldDecl(hasBitWidth(1))))));
-  auto bitfieldConstruct = cxxConstructorDecl(hasDescendant(cxxCtorInitializer(
+  auto BitfieldConstruct = cxxConstructorDecl(hasDescendant(cxxCtorInitializer(
       withInitializer(equalsBoundNode("implicitCastFromBool")),
       forField(hasBitWidth(1)))));
   Finder->addMatcher(
       traverse(
           TK_AsIs,
           implicitCastExpr(
-              implicitCastFromBool,
+              ImplicitCastFromBool,
               // Exclude comparisons of bools, as they are always cast to
               // integers in such context:
               //   bool_expr_a == bool_expr_b
               //   bool_expr_a != bool_expr_b
               unless(hasParent(
-                  binaryOperator(anyOf(boolComparison, boolXor,
-                                       boolOpAssignment, bitfieldAssignment)))),
+                  binaryOperator(anyOf(BoolComparison, BoolXor,
+                                       BoolOpAssignment, BitfieldAssignment)))),
               implicitCastExpr().bind("implicitCastFromBool"),
-              unless(hasParent(bitfieldConstruct)),
+              unless(hasParent(BitfieldConstruct)),
               // Check also for nested casts, for example: bool -> int -> float.
               anyOf(hasParent(implicitCastExpr().bind("furtherImplicitCast")),
                     anything()),
               unless(isInTemplateInstantiation()),
               unless(hasAncestor(functionTemplateDecl())))),
       this);
 }
 

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

bool VisitCXXConstCastExpr(const CXXConstCastExpr *) {
     Usage = NonConst;
     return false; // Stop traversal.
   }
 
   // Our AST is
   //  `-ImplicitCastExpr
   //  (possibly `-UnaryOperator Deref)
   //        `-CXXThisExpr 'S *' this
-  bool VisitUser(const ImplicitCastExpr *Cast) {
+  bool visitUser(const ImplicitCastExpr *Cast) {
     if (Cast->getCastKind() != CK_NoOp)
       return false; // Stop traversal.
 
     // Only allow NoOp cast to 'const S' or 'const S *'.
     QualType QT = Cast->getType();
     if (QT->isPointerType())
       QT = QT->getPointeeType();
 
     if (!QT.isConstQualified())
       return false; // Stop traversal.
 
     const auto *Parent = getParent<Stmt>(Cast);
     if (!Parent)
       return false; // Stop traversal.
 
     if (isa<ReturnStmt>(Parent))
       return true; // return (const S*)this;
 
     if (isa<CallExpr>(Parent))
       return true; // use((const S*)this);
 
     // ((const S*)this)->Member
     if (const auto *Member = dyn_cast<MemberExpr>(Parent))
-      return VisitUser(Member, /*OnConstObject=*/true);
+      return visitUser(Member, /*OnConstObject=*/true);
 
     return false; // Stop traversal.
   }
 
   // If OnConstObject is true, then this is a MemberExpr using
   // a constant this, i.e. 'const S' or 'const S *'.
-  bool VisitUser(const MemberExpr *Member, bool OnConstObject) {
+  bool visitUser(const MemberExpr *Member, bool OnConstObject) {
     if (Member->isBoundMemberFunction(Ctxt)) {
       if (!OnConstObject || Member->getFoundDecl().getAccess() != AS_public) {
         // Non-public non-static member functions might not preserve the
         // logical constness. E.g. in
         // class C {
         //   int &data() const;
         // public:
         //   int &get() { return data(); }
if (const auto *Cast = dyn_cast_or_null<ImplicitCastExpr>(Parent)) {
       if (Cast->getCastKind() == CK_LValueToRValue)
         return true;
 
       if (Cast->getCastKind() == CK_NoOp && Cast->getType().isConstQualified())
         return true;
     }
 
     if (const auto *M = dyn_cast_or_null<MemberExpr>(Parent))
-      return VisitUser(M, /*OnConstObject=*/false);
+      return visitUser(M, /*OnConstObject=*/false);
 
     return false; // Stop traversal.
   }
 
   bool VisitCXXThisExpr(const CXXThisExpr *E) {
     Usage = Const;
 
     const auto *Parent = getParent<Expr>(E);
 
     // Look through deref of this.
     if (const auto *UnOp = dyn_cast_or_null<UnaryOperator>(Parent)) {
       if (UnOp->getOpcode() == UO_Deref) {
         Parent = getParent<Expr>(UnOp);
       }
     }
 
     // It's okay to
     //  return (const S*)this;
     //  use((const S*)this);
     //  ((const S*)this)->f()
     // when 'f' is a public member function.
     if (const auto *Cast = dyn_cast_or_null<ImplicitCastExpr>(Parent)) {
-      if (VisitUser(Cast))
+      if (visitUser(Cast))
         return true;
 
       // And it's also okay to
       //   (const T)(S->t)
       //   (LValueToRValue)(S->t)
       // when 't' is either of builtin type or a public member.
     } else if (const auto *Member = dyn_cast_or_null<MemberExpr>(Parent)) {
-      if (VisitUser(Member, /*OnConstObject=*/false))
+      if (visitUser(Member, /*OnConstObject=*/false))
         return true;
     }
 
     // Unknown user of this.
     Usage = NonConst;
     return false; // Stop traversal.
   }
 };
static SourceLocation getConstInsertionPoint(const CXXMethodDecl *M) {
 
   return FTL.getRParenLoc().getLocWithOffset(1);
 }
 
 void MakeMemberFunctionConstCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Definition = Result.Nodes.getNodeAs<CXXMethodDecl>("x");
 
-  auto Declaration = Definition->getCanonicalDecl();
+  const auto *Declaration = Definition->getCanonicalDecl();
 
   auto Diag = diag(Definition->getLocation(), "method %0 can be made const")
               << Definition
               << FixItHint::CreateInsertion(getConstInsertionPoint(Definition),
                                             " const");
   if (Declaration != Definition) {
     Diag << FixItHint::CreateInsertion(getConstInsertionPoint(Declaration),
                                        " const");
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

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

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 static const IfStmt *getPrecedingIf(const SourceManager &SM,
                                     ASTContext *Context, const IfStmt *If) {
-  auto parents = Context->getParents(*If);
-  if (parents.size() != 1)
+  auto Parents = Context->getParents(*If);
+  if (Parents.size() != 1)
     return nullptr;
-  if (const auto *PrecedingIf = parents[0].get<IfStmt>()) {
+  if (const auto *PrecedingIf = Parents[0].get<IfStmt>()) {
     SourceLocation PreviousElseLoc = PrecedingIf->getElseLoc();
     if (SM.getExpansionLineNumber(PreviousElseLoc) ==
         SM.getExpansionLineNumber(If->getIfLoc()))
       return PrecedingIf;
   }
   return nullptr;
 }
 
 void MisleadingIndentationCheck::danglingElseCheck(const SourceManager &SM,
                                                    ASTContext *Context,
                                                    const IfStmt *If) {
   SourceLocation IfLoc = If->getIfLoc();
   SourceLocation ElseLoc = If->getElseLoc();
 
   if (IfLoc.isMacroID() || ElseLoc.isMacroID())
     return;
 
   if (SM.getExpansionLineNumber(If->getThen()->getEndLoc()) ==
       SM.getExpansionLineNumber(ElseLoc))
     return;
 
   // Find location of first 'if' in a 'if else if' chain.
-  for (auto PrecedingIf = getPrecedingIf(SM, Context, If); PrecedingIf;
+  for (const auto *PrecedingIf = getPrecedingIf(SM, Context, If); PrecedingIf;
        PrecedingIf = getPrecedingIf(SM, Context, PrecedingIf))
     IfLoc = PrecedingIf->getIfLoc();
 
   if (SM.getExpansionColumnNumber(IfLoc) !=
       SM.getExpansionColumnNumber(ElseLoc))
     diag(ElseLoc, "different indentation for 'if' and corresponding 'else'");
 }
 
 void MisleadingIndentationCheck::missingBracesCheck(const SourceManager &SM,
                                                     const CompoundStmt *CStmt) {
   const static StringRef StmtNames[] = {"if", "for", "while"};
-  for (unsigned int i = 0; i < CStmt->size() - 1; i++) {
-    const Stmt *CurrentStmt = CStmt->body_begin()[i];
+  for (unsigned int I = 0; I < CStmt->size() - 1; I++) {
+    const Stmt *CurrentStmt = CStmt->body_begin()[I];
     const Stmt *Inner = nullptr;
     int StmtKind = 0;
 
     if (const auto *CurrentIf = dyn_cast<IfStmt>(CurrentStmt)) {
       StmtKind = 0;
       Inner =
           CurrentIf->getElse() ? CurrentIf->getElse() : CurrentIf->getThen();
     } else if (const auto *CurrentFor = dyn_cast<ForStmt>(CurrentStmt)) {
for (unsigned int I = 0; I < CStmt->size() - 1; I++) {
     if (InnerLoc.isInvalid() || InnerLoc.isMacroID() || OuterLoc.isInvalid() ||
         OuterLoc.isMacroID())
       continue;
 
     if (SM.getExpansionLineNumber(InnerLoc) ==
         SM.getExpansionLineNumber(OuterLoc))
       continue;
 
-    const Stmt *NextStmt = CStmt->body_begin()[i + 1];
+    const Stmt *NextStmt = CStmt->body_begin()[I + 1];
     SourceLocation NextLoc = NextStmt->getBeginLoc();
 
     if (NextLoc.isInvalid() || NextLoc.isMacroID())
       continue;
 
     if (SM.getExpansionColumnNumber(InnerLoc) ==
         SM.getExpansionColumnNumber(NextLoc)) {
       diag(NextLoc, "misleading indentation: statement is indented too deeply");

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

if ((Function->getOverloadedOperator() == OO_PlusPlus ||
       continue;
 
     // Sanity check the source locations.
     if (!Parm->getLocation().isValid() || Parm->getLocation().isMacroID() ||
         !SM.isWrittenInSameFile(Parm->getBeginLoc(), Parm->getLocation()))
       continue;
 
     // Skip gmock testing::Unused parameters.
-    if (auto Typedef = Parm->getType()->getAs<clang::TypedefType>())
+    if (const auto *Typedef = Parm->getType()->getAs<clang::TypedefType>())
       if (Typedef->getDecl()->getQualifiedNameAsString() == "testing::Unused")
         continue;
 
     // Skip std::nullptr_t.
     if (Parm->getType().getCanonicalType()->isNullPtrType())
       continue;
 
     // Look for comments. We explicitly want to allow idioms like

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

if (const auto *Return = Result.Nodes.getNodeAs<CompoundStmt>("return"))
     checkRedundantReturn(Result, Return);
   else if (const auto *Continue =
                Result.Nodes.getNodeAs<CompoundStmt>("continue"))
     checkRedundantContinue(Result, Continue);
 }
 
 void RedundantControlFlowCheck::checkRedundantReturn(
     const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
-  CompoundStmt::const_reverse_body_iterator last = Block->body_rbegin();
-  if (const auto *Return = dyn_cast<ReturnStmt>(*last))
+  CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
+  if (const auto *Return = dyn_cast<ReturnStmt>(*Last))
     issueDiagnostic(Result, Block, Return->getSourceRange(),
                     RedundantReturnDiag);
 }
 
 void RedundantControlFlowCheck::checkRedundantContinue(
     const MatchFinder::MatchResult &Result, const CompoundStmt *Block) {
-  CompoundStmt::const_reverse_body_iterator last = Block->body_rbegin();
-  if (const auto *Continue = dyn_cast<ContinueStmt>(*last))
+  CompoundStmt::const_reverse_body_iterator Last = Block->body_rbegin();
+  if (const auto *Continue = dyn_cast<ContinueStmt>(*Last))
     issueDiagnostic(Result, Block, Continue->getSourceRange(),
                     RedundantContinueDiag);
 }
 
 void RedundantControlFlowCheck::issueDiagnostic(
     const MatchFinder::MatchResult &Result, const CompoundStmt *const Block,
     const SourceRange &StmtRange, const char *const Diag) {
   SourceManager &SM = *Result.SourceManager;

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

void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
 
   const bool DifferentHeaders =
       !SM.isInMainFile(D->getLocation()) &&
       !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation());
 
   bool MultiVar = false;
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // Is this a multivariable declaration?
-    for (const auto Other : VD->getDeclContext()->decls()) {
+    for (const auto *Other : VD->getDeclContext()->decls()) {
       if (Other != D && Other->getBeginLoc() == VD->getBeginLoc()) {
         MultiVar = true;
         break;
       }
     }
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(

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

explicit RedundantPreprocessorCallbacks(ClangTidyCheck &Check,
                            "consider removing it"),
         NoteDescription("previous %select{#if|#ifdef|#ifndef}0 was here") {}
 
   void If(SourceLocation Loc, SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override {
     StringRef Condition =
         Lexer::getSourceText(CharSourceRange::getTokenRange(ConditionRange),
                              PP.getSourceManager(), PP.getLangOpts());
-    CheckMacroRedundancy(Loc, Condition, IfStack, DK_If, DK_If, true);
+    checkMacroRedundancy(Loc, Condition, IfStack, DK_If, DK_If, true);
   }
 
   void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
              const MacroDefinition &MacroDefinition) override {
     std::string MacroName = PP.getSpelling(MacroNameTok);
-    CheckMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifdef, DK_Ifdef, true);
-    CheckMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifdef, DK_Ifndef,
+    checkMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifdef, DK_Ifdef, true);
+    checkMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifdef, DK_Ifndef,
                          false);
   }
 
   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
               const MacroDefinition &MacroDefinition) override {
     std::string MacroName = PP.getSpelling(MacroNameTok);
-    CheckMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifndef, DK_Ifndef,
+    checkMacroRedundancy(Loc, MacroName, IfndefStack, DK_Ifndef, DK_Ifndef,
                          true);
-    CheckMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifndef, DK_Ifdef,
+    checkMacroRedundancy(Loc, MacroName, IfdefStack, DK_Ifndef, DK_Ifdef,
                          false);
   }
 
   void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
     if (!IfStack.empty() && IfLoc == IfStack.back().Loc)
       IfStack.pop_back();
     if (!IfdefStack.empty() && IfLoc == IfdefStack.back().Loc)
       IfdefStack.pop_back();
     if (!IfndefStack.empty() && IfLoc == IfndefStack.back().Loc)
       IfndefStack.pop_back();
   }
 
 private:
-  void CheckMacroRedundancy(SourceLocation Loc, StringRef MacroName,
+  void checkMacroRedundancy(SourceLocation Loc, StringRef MacroName,
                             SmallVector<PreprocessorEntry, 4> &Stack,
                             DirectiveKind WarningKind, DirectiveKind NoteKind,
                             bool Store) {
     if (PP.getSourceManager().isInMainFile(Loc)) {
       for (const auto &Entry : Stack) {
         if (Entry.Condition == MacroName) {
           Check.diag(Loc, WarningDescription) << WarningKind;
           Check.diag(Entry.Loc, NoteDescription, DiagnosticIDs::Note)

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

: ClangTidyCheck(Name, Context),
       StringNames(utils::options::parseStringList(
           Options.get("StringNames", DefaultStringNames))) {}
 
 void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringNames", DefaultStringNames);
 }
 
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
-  const auto hasStringTypeName = hasAnyNameStdString(StringNames);
-  const auto hasStringCtorName =
+  const auto HasStringTypeName = hasAnyNameStdString(StringNames);
+  const auto HasStringCtorName =
       hasAnyNameStdString(removeNamespaces(StringNames));
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(
       anyOf(cxxConstructExpr(argumentCountIs(1),
-                             hasDeclaration(cxxMethodDecl(hasStringCtorName))),
+                             hasDeclaration(cxxMethodDecl(HasStringCtorName))),
             // If present, the second argument is the alloc object which must
             // not be present explicitly.
             cxxConstructExpr(argumentCountIs(2),
-                             hasDeclaration(cxxMethodDecl(hasStringCtorName)),
+                             hasDeclaration(cxxMethodDecl(HasStringCtorName)),
                              hasArgument(1, cxxDefaultArgExpr()))));
 
   // Match a string constructor expression with an empty string literal.
   const auto EmptyStringCtorExpr = cxxConstructExpr(
       StringConstructorExpr,
       hasArgument(0, ignoringParenImpCasts(stringLiteral(hasSize(0)))));
 
   const auto EmptyStringCtorExprWithTemporaries =
       cxxConstructExpr(StringConstructorExpr,
                        hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)));
 
   const auto StringType = hasType(hasUnqualifiedDesugaredType(
-      recordType(hasDeclaration(cxxRecordDecl(hasStringTypeName)))));
+      recordType(hasDeclaration(cxxRecordDecl(HasStringTypeName)))));
   const auto EmptyStringInit = traverse(
       TK_AsIs, expr(ignoringImplicit(anyOf(
                    EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries))));
 
   // Match a variable declaration with an empty string literal as initializer.
   // Examples:
   //     string foo = "";
   //     string bar("");

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

for (auto NegatableOp : OppositeOverloads) {
     if (Opcode == NegatableOp.first)
       return getOperatorName(NegatableOp.second);
     if (Opcode == NegatableOp.second)
       return getOperatorName(NegatableOp.first);
   }
   return StringRef();
 }
 
-std::string asBool(StringRef text, bool NeedsStaticCast) {
+std::string asBool(StringRef Text, bool NeedsStaticCast) {
   if (NeedsStaticCast)
-    return ("static_cast<bool>(" + text + ")").str();
+    return ("static_cast<bool>(" + Text + ")").str();
 
-  return std::string(text);
+  return std::string(Text);
 }
 
 bool needsNullPtrComparison(const Expr *E) {
   if (const auto *ImpCast = dyn_cast<ImplicitCastExpr>(E))
     return ImpCast->getCastKind() == CK_PointerToBoolean ||
            ImpCast->getCastKind() == CK_MemberPointerToBoolean;
 
   return false;
if (Bool->getBeginLoc().isMacroID())
     return;
 
   // FIXME: why do we need this?
   if (!isa<CXXBoolLiteralExpr>(Other) && containsBoolLiteral(Other))
     return;
 
   bool BoolValue = Bool->getValue();
 
-  auto replaceWithExpression = [this, &Result, LHS, RHS, Bool](
-                                   const Expr *ReplaceWith, bool Negated) {
+  auto ReplaceWithExpression = [this, &Result, LHS, RHS,
+                                Bool](const Expr *ReplaceWith, bool Negated) {
     std::string Replacement =
         replacementExpression(Result, Negated, ReplaceWith);
     SourceRange Range(LHS->getBeginLoc(), RHS->getEndLoc());
     issueDiag(Result, Bool->getBeginLoc(), SimplifyOperatorDiagnostic, Range,
               Replacement);
   };
 
   switch (Op->getOpcode()) {
     case BO_LAnd:
       if (BoolValue) {
         // expr && true -> expr
-        replaceWithExpression(Other, /*Negated=*/false);
+        ReplaceWithExpression(Other, /*Negated=*/false);
       } else {
         // expr && false -> false
-        replaceWithExpression(Bool, /*Negated=*/false);
+        ReplaceWithExpression(Bool, /*Negated=*/false);
       }
       break;
     case BO_LOr:
       if (BoolValue) {
         // expr || true -> true
-        replaceWithExpression(Bool, /*Negated=*/false);
+        ReplaceWithExpression(Bool, /*Negated=*/false);
       } else {
         // expr || false -> expr
-        replaceWithExpression(Other, /*Negated=*/false);
+        ReplaceWithExpression(Other, /*Negated=*/false);
       }
       break;
     case BO_EQ:
       // expr == true -> expr, expr == false -> !expr
-      replaceWithExpression(Other, /*Negated=*/!BoolValue);
+      ReplaceWithExpression(Other, /*Negated=*/!BoolValue);
       break;
     case BO_NE:
       // expr != true -> !expr, expr != false -> expr
-      replaceWithExpression(Other, /*Negated=*/BoolValue);
+      ReplaceWithExpression(Other, /*Negated=*/BoolValue);
       break;
     default:
       break;
   }
 }
 
 void SimplifyBooleanExprCheck::matchBoolCondition(MatchFinder *Finder,
                                                   bool Value,

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

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
-static const char kDefaultTypes[] =
+static const char KDefaultTypes[] =
     "::std::basic_string;::std::basic_string_view;::std::vector;::std::array";
 
 SimplifySubscriptExprCheck::SimplifySubscriptExprCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), Types(utils::options::parseStringList(
-                                         Options.get("Types", kDefaultTypes))) {
+                                         Options.get("Types", KDefaultTypes))) {
 }
 
 void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
   const auto TypesMatcher = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
           llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));
 
   Finder->addMatcher(

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

 constexpr llvm::StringLiteral FloatingLiteralCheck::Suffixes;
 
 struct NewSuffix {
   SourceRange LiteralLocation;
   StringRef OldSuffix;
   llvm::Optional<FixItHint> FixIt;
 };
 
-llvm::Optional<SourceLocation> GetMacroAwareLocation(SourceLocation Loc,
+llvm::Optional<SourceLocation> getMacroAwareLocation(SourceLocation Loc,
                                                      const SourceManager &SM) {
   // Do nothing if the provided location is invalid.
   if (Loc.isInvalid())
     return llvm::None;
   // Look where the location was *actually* written.
   SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
   if (SpellingLoc.isInvalid())
     return llvm::None;
   return SpellingLoc;
 }
 
-llvm::Optional<SourceRange> GetMacroAwareSourceRange(SourceRange Loc,
+llvm::Optional<SourceRange> getMacroAwareSourceRange(SourceRange Loc,
                                                      const SourceManager &SM) {
   llvm::Optional<SourceLocation> Begin =
-      GetMacroAwareLocation(Loc.getBegin(), SM);
-  llvm::Optional<SourceLocation> End = GetMacroAwareLocation(Loc.getEnd(), SM);
+      getMacroAwareLocation(Loc.getBegin(), SM);
+  llvm::Optional<SourceLocation> End = getMacroAwareLocation(Loc.getEnd(), SM);
   if (!Begin || !End)
     return llvm::None;
   return SourceRange(*Begin, *End);
 }
 
 llvm::Optional<std::string>
 getNewSuffix(llvm::StringRef OldSuffix,
              const std::vector<std::string> &NewSuffixes) {
shouldReplaceLiteralSuffix(const Expr &Literal,
   ReplacementDsc.LiteralLocation = L.getSourceRange();
 
   // Was this literal fully spelled or is it a product of macro expansion?
   bool RangeCanBeFixed =
       utils::rangeCanBeFixed(ReplacementDsc.LiteralLocation, &SM);
 
   // The literal may have macro expansion, we need the final expanded src range.
   llvm::Optional<SourceRange> Range =
-      GetMacroAwareSourceRange(ReplacementDsc.LiteralLocation, SM);
+      getMacroAwareSourceRange(ReplacementDsc.LiteralLocation, SM);
   if (!Range)
     return llvm::None;
 
   if (RangeCanBeFixed)
     ReplacementDsc.LiteralLocation = *Range;
   // Else keep the naive literal location!
 
   // Get the whole literal from the source buffer.

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

AST_MATCHER_P(Stmt, nextStmt, ast_matchers::internal::Matcher<Stmt>,
   return InnerMatcher.matches(**I, Finder, Builder);
 }
 } // namespace
 
 namespace tidy {
 namespace readability {
 
 void UseAnyOfAllOfCheck::registerMatchers(MatchFinder *Finder) {
-  auto returns = [](bool V) {
+  auto Returns = [](bool V) {
     return returnStmt(hasReturnValue(cxxBoolLiteral(equals(V))));
   };
 
-  auto returnsButNotTrue =
+  auto ReturnsButNotTrue =
       returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(true)))));
-  auto returnsButNotFalse =
+  auto ReturnsButNotFalse =
       returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(false)))));
 
   Finder->addMatcher(
       cxxForRangeStmt(
-          nextStmt(returns(false).bind("final_return")),
-          hasBody(allOf(hasDescendant(returns(true)),
+          nextStmt(Returns(false).bind("final_return")),
+          hasBody(allOf(hasDescendant(Returns(true)),
                         unless(anyOf(hasDescendant(breakStmt()),
                                      hasDescendant(gotoStmt()),
-                                     hasDescendant(returnsButNotTrue))))))
+                                     hasDescendant(ReturnsButNotTrue))))))
           .bind("any_of_loop"),
       this);
 
   Finder->addMatcher(
       cxxForRangeStmt(
-          nextStmt(returns(true).bind("final_return")),
-          hasBody(allOf(hasDescendant(returns(false)),
+          nextStmt(Returns(true).bind("final_return")),
+          hasBody(allOf(hasDescendant(Returns(false)),
                         unless(anyOf(hasDescendant(breakStmt()),
                                      hasDescendant(gotoStmt()),
-                                     hasDescendant(returnsButNotFalse))))))
+                                     hasDescendant(ReturnsButNotFalse))))))
           .bind("all_of_loop"),
       this);
 }
 
 static bool isViableLoop(const CXXForRangeStmt &S, ASTContext &Context) {
 
   ExprMutationAnalyzer Mutations(*S.getBody(), Context);
   if (Mutations.isMutated(S.getLoopVariable()))

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) {
-  const Expr *E_base = E->IgnoreImpCasts();
-  if (clang::isa<clang::BinaryOperator>(E_base) ||
-      clang::isa<clang::ConditionalOperator>(E_base)) {
+  const Expr *EBase = E->IgnoreImpCasts();
+  if (isa<BinaryOperator>(EBase) || isa<ConditionalOperator>(EBase)) {
     return true;
   }
 
-  if (const auto *Operator =
-          clang::dyn_cast<clang::CXXOperatorCallExpr>(E_base)) {
+  if (const auto *Operator = dyn_cast<CXXOperatorCallExpr>(EBase)) {
     return Operator->isInfixBinaryOp();
   }
 
   return false;
 }
 
 bool exprHasBitFlagWithSpelling(const Expr *Flags, const SourceManager &SM,
                                 const LangOptions &LangOpts,
                                 StringRef FlagName) {
   // If the Flag is an integer constant, check it.
   if (isa<IntegerLiteral>(Flags)) {
     if (!SM.isMacroBodyExpansion(Flags->getBeginLoc()) &&
         !SM.isMacroArgExpansion(Flags->getBeginLoc()))
       return false;
 
     // Get the macro name.
     auto MacroName = Lexer::getSourceText(
         CharSourceRange::getTokenRange(Flags->getSourceRange()), SM, LangOpts);
 
     return MacroName == FlagName;
   }
   // If it's a binary OR operation.
   if (const auto *BO = dyn_cast<BinaryOperator>(Flags))
-    if (BO->getOpcode() == clang::BinaryOperatorKind::BO_Or)
+    if (BO->getOpcode() == BinaryOperatorKind::BO_Or)
       return exprHasBitFlagWithSpelling(BO->getLHS()->IgnoreParenCasts(), SM,
                                         LangOpts, FlagName) ||
              exprHasBitFlagWithSpelling(BO->getRHS()->IgnoreParenCasts(), SM,
                                         LangOpts, FlagName);
 
   // Otherwise, assume it has the flag.
   return true;
 }

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

if (const auto *Throw = dyn_cast<CXXThrowExpr>(St)) {
     } else
       // A rethrow of a caught exception happens which makes it possible
       // to throw all exception that are caught in the 'catch' clause of
       // the parent try-catch block.
       Results.registerExceptions(Caught);
   } else if (const auto *Try = dyn_cast<CXXTryStmt>(St)) {
     ExceptionInfo Uncaught =
         throwsException(Try->getTryBlock(), Caught, CallStack);
-    for (unsigned i = 0; i < Try->getNumHandlers(); ++i) {
-      const CXXCatchStmt *Catch = Try->getHandler(i);
+    for (unsigned I = 0; I < Try->getNumHandlers(); ++I) {
+      const CXXCatchStmt *Catch = Try->getHandler(I);
 
       // Everything is catched through 'catch(...)'.
       if (!Catch->getExceptionDecl()) {
         ExceptionInfo Rethrown = throwsException(
             Catch->getHandlerBlock(), Uncaught.getExceptionTypes(), CallStack);
         Results.merge(Rethrown);
         Uncaught.clear();
       } else {

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

if (Descendant == Ancestor)
     return true;
   for (const Stmt *Parent : getParentStmts(Descendant, Context)) {
     if (isDescendantOrEqual(Parent, Ancestor, Context))
       return true;
   }
 
   return false;
 }
-}
+} // namespace
 
 ExprSequence::ExprSequence(const CFG *TheCFG, const Stmt *Root,
                            ASTContext *TheContext)
     : Context(TheContext), Root(Root) {
   for (const auto &SyntheticStmt : TheCFG->synthetic_stmts()) {
     SyntheticStmtSourceMap[SyntheticStmt.first] = SyntheticStmt.second;
   }
 }

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

 #include <algorithm>
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 namespace {
 
-StringRef RemoveFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
+StringRef removeFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
   for (StringRef Suffix : Suffixes) {
     if (Str.endswith(Suffix)) {
       return Str.substr(0, Str.size() - Suffix.size());
     }
   }
   return Str;
 }
 
-StringRef MakeCanonicalName(StringRef Str, IncludeSorter::IncludeStyle Style) {
+StringRef makeCanonicalName(StringRef Str, IncludeSorter::IncludeStyle Style) {
   // The list of suffixes to remove from source file names to get the
   // "canonical" file names.
   // E.g. tools/sort_includes.cc and tools/sort_includes_test.cc
   // would both canonicalize to tools/sort_includes and tools/sort_includes.h
   // (once canonicalized) will match as being the main include file associated
   // with the source files.
   if (Style == IncludeSorter::IS_LLVM) {
-    return RemoveFirstSuffix(
-        RemoveFirstSuffix(Str, {".cc", ".cpp", ".c", ".h", ".hpp"}), {"Test"});
+    return removeFirstSuffix(
+        removeFirstSuffix(Str, {".cc", ".cpp", ".c", ".h", ".hpp"}), {"Test"});
   }
   if (Style == IncludeSorter::IS_Google_ObjC) {
     StringRef Canonical =
-        RemoveFirstSuffix(RemoveFirstSuffix(Str, {".cc", ".cpp", ".c", ".h",
+        removeFirstSuffix(removeFirstSuffix(Str, {".cc", ".cpp", ".c", ".h",
                                                   ".hpp", ".mm", ".m"}),
                           {"_unittest", "_regtest", "_test", "Test"});
 
     // Objective-C categories have a `+suffix` format, but should be grouped
     // with the file they are a category of.
     size_t StartIndex = Canonical.find_last_of('/');
     if (StartIndex == StringRef::npos) {
       StartIndex = 0;
     }
     return Canonical.substr(
         0, Canonical.find_first_of('+', StartIndex));
   }
-  return RemoveFirstSuffix(
-      RemoveFirstSuffix(Str, {".cc", ".cpp", ".c", ".h", ".hpp"}),
+  return removeFirstSuffix(
+      removeFirstSuffix(Str, {".cc", ".cpp", ".c", ".h", ".hpp"}),
       {"_unittest", "_regtest", "_test"});
 }
 
 // Scan to the end of the line and return the offset of the next line.
-size_t FindNextLine(const char *Text) {
+size_t findNextLine(const char *Text) {
   size_t EOLIndex = std::strcspn(Text, "\n");
   return Text[EOLIndex] == '\0' ? EOLIndex : EOLIndex + 1;
 }
 
 IncludeSorter::IncludeKinds
-DetermineIncludeKind(StringRef CanonicalFile, StringRef IncludeFile,
+determineIncludeKind(StringRef CanonicalFile, StringRef IncludeFile,
                      bool IsAngled, IncludeSorter::IncludeStyle Style) {
   // Compute the two "canonical" forms of the include's filename sans extension.
   // The first form is the include's filename without ".h" or "-inl.h" at the
   // end. The second form is the first form with "/public/" in the file path
   // replaced by "/internal/".
   if (IsAngled) {
     // If the system include (<foo>) ends with ".h", then it is a normal C-style
     // include. Otherwise assume it is a C++-style extensionless include.
     return IncludeFile.endswith(".h") ? IncludeSorter::IK_CSystemInclude
                                       : IncludeSorter::IK_CXXSystemInclude;
   }
-  StringRef CanonicalInclude = MakeCanonicalName(IncludeFile, Style);
+  StringRef CanonicalInclude = makeCanonicalName(IncludeFile, Style);
   if (CanonicalFile.endswith(CanonicalInclude)
       || CanonicalInclude.endswith(CanonicalFile)) {
     return IncludeSorter::IK_MainTUInclude;
   }
   if ((Style == IncludeSorter::IS_Google) ||
       (Style == IncludeSorter::IS_Google_ObjC)) {
     std::pair<StringRef, StringRef> Parts = CanonicalInclude.split("/public/");
     std::string AltCanonicalInclude =

 }
 
 } // namespace
 
 IncludeSorter::IncludeSorter(const SourceManager *SourceMgr,
                              const FileID FileID, StringRef FileName,
                              IncludeStyle Style)
     : SourceMgr(SourceMgr), Style(Style), CurrentFileID(FileID),
-      CanonicalFile(MakeCanonicalName(FileName, Style)) {}
+      CanonicalFile(makeCanonicalName(FileName, Style)) {}
 
 void IncludeSorter::AddInclude(StringRef FileName, bool IsAngled,
                                SourceLocation HashLocation,
                                SourceLocation EndLocation) {
-  int Offset = FindNextLine(SourceMgr->getCharacterData(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);
+      determineIncludeKind(CanonicalFile, FileName, IsAngled, Style);
   if (Kind != IK_InvalidInclude)
     IncludeBucket[Kind].push_back(FileName.str());
 }
 
 Optional<FixItHint> IncludeSorter::CreateIncludeInsertion(StringRef FileName,
                                                           bool IsAngled) {
   std::string IncludeStmt;
   if (Style == IncludeStyle::IS_Google_ObjC) {
if (SourceLocations.empty()) {
     // If there are no includes in this file, add it in the first line.
     // FIXME: insert after the file comment or the header guard, if present.
     IncludeStmt.append("\n");
     return FixItHint::CreateInsertion(
         SourceMgr->getLocForStartOfFile(CurrentFileID), IncludeStmt);
   }
 
   auto IncludeKind =
-      DetermineIncludeKind(CanonicalFile, FileName, IsAngled, Style);
+      determineIncludeKind(CanonicalFile, FileName, IsAngled, Style);
 
   if (!IncludeBucket[IncludeKind].empty()) {
     for (const std::string &IncludeEntry : IncludeBucket[IncludeKind]) {
       if (compareHeaders(FileName, IncludeEntry, Style) < 0) {
         const auto &Location = IncludeLocations[IncludeEntry][0];
         return FixItHint::CreateInsertion(Location.getBegin(), IncludeStmt);
-      } else if (FileName == IncludeEntry) {
+      }
+      if (FileName == IncludeEntry) {
         return llvm::None;
       }
     }
     // FileName comes after all include entries in bucket, insert it after
     // last.
     const std::string &LastInclude = IncludeBucket[IncludeKind].back();
     SourceRange LastIncludeLocation = IncludeLocations[LastInclude].back();
     return FixItHint::CreateInsertion(LastIncludeLocation.getEnd(),
                                       IncludeStmt);
   }
   // Find the non-empty include bucket to be sorted directly above
   // 'IncludeKind'. If such a bucket exists, we'll want to sort the include
   // after that bucket. If no such bucket exists, find the first non-empty
   // include bucket in the file. In that case, we'll want to sort the include
   // before that bucket.
   IncludeKinds NonEmptyKind = IK_InvalidInclude;
-  for (int i = IK_InvalidInclude - 1; i >= 0; --i) {
-    if (!IncludeBucket[i].empty()) {
-      NonEmptyKind = static_cast<IncludeKinds>(i);
+  for (int I = IK_InvalidInclude - 1; I >= 0; --I) {
+    if (!IncludeBucket[I].empty()) {
+      NonEmptyKind = static_cast<IncludeKinds>(I);
       if (NonEmptyKind < IncludeKind)
         break;
     }
   }
   if (NonEmptyKind == IK_InvalidInclude) {
     return llvm::None;
   }