[clang-tidy] Cleaning up language options.

[xazax.hun]

Summary

In some cases do not register the matcher when the check method of a checker should not run anyways.

Refactor some checks to use a shorter way to get language options.

[Eugene.Zelenko]

I think will be good idea to enable modernize-loop-convert, modernize-use-auto, modernize-use-default, modernize-use-nullptr only in C++11 mode.

Probably modernize-avoid-bind code code be simplified too.

[xazax.hun]

In D24881#551487, @Eugene.Zelenko wrote:

I think will be good idea to enable modernize-loop-convert, modernize-use-auto, modernize-use-default, modernize-use-nullptr only in C++11 mode.

Probably modernize-avoid-bind code code be simplified too.

As far as I can see there is a discrepancy between these modernization checks. Loop convert, use auto, use default, use nullptr is registered for older standards deliberately.

See the following comment:

// Only register the matchers for C++. Because this checker is used for
// modernization, it is reasonable to run it on any C++ standard with the
// assumption the user is trying to modernize their codebase.

So basically the question is: should we require the users to run the clang tidy in C++11 mode (hence change their build settings) to get these modernization checks?

I am okay with either of the answers but I wonder what do you think.

[Eugene.Zelenko]

I think it's reasonable to compile code in C++11 with minimal changes (only modernize-replace-auto-ptr is really needed) and test it before further modernization.

[alexfh]

Thank you for the cleanup! Please clang-format-diff the files before submitting. Otherwise looks good.

clang-tidy/cert/StrToNumCheck.cpp

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, Result.Context->getLangOpts(),
+    Conversion = ClassifyFormatString(FmtStr, getLangOpts(),
                                       Result.Context->getTargetInfo());
     if (Conversion != ConversionKind::None)
       FuncDecl = FFD;
   }
 
   if (!FuncDecl)
     return;
 

clang-tidy/cppcoreguidelines/ProTypeCstyleCastCheck.cpp

if (MatchedCast->getCastKind() == CK_BaseToDerived) {
     if (SourceDecl->isPolymorphic()) {
       // Leave type spelling exactly as it was (unlike
       // 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, Result.Context->getLangOpts());
+          *Result.SourceManager, getLangOpts());
 
       auto diag_builder = diag(
           MatchedCast->getLocStart(),
           "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(
             Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
                                        *Result.SourceManager,
-                                       Result.Context->getLangOpts()),
+                                       getLangOpts()),
             ")");
       }
       auto ParenRange = CharSourceRange::getTokenRange(
           MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
       diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
     } else {
       diag(
           MatchedCast->getLocStart(),

clang-tidy/google/AvoidCStyleCastsCheck.cpp

void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   if (SourceType == DestType) {
     diag(CastExpr->getLocStart(),
          "possibly redundant cast between typedefs of the same type");
     return;
   }
 
 
   // The rest of this check is only relevant to C++.
-  if (!Result.Context->getLangOpts().CPlusPlus)
+  if (!getLangOpts().CPlusPlus)
     return;
   // Ignore code inside extern "C" {} blocks.
   if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context)
            .empty())
     return;
   // Ignore code in .c files and headers included from them, even if they are
   // compiled as C++.
   if (getCurrentMainFile().endswith(".c"))
     return;
   // Ignore code in .c files #included in other files (which shouldn't be done,
   // but people still do this for test and other purposes).
   SourceManager &SM = *Result.SourceManager;
   if (SM.getFilename(SM.getSpellingLoc(CastExpr->getLocStart())).endswith(".c"))
     return;
 
   // Leave type spelling exactly as it was (unlike
   // getTypeAsWritten().getAsString() which would spell enum types 'enum X').
   StringRef DestTypeString =
       Lexer::getSourceText(CharSourceRange::getTokenRange(
                                CastExpr->getLParenLoc().getLocWithOffset(1),
                                CastExpr->getRParenLoc().getLocWithOffset(-1)),
-                           SM, Result.Context->getLangOpts());
+                           SM, getLangOpts());
 
   auto diag_builder =
       diag(CastExpr->getLocStart(), "C-style casts are discouraged; use %0");
 
   auto ReplaceWithCast = [&](StringRef CastType) {
     diag_builder << CastType;
 
     const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
     std::string CastText = (CastType + "<" + DestTypeString + ">").str();
     if (!isa<ParenExpr>(SubExpr)) {
       CastText.push_back('(');
       diag_builder << FixItHint::CreateInsertion(
           Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM,
-                                     Result.Context->getLangOpts()),
+                                     getLangOpts()),
           ")");
     }
     diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
   };
 
   // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
   switch (CastExpr->getCastKind()) {
   case CK_NoOp:

clang-tidy/google/ExplicitConstructorCheck.cpp

bool takesInitializerList = isStdInitializerList(
       Ctor->getParamDecl(0)->getType().getNonReferenceType());
   if (Ctor->isExplicit() &&
       (Ctor->isCopyOrMoveConstructor() || takesInitializerList)) {
     auto isKWExplicit = [](const Token &Tok) {
       return Tok.is(tok::raw_identifier) &&
              Tok.getRawIdentifier() == "explicit";
     };
     SourceRange ExplicitTokenRange =
-        FindToken(*Result.SourceManager, Result.Context->getLangOpts(),
+        FindToken(*Result.SourceManager, getLangOpts(),
                   Ctor->getOuterLocStart(), Ctor->getLocEnd(), isKWExplicit);
     StringRef ConstructorDescription;
     if (Ctor->isMoveConstructor())
       ConstructorDescription = "move";
     else if (Ctor->isCopyConstructor())
       ConstructorDescription = "copy";
     else
       ConstructorDescription = "initializer-list";

clang-tidy/llvm/TwineLocalCheck.cpp

if (VD->hasInit()) {
     SourceRange TypeRange =
         VD->getTypeSourceInfo()->getTypeLoc().getSourceRange();
 
     // A real Twine, turn it into a std::string.
     if (VD->getType()->getCanonicalTypeUnqualified() ==
         C->getType()->getCanonicalTypeUnqualified()) {
       SourceLocation EndLoc = Lexer::getLocForEndOfToken(
           VD->getInit()->getLocEnd(), 0, *Result.SourceManager,
-          Result.Context->getLangOpts());
+          getLangOpts());
       Diag << FixItHint::CreateReplacement(TypeRange, "std::string")
            << FixItHint::CreateInsertion(VD->getInit()->getLocStart(), "(")
            << FixItHint::CreateInsertion(EndLoc, ").str()");
     } else {
       // Just an implicit conversion. Insert the real type.
       Diag << FixItHint::CreateReplacement(
           TypeRange,
           C->getType().getAsString(Result.Context->getPrintingPolicy()));
     }
   }
 }
 
 } // namespace llvm
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/AssertSideEffectCheck.cpp

Finder->addMatcher(
                                   hasOperatorName("!"),
                                   hasUnaryOperand(DescendantWithSideEffect))))))
           .bind("condStmt"),
       this);
 }
 
 void AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
-  const LangOptions LangOpts = Result.Context->getLangOpts();
+  const LangOptions LangOpts = getLangOpts();
   SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getLocStart();
 
   StringRef AssertMacroName;
   while (Loc.isValid() && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroName(Loc, SM, LangOpts);
 
     // Check if this macro is an assert.
     if (std::find(AssertMacros.begin(), AssertMacros.end(), MacroName) !=

clang-tidy/misc/InaccurateEraseCheck.cpp

void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
   const SourceLocation Loc = MemberCall->getLocStart();
 
   FixItHint Hint;
 
   if (!Loc.isMacroID() && EndExpr) {
     const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("InaccAlgCall");
     std::string ReplacementText = Lexer::getSourceText(
         CharSourceRange::getTokenRange(EndExpr->getSourceRange()),
-        *Result.SourceManager, Result.Context->getLangOpts());
+        *Result.SourceManager, getLangOpts());
     const SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         AlgCall->getLocEnd(), 0, *Result.SourceManager,
-        Result.Context->getLangOpts());
+        getLangOpts());
     Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText);
   }
 
   diag(Loc, "this call will remove at most one item even when multiple items "
             "should be removed")
       << Hint;
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/InefficientAlgorithmCheck.cpp

void InefficientAlgorithmCheck::check(const MatchFinder::MatchResult &Result) {
   if (Unordered && AlgDecl->getName().find("bound") != llvm::StringRef::npos)
     return;
 
   const auto *AlgParam = Result.Nodes.getNodeAs<Expr>("AlgParam");
   const auto *IneffContExpr = Result.Nodes.getNodeAs<Expr>("IneffContExpr");
   FixItHint Hint;
 
   SourceManager &SM = *Result.SourceManager;
-  LangOptions LangOpts = Result.Context->getLangOpts();
+  LangOptions LangOpts = getLangOpts();
 
   CharSourceRange CallRange =
       CharSourceRange::getTokenRange(AlgCall->getSourceRange());
 
   // FIXME: Create a common utility to extract a file range that the given token
   // sequence is exactly spelled at (without macro argument expansions etc.).
   // We can't use Lexer::makeFileCharRange here, because for
   //

clang-tidy/misc/StringIntegerAssignmentCheck.cpp

void StringIntegerAssignmentCheck::check(
   bool IsLiteral = false;
   if (const auto *Literal = dyn_cast<IntegerLiteral>(Argument)) {
     IsOneDigit = Literal->getValue().getLimitedValue() < 10;
     IsLiteral = true;
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(
       Argument->getLocEnd(), 0, *Result.SourceManager,
-      Result.Context->getLangOpts());
+      getLangOpts());
   if (IsOneDigit) {
     Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "L'" : "'")
          << FixItHint::CreateInsertion(EndLoc, "'");
     return;
   }
   if (IsLiteral) {
     Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "L\"" : "\"")
          << FixItHint::CreateInsertion(EndLoc, "\"");

clang-tidy/misc/SuspiciousStringCompareCheck.cpp

void SuspiciousStringCompareCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("decl");
   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
   assert(Decl != nullptr && Call != nullptr);
 
   if (Result.Nodes.getNodeAs<Stmt>("missing-comparison")) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
-        Result.Context->getLangOpts());
+        getLangOpts());
 
     diag(Call->getLocStart(),
          "function %0 is called without explicitly comparing result")
         << Decl << FixItHint::CreateInsertion(EndLoc, " != 0");
   }
 
   if (const auto *E = Result.Nodes.getNodeAs<Expr>("logical-not-comparison")) {
     SourceLocation EndLoc = Lexer::getLocForEndOfToken(
         Call->getRParenLoc(), 0, Result.Context->getSourceManager(),
-        Result.Context->getLangOpts());
+        getLangOpts());
     SourceLocation NotLoc = E->getLocStart();
 
     diag(Call->getLocStart(),
          "function %0 is compared using logical not operator")
         << Decl << FixItHint::CreateRemoval(
                        CharSourceRange::getTokenRange(NotLoc, NotLoc))
         << FixItHint::CreateInsertion(EndLoc, " == 0");
   }

clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

const auto *ReleaseMember =
       Result.Nodes.getNodeAs<MemberExpr>("release_member");
   const auto *Right = Result.Nodes.getNodeAs<Expr>("right");
   const auto *Left = Result.Nodes.getNodeAs<Expr>("left");
   const auto *ResetCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("reset_call");
 
   std::string LeftText = clang::Lexer::getSourceText(
       CharSourceRange::getTokenRange(Left->getSourceRange()),
-      *Result.SourceManager, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
   std::string RightText = clang::Lexer::getSourceText(
       CharSourceRange::getTokenRange(Right->getSourceRange()),
-      *Result.SourceManager, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
 
   if (ResetMember->isArrow())
     LeftText = "*" + LeftText;
   if (ReleaseMember->isArrow())
     RightText = "*" + RightText;
   std::string DiagText;
   // Even if x was rvalue, *x is not rvalue anymore.
   if (!Right->isRValue() || ReleaseMember->isArrow()) {

clang-tidy/misc/UnusedAliasDeclsCheck.cpp

 }
 
 void UnusedAliasDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *AliasDecl = Result.Nodes.getNodeAs<NamedDecl>("alias")) {
     FoundDecls[AliasDecl] = CharSourceRange::getCharRange(
         AliasDecl->getLocStart(),
         Lexer::findLocationAfterToken(
             AliasDecl->getLocEnd(), tok::semi, *Result.SourceManager,
-            Result.Context->getLangOpts(),
+            getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     return;
   }
 
   if (const auto *NestedName =
           Result.Nodes.getNodeAs<NestedNameSpecifier>("nns")) {
     if (const auto *AliasDecl = NestedName->getAsNamespaceAlias()) {
       FoundDecls[AliasDecl] = CharSourceRange();

clang-tidy/misc/UnusedRAIICheck.cpp

void UnusedRAIICheck::check(const MatchFinder::MatchResult &Result) {
   // Otherwise just suggest adding a name. To find the place to insert the name
   // find the first TypeLoc in the children of E, which always points to the
   // written type.
   auto Matches =
       match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context);
   const auto *TL = selectFirst<TypeLoc>("t", Matches);
   D << FixItHint::CreateInsertion(
       Lexer::getLocForEndOfToken(TL->getLocEnd(), 0, *Result.SourceManager,
-                                 Result.Context->getLangOpts()),
+                                 getLangOpts()),
       Replacement);
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     if (isa<FunctionDecl>(Using->getDeclContext()))
       return;
 
     UsingDeclContext Context(Using);
     Context.UsingDeclRange = CharSourceRange::getCharRange(
         Using->getLocStart(),
         Lexer::findLocationAfterToken(
             Using->getLocEnd(), tok::semi, *Result.SourceManager,
-            Result.Context->getLangOpts(),
+            getLangOpts(),
             /*SkipTrailingWhitespaceAndNewLine=*/true));
     for (const auto *UsingShadow : Using->shadows()) {
       const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
       if (ShouldCheckDecl(TargetDecl))
         Context.UsingTargetDecls.insert(TargetDecl);
     }
     if (!Context.UsingTargetDecls.empty())
       Contexts.push_back(Context);

clang-tidy/modernize/PassByValueCheck.cpp

if (RefTL.isNull())
       continue;
 
     TypeLoc ValueTL = RefTL.getPointeeLoc();
     auto TypeRange = CharSourceRange::getTokenRange(ParmDecl->getLocStart(),
                                                     ParamTL.getLocEnd());
     std::string ValueStr =
         Lexer::getSourceText(
             CharSourceRange::getTokenRange(ValueTL.getSourceRange()), SM,
-            Result.Context->getLangOpts())
+            getLangOpts())
             .str();
     ValueStr += ' ';
     Diag << FixItHint::CreateReplacement(TypeRange, ValueStr);
   }
 
   // Use std::move in the initialization list.
   Diag << FixItHint::CreateInsertion(Initializer->getRParenLoc(), ")")
        << FixItHint::CreateInsertion(

clang-tidy/modernize/RawStringLiteralCheck.cpp

RawStringLiteralCheck::RawStringLiteralCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       DelimiterStem(Options.get("DelimiterStem", "lit")) {}
 
 void RawStringLiteralCheck::storeOptions(ClangTidyOptions::OptionMap &Options) {
   ClangTidyCheck::storeOptions(Options);
 }
 
 void RawStringLiteralCheck::registerMatchers(MatchFinder *Finder) {
+  // Raw string literals require C++11 or later.
+  if (!getLangOpts().CPlusPlus11)
+    return;
+
   Finder->addMatcher(
       stringLiteral(unless(hasParent(predefinedExpr()))).bind("lit"), this);
 }
 
 void RawStringLiteralCheck::check(const MatchFinder::MatchResult &Result) {
-  // Raw string literals require C++11 or later.
-  if (!Result.Context->getLangOpts().CPlusPlus11)
-    return;
-
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("lit");
   if (Literal->getLocStart().isMacroID())
     return;
 
   if (containsEscapedCharacters(Result, Literal))
     replaceWithRawStringLiteral(Result, Literal);
 }
 
 void RawStringLiteralCheck::replaceWithRawStringLiteral(
     const MatchFinder::MatchResult &Result, const StringLiteral *Literal) {
   CharSourceRange CharRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Literal->getSourceRange()),
-      *Result.SourceManager, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
   diag(Literal->getLocStart(),
        "escaped string literal can be written as a raw string literal")
       << FixItHint::CreateReplacement(
           CharRange, asRawStringLiteral(Literal, DelimiterStem));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tidy/modernize/RedundantVoidArgCheck.cpp

 const char NamedCastId[] = "named-cast";
 const char CStyleCastId[] = "c-style-cast";
 const char ExplicitCastId[] = "explicit-cast";
 const char LambdaId[] = "lambda";
 
 } // namespace
 
 void RedundantVoidArgCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
   Finder->addMatcher(functionDecl(parameterCountIs(0), unless(isImplicit()),
                                   unless(isExternC()))
                          .bind(FunctionId),
                      this);
   Finder->addMatcher(typedefNameDecl().bind(TypedefId), this);
   auto ParenFunctionType = parenType(innerType(functionType()));
   auto PointerToFunctionType = pointee(ParenFunctionType);
   auto FunctionOrMemberPointer =
Finder->addMatcher(
       cxxReinterpretCastExpr(CastDestinationIsFunction).bind(NamedCastId),
       this);
   Finder->addMatcher(
       cxxConstCastExpr(CastDestinationIsFunction).bind(NamedCastId), this);
   Finder->addMatcher(lambdaExpr().bind(LambdaId), this);
 }
 
 void RedundantVoidArgCheck::check(const MatchFinder::MatchResult &Result) {
-  if (!Result.Context->getLangOpts().CPlusPlus) {
-    return;
-  }
-
   const BoundNodes &Nodes = Result.Nodes;
   if (const auto *Function = Nodes.getNodeAs<FunctionDecl>(FunctionId)) {
     processFunctionDecl(Result, Function);
   } else if (const auto *TypedefName =
                  Nodes.getNodeAs<TypedefNameDecl>(TypedefId)) {
     processTypedefNameDecl(Result, TypedefName);
   } else if (const auto *Member = Nodes.getNodeAs<FieldDecl>(FieldId)) {
     processFieldDecl(Result, Member);
void RedundantVoidArgCheck::processFunctionDecl(
   }
 }
 
 void RedundantVoidArgCheck::removeVoidArgumentTokens(
     const ast_matchers::MatchFinder::MatchResult &Result, SourceRange Range,
     StringRef GrammarLocation) {
   CharSourceRange CharRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Range), *Result.SourceManager,
-      Result.Context->getLangOpts());
+      getLangOpts());
 
   std::string DeclText = Lexer::getSourceText(CharRange, *Result.SourceManager,
-                                              Result.Context->getLangOpts())
+                                              getLangOpts())
                              .str();
-  Lexer PrototypeLexer(CharRange.getBegin(), Result.Context->getLangOpts(),
+  Lexer PrototypeLexer(CharRange.getBegin(), getLangOpts(),
                        DeclText.data(), DeclText.data(),
                        DeclText.data() + DeclText.size());
   enum TokenState {
     NothingYet,
     SawLeftParen,
     SawVoid,
   };
   TokenState State = NothingYet;

clang-tidy/modernize/ShrinkToFitCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus11)
+    return;
+
   // Swap as a function need not to be considered, because rvalue can not
   // be bound to a non-const reference.
   const auto ShrinkableAsMember =
       memberExpr(member(valueDecl().bind("ContainerDecl")));
   const auto ShrinkableAsDecl =
       declRefExpr(hasDeclaration(valueDecl().bind("ContainerDecl")));
   const auto CopyCtorCall = cxxConstructExpr(hasArgument(
       0, anyOf(ShrinkableAsMember, ShrinkableAsDecl,
Finder->addMatcher(
           has(ignoringParenImpCasts(memberExpr(hasDescendant(CopyCtorCall)))),
           hasArgument(0, SwapParam.bind("ContainerToShrink")),
           unless(isInTemplateInstantiation()))
           .bind("CopyAndSwapTrick"),
       this);
 }
 
 void ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
-  const LangOptions &Opts = Result.Context->getLangOpts();
-
-  if (!Opts.CPlusPlus11)
-    return;
-
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("CopyAndSwapTrick");
   const auto *Container = Result.Nodes.getNodeAs<Expr>("ContainerToShrink");
   FixItHint Hint;
 
   if (!MemberCall->getLocStart().isMacroID()) {
+    const LangOptions &Opts = getLangOpts();
     std::string ReplacementText;
     if (const auto *UnaryOp = llvm::dyn_cast<UnaryOperator>(Container)) {
       ReplacementText =
           Lexer::getSourceText(CharSourceRange::getTokenRange(
                                    UnaryOp->getSubExpr()->getSourceRange()),
                                *Result.SourceManager, Opts);
       ReplacementText += "->shrink_to_fit()";
     } else {

clang-tidy/modernize/UseOverrideCheck.cpp

Message = (llvm::Twine(Redundant) +
                " redundant since the function is already declared " + Correct)
                   .str();
   }
 
   DiagnosticBuilder Diag = diag(Method->getLocation(), Message);
 
   CharSourceRange FileRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Method->getSourceRange()), Sources,
-      Result.Context->getLangOpts());
+      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);

clang-tidy/mpi/TypeMismatchCheck.cpp

if (FuncClassifier.isReduceType(Identifier)) {
                FuncClassifier.isAlltoallType(Identifier)) {
       addPair(0, 2);
       addPair(3, 5);
     } else if (FuncClassifier.isBcastType(Identifier)) {
       addPair(0, 2);
     }
   }
   checkArguments(BufferTypes, BufferExprs, MPIDatatypes,
-                 Result.Context->getLangOpts());
+                 getLangOpts());
 }
 
 void TypeMismatchCheck::checkArguments(ArrayRef<const Type *> BufferTypes,
                                        ArrayRef<const Expr *> BufferExprs,
                                        ArrayRef<StringRef> MPIDatatypes,
                                        const LangOptions &LO) {
   std::string BufferTypeName;
 

clang-tidy/readability/AvoidConstParamsInDecls.cpp

void AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
   if (Param->getLocStart().isMacroID() != Param->getLocEnd().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, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
 
   if (!FileRange.isValid())
     return;
 
   auto Tok = ConstTok(FileRange, Result);
   if (!Tok)
     return;
   Diag << FixItHint::CreateRemoval(
       CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation()));
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/ContainerSizeEmptyCheck.cpp

 void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("SizeCallExpr");
   const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("SizeBinaryOp");
   const auto *E = Result.Nodes.getNodeAs<Expr>("STLObject");
   FixItHint Hint;
   std::string ReplacementText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(E->getSourceRange()),
-      *Result.SourceManager, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
   if (E->getType()->isPointerType())
     ReplacementText += "->empty()";
   else
     ReplacementText += ".empty()";
 
   if (BinaryOp) { // Determine the correct transformation.
     bool Negation = false;
     const bool ContainerIsLHS =

clang-tidy/readability/NamespaceCommentCheck.cpp

void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
   if (EndLine - StartLine + 1 <= ShortNamespaceLines)
     return;
 
   // Find next token after the namespace closing brace.
   SourceLocation AfterRBrace = ND->getRBraceLoc().getLocWithOffset(1);
   SourceLocation Loc = AfterRBrace;
   Token Tok;
   // Skip whitespace until we find the next token.
-  while (Lexer::getRawToken(Loc, Tok, Sources, Result.Context->getLangOpts()) ||
+  while (Lexer::getRawToken(Loc, Tok, Sources, getLangOpts()) ||
          Tok.is(tok::semi)) {
     Loc = Loc.getLocWithOffset(1);
   }
   if (!locationsInSameFile(Sources, ND->getRBraceLoc(), Loc))
     return;
 
   bool NextTokenIsOnSameLine = Sources.getSpellingLineNumber(Loc) == EndLine;
   // If we insert a line comment before the token in the same line, we need

clang-tidy/readability/RedundantControlFlowCheck.cpp

void RedundantControlFlowCheck::issueDiagnostic(
   if (isLocationInMacroExpansion(SM, StmtRange.getBegin()))
     return;
 
   CompoundStmt::const_reverse_body_iterator Previous = ++Block->body_rbegin();
   SourceLocation Start;
   if (Previous != Block->body_rend())
     Start = Lexer::findLocationAfterToken(
         dyn_cast<Stmt>(*Previous)->getLocEnd(), tok::semi, SM,
-        Result.Context->getLangOpts(),
+        getLangOpts(),
         /*SkipTrailingWhitespaceAndNewLine=*/true);
   if (!Start.isValid())
     Start = StmtRange.getBegin();
   auto RemovedRange = CharSourceRange::getCharRange(
       Start,
       Lexer::findLocationAfterToken(StmtRange.getEnd(), tok::semi, SM,
-                                    Result.Context->getLangOpts(),
+                                    getLangOpts(),
                                     /*SkipTrailingWhitespaceAndNewLine=*/true));
 
   diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/RedundantSmartptrGetCheck.cpp

void RedundantSmartptrGetCheck::check(const MatchFinder::MatchResult &Result) {
 
   if (IsPtrToPtr && IsMemberExpr) {
     // Ignore this case (eg. Foo->get()->DoSomething());
     return;
   }
 
   StringRef SmartptrText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(Smartptr->getSourceRange()),
-      *Result.SourceManager, Result.Context->getLangOpts());
+      *Result.SourceManager, getLangOpts());
   // Replace foo->get() with *foo, and foo.get() with foo.
   std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str();
   diag(GetCall->getLocStart(), "redundant get() call on smart pointer")
       << FixItHint::CreateReplacement(GetCall->getSourceRange(), Replacement);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/SimplifyBooleanExprCheck.cpp

 }
 
 void SimplifyBooleanExprCheck::issueDiag(
     const ast_matchers::MatchFinder::MatchResult &Result, SourceLocation Loc,
     StringRef Description, SourceRange ReplacementRange,
     StringRef Replacement) {
   CharSourceRange CharRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(ReplacementRange), *Result.SourceManager,
-      Result.Context->getLangOpts());
+      getLangOpts());
 
   DiagnosticBuilder Diag = diag(Loc, Description);
   if (!containsDiscardedTokens(Result, CharRange))
     Diag << FixItHint::CreateReplacement(CharRange, Replacement);
 }
 
 void SimplifyBooleanExprCheck::replaceWithExpression(
     const ast_matchers::MatchFinder::MatchResult &Result,

clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.cpp

void StaticDefinitionInAnonymousNamespaceCheck::check(
   auto Diag =
       diag(Def->getLocation(), "%0 is a static definition in "
                                "anonymous namespace; static is redundant here")
       << Def;
   Token Tok;
   SourceLocation Loc = Def->getSourceRange().getBegin();
   while (Loc < Def->getSourceRange().getEnd() &&
          !Lexer::getRawToken(Loc, Tok, *Result.SourceManager,
-                             Result.Context->getLangOpts(), true)) {
+                             getLangOpts(), true)) {
     SourceRange TokenRange(Tok.getLocation(), Tok.getEndLoc());
     StringRef SourceText = Lexer::getSourceText(
         CharSourceRange::getTokenRange(TokenRange),
-        *Result.SourceManager, Result.Context->getLangOpts());
+        *Result.SourceManager, getLangOpts());
     if (SourceText == "static") {
       Diag << FixItHint::CreateRemoval(TokenRange);
       break;
     }
     Loc = Tok.getEndLoc();
   }
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

void UniqueptrDeleteReleaseCheck::check(
   // Ignore dependent types.
   // It can give us false positives, so we go with false negatives instead to
   // be safe.
   if (PtrExpr->getType()->isDependentType())
     return;
 
   SourceLocation AfterPtr =
       Lexer::getLocForEndOfToken(PtrExpr->getLocEnd(), 0, *Result.SourceManager,
-                                 Result.Context->getLangOpts());
+                                 getLangOpts());
 
   diag(DeleteExpr->getLocStart(),
        "prefer '= nullptr' to 'delete x.release()' to reset unique_ptr<> "
        "objects")
       << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
              DeleteExpr->getLocStart(), PtrExpr->getLocStart()))
       << FixItHint::CreateReplacement(
              CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
              " = nullptr");
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang