[clangd] proof-of-concept: clang-tidy only runs over main-file

[sammccall]

Summary

based on D54259, with API updates to make everything build again.

Not ready for review, probably won't become ready in this explicit form.

clang-query/Query.cpp

if (QS.BindRoot) {
       if (M)
         MaybeBoundMatcher = *M;
     }
     CollectBoundNodes Collect(Matches);
     if (!Finder.addDynamicMatcher(MaybeBoundMatcher, &Collect)) {
       OS << "Not a valid top-level matcher.\n";
       return false;
     }
-    Finder.matchAST(AST->getASTContext());
+    Finder.matchAST(AST->getASTContext(), AST->getASTContext().fullBounds());
 
     if (QS.PrintMatcher) {
       std::string prefixText = "Matcher: ";
       OS << "\n  " << prefixText << Source << "\n";
       OS << "  " << std::string(prefixText.size() + Source.size(), '=') << '\n';
     }
 
     for (auto MI = Matches.begin(), ME = Matches.end(); MI != ME; ++MI) {

clang-reorder-fields/ReorderFieldsAction.cpp

 
 /// \brief Finds the definition of a record by name.
 ///
 /// \returns nullptr if the name is ambiguous or not found.
 static const RecordDecl *findDefinition(StringRef RecordName,
                                         ASTContext &Context) {
   auto Results =
       match(recordDecl(hasName(RecordName), isDefinition()).bind("recordDecl"),
-            Context);
+            Context, Context.fullBounds());
   if (Results.empty()) {
     llvm::errs() << "Definition of " << RecordName << "  not found\n";
     return nullptr;
   }
   if (Results.size() > 1) {
     llvm::errs() << "The name " << RecordName
                  << " is ambiguous, several definitions found\n";
     return nullptr;
findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer,
                           ASTContext &Context) {
   SmallSetVector<FieldDecl *, 1> Results;
   // Note that this does not pick up member fields of base classes since
   // for those accesses Sema::PerformObjectMemberConversion always inserts an
   // UncheckedDerivedToBase ImplicitCastExpr between the this expr and the
   // object expression
   auto FoundExprs =
       match(findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME")),
-            *Initializer->getInit(), Context);
+            *Initializer->getInit(), Context, Context.fullBounds());
   for (BoundNodes &BN : FoundExprs)
     if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
       if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))
         Results.insert(FD);
   return Results;
 }
 
 /// \brief Reorders fields in the definition of a struct/class.
void HandleTranslationUnit(ASTContext &Context) override {
     // We only need to reorder init list expressions for
     // plain C structs or C++ aggregate types.
     // For other types the order of constructor parameters is used,
     // which we don't change at the moment.
     // Now (v0) partial initialization is not supported.
     if (!CXXRD || CXXRD->isAggregate())
       for (auto Result :
            match(initListExpr(hasType(equalsNode(RD))).bind("initListExpr"),
-                 Context))
+                 Context, Context.fullBounds()))
         if (!reorderFieldsInInitListExpr(
                 Result.getNodeAs<InitListExpr>("initListExpr"), NewFieldsOrder,
                 Context, Replacements)) {
           Replacements.clear();
           return;
         }
   }
 };

clang-tidy/abseil/RedundantStrcatCallsCheck.cpp

 
 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>(
+  if (const auto *SubStrcatCall = selectFirst<const CallExpr>(
           "StrCat",
-          match(stmt(anyOf(
-                    cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)),
+          match(
+              stmt(anyOf(cxxConstructExpr(IsAlphanum, hasArgument(0, IsStrcat)),
                          IsStrcat)),
-                *Arg->IgnoreParenImpCasts(), *Result.Context))) {
+              *Arg->IgnoreParenImpCasts(), *Result.Context, *Result.Bounds))) {
     RemoveCallLeaveArgs(SubStrcatCall, CheckResult);
     return SubStrcatCall;
   }
   return nullptr;
 }
 
 StrCatCheckResult ProcessCall(const CallExpr* RootCall, bool IsAppend,
                               const MatchFinder::MatchResult& Result) {

clang-tidy/bugprone/BoolPointerImplicitConversionCheck.cpp

void BoolPointerImplicitConversionCheck::check(
   // Check that we don't dereference the variable anywhere within the if. This
   // avoids false positives for checks of the pointer for nullptr before it is
   // dereferenced. If there is a dereferencing operator on this variable don't
   // emit a diagnostic. Also ignore array subscripts.
   const Decl *D = Var->getDecl();
   auto DeclRef = ignoringParenImpCasts(declRefExpr(to(equalsNode(D))));
   if (!match(findAll(
                  unaryOperator(hasOperatorName("*"), hasUnaryOperand(DeclRef))),
-             *If, *Result.Context)
+             *If, *Result.Context, *Result.Bounds)
            .empty() ||
       !match(findAll(arraySubscriptExpr(hasBase(DeclRef))), *If,
-             *Result.Context)
+             *Result.Context, *Result.Bounds)
            .empty() ||
       // FIXME: We should still warn if the paremater is implicitly converted to
       // bool.
       !match(findAll(callExpr(hasAnyArgument(ignoringParenImpCasts(DeclRef)))),
-             *If, *Result.Context)
+             *If, *Result.Context, *Result.Bounds)
            .empty() ||
       !match(findAll(cxxDeleteExpr(has(ignoringParenImpCasts(expr(DeclRef))))),
-             *If, *Result.Context)
+             *If, *Result.Context, *Result.Bounds)
            .empty())
     return;
 
   diag(Var->getBeginLoc(), "dubious check of 'bool *' against 'nullptr', did "
                            "you mean to dereference it?")
       << FixItHint::CreateInsertion(Var->getBeginLoc(), "*");
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/bugprone/MultipleStatementMacroCheck.cpp

 namespace bugprone {
 
 namespace {
 
 AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); }
 
 /// \brief Find the next statement after `S`.
 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
-  auto Parents = Result.Context->getParents(*S);
+  auto Parents = Result.Context->getParents(*S, *Result.Bounds);
   if (Parents.empty())
     return nullptr;
   const auto *Parent = Parents[0].get<Stmt>();
   if (!Parent)
     return nullptr;
   const Stmt *Prev = nullptr;
   for (const Stmt *Child : Parent->children()) {
     if (Prev == S)

clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 namespace {
 
 bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
+                                     ASTContext::Bounds *Bounds,
                                      const StringLiteral *Lit) {
   // String literals surrounded by parentheses are assumed to be on purpose.
   //    i.e.:  const char* Array[] = { ("a" "b" "c"), "d", [...] };
-  auto Parents = Ctx->getParents(*Lit);
+  auto Parents = Ctx->getParents(*Lit, *Bounds);
   if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr)
     return true;
 
   // Appropriately indented string literals are assumed to be on purpose.
   // The following frequent indentation is accepted:
   //     const char* Array[] = {
   //       "first literal"
   //           "indented literal"
bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
   // There is no pattern recognized by the checker, assume it's not on purpose.
   return false;
 }
 
 AST_MATCHER_P(StringLiteral, isConcatenatedLiteral, unsigned,
               MaxConcatenatedTokens) {
   return Node.getNumConcatenated() > 1 &&
          Node.getNumConcatenated() < MaxConcatenatedTokens &&
-         !isConcatenatedLiteralsOnPurpose(&Finder->getASTContext(), &Node);
+         !isConcatenatedLiteralsOnPurpose(&Finder->getASTContext(),
+                                          &Finder->getASTBounds(), &Node);
 }
 
 } // namespace
 
 SuspiciousMissingCommaCheck::SuspiciousMissingCommaCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       SizeThreshold(Options.get("SizeThreshold", 5U)),

clang-tidy/bugprone/UnusedRaiiCheck.cpp

if (TOE->getNumArgs() == 0) {
           CharSourceRange::getTokenRange(TOE->getParenOrBraceRange()),
           Replacement);
       return;
     }
 
   // 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);
+  auto Matches = match(expr(hasDescendant(typeLoc().bind("t"))), *E,
+                       *Result.Context, *Result.Bounds);
   const auto *TL = selectFirst<TypeLoc>("t", Matches);
   D << FixItHint::CreateInsertion(
       Lexer::getLocForEndOfToken(TL->getEndLoc(), 0, *Result.SourceManager,
                                  getLangOpts()),
       Replacement);
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/bugprone/UseAfterMoveCheck.cpp

struct UseAfterMove {
   // Is the order in which the move and the use are evaluated undefined?
   bool EvaluationOrderUndefined;
 };
 
 /// Finds uses of a variable after a move (and maintains state required by the
 /// various internal helper functions).
 class UseAfterMoveFinder {
 public:
-  UseAfterMoveFinder(ASTContext *TheContext);
+  UseAfterMoveFinder(ASTContext *Context, ASTContext::Bounds *Bounds)
+      : Context(Context), Bounds(Bounds) {}
 
   // Within the given function body, finds the first use of 'MovedVariable' that
   // occurs after 'MovingCall' (the expression that performs the move). If a
   // use-after-move is found, writes information about it to 'TheUseAfterMove'.
   // Returns whether a use-after-move was found.
   bool find(Stmt *FunctionBody, const Expr *MovingCall,
             const ValueDecl *MovedVariable, UseAfterMove *TheUseAfterMove);
 
 private:
   bool findInternal(const CFGBlock *Block, const Expr *MovingCall,
                     const ValueDecl *MovedVariable,
                     UseAfterMove *TheUseAfterMove);
   void getUsesAndReinits(const CFGBlock *Block, const ValueDecl *MovedVariable,
                          llvm::SmallVectorImpl<const DeclRefExpr *> *Uses,
                          llvm::SmallPtrSetImpl<const Stmt *> *Reinits);
   void getDeclRefs(const CFGBlock *Block, const Decl *MovedVariable,
                    llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs);
   void getReinits(const CFGBlock *Block, const ValueDecl *MovedVariable,
                   llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
                   llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs);
 
   ASTContext *Context;
+  ASTContext::Bounds *Bounds;
   std::unique_ptr<ExprSequence> Sequence;
   std::unique_ptr<StmtToBlockMap> BlockMap;
   llvm::SmallPtrSet<const CFGBlock *, 8> Visited;
 };
 
 } // namespace
 
 
 // Matches nodes that are
 // - Part of a decltype argument or class template argument (we check this by
 //   seeing if they are children of a TypeLoc), or
 // - Part of a function template argument (we check this by seeing if they are
 //   children of a DeclRefExpr that references a function template).
 // DeclRefExprs that fulfill these conditions should not be counted as a use or
 // move.
 static StatementMatcher inDecltypeOrTemplateArg() {
   return anyOf(hasAncestor(typeLoc()),
                hasAncestor(declRefExpr(
                    to(functionDecl(ast_matchers::isTemplateInstantiation())))));
 }
 
-UseAfterMoveFinder::UseAfterMoveFinder(ASTContext *TheContext)
-    : Context(TheContext) {}
-
 bool UseAfterMoveFinder::find(Stmt *FunctionBody, const Expr *MovingCall,
                               const ValueDecl *MovedVariable,
                               UseAfterMove *TheUseAfterMove) {
   // Generate the CFG manually instead of through an AnalysisDeclContext because
   // it seems the latter can't be used to generate a CFG for the body of a
   // labmda.
   //
   // We include implicit and temporary destructors in the CFG so that
   // destructors marked [[noreturn]] are handled correctly in the control flow
   // analysis. (These are used in some styles of assertion macros.)
   CFG::BuildOptions Options;
   Options.AddImplicitDtors = true;
   Options.AddTemporaryDtors = true;
   std::unique_ptr<CFG> TheCFG =
       CFG::buildCFG(nullptr, FunctionBody, Context, Options);
   if (!TheCFG)
     return false;
 
-  Sequence =
-      llvm::make_unique<ExprSequence>(TheCFG.get(), FunctionBody, Context);
-  BlockMap = llvm::make_unique<StmtToBlockMap>(TheCFG.get(), Context);
+  Sequence = llvm::make_unique<ExprSequence>(TheCFG.get(), FunctionBody,
+                                             Context, Bounds);
+  BlockMap = llvm::make_unique<StmtToBlockMap>(TheCFG.get(), Context, Bounds);
   Visited.clear();
 
   const CFGBlock *Block = BlockMap->blockContainingStmt(MovingCall);
   if (!Block)
     return false;
 
   return findInternal(Block, MovingCall, MovedVariable, TheUseAfterMove);
 }
auto addDeclRefs = [this, Block,
         }
       }
     };
 
     auto DeclRefMatcher = declRefExpr(hasDeclaration(equalsNode(MovedVariable)),
                                       unless(inDecltypeOrTemplateArg()))
                               .bind("declref");
 
-    addDeclRefs(match(findAll(DeclRefMatcher), *S->getStmt(), *Context));
+    addDeclRefs(
+        match(findAll(DeclRefMatcher), *S->getStmt(), *Context, *Bounds));
     addDeclRefs(match(
         findAll(cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("*"),
                                           hasOverloadedOperatorName("->"),
                                           hasOverloadedOperatorName("[]")),
                                     hasArgument(0, DeclRefMatcher))
                     .bind("operator")),
-        *S->getStmt(), *Context));
+        *S->getStmt(), *Context, *Bounds));
   }
 }
 
 void UseAfterMoveFinder::getReinits(
     const CFGBlock *Block, const ValueDecl *MovedVariable,
     llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
     llvm::SmallPtrSetImpl<const DeclRefExpr *> *DeclRefs) {
   auto DeclRefMatcher =
void UseAfterMoveFinder::getReinits(
   Stmts->clear();
   DeclRefs->clear();
   for (const auto &Elem : *Block) {
     Optional<CFGStmt> S = Elem.getAs<CFGStmt>();
     if (!S)
       continue;
 
     SmallVector<BoundNodes, 1> Matches =
-        match(findAll(ReinitMatcher), *S->getStmt(), *Context);
+        match(findAll(ReinitMatcher), *S->getStmt(), *Context, *Bounds);
 
     for (const auto &Match : Matches) {
       const auto *TheStmt = Match.getNodeAs<Stmt>("reinit");
       const auto *TheDeclRef = Match.getNodeAs<DeclRefExpr>("declref");
       if (TheStmt && BlockMap->blockContainingStmt(TheStmt) == Block) {
         Stmts->insert(TheStmt);
 
         // We count DeclStmts as reinitializations, but they don't have a
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, Result.Bounds);
   UseAfterMove Use;
   if (finder.find(FunctionBody, MovingCall, Arg->getDecl(), &Use))
     emitDiagnostic(MovingCall, Arg, Use, this, Result.Context);
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.cpp

return stmt(hasAncestor(cxxForRangeStmt(
       .matches(Node, Finder, Builder);
 }
 
 AST_MATCHER_P(Expr, hasParentIgnoringImpCasts,
               ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
   const Expr *E = &Node;
   do {
     ASTContext::DynTypedNodeList Parents =
-        Finder->getASTContext().getParents(*E);
+        Finder->getASTContext().getParents(*E, Finder->getASTBounds());
     if (Parents.size() != 1)
       return false;
     E = Parents[0].get<Expr>();
     if (!E)
       return false;
   } while (isa<ImplicitCastExpr>(E));
 
   return InnerMatcher.matches(*E, Finder, Builder);

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.h

 private:
   // Checks Type.6 part 1:
   // Issue a diagnostic for any constructor of a non-trivially-constructible
   // type that does not initialize all member variables.
   //
   // To fix: Write a data member initializer, or mention it in the member
   // initializer list.
   void checkMissingMemberInitializer(ASTContext &Context,
+                                     ASTContext::Bounds &Bounds,
                                      const CXXRecordDecl &ClassDecl,
                                      const CXXConstructorDecl *Ctor);
 
   // A subtle side effect of Type.6 part 2:
   // Make sure to initialize trivially constructible base classes.
   void checkMissingBaseClassInitializer(const ASTContext &Context,
                                         const CXXRecordDecl &ClassDecl,
                                         const CXXConstructorDecl *Ctor);

clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

if (F->isAnonymousStructOrUnion()) {
         forEachField(*R, R->fields(), Fn);
     } else {
       Fn(F);
     }
   }
 }
 
 void removeFieldsInitializedInBody(
-    const Stmt &Stmt, ASTContext &Context,
+    const Stmt &Stmt, ASTContext &Context, ASTContext::Bounds &Bounds,
     SmallPtrSetImpl<const FieldDecl *> &FieldDecls) {
   auto Matches =
       match(findAll(binaryOperator(
                 hasOperatorName("="),
                 hasLHS(memberExpr(member(fieldDecl().bind("fieldDecl")))))),
-            Stmt, Context);
+            Stmt, Context, Bounds);
   for (const auto &Match : Matches)
     FieldDecls.erase(Match.getNodeAs<FieldDecl>("fieldDecl"));
 }
 
 StringRef getName(const FieldDecl *Field) { return Field->getName(); }
 
 StringRef getName(const RecordDecl *Record) {
   // Get the typedef name if this is a C-style anonymous struct and typedef.
Finder->addMatcher(
       this);
 }
 
 void ProTypeMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor")) {
     // Skip declarations delayed by late template parsing without a body.
     if (!Ctor->getBody())
       return;
-    checkMissingMemberInitializer(*Result.Context, *Ctor->getParent(), Ctor);
+    checkMissingMemberInitializer(*Result.Context, *Result.Bounds,
+                                  *Ctor->getParent(), Ctor);
     checkMissingBaseClassInitializer(*Result.Context, *Ctor->getParent(), Ctor);
   } else if (const auto *Record =
                  Result.Nodes.getNodeAs<CXXRecordDecl>("record")) {
     assert(Record->hasDefaultConstructor() &&
            "Matched record should have a default constructor");
-    checkMissingMemberInitializer(*Result.Context, *Record, nullptr);
+    checkMissingMemberInitializer(*Result.Context, *Result.Bounds, *Record,
+                                  nullptr);
     checkMissingBaseClassInitializer(*Result.Context, *Record, nullptr);
   } else if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var")) {
     checkUninitializedTrivialType(*Result.Context, Var);
   }
 }
 
 void ProTypeMemberInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "IgnoreArrays", IgnoreArrays);

 static bool isEmpty(ASTContext &Context, const QualType &Type) {
   if (const CXXRecordDecl *ClassDecl = Type->getAsCXXRecordDecl()) {
     return ClassDecl->isEmpty();
   }
   return isIncompleteOrZeroLengthArrayType(Context, Type);
 }
 
 void ProTypeMemberInitCheck::checkMissingMemberInitializer(
-    ASTContext &Context, const CXXRecordDecl &ClassDecl,
-    const CXXConstructorDecl *Ctor) {
+    ASTContext &Context, ASTContext::Bounds &Bounds,
+    const CXXRecordDecl &ClassDecl, const CXXConstructorDecl *Ctor) {
   bool IsUnion = ClassDecl.isUnion();
 
   if (IsUnion && ClassDecl.hasInClassInitializer())
     return;
 
   // Gather all fields (direct and indirect) that need to be initialized.
   SmallPtrSet<const FieldDecl *, 16> FieldsToInit;
   forEachField(ClassDecl, ClassDecl.fields(), [&](const FieldDecl *F) {
for (const CXXCtorInitializer *Init : Ctor->inits()) {
       // Remove any fields that were explicitly written in the initializer list
       // or in-class.
       if (Init->isAnyMemberInitializer() && Init->isWritten()) {
         if (IsUnion)
           return; // We can only initialize one member of a union.
         FieldsToInit.erase(Init->getAnyMember());
       }
     }
-    removeFieldsInitializedInBody(*Ctor->getBody(), Context, FieldsToInit);
+    removeFieldsInitializedInBody(*Ctor->getBody(), Context, Bounds,
+                                  FieldsToInit);
   }
 
   // Collect all fields in order, both direct fields and indirect fields from
   // anonmyous record types.
   SmallVector<const FieldDecl *, 16> OrderedFields;
   forEachField(ClassDecl, ClassDecl.fields(),
                [&](const FieldDecl *F) { OrderedFields.push_back(F); });
 

clang-tidy/google/AvoidCStyleCastsCheck.cpp

if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) {
     }
   }
 
   // The rest of this check is only relevant to C++.
   // We also disable it for Objective-C++.
   if (!getLangOpts().CPlusPlus || getLangOpts().ObjC)
     return;
   // Ignore code inside extern "C" {} blocks.
-  if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context)
+  if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context,
+             *Result.Bounds)
            .empty())
     return;
   // Ignore code in .c files and headers included from them, even if they are
   // compiled as C++.
   if (getCurrentMainFile().endswith(".c"))
     return;
 
   SourceManager &SM = *Result.SourceManager;

clang-tidy/modernize/LoopConvertCheck.h

struct RangeDescriptor {
     bool DerefByConstRef;
     bool DerefByValue;
     std::string ContainerString;
     QualType ElemType;
   };
 
   void getAliasRange(SourceManager &SM, SourceRange &DeclRange);
 
-  void doConversion(ASTContext *Context, const VarDecl *IndexVar,
-                    const ValueDecl *MaybeContainer, const UsageResult &Usages,
-                    const DeclStmt *AliasDecl, bool AliasUseRequired,
-                    bool AliasFromForInit, const ForStmt *Loop,
-                    RangeDescriptor Descriptor);
+  void doConversion(ASTContext *Context, ASTContext::Bounds *Bounds,
+                    const VarDecl *IndexVar, const ValueDecl *MaybeContainer,
+                    const UsageResult &Usages, const DeclStmt *AliasDecl,
+                    bool AliasUseRequired, bool AliasFromForInit,
+                    const ForStmt *Loop, RangeDescriptor Descriptor);
 
   StringRef getContainerString(ASTContext *Context, const ForStmt *Loop,
                                const Expr *ContainerExpr);
 
   void getArrayLoopQualifiers(ASTContext *Context,
+                              ASTContext::Bounds *Bounds,
                               const ast_matchers::BoundNodes &Nodes,
                               const Expr *ContainerExpr,
                               const UsageResult &Usages,
                               RangeDescriptor &Descriptor);
 
   void getIteratorLoopQualifiers(ASTContext *Context,
                                  const ast_matchers::BoundNodes &Nodes,
                                  RangeDescriptor &Descriptor);
 
-  void determineRangeDescriptor(ASTContext *Context,
+  void determineRangeDescriptor(ASTContext *Context, ASTContext::Bounds *Bounds,
                                 const ast_matchers::BoundNodes &Nodes,
                                 const ForStmt *Loop, LoopFixerKind FixerKind,
                                 const Expr *ContainerExpr,
                                 const UsageResult &Usages,
                                 RangeDescriptor &Descriptor);
 
   bool isConvertible(ASTContext *Context, const ast_matchers::BoundNodes &Nodes,
                      const ForStmt *Loop, LoopFixerKind FixerKind);

clang-tidy/modernize/LoopConvertCheck.cpp

static bool isDirectMemberExpr(const Expr *E) {
   if (const auto *Member = dyn_cast<MemberExpr>(E->IgnoreParenImpCasts()))
     return isa<CXXThisExpr>(Member->getBase()->IgnoreParenImpCasts());
   return false;
 }
 
 /// \brief Given an expression that represents an usage of an element from the
 /// containter that we are iterating over, returns false when it can be
 /// guaranteed this element cannot be modified as a result of this usage.
-static bool canBeModified(ASTContext *Context, const Expr *E) {
+static bool canBeModified(ASTContext *Context, ASTContext::Bounds *Bounds,
+                          const Expr *E) {
   if (E->getType().isConstQualified())
     return false;
-  auto Parents = Context->getParents(*E);
+  auto Parents = Context->getParents(*E, *Bounds);
   if (Parents.size() != 1)
     return true;
   if (const auto *Cast = Parents[0].get<ImplicitCastExpr>()) {
     if ((Cast->getCastKind() == CK_NoOp &&
          Cast->getType() == E->getType().withConst()) ||
         (Cast->getCastKind() == CK_LValueToRValue &&
          !Cast->getType().isNull() && Cast->getType()->isFundamentalType()))
       return false;
   }
   // FIXME: Make this function more generic.
   return true;
 }
 
 /// \brief Returns true when it can be guaranteed that the elements of the
 /// container are not being modified.
-static bool usagesAreConst(ASTContext *Context, const UsageResult &Usages) {
+static bool usagesAreConst(ASTContext *Context, ASTContext::Bounds *Bounds,
+                           const UsageResult &Usages) {
   for (const Usage &U : Usages) {
     // Lambda captures are just redeclarations (VarDecl) of the same variable,
     // not expressions. If we want to know if a variable that is captured by
     // reference can be modified in an usage inside the lambda's body, we need
     // to find the expression corresponding to that particular usage, later in
     // this loop.
     if (U.Kind != Usage::UK_CaptureByCopy && U.Kind != Usage::UK_CaptureByRef &&
-        canBeModified(Context, U.Expression))
+        canBeModified(Context, Bounds, U.Expression))
       return false;
   }
   return true;
 }
 
 /// \brief Returns true if the elements of the container are never accessed
 /// by reference.
 static bool usagesReturnRValues(const UsageResult &Usages) {
void LoopConvertCheck::getAliasRange(SourceManager &SM, SourceRange &Range) {
   unsigned Offset = std::strspn(TextAfter, " \t\r\n");
   Range =
       SourceRange(Range.getBegin(), Range.getEnd().getLocWithOffset(Offset));
 }
 
 /// \brief Computes the changes needed to convert a given for loop, and
 /// applies them.
 void LoopConvertCheck::doConversion(
-    ASTContext *Context, const VarDecl *IndexVar,
+    ASTContext *Context, ASTContext::Bounds *Bounds, const VarDecl *IndexVar,
     const ValueDecl *MaybeContainer, const UsageResult &Usages,
     const DeclStmt *AliasDecl, bool AliasUseRequired, bool AliasFromForInit,
     const ForStmt *Loop, RangeDescriptor Descriptor) {
   auto Diag = diag(Loop->getForLoc(), "use range-based for loop instead");
 
   std::string VarName;
   bool VarNameFromAlias = (Usages.size() == 1) && AliasDecl;
   bool AliasVarIsRef = false;
if (VarNameFromAlias) {
     for (const auto &Usage : Usages) {
       std::string ReplaceText;
       SourceRange Range = Usage.Range;
       if (Usage.Expression) {
         // If this is an access to a member through the arrow operator, after
         // the replacement it must be accessed through the '.' operator.
         ReplaceText = Usage.Kind == Usage::UK_MemberThroughArrow ? VarName + "."
                                                                  : VarName;
-        auto Parents = Context->getParents(*Usage.Expression);
+        auto Parents = Context->getParents(*Usage.Expression, *Bounds);
         if (Parents.size() == 1) {
           if (const auto *Paren = Parents[0].get<ParenExpr>()) {
             // Usage.Expression will be replaced with the new index variable,
             // and parenthesis around a simple DeclRefExpr can always be
             // removed.
             Range = Paren->getSourceRange();
           } else if (const auto *UOP = Parents[0].get<UnaryOperator>()) {
             // If we are taking the address of the loop variable, then we must
StringRef LoopConvertCheck::getContainerString(ASTContext *Context,
   }
 
   return ContainerString;
 }
 
 /// \brief Determines what kind of 'auto' must be used after converting a for
 /// loop that iterates over an array or pseudoarray.
 void LoopConvertCheck::getArrayLoopQualifiers(ASTContext *Context,
+                                              ASTContext::Bounds *Bounds,
                                               const BoundNodes &Nodes,
                                               const Expr *ContainerExpr,
                                               const UsageResult &Usages,
                                               RangeDescriptor &Descriptor) {
   // On arrays and pseudoarrays, we must figure out the qualifiers from the
   // usages.
-  if (usagesAreConst(Context, Usages) ||
+  if (usagesAreConst(Context, Bounds, Usages) ||
       containerIsConst(ContainerExpr, Descriptor.ContainerNeedsDereference)) {
     Descriptor.DerefByConstRef = true;
   }
   if (usagesReturnRValues(Usages)) {
     // If the index usages (dereference, subscript, at, ...) return rvalues,
     // then we should not use a reference, because we need to keep the code
     // correct if it mutates the returned objects.
     Descriptor.DerefByValue = true;
if (const auto *DerefType =
           CanonicalInitVarType->getPointeeType().isConstQualified();
       Descriptor.ElemType = CanonicalInitVarType->getPointeeType();
     }
   }
 }
 
 /// \brief Determines the parameters needed to build the range replacement.
 void LoopConvertCheck::determineRangeDescriptor(
-    ASTContext *Context, const BoundNodes &Nodes, const ForStmt *Loop,
-    LoopFixerKind FixerKind, const Expr *ContainerExpr,
+    ASTContext *Context, ASTContext::Bounds *Bounds, const BoundNodes &Nodes,
+    const ForStmt *Loop, LoopFixerKind FixerKind, const Expr *ContainerExpr,
     const UsageResult &Usages, RangeDescriptor &Descriptor) {
   Descriptor.ContainerString = getContainerString(Context, Loop, ContainerExpr);
 
   if (FixerKind == LFK_Iterator)
     getIteratorLoopQualifiers(Context, Nodes, Descriptor);
   else
-    getArrayLoopQualifiers(Context, Nodes, ContainerExpr, Usages, Descriptor);
+    getArrayLoopQualifiers(Context, Bounds, Nodes, ContainerExpr, Usages,
+                           Descriptor);
 }
 
 /// \brief Check some of the conditions that must be met for the loop to be
 /// convertible.
 bool LoopConvertCheck::isConvertible(ASTContext *Context,
                                      const ast_matchers::BoundNodes &Nodes,
                                      const ForStmt *Loop,
                                      LoopFixerKind FixerKind) {
if (FixerKind == LFK_Array) {
     // by a variable to be risky conversions.
     if (!getReferencedVariable(ContainerExpr) &&
         !isDirectMemberExpr(ContainerExpr))
       ConfidenceLevel.lowerTo(Confidence::CL_Risky);
   }
 
   // Find out which qualifiers we have to use in the loop range.
   const UsageResult &Usages = Finder.getUsages();
-  determineRangeDescriptor(Context, Nodes, Loop, FixerKind, ContainerExpr,
-                           Usages, Descriptor);
+  determineRangeDescriptor(Context, Result.Bounds, Nodes, Loop, FixerKind,
+                           ContainerExpr, Usages, Descriptor);
 
   // Ensure that we do not try to move an expression dependent on a local
   // variable declared inside the loop outside of it.
   // FIXME: Determine when the external dependency isn't an expression converted
   // by another loop.
   TUInfo->getParentFinder().gatherAncestors(Context->getTranslationUnitDecl());
   DependencyFinderASTVisitor DependencyFinder(
       &TUInfo->getParentFinder().getStmtToParentStmtMap(),
       &TUInfo->getParentFinder().getDeclToParentStmtMap(),
       &TUInfo->getReplacedVars(), Loop);
 
   if (DependencyFinder.dependsOnInsideVariable(ContainerExpr) ||
       Descriptor.ContainerString.empty() || Usages.empty() ||
       ConfidenceLevel.getLevel() < MinConfidence)
     return;
 
-  doConversion(Context, LoopVar, getReferencedVariable(ContainerExpr), Usages,
+  doConversion(Context, Result.Bounds, LoopVar,
+               getReferencedVariable(ContainerExpr), Usages,
                Finder.getAliasDecl(), Finder.aliasUseRequired(),
                Finder.aliasFromForInit(), Loop, Descriptor);
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tidy/modernize/MakeSmartPtrCheck.h

 
 private:
   std::unique_ptr<utils::IncludeInserter> Inserter;
   const utils::IncludeSorter::IncludeStyle IncludeStyle;
   const std::string MakeSmartPtrFunctionHeader;
   const std::string MakeSmartPtrFunctionName;
   const bool IgnoreMacros;
 
-  void checkConstruct(SourceManager &SM, ASTContext *Ctx,
+  void checkConstruct(SourceManager &SM, ASTContext *, ASTContext::Bounds *,
                       const CXXConstructExpr *Construct, const QualType *Type,
                       const CXXNewExpr *New);
-  void checkReset(SourceManager &SM, ASTContext *Ctx,
+  void checkReset(SourceManager &SM, ASTContext *, ASTContext::Bounds *,
                   const CXXMemberCallExpr *Member, const CXXNewExpr *New);
 
   /// Returns true when the fixes for replacing CXXNewExpr are generated.
   bool replaceNew(DiagnosticBuilder &Diag, const CXXNewExpr *New,
-                  SourceManager &SM, ASTContext *Ctx);
+                  SourceManager &SM, ASTContext *, ASTContext::Bounds *);
   void insertHeader(DiagnosticBuilder &Diag, FileID FD);
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H

clang-tidy/modernize/MakeSmartPtrCheck.cpp

void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   // For example,
   //    P.reset(new int[5]) // check fix: P = make_unique<int []>(5)
   //
   // The fix of the check has side effect, it introduces default initialization
   // which maybe unexpected and cause performance regression.
   if (New->isArray() && !New->hasInitializer())
     return;
   if (Construct)
-    checkConstruct(SM, Result.Context, Construct, Type, New);
+    checkConstruct(SM, Result.Context, Result.Bounds, Construct, Type, New);
   else if (Reset)
-    checkReset(SM, Result.Context, Reset, New);
+    checkReset(SM, Result.Context, Result.Bounds, Reset, New);
 }
 
 void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,
+                                       ASTContext::Bounds *Bounds,
                                        const CXXConstructExpr *Construct,
                                        const QualType *Type,
                                        const CXXNewExpr *New) {
   SourceLocation ConstructCallStart = Construct->getExprLoc();
   bool InMacro = ConstructCallStart.isMacroID();
 
   if (InMacro && IgnoreMacros) {
     return;
void MakeSmartPtrCheck::checkConstruct(SourceManager &SM, ASTContext *Ctx,
   auto Diag = diag(ConstructCallStart, "use %0 instead")
               << MakeSmartPtrFunctionName;
 
   // Disable the fix in macros.
   if (InMacro) {
     return;
   }
 
-  if (!replaceNew(Diag, New, SM, Ctx)) {
+  if (!replaceNew(Diag, New, SM, Ctx, Bounds)) {
     return;
   }
 
   // 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)
Diag << FixItHint::CreateReplacement(
                                       BraceRange.getEnd().getLocWithOffset(1)),
         ")");
   }
 
   insertHeader(Diag, SM.getFileID(ConstructCallStart));
 }
 
 void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
+                                   ASTContext::Bounds *Bounds,
                                    const CXXMemberCallExpr *Reset,
                                    const CXXNewExpr *New) {
   const auto *Expr = cast<MemberExpr>(Reset->getCallee());
   SourceLocation OperatorLoc = Expr->getOperatorLoc();
   SourceLocation ResetCallStart = Reset->getExprLoc();
   SourceLocation ExprStart = Expr->getBeginLoc();
   SourceLocation ExprEnd =
       Lexer::getLocForEndOfToken(Expr->getEndLoc(), 0, SM, getLangOpts());
void MakeSmartPtrCheck::checkReset(SourceManager &SM, ASTContext *Ctx,
   auto Diag = diag(ResetCallStart, "use %0 instead")
               << MakeSmartPtrFunctionName;
 
   // Disable the fix in macros.
   if (InMacro) {
     return;
   }
 
-  if (!replaceNew(Diag, New, SM, Ctx)) {
+  if (!replaceNew(Diag, New, SM, Ctx, Bounds)) {
     return;
   }
 
   Diag << FixItHint::CreateReplacement(
       CharSourceRange::getCharRange(OperatorLoc, ExprEnd),
       (llvm::Twine(" = ") + MakeSmartPtrFunctionName + "<" +
        GetNewExprName(New, SM, getLangOpts()) + ">")
           .str());
 
   if (Expr->isArrow())
     Diag << FixItHint::CreateInsertion(ExprStart, "*");
 
   insertHeader(Diag, SM.getFileID(OperatorLoc));
 }
 
 bool MakeSmartPtrCheck::replaceNew(DiagnosticBuilder &Diag,
                                    const CXXNewExpr *New, SourceManager &SM,
-                                   ASTContext *Ctx) {
+                                   ASTContext *Ctx,
+                                   ASTContext::Bounds *Bounds) {
   auto SkipParensParents = [&](const Expr *E) {
     for (const Expr *OldE = nullptr; E != OldE;) {
       OldE = E;
-      for (const auto &Node : Ctx->getParents(*E)) {
+      for (const auto &Node : Ctx->getParents(*E, *Bounds)) {
         if (const Expr *Parent = Node.get<ParenExpr>()) {
           E = Parent;
           break;
         }
       }
     }
     return E;
   };

clang-tidy/modernize/UseEqualsDefaultCheck.cpp

internal::Matcher<Expr> accessToFieldInVar(const FieldDecl *Field,
   return ignoringImpCasts(
       memberExpr(hasObjectExpression(declRefExpr(to(varDecl(equalsNode(Var))))),
                  member(fieldDecl(equalsNode(Field)))));
 }
 
 /// \brief Check that the given constructor has copy signature and that it
 /// copy-initializes all its bases and members.
 static bool isCopyConstructorAndCanBeDefaulted(ASTContext *Context,
+                                               ASTContext::Bounds *Bounds,
                                                const CXXConstructorDecl *Ctor) {
   // An explicitly-defaulted constructor cannot have default arguments.
   if (Ctor->getMinRequiredArguments() != 1)
     return false;
 
   const auto *Record = Ctor->getParent();
   const auto *Param = Ctor->getParamDecl(0);
 
if (match(
             cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
                 isBaseInitializer(),
                 withInitializer(cxxConstructExpr(allOf(
                     hasType(equalsNode(Base)),
                     hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
                     argumentCountIs(1),
                     hasArgument(
                         0, declRefExpr(to(varDecl(equalsNode(Param))))))))))),
-            *Ctor, *Context)
+            *Ctor, *Context, *Bounds)
             .empty())
       return false;
   }
 
   // Ensure that all the members are copied.
   for (const auto *Field : FieldsToInit) {
     auto AccessToFieldInParam = accessToFieldInVar(Field, Param);
     // The initialization is a CXXConstructExpr for class types.
     if (match(
             cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer(
                 isMemberInitializer(), forField(equalsNode(Field)),
                 withInitializer(anyOf(
                     AccessToFieldInParam,
                     initListExpr(has(AccessToFieldInParam)),
                     cxxConstructExpr(allOf(
                         hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
                         argumentCountIs(1),
                         hasArgument(0, AccessToFieldInParam)))))))),
-            *Ctor, *Context)
+            *Ctor, *Context, *Bounds)
             .empty())
       return false;
   }
 
   // Ensure that we don't do anything else, like initializing an indirect base.
   return Ctor->getNumCtorInitializers() ==
          BasesToInit.size() + FieldsToInit.size();
 }
 
 /// \brief Checks that the given method is an overloading of the assignment
 /// operator, has copy signature, returns a reference to "*this" and copies
 /// all its members and subobjects.
 static bool isCopyAssignmentAndCanBeDefaulted(ASTContext *Context,
+                                              ASTContext::Bounds *Bounds,
                                               const CXXMethodDecl *Operator) {
   const auto *Record = Operator->getParent();
   const auto *Param = Operator->getParamDecl(0);
 
   // Base classes and members that have to be copied.
   auto BasesToInit = getAllDirectBases(Record);
   auto FieldsToInit = getAllNamedFields(Record);
 
   const auto *Compound = cast<CompoundStmt>(Operator->getBody());
 
   // The assignment operator definition has to end with the following return
   // statement:
   //   return *this;
   if (Compound->body_empty() ||
       match(returnStmt(has(ignoringParenImpCasts(unaryOperator(
                 hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))),
-            *Compound->body_back(), *Context)
+            *Compound->body_back(), *Context, *Bounds)
           .empty())
     return false;
 
   // Ensure that all the bases are copied.
   for (const auto *Base : BasesToInit) {
     // Assignment operator of a base class:
     //   Base::operator=(Other);
     //
if (match(compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(allOf(
                                        hasSourceExpression(cxxThisExpr()))),
                   // - The called method is the operator=.
                   callee(cxxMethodDecl(isCopyAssignmentOperator())),
                   // - The argument is (an implicit cast to a Base of) the
                   // argument taken by "Operator".
                   argumentCountIs(1),
                   hasArgument(0,
                               declRefExpr(to(varDecl(equalsNode(Param)))))))))),
-              *Compound, *Context)
+              *Compound, *Context, *Bounds)
             .empty())
       return false;
   }
 
   // Ensure that all the members are copied.
   for (const auto *Field : FieldsToInit) {
     // The assignment of data members:
     //   Field = Other.Field;
     // Is a BinaryOperator in non-class types, and a CXXOperatorCallExpr
     // otherwise.
     auto LHS = memberExpr(hasObjectExpression(cxxThisExpr()),
                           member(fieldDecl(equalsNode(Field))));
     auto RHS = accessToFieldInVar(Field, Param);
     if (match(
             compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
                 binaryOperator(hasOperatorName("="), hasLHS(LHS), hasRHS(RHS)),
                 cxxOperatorCallExpr(hasOverloadedOperatorName("="),
                                     argumentCountIs(2), hasArgument(0, LHS),
                                     hasArgument(1, RHS))))))),
-            *Compound, *Context)
+            *Compound, *Context, *Bounds)
             .empty())
       return false;
   }
 
   // Ensure that we don't do anything else.
   return Compound->size() == BasesToInit.size() + FieldsToInit.size() + 1;
 }
 
bool ApplyFix = SpecialFunctionDecl->isCopyAssignmentOperator() ||
                   bodyEmpty(Result.Context, Body);
 
   std::vector<FixItHint> RemoveInitializers;
 
   if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(SpecialFunctionDecl)) {
     if (Ctor->getNumParams() == 0) {
       SpecialFunctionName = "default constructor";
     } else {
-      if (!isCopyConstructorAndCanBeDefaulted(Result.Context, Ctor))
+      if (!isCopyConstructorAndCanBeDefaulted(Result.Context, Result.Bounds,
+                                              Ctor))
         return;
       SpecialFunctionName = "copy constructor";
       // If there are constructor initializers, they must be removed.
       for (const auto *Init : Ctor->inits()) {
         RemoveInitializers.emplace_back(
             FixItHint::CreateRemoval(Init->getSourceRange()));
       }
     }
   } else if (isa<CXXDestructorDecl>(SpecialFunctionDecl)) {
     SpecialFunctionName = "destructor";
   } else {
-    if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, SpecialFunctionDecl))
+    if (!isCopyAssignmentAndCanBeDefaulted(Result.Context, Result.Bounds,
+                                           SpecialFunctionDecl))
       return;
     SpecialFunctionName = "copy-assignment operator";
   }
 
   // The location of the body is more useful inside a macro as spelling and
   // expansion locations are reported.
   SourceLocation Location = SpecialFunctionDecl->getLocation();
   if (Location.isMacroID())

clang-tidy/modernize/UseNullptrCheck.cpp

 /// an implicit cast is nested within. However, there is no guarantee that only
 /// 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)
-      : SM(Context.getSourceManager()), Context(Context),
+  CastSequenceVisitor(ASTContext &Context, ASTContext::Bounds &Bounds,
+                      ArrayRef<StringRef> NullMacros, ClangTidyCheck &check)
+      : SM(Context.getSourceManager()), Context(Context), Bounds(Bounds),
         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;
bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
                               ast_type_traits::DynTypedNode &Result) {
     // Below we're only following the first parent back up the AST. This should
     // be fine since for the statements we care about there should only be one
     // parent, except for the case specified below.
 
     assert(MacroLoc.isFileID());
 
     while (true) {
-      const auto &Parents = Context.getParents(Start);
+      const auto &Parents = Context.getParents(Start, Bounds);
       if (Parents.empty())
         return false;
       if (Parents.size() > 1) {
         // If there are more than one parents, don't do the replacement unless
         // they are InitListsExpr (semantic and syntactic form). In this case we
         // can choose any one here, and the ASTVisitor will take care of
         // traversing the right one.
         for (const auto &Parent : Parents) {
bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
     }
 
     llvm_unreachable("findContainingAncestor");
   }
 
 private:
   SourceManager &SM;
   ASTContext &Context;
+  ASTContext::Bounds &Bounds;
   ArrayRef<StringRef> NullMacros;
   ClangTidyCheck &Check;
   Expr *FirstSubExpr;
   bool PruneSubtree;
 };
 
 } // namespace
 

 
 void UseNullptrCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *NullCast = Result.Nodes.getNodeAs<CastExpr>(CastSequence);
   assert(NullCast && "Bad Callback. No node provided");
 
   // Given an implicit null-ptr cast or an explicit cast with an implicit
   // null-to-pointer cast within use CastSequenceVisitor to identify sequences
   // of explicit casts that can be converted into 'nullptr'.
-  CastSequenceVisitor(*Result.Context, NullMacros, *this)
+  CastSequenceVisitor(*Result.Context, *Result.Bounds, NullMacros, *this)
       .TraverseStmt(const_cast<CastExpr *>(NullCast));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tidy/performance/ForRangeCopyCheck.h

private:
   // suggests it be converted to a const reference.
   bool handleConstValueCopy(const VarDecl &LoopVar, ASTContext &Context);
 
   // Checks if the loop variable is a non-const value and whether only
   // const methods are invoked on it or whether it is only used as a const
   // reference argument. If so it suggests it be made a const reference.
   bool handleCopyIsOnlyConstReferenced(const VarDecl &LoopVar,
                                        const CXXForRangeStmt &ForRange,
-                                       ASTContext &Context);
+                                       ASTContext &, ASTContext::Bounds &);
 
   const bool WarnOnAllAutoCopies;
   const std::vector<std::string> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_FORRANGECOPYCHECK_H

clang-tidy/performance/ForRangeCopyCheck.cpp

void ForRangeCopyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Var = Result.Nodes.getNodeAs<VarDecl>("loopVar");
 
   // Ignore code in macros since we can't place the fixes correctly.
   if (Var->getBeginLoc().isMacroID())
     return;
   if (handleConstValueCopy(*Var, *Result.Context))
     return;
   const auto *ForRange = Result.Nodes.getNodeAs<CXXForRangeStmt>("forRange");
-  handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context);
+  handleCopyIsOnlyConstReferenced(*Var, *ForRange, *Result.Context,
+                                  *Result.Bounds);
 }
 
 bool ForRangeCopyCheck::handleConstValueCopy(const VarDecl &LoopVar,
                                              ASTContext &Context) {
   if (WarnOnAllAutoCopies) {
     // For aggressive check just test that loop variable has auto type.
     if (!isa<AutoType>(LoopVar.getType()))
       return false;
auto Diagnostic =
       << utils::fixit::changeVarDeclToReference(LoopVar, Context);
   if (!LoopVar.getType().isConstQualified())
     Diagnostic << utils::fixit::changeVarDeclToConst(LoopVar);
   return true;
 }
 
 bool ForRangeCopyCheck::handleCopyIsOnlyConstReferenced(
     const VarDecl &LoopVar, const CXXForRangeStmt &ForRange,
-    ASTContext &Context) {
+    ASTContext &Context, ASTContext::Bounds &Bounds) {
   llvm::Optional<bool> Expensive =
       utils::type_traits::isExpensiveToCopy(LoopVar.getType(), Context);
   if (LoopVar.getType().isConstQualified() || !Expensive || !*Expensive)
     return false;
   // We omit the case where the loop variable is not used in the loop body. E.g.
   //
   // for (auto _ : benchmark_state) {
   // }
   //
   // Because the fix (changing to `const auto &`) will introduce an unused
   // compiler warning which can't be suppressed.
   // Since this case is very rare, it is safe to ignore it.
-  if (!ExprMutationAnalyzer(*ForRange.getBody(), Context).isMutated(&LoopVar) &&
+  if (!ExprMutationAnalyzer(*ForRange.getBody(), Context, Bounds)
+           .isMutated(&LoopVar) &&
       !utils::decl_ref_expr::allDeclRefExprs(LoopVar, *ForRange.getBody(),
-                                             Context)
+                                             Context, Bounds)
            .empty()) {
     diag(LoopVar.getLocation(),
          "loop variable is copied but only used as const reference; consider "
          "making it a const reference")
         << utils::fixit::changeVarDeclToConst(LoopVar)
         << utils::fixit::changeVarDeclToReference(LoopVar, Context);
     return true;
   }
   return false;
 }
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang

clang-tidy/performance/InefficientVectorOperationCheck.cpp

void InefficientVectorOperationCheck::check(
   const auto *LoopParent = Result.Nodes.getNodeAs<CompoundStmt>(LoopParentName);
 
   const Stmt *LoopStmt = ForLoop;
   if (!LoopStmt)
     LoopStmt = RangeLoop;
 
   llvm::SmallPtrSet<const DeclRefExpr *, 16> AllVectorVarRefs =
       utils::decl_ref_expr::allDeclRefExprs(*VectorVarDecl, *LoopParent,
-                                            *Context);
+                                            *Context, *Result.Bounds);
   for (const auto *Ref : AllVectorVarRefs) {
     // Skip cases where there are usages (defined as DeclRefExpr that refers to
     // "v") of vector variable `v` before the for loop. We consider these usages
     // are operations causing memory preallocation (e.g. "v.resize(n)",
     // "v.reserve(n)").
     //
     // FIXME: make it more intelligent to identify the pre-allocating operations
     // before the for loop.

clang-tidy/performance/UnnecessaryCopyInitialization.h

public:
   UnnecessaryCopyInitialization(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   void handleCopyFromMethodReturn(const VarDecl &Var, const Stmt &BlockStmt,
                                   bool IssueFix, const VarDecl *ObjectArg,
-                                  ASTContext &Context);
+                                  ASTContext &Context, ASTContext::Bounds &Bounds);
   void handleCopyFromLocalVar(const VarDecl &NewVar, const VarDecl &OldVar,
                               const Stmt &BlockStmt, bool IssueFix,
-                              ASTContext &Context);
+                              ASTContext &Context, ASTContext::Bounds &Bounds);
   const std::vector<std::string> AllowedTypes;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_COPY_INITIALIZATION_H

clang-tidy/performance/UnnecessaryCopyInitialization.cpp

void UnnecessaryCopyInitialization::check(
   // 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())
       return;
 
   if (OldVar == nullptr) {
     handleCopyFromMethodReturn(*NewVar, *BlockStmt, IssueFix, ObjectArg,
-                               *Result.Context);
+                               *Result.Context, *Result.Bounds);
   } else {
     handleCopyFromLocalVar(*NewVar, *OldVar, *BlockStmt, IssueFix,
-                           *Result.Context);
+                           *Result.Context, *Result.Bounds);
   }
 }
 
 void UnnecessaryCopyInitialization::handleCopyFromMethodReturn(
     const VarDecl &Var, const Stmt &BlockStmt, bool IssueFix,
-    const VarDecl *ObjectArg, ASTContext &Context) {
+    const VarDecl *ObjectArg, ASTContext &Context, ASTContext::Bounds &Bounds) {
   bool IsConstQualified = Var.getType().isConstQualified();
-  if (!IsConstQualified && !isOnlyUsedAsConst(Var, BlockStmt, Context))
+  if (!IsConstQualified && !isOnlyUsedAsConst(Var, BlockStmt, Context, Bounds))
     return;
   if (ObjectArg != nullptr &&
-      !isOnlyUsedAsConst(*ObjectArg, BlockStmt, Context))
+      !isOnlyUsedAsConst(*ObjectArg, BlockStmt, Context, Bounds))
     return;
 
   auto Diagnostic =
       diag(Var.getLocation(),
            IsConstQualified ? "the const qualified variable %0 is "
                               "copy-constructed from a const reference; "
                               "consider making it a const reference"
                             : "the variable %0 is copy-constructed from a "
                               "const reference but is only used as const "
                               "reference; consider making it a const reference")
       << &Var;
   if (IssueFix)
     recordFixes(Var, Context, Diagnostic);
 }
 
 void UnnecessaryCopyInitialization::handleCopyFromLocalVar(
     const VarDecl &NewVar, const VarDecl &OldVar, const Stmt &BlockStmt,
-    bool IssueFix, ASTContext &Context) {
-  if (!isOnlyUsedAsConst(NewVar, BlockStmt, Context) ||
-      !isOnlyUsedAsConst(OldVar, BlockStmt, Context))
+    bool IssueFix, ASTContext &Context, ASTContext::Bounds &Bounds) {
+  if (!isOnlyUsedAsConst(NewVar, BlockStmt, Context, Bounds) ||
+      !isOnlyUsedAsConst(OldVar, BlockStmt, Context, Bounds))
     return;
 
   auto Diagnostic = diag(NewVar.getLocation(),
                          "local copy %0 of the variable %1 is never modified; "
                          "consider avoiding the copy")
                     << &NewVar << &OldVar;
   if (IssueFix)
     recordFixes(NewVar, Context, Diagnostic);

clang-tidy/performance/UnnecessaryValueParamCheck.cpp

 
 std::string paramNameOrIndex(StringRef Name, size_t Index) {
   return (Name.empty() ? llvm::Twine('#') + llvm::Twine(Index + 1)
                        : llvm::Twine('\'') + Name + llvm::Twine('\''))
       .str();
 }
 
 bool isReferencedOutsideOfCallExpr(const FunctionDecl &Function,
-                                   ASTContext &Context) {
+                                   ASTContext &Context,
+                                   ASTContext::Bounds &Bounds) {
   auto Matches = match(declRefExpr(to(functionDecl(equalsNode(&Function))),
                                    unless(hasAncestor(callExpr()))),
-                       Context);
+                       Context, Bounds);
   return !Matches.empty();
 }
 
 bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
-                         ASTContext &Context) {
+                         ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto Matches =
       match(decl(forEachDescendant(declRefExpr(
                 equalsNode(&DeclRef),
                 unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(),
                                               whileStmt(), doStmt()))))))),
-            Decl, Context);
+            Decl, Context, Bounds);
   return Matches.empty();
 }
 
 bool isExplicitTemplateSpecialization(const FunctionDecl &Function) {
   if (const auto *SpecializationInfo = Function.getTemplateSpecializationInfo())
     if (SpecializationInfo->getTemplateSpecializationKind() ==
         TSK_ExplicitSpecialization)
       return true;
Finder->addMatcher(
       this);
 }
 
 void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
 
   FunctionParmMutationAnalyzer &Analyzer =
-      MutationAnalyzers.try_emplace(Function, *Function, *Result.Context)
+      MutationAnalyzers
+          .try_emplace(Function, *Function, *Result.Context, *Result.Bounds)
           .first->second;
   if (Analyzer.isMutated(Param))
     return;
 
   const bool IsConstQualified =
       Param->getType().getCanonicalType().isConstQualified();
 
   // If the parameter is non-const, check if it has a move constructor and is
   // only referenced once to copy-construct another object or whether it has a
   // move assignment operator and is only referenced once when copy-assigned.
   // In this case wrap DeclRefExpr with std::move() to avoid the unnecessary
   // copy.
   if (!IsConstQualified) {
     auto AllDeclRefExprs = utils::decl_ref_expr::allDeclRefExprs(
-        *Param, *Function, *Result.Context);
+        *Param, *Function, *Result.Context, *Result.Bounds);
     if (AllDeclRefExprs.size() == 1) {
       auto CanonicalType = Param->getType().getCanonicalType();
       const auto &DeclRefExpr = **AllDeclRefExprs.begin();
 
-      if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context) &&
+      if (!hasLoopStmtAncestor(DeclRefExpr, *Function, *Result.Context, *Result.Bounds) &&
           ((utils::type_traits::hasNonTrivialMoveConstructor(CanonicalType) &&
             utils::decl_ref_expr::isCopyConstructorArgument(
-                DeclRefExpr, *Function, *Result.Context)) ||
+                DeclRefExpr, *Function, *Result.Context, *Result.Bounds)) ||
            (utils::type_traits::hasNonTrivialMoveAssignment(CanonicalType) &&
             utils::decl_ref_expr::isCopyAssignmentArgument(
-                DeclRefExpr, *Function, *Result.Context)))) {
+                DeclRefExpr, *Function, *Result.Context, *Result.Bounds)))) {
         handleMoveFix(*Param, DeclRefExpr, *Result.Context);
         return;
       }
     }
   }
 
   const size_t Index = std::find(Function->parameters().begin(),
                                  Function->parameters().end(), Param) -
void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
   // Do not propose fixes when:
   // 1. the ParmVarDecl is in a macro, since we cannot place them correctly
   // 2. the function is virtual as it might break overrides
   // 3. the function is referenced outside of a call expression within the
   //    compilation unit as the signature change could introduce build errors.
   // 4. the function is an explicit template specialization.
   const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
   if (Param->getBeginLoc().isMacroID() || (Method && Method->isVirtual()) ||
-      isReferencedOutsideOfCallExpr(*Function, *Result.Context) ||
+      isReferencedOutsideOfCallExpr(*Function, *Result.Context,
+                                    *Result.Bounds) ||
       isExplicitTemplateSpecialization(*Function))
     return;
   for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
        FunctionDecl = FunctionDecl->getPreviousDecl()) {
     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
     Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
                                                    *Result.Context);
     // The parameter of each declaration needs to be checked individually as to

clang-tidy/readability/ImplicitBoolConversionCheck.h

public:
   ImplicitBoolConversionCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void handleCastToBool(const ImplicitCastExpr *CastExpression,
-                        const Stmt *ParentStatement, ASTContext &Context);
+                        const Stmt *ParentStatement, ASTContext &Context,
+                        ASTContext::Bounds &Bounds);
   void handleCastFromBool(const ImplicitCastExpr *CastExpression,
                           const ImplicitCastExpr *FurtherImplicitCastExpression,
                           ASTContext &Context);
 
   const bool AllowIntegerConditions;
   const bool AllowPointerConditions;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CONVERSION_H

clang-tidy/readability/ImplicitBoolConversionCheck.cpp

if (const auto *OperatorCall = dyn_cast<CXXOperatorCallExpr>(Statement)) {
     return areParensNeededForOverloadedOperator(OperatorCall->getOperator());
   }
 
   return isa<BinaryOperator>(Statement) || isa<UnaryOperator>(Statement);
 }
 
 void fixGenericExprCastToBool(DiagnosticBuilder &Diag,
                               const ImplicitCastExpr *Cast, const Stmt *Parent,
-                              ASTContext &Context) {
+                              ASTContext &Context, ASTContext::Bounds &Bounds) {
   // In case of expressions like (! integer), we should remove the redundant not
   // operator and use inverted comparison (integer == 0).
   bool InvertComparison =
       Parent != nullptr && isUnaryLogicalNotOperator(Parent);
   if (InvertComparison) {
     SourceLocation ParentStartLoc = Parent->getBeginLoc();
     SourceLocation ParentEndLoc =
         cast<UnaryOperator>(Parent)->getSubExpr()->getBeginLoc();
     Diag << FixItHint::CreateRemoval(
         CharSourceRange::getCharRange(ParentStartLoc, ParentEndLoc));
 
-    Parent = Context.getParents(*Parent)[0].get<Stmt>();
+    Parent = Context.getParents(*Parent, Bounds)[0].get<Stmt>();
   }
 
   const Expr *SubExpr = Cast->getSubExpr();
 
   bool NeedInnerParens = areParensNeededForStatement(SubExpr);
   bool NeedOuterParens =
       Parent != nullptr && areParensNeededForStatement(Parent);
 
StringRef getEquivalentForBoolLiteral(const CXXBoolLiteralExpr *BoolLiteral,
 
   if (DestType->isUnsignedIntegerType()) {
     return BoolLiteral->getValue() ? "1u" : "0u";
   }
   return BoolLiteral->getValue() ? "1" : "0";
 }
 
 bool isCastAllowedInCondition(const ImplicitCastExpr *Cast,
-                              ASTContext &Context) {
+                              ASTContext &Context, ASTContext::Bounds &Bounds) {
   std::queue<const Stmt *> Q;
   Q.push(Cast);
   while (!Q.empty()) {
-    for (const auto &N : Context.getParents(*Q.front())) {
+    for (const auto &N : Context.getParents(*Q.front(), Bounds)) {
       const Stmt *S = N.get<Stmt>();
       if (!S)
         return false;
       if (isa<IfStmt>(S) || isa<ConditionalOperator>(S) || isa<ForStmt>(S) ||
           isa<WhileStmt>(S) || isa<BinaryConditionalOperator>(S))
         return true;
       if (isa<ParenExpr>(S) || isa<ImplicitCastExpr>(S) ||
           isUnaryLogicalNotOperator(S) ||
Finder->addMatcher(
       this);
 }
 
 void ImplicitBoolConversionCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *CastToBool =
           Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastToBool")) {
     const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt");
-    return handleCastToBool(CastToBool, Parent, *Result.Context);
+    return handleCastToBool(CastToBool, Parent, *Result.Context,
+                            *Result.Bounds);
   }
 
   if (const auto *CastFromBool =
           Result.Nodes.getNodeAs<ImplicitCastExpr>("implicitCastFromBool")) {
     const auto *NextImplicitCast =
         Result.Nodes.getNodeAs<ImplicitCastExpr>("furtherImplicitCast");
     return handleCastFromBool(CastFromBool, NextImplicitCast, *Result.Context);
   }
 }
 
 void ImplicitBoolConversionCheck::handleCastToBool(const ImplicitCastExpr *Cast,
                                                    const Stmt *Parent,
-                                                   ASTContext &Context) {
+                                                   ASTContext &Context,
+                                                   ASTContext::Bounds &Bounds) {
   if (AllowPointerConditions &&
       (Cast->getCastKind() == CK_PointerToBoolean ||
        Cast->getCastKind() == CK_MemberPointerToBoolean) &&
-      isCastAllowedInCondition(Cast, Context)) {
+      isCastAllowedInCondition(Cast, Context, Bounds)) {
     return;
   }
 
   if (AllowIntegerConditions && Cast->getCastKind() == CK_IntegralToBoolean &&
-      isCastAllowedInCondition(Cast, Context)) {
+      isCastAllowedInCondition(Cast, Context, Bounds)) {
     return;
   }
 
   auto Diag = diag(Cast->getBeginLoc(), "implicit conversion %0 -> bool")
               << Cast->getSubExpr()->getType();
 
   StringRef EquivalentLiteral =
       getEquivalentBoolLiteralForExpr(Cast->getSubExpr(), Context);
   if (!EquivalentLiteral.empty()) {
     Diag << tooling::fixit::createReplacement(*Cast, EquivalentLiteral);
   } else {
-    fixGenericExprCastToBool(Diag, Cast, Parent, Context);
+    fixGenericExprCastToBool(Diag, Cast, Parent, Context, Bounds);
   }
 }
 
 void ImplicitBoolConversionCheck::handleCastFromBool(
     const ImplicitCastExpr *Cast, const ImplicitCastExpr *NextImplicitCast,
     ASTContext &Context) {
   QualType DestType =
       NextImplicitCast ? NextImplicitCast->getType() : Cast->getType();

clang-tidy/readability/MagicNumbersCheck.cpp

if (AsDecl->getType().isConstQualified())
       return true;
 
     return AsDecl->isImplicit();
   }
 
   if (Node.get<clang::EnumConstantDecl>() != nullptr)
     return true;
 
-  return llvm::any_of(Result.Context->getParents(Node),
+  return llvm::any_of(Result.Context->getParents(Node, *Result.Bounds),
                       [&Result](const DynTypedNode &Parent) {
                         return isUsedToInitializeAConstant(Result, Parent);
                       });
 }
 
 } // namespace
 
 namespace clang {

 void MagicNumbersCheck::check(const MatchFinder::MatchResult &Result) {
   checkBoundMatch<IntegerLiteral>(Result, "integer");
   checkBoundMatch<FloatingLiteral>(Result, "float");
 }
 
 bool MagicNumbersCheck::isConstant(const MatchFinder::MatchResult &Result,
                                    const Expr &ExprResult) const {
   return llvm::any_of(
-      Result.Context->getParents(ExprResult),
+      Result.Context->getParents(ExprResult, *Result.Bounds),
       [&Result](const DynTypedNode &Parent) {
         return isUsedToInitializeAConstant(Result, Parent) ||
                // Ignore this instance, because this match reports the location
                // where the template is defined, not where it is instantiated.
                Parent.get<SubstNonTypeTemplateParmExpr>();
       });
 }
 

clang-tidy/readability/MisleadingIndentationCheck.h

 public:
   MisleadingIndentationCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
 private:
   void danglingElseCheck(const SourceManager &SM, ASTContext *Context,
-                         const IfStmt *If);
+                         ASTContext::Bounds *Bounds, const IfStmt *If);
   void missingBracesCheck(const SourceManager &SM, const CompoundStmt *CStmt);
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISLEADING_INDENTATION_H

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);
+                                    ASTContext *Context,
+                                    ASTContext::Bounds *Bounds,
+                                    const IfStmt *If) {
+  auto parents = Context->getParents(*If, *Bounds);
   if (parents.size() != 1)
     return nullptr;
   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,
+                                                   ASTContext::Bounds *Bounds,
                                                    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;
-       PrecedingIf = getPrecedingIf(SM, Context, PrecedingIf))
+  for (auto PrecedingIf = getPrecedingIf(SM, Context, Bounds, If); PrecedingIf;
+       PrecedingIf = getPrecedingIf(SM, Context, Bounds, 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,
void MisleadingIndentationCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       compoundStmt(has(stmt(anyOf(ifStmt(), forStmt(), whileStmt()))))
           .bind("compound"),
       this);
 }
 
 void MisleadingIndentationCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if"))
-    danglingElseCheck(*Result.SourceManager, Result.Context, If);
+    danglingElseCheck(*Result.SourceManager, Result.Context, Result.Bounds, If);
 
   if (const auto *CStmt = Result.Nodes.getNodeAs<CompoundStmt>("compound"))
     missingBracesCheck(*Result.SourceManager, CStmt);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tidy/readability/RedundantDeclarationCheck.cpp

void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
   if (!Prev->getLocation().isValid())
     return;
   if (Prev->getLocation() == D->getLocation())
     return;
   if (IgnoreMacros &&
       (D->getLocation().isMacroID() || Prev->getLocation().isMacroID()))
     return;
   // Don't complain when the previous declaration is a friend declaration.
-  for (const auto &Parent : Result.Context->getParents(*Prev))
+  for (const auto &Parent : Result.Context->getParents(*Prev, *Result.Bounds))
     if (Parent.get<FriendDecl>())
       return;
 
   const SourceManager &SM = *Result.SourceManager;
 
   const bool DifferentHeaders =
       !SM.isInMainFile(D->getLocation()) &&
       !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation());

clang-tidy/utils/ASTUtils.h

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

clang-tidy/utils/ASTUtils.cpp

 #include "clang/Lex/Lexer.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 using namespace ast_matchers;
 
 const FunctionDecl *getSurroundingFunction(ASTContext &Context,
+                                           ASTContext::Bounds &Bounds,
                                            const Stmt &Statement) {
   return selectFirst<const FunctionDecl>(
       "function", match(stmt(hasAncestor(functionDecl().bind("function"))),
-                        Statement, Context));
+                        Statement, Context, Bounds));
 }
 
 bool IsBinaryOrTernary(const Expr *E) {
   const Expr *E_base = E->IgnoreImpCasts();
   if (clang::isa<clang::BinaryOperator>(E_base) ||
       clang::isa<clang::ConditionalOperator>(E_base)) {
     return true;
   }

clang-tidy/utils/DeclRefExprUtils.h

 
 /// \brief Returns true if all ``DeclRefExpr`` to the variable within ``Stmt``
 /// do not modify it.
 ///
 /// Returns ``true`` if only const methods or operators are called on the
 /// variable or the variable is a const reference or value argument to a
 /// ``callExpr()``.
 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
-                       ASTContext &Context);
+                       ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns set of all ``DeclRefExprs`` to ``VarDecl`` within ``Stmt``.
 llvm::SmallPtrSet<const DeclRefExpr *, 16>
-allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context);
+allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns set of all ``DeclRefExprs`` to ``VarDecl`` within ``Decl``.
 llvm::SmallPtrSet<const DeclRefExpr *, 16>
-allDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl, ASTContext &Context);
+allDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl, ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns set of all ``DeclRefExprs`` to ``VarDecl`` within ``Stmt`` where
 /// ``VarDecl`` is guaranteed to be accessed in a const fashion.
 llvm::SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt,
-                           ASTContext &Context);
+                           ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns set of all ``DeclRefExprs`` to ``VarDecl`` within ``Decl`` where
 /// ``VarDecl`` is guaranteed to be accessed in a const fashion.
 llvm::SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl,
-                           ASTContext &Context);
+                           ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns ``true`` if ``DeclRefExpr`` is the argument of a copy-constructor
 /// call expression within ``Decl``.
 bool isCopyConstructorArgument(const DeclRefExpr &DeclRef, const Decl &Decl,
-                               ASTContext &Context);
+                               ASTContext &Context, ASTContext::Bounds &Bounds);
 
 /// Returns ``true`` if ``DeclRefExpr`` is the argument of a copy-assignment
 /// operator CallExpr within ``Decl``.
 bool isCopyAssignmentArgument(const DeclRefExpr &DeclRef, const Decl &Decl,
-                              ASTContext &Context);
+                              ASTContext &Context, ASTContext::Bounds &Bounds);
 
 } // namespace decl_ref_expr
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_DECLREFEXPRUTILS_H

clang-tidy/utils/DeclRefExprUtils.cpp

 }
 
 } // namespace
 
 // Finds all DeclRefExprs where a const method is called on VarDecl or VarDecl
 // is the a const reference or value argument to a CallExpr or CXXConstructExpr.
 SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt,
-                           ASTContext &Context) {
+                           ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto DeclRefToVar =
       declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef");
   auto ConstMethodCallee = callee(cxxMethodDecl(isConst()));
   // Match method call expressions where the variable is referenced as the this
   // implicit object argument and opertor call expression for member operators
   // where the variable is the 0-th argument.
   auto Matches = match(
       findAll(expr(anyOf(cxxMemberCallExpr(ConstMethodCallee, on(DeclRefToVar)),
                          cxxOperatorCallExpr(ConstMethodCallee,
                                              hasArgument(0, DeclRefToVar))))),
-      Stmt, Context);
+      Stmt, Context, Bounds);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   auto ConstReferenceOrValue =
       qualType(anyOf(referenceType(pointee(qualType(isConstQualified()))),
                      unless(anyOf(referenceType(), pointerType()))));
   auto UsedAsConstRefOrValueArg = forEachArgumentWithParam(
       DeclRefToVar, parmVarDecl(hasType(ConstReferenceOrValue)));
-  Matches = match(findAll(callExpr(UsedAsConstRefOrValueArg)), Stmt, Context);
-  extractNodesByIdTo(Matches, "declRef", DeclRefs);
   Matches =
-      match(findAll(cxxConstructExpr(UsedAsConstRefOrValueArg)), Stmt, Context);
+      match(findAll(callExpr(UsedAsConstRefOrValueArg)), Stmt, Context, Bounds);
+  extractNodesByIdTo(Matches, "declRef", DeclRefs);
+  Matches = match(findAll(cxxConstructExpr(UsedAsConstRefOrValueArg)), Stmt,
+                  Context, Bounds);
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   return DeclRefs;
 }
 
 // Finds all DeclRefExprs where a const method is called on VarDecl or VarDecl
 // is the a const reference or value argument to a CallExpr or CXXConstructExpr.
 SmallPtrSet<const DeclRefExpr *, 16>
 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl,
-                           ASTContext &Context) {
+                           ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto DeclRefToVar =
       declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef");
   auto ConstMethodCallee = callee(cxxMethodDecl(isConst()));
   // Match method call expressions where the variable is referenced as the this
   // implicit object argument and opertor call expression for member operators
   // where the variable is the 0-th argument.
   auto Matches =
       match(decl(forEachDescendant(expr(
                 anyOf(cxxMemberCallExpr(ConstMethodCallee, on(DeclRefToVar)),
                       cxxOperatorCallExpr(ConstMethodCallee,
                                           hasArgument(0, DeclRefToVar)))))),
-            Decl, Context);
+            Decl, Context, Bounds);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   auto ConstReferenceOrValue =
       qualType(anyOf(referenceType(pointee(qualType(isConstQualified()))),
                      unless(anyOf(referenceType(), pointerType()))));
   auto UsedAsConstRefOrValueArg = forEachArgumentWithParam(
       DeclRefToVar, parmVarDecl(hasType(ConstReferenceOrValue)));
   Matches = match(decl(forEachDescendant(callExpr(UsedAsConstRefOrValueArg))),
-                  Decl, Context);
+                  Decl, Context, Bounds);
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   Matches =
       match(decl(forEachDescendant(cxxConstructExpr(UsedAsConstRefOrValueArg))),
-            Decl, Context);
+            Decl, Context, Bounds);
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   return DeclRefs;
 }
 
 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
-                       ASTContext &Context) {
+                       ASTContext &Context, ASTContext::Bounds &Bounds) {
   // Collect all DeclRefExprs to the loop variable and all CallExprs and
   // CXXConstructExprs where the loop variable is used as argument to a const
   // reference parameter.
   // If the difference is empty it is safe for the loop variable to be a const
   // reference.
-  auto AllDeclRefs = allDeclRefExprs(Var, Stmt, Context);
-  auto ConstReferenceDeclRefs = constReferenceDeclRefExprs(Var, Stmt, Context);
+  auto AllDeclRefs = allDeclRefExprs(Var, Stmt, Context, Bounds);
+  auto ConstReferenceDeclRefs =
+      constReferenceDeclRefExprs(Var, Stmt, Context, Bounds);
   return isSetDifferenceEmpty(AllDeclRefs, ConstReferenceDeclRefs);
 }
 
 SmallPtrSet<const DeclRefExpr *, 16>
-allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context) {
+allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto Matches = match(
       findAll(declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef")),
-      Stmt, Context);
+      Stmt, Context, Bounds);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   return DeclRefs;
 }
 
 SmallPtrSet<const DeclRefExpr *, 16>
-allDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl, ASTContext &Context) {
+allDeclRefExprs(const VarDecl &VarDecl, const Decl &Decl, ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto Matches = match(
       decl(forEachDescendant(
           declRefExpr(to(varDecl(equalsNode(&VarDecl)))).bind("declRef"))),
-      Decl, Context);
+      Decl, Context, Bounds);
   SmallPtrSet<const DeclRefExpr *, 16> DeclRefs;
   extractNodesByIdTo(Matches, "declRef", DeclRefs);
   return DeclRefs;
 }
 
 bool isCopyConstructorArgument(const DeclRefExpr &DeclRef, const Decl &Decl,
-                               ASTContext &Context) {
+                               ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto UsedAsConstRefArg = forEachArgumentWithParam(
       declRefExpr(equalsNode(&DeclRef)),
       parmVarDecl(hasType(matchers::isReferenceToConst())));
   auto Matches = match(
       decl(hasDescendant(
           cxxConstructExpr(UsedAsConstRefArg, hasDeclaration(cxxConstructorDecl(
                                                   isCopyConstructor())))
               .bind("constructExpr"))),
-      Decl, Context);
+      Decl, Context, Bounds);
   return !Matches.empty();
 }
 
 bool isCopyAssignmentArgument(const DeclRefExpr &DeclRef, const Decl &Decl,
-                              ASTContext &Context) {
+                              ASTContext &Context, ASTContext::Bounds &Bounds) {
   auto UsedAsConstRefArg = forEachArgumentWithParam(
       declRefExpr(equalsNode(&DeclRef)),
       parmVarDecl(hasType(matchers::isReferenceToConst())));
   auto Matches = match(
       decl(hasDescendant(
           cxxOperatorCallExpr(UsedAsConstRefArg, hasOverloadedOperatorName("="),
                               callee(cxxMethodDecl(isCopyAssignmentOperator())))
               .bind("operatorCallExpr"))),
-      Decl, Context);
+      Decl, Context, Bounds);
   return !Matches.empty();
 }
 
 } // namespace decl_ref_expr
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/ExprSequence.h

 /// - In addition, some `Stmt`s are known to be sequenced before or after
 ///   their siblings. For example, the `Stmt`s that make up a `CompoundStmt`are
 ///   all sequenced relative to each other. The function
 ///   `getSequenceSuccessor()` implements these sequencing rules.
 class ExprSequence {
 public:
   /// Initializes this `ExprSequence` with sequence information for the given
   /// `CFG`. `Root` is the root statement the CFG was built from.
-  ExprSequence(const CFG *TheCFG, const Stmt *Root, ASTContext *TheContext);
+  ExprSequence(const CFG *TheCFG, const Stmt *Root, ASTContext *TheContext,
+               ASTContext::Bounds *Bounds);
 
   /// Returns whether \p Before is sequenced before \p After.
   bool inSequence(const Stmt *Before, const Stmt *After) const;
 
   /// Returns whether \p After can potentially be evaluated after \p Before.
   /// This is exactly equivalent to `!inSequence(After, Before)` but makes some
   /// conditions read more naturally.
   bool potentiallyAfter(const Stmt *After, const Stmt *Before) const;
 
 private:
   // Returns the sibling of \p S (if any) that is directly sequenced after \p S,
   // or nullptr if no such sibling exists. For example, if \p S is the child of
   // a `CompoundStmt`, this would return the Stmt that directly follows \p S in
   // the `CompoundStmt`.
   //
   // As the sequencing of many constructs that change control flow is already
   // encoded in the `CFG`, this function only implements the sequencing rules
   // for those constructs where sequencing cannot be inferred from the `CFG`.
   const Stmt *getSequenceSuccessor(const Stmt *S) const;
 
   const Stmt *resolveSyntheticStmt(const Stmt *S) const;
 
   ASTContext *Context;
+  ASTContext::Bounds *Bounds;
   const Stmt *Root;
 
   llvm::DenseMap<const Stmt *, const Stmt *> SyntheticStmtSourceMap;
 };
 
 /// Maps `Stmt`s to the `CFGBlock` that contains them. Some `Stmt`s may be
 /// contained in more than one `CFGBlock`; in this case, they are mapped to the
 /// innermost block (i.e. the one that is furthest from the root of the tree).
 class StmtToBlockMap {
 public:
   /// Initializes the map for the given `CFG`.
-  StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext);
+  StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext, ASTContext::Bounds *Bounds);
 
   /// Returns the block that \p S is contained in. Some `Stmt`s may be contained
   /// in more than one `CFGBlock`; in this case, this function returns the
   /// innermost block (i.e. the one that is furthest from the root of the tree).
   const CFGBlock *blockContainingStmt(const Stmt *S) const;
 
 private:
   ASTContext *Context;
+  ASTContext::Bounds *Bounds;
 
   llvm::DenseMap<const Stmt *, const CFGBlock *> Map;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRSEQUENCE_H

clang-tidy/utils/ExprSequence.cpp

 //
 // The case that a Stmt has multiple parents is rare but does actually occur in
 // the parts of the AST that we're interested in. Specifically, InitListExpr
 // nodes cause ASTContext::getParent() to return multiple parents for certain
 // nodes in their subtree because RecursiveASTVisitor visits both the syntactic
 // and semantic forms of InitListExpr, and the parent-child relationships are
 // different between the two forms.
 static SmallVector<const Stmt *, 1> getParentStmts(const Stmt *S,
-                                                   ASTContext *Context) {
+                                                   ASTContext *Context,
+                                                   ASTContext::Bounds *Bounds) {
   SmallVector<const Stmt *, 1> Result;
 
-  ASTContext::DynTypedNodeList Parents = Context->getParents(*S);
+  ASTContext::DynTypedNodeList Parents = Context->getParents(*S, *Bounds);
 
   SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(),
                                                                Parents.end());
 
   while (!NodesToProcess.empty()) {
     ast_type_traits::DynTypedNode Node = NodesToProcess.back();
     NodesToProcess.pop_back();
 
     if (const auto *S = Node.get<Stmt>()) {
       Result.push_back(S);
     } else {
-      Parents = Context->getParents(Node);
+      Parents = Context->getParents(Node, *Bounds);
       NodesToProcess.append(Parents.begin(), Parents.end());
     }
   }
 
   return Result;
 }
 
 namespace {
 bool isDescendantOrEqual(const Stmt *Descendant, const Stmt *Ancestor,
-                         ASTContext *Context) {
+                         ASTContext *Context, ASTContext::Bounds *Bounds) {
   if (Descendant == Ancestor)
     return true;
-  for (const Stmt *Parent : getParentStmts(Descendant, Context)) {
-    if (isDescendantOrEqual(Parent, Ancestor, Context))
+  for (const Stmt *Parent : getParentStmts(Descendant, Context, Bounds)) {
+    if (isDescendantOrEqual(Parent, Ancestor, Context, Bounds))
       return true;
   }
 
   return false;
 }
 }
 
 ExprSequence::ExprSequence(const CFG *TheCFG, const Stmt *Root,
-                           ASTContext *TheContext)
-    : Context(TheContext), Root(Root) {
+                           ASTContext *TheContext, ASTContext::Bounds *Bounds)
+    : Context(TheContext), Bounds(Bounds), Root(Root) {
   for (const auto &SyntheticStmt : TheCFG->synthetic_stmts()) {
     SyntheticStmtSourceMap[SyntheticStmt.first] = SyntheticStmt.second;
   }
 }
 
 bool ExprSequence::inSequence(const Stmt *Before, const Stmt *After) const {
   Before = resolveSyntheticStmt(Before);
   After = resolveSyntheticStmt(After);
 
   // If 'After' is in the subtree of the siblings that follow 'Before' in the
   // chain of successors, we know that 'After' is sequenced after 'Before'.
   for (const Stmt *Successor = getSequenceSuccessor(Before); Successor;
        Successor = getSequenceSuccessor(Successor)) {
-    if (isDescendantOrEqual(After, Successor, Context))
+    if (isDescendantOrEqual(After, Successor, Context, Bounds))
       return true;
   }
 
   // If 'After' is a parent of 'Before' or is sequenced after one of these
   // parents, we know that it is sequenced after 'Before'.
-  for (const Stmt *Parent : getParentStmts(Before, Context)) {
+  for (const Stmt *Parent : getParentStmts(Before, Context, Bounds)) {
     if (Parent == After || inSequence(Parent, After))
       return true;
   }
 
   return false;
 }
 
 bool ExprSequence::potentiallyAfter(const Stmt *After,
                                     const Stmt *Before) const {
   return !inSequence(After, Before);
 }
 
 const Stmt *ExprSequence::getSequenceSuccessor(const Stmt *S) const {
-  for (const Stmt *Parent : getParentStmts(S, Context)) {
+  for (const Stmt *Parent : getParentStmts(S, Context, Bounds)) {
     // If a statement has multiple parents, make sure we're using the parent
     // that lies within the sub-tree under Root.
-    if (!isDescendantOrEqual(Parent, Root, Context))
+    if (!isDescendantOrEqual(Parent, Root, Context, Bounds))
       continue;
 
     if (const auto *BO = dyn_cast<BinaryOperator>(Parent)) {
       // Comma operator: Right-hand side is sequenced after the left-hand side.
       if (BO->getLHS() == S && BO->getOpcode() == BO_Comma)
         return BO->getRHS();
     } else if (const auto *InitList = dyn_cast<InitListExpr>(Parent)) {
       // Initializer list: Each initializer clause is sequenced after the

 }
 
 const Stmt *ExprSequence::resolveSyntheticStmt(const Stmt *S) const {
   if (SyntheticStmtSourceMap.count(S))
     return SyntheticStmtSourceMap.lookup(S);
   return S;
 }
 
-StmtToBlockMap::StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext)
-    : Context(TheContext) {
+StmtToBlockMap::StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext, ASTContext::Bounds *Bounds)
+    : Context(TheContext),Bounds(Bounds) {
   for (const auto *B : *TheCFG) {
     for (const auto &Elem : *B) {
       if (Optional<CFGStmt> S = Elem.getAs<CFGStmt>())
         Map[S->getStmt()] = B;
     }
   }
 }
 
 const CFGBlock *StmtToBlockMap::blockContainingStmt(const Stmt *S) const {
   while (!Map.count(S)) {
-    SmallVector<const Stmt *, 1> Parents = getParentStmts(S, Context);
+    SmallVector<const Stmt *, 1> Parents = getParentStmts(S, Context, Bounds);
     if (Parents.empty())
       return nullptr;
     S = Parents[0];
   }
 
   return Map.lookup(S);
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/NamespaceAliaser.h

 // This class creates function-level namespace aliases.
 class NamespaceAliaser {
 public:
   explicit NamespaceAliaser(const SourceManager &SourceMgr);
   // Adds a namespace alias for \p Namespace valid near \p
   // Statement. Picks the first available name from \p Abbreviations.
   // Returns ``llvm::None`` if an alias already exists or there is an error.
   llvm::Optional<FixItHint>
-  createAlias(ASTContext &Context, const Stmt &Statement,
-              llvm::StringRef Namespace,
+  createAlias(ASTContext &Context, ASTContext::Bounds &Bounds,
+              const Stmt &Statement, llvm::StringRef Namespace,
               const std::vector<std::string> &Abbreviations);
 
   // Get an alias name for \p Namespace valid at \p Statement. Returns \p
   // Namespace if there is no alias.
-  std::string getNamespaceName(ASTContext &Context, const Stmt &Statement,
+  std::string getNamespaceName(ASTContext &Context, ASTContext::Bounds &Bounds,
+                               const Stmt &Statement,
                                llvm::StringRef Namespace) const;
 
 private:
   const SourceManager &SourceMgr;
   llvm::DenseMap<const FunctionDecl *, llvm::StringMap<std::string>>
       AddedAliases;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_NAMESPACEALIASER_H

clang-tidy/utils/NamespaceAliaser.cpp

NamespaceAliaser::NamespaceAliaser(const SourceManager &SourceMgr)
     : SourceMgr(SourceMgr) {}
 
 AST_MATCHER_P(NamespaceAliasDecl, hasTargetNamespace,
               ast_matchers::internal::Matcher<NamespaceDecl>, innerMatcher) {
   return innerMatcher.matches(*Node.getNamespace(), Finder, Builder);
 }
 
 Optional<FixItHint>
-NamespaceAliaser::createAlias(ASTContext &Context, const Stmt &Statement,
-                              StringRef Namespace,
+NamespaceAliaser::createAlias(ASTContext &Context, ASTContext::Bounds &Bounds,
+                              const Stmt &Statement, StringRef Namespace,
                               const std::vector<std::string> &Abbreviations) {
-  const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
+  const FunctionDecl *Function = getSurroundingFunction(Context, Bounds, Statement);
   if (!Function || !Function->hasBody())
     return None;
 
   if (AddedAliases[Function].count(Namespace.str()) != 0)
     return None;
 
   // FIXME: Doesn't consider the order of declarations.
   // If we accidentially pick an alias defined later in the function,
   // the output won't compile.
   // FIXME: Also doesn't consider file or class-scope aliases.
 
   const auto *ExistingAlias = selectFirst<NamedDecl>(
       "alias",
       match(functionDecl(hasBody(compoundStmt(has(declStmt(
                 has(namespaceAliasDecl(hasTargetNamespace(hasName(Namespace)))
                         .bind("alias"))))))),
-            *Function, Context));
+            *Function, Context, Bounds));
 
   if (ExistingAlias != nullptr) {
     AddedAliases[Function][Namespace.str()] = ExistingAlias->getName().str();
     return None;
   }
 
   for (const auto &Abbreviation : Abbreviations) {
     DeclarationMatcher ConflictMatcher = namedDecl(hasName(Abbreviation));
     const auto HasConflictingChildren =
-        !match(findAll(ConflictMatcher), *Function, Context).empty();
+        !match(findAll(ConflictMatcher), *Function, Context, Bounds).empty();
     const auto HasConflictingAncestors =
         !match(functionDecl(hasAncestor(decl(has(ConflictMatcher)))), *Function,
-               Context)
+               Context, Bounds)
              .empty();
     if (HasConflictingAncestors || HasConflictingChildren)
       continue;
 
     std::string Declaration =
         (llvm::Twine("\nnamespace ") + Abbreviation + " = " + Namespace + ";")
             .str();
     SourceLocation Loc =
         Lexer::getLocForEndOfToken(Function->getBody()->getBeginLoc(), 0,
                                    SourceMgr, Context.getLangOpts());
     AddedAliases[Function][Namespace.str()] = Abbreviation;
     return FixItHint::CreateInsertion(Loc, Declaration);
   }
 
   return None;
 }
 
 std::string NamespaceAliaser::getNamespaceName(ASTContext &Context,
+                                               ASTContext::Bounds &Bounds,
                                                const Stmt &Statement,
                                                StringRef Namespace) const {
-  const auto *Function = getSurroundingFunction(Context, Statement);
+  const auto *Function = getSurroundingFunction(Context, Bounds, Statement);
   auto FunctionAliases = AddedAliases.find(Function);
   if (FunctionAliases != AddedAliases.end()) {
     if (FunctionAliases->second.count(Namespace) != 0) {
       return FunctionAliases->second.find(Namespace)->getValue();
     }
   }
   return Namespace.str();
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/UsingInserter.h

 //===---------- UsingInserter.h - clang-tidy ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_USINGINSERTER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_USINGINSERTER_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Stmt.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include <set>
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 // UsingInserter adds using declarations for |QualifiedName| to the surrounding
 // function.
 // This allows using a shorter name without clobbering other scopes.
 class UsingInserter {
 public:
   UsingInserter(const SourceManager &SourceMgr);
 
   // Creates a \p using declaration fixit. Returns ``llvm::None`` on error
   // or if the using declaration already exists.
   llvm::Optional<FixItHint>
-  createUsingDeclaration(ASTContext &Context, const Stmt &Statement,
-                         llvm::StringRef QualifiedName);
+  createUsingDeclaration(ASTContext &Context, ASTContext::Bounds &Bounds,
+                         const Stmt &Statement, llvm::StringRef QualifiedName);
 
   // Returns the unqualified version of the name if there is an
   // appropriate using declaration and the qualified name otherwise.
-  llvm::StringRef getShortName(ASTContext &Context, const Stmt &Statement,
+  llvm::StringRef getShortName(ASTContext &Context, ASTContext::Bounds &Bounds,
+                               const Stmt &Statement,
                                llvm::StringRef QualifiedName);
 
 private:
   typedef std::pair<const FunctionDecl *, std::string> NameInFunction;
   const SourceManager &SourceMgr;
   std::set<NameInFunction> AddedUsing;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_USINGINSERTER_H

clang-tidy/utils/UsingInserter.cpp

if (LastSeparatorPos == StringRef::npos)
     return QualifiedName;
   return QualifiedName.drop_front(LastSeparatorPos + 2);
 }
 
 UsingInserter::UsingInserter(const SourceManager &SourceMgr)
     : SourceMgr(SourceMgr) {}
 
 Optional<FixItHint> UsingInserter::createUsingDeclaration(
-    ASTContext &Context, const Stmt &Statement, StringRef QualifiedName) {
+    ASTContext &Context, ASTContext::Bounds &Bounds, const Stmt &Statement, StringRef QualifiedName) {
   StringRef UnqualifiedName = getUnqualifiedName(QualifiedName);
-  const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
+  const FunctionDecl *Function =
+      getSurroundingFunction(Context, Bounds, Statement);
   if (!Function)
     return None;
 
   if (AddedUsing.count(std::make_pair(Function, QualifiedName.str())) != 0)
     return None;
 
   SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
       Function->getBody()->getBeginLoc(), 0, SourceMgr, Context.getLangOpts());
 
   // Only use using declarations in the main file, not in includes.
   if (SourceMgr.getFileID(InsertLoc) != SourceMgr.getMainFileID())
     return None;
 
   // FIXME: This declaration could be masked. Investigate if
   // there is a way to avoid using Sema.
   bool AlreadyHasUsingDecl =
       !match(stmt(hasAncestor(decl(has(usingDecl(hasAnyUsingShadowDecl(
                  hasTargetDecl(hasName(QualifiedName.str())))))))),
-             Statement, Context)
+             Statement, Context, Bounds)
            .empty();
   if (AlreadyHasUsingDecl) {
     AddedUsing.emplace(NameInFunction(Function, QualifiedName.str()));
     return None;
   }
   // Find conflicting declarations and references.
   auto ConflictingDecl = namedDecl(hasName(UnqualifiedName));
   bool HasConflictingDeclaration =
-      !match(findAll(ConflictingDecl), *Function, Context).empty();
-  bool HasConflictingDeclRef =
-      !match(findAll(declRefExpr(to(ConflictingDecl))), *Function, Context)
+      !match(findAll(ConflictingDecl), *Function, Context, Bounds).empty();
+  bool HasConflictingDeclRef = !match(findAll(declRefExpr(to(ConflictingDecl))),
+                                      *Function, Context, Bounds)
                                     .empty();
   if (HasConflictingDeclaration || HasConflictingDeclRef)
     return None;
 
   std::string Declaration =
       (llvm::Twine("\nusing ") + QualifiedName + ";").str();
 
   AddedUsing.emplace(std::make_pair(Function, QualifiedName.str()));
   return FixItHint::CreateInsertion(InsertLoc, Declaration);
 }
 
 StringRef UsingInserter::getShortName(ASTContext &Context,
+                                      ASTContext::Bounds &Bounds,
                                       const Stmt &Statement,
                                       StringRef QualifiedName) {
-  const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
+  const FunctionDecl *Function =
+      getSurroundingFunction(Context, Bounds, Statement);
   if (AddedUsing.count(NameInFunction(Function, QualifiedName.str())) != 0)
     return getUnqualifiedName(QualifiedName);
   return QualifiedName;
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clangd/ClangdUnit.cpp

ParsedAST::build(std::unique_ptr<CompilerInvocation> CI,
   ast_matchers::MatchFinder CTFinder;
   llvm::Optional<tidy::ClangTidyContext> CTContext;
   {
     trace::Span Tracer("ClangTidyInit");
     tidy::ClangTidyCheckFactories CTFactories;
     for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
       E.instantiate()->addCheckFactories(CTFactories);
     auto CTOpts = tidy::ClangTidyOptions::getDefaults();
-    // FIXME: this needs to be configurable, and we need to support .clang-tidy
-    // files and other options providers.
-    // There is an important bug to fix before turning on arbitrary checks:
-    // we must restrict the AST parent map to the current file for performance.
-    // The placeholder check here does not use hasAncestor() so is unaffected.
-    CTOpts.Checks = "bugprone-sizeof-expression";
+    CTOpts.Checks = "*";
     CTContext.emplace(llvm::make_unique<tidy::DefaultOptionsProvider>(
         tidy::ClangTidyGlobalOptions(), CTOpts));
     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
     CTContext->setASTContext(&Clang->getASTContext());
     CTContext->setCurrentFile(MainInput.getFile());
     CTFactories.createChecks(CTContext.getPointer(), CTChecks);
     for (const auto &Check : CTChecks) {
       Check->registerPPCallbacks(*Clang);
ParsedAST::build(std::unique_ptr<CompilerInvocation> CI,
   if (!Action->Execute())
     log("Execute() failed when building AST for {0}", MainInput.getFile());
 
   std::vector<Decl *> ParsedDecls = Action->takeTopLevelDecls();
   {
     // Run the AST-dependent part of the clang-tidy checks.
     // (The preprocessor part ran already, via PPCallbacks).
     trace::Span Tracer("ClangTidyMatch");
-    CTFinder.matchAST(Clang->getASTContext(), ParsedDecls);
+    CTFinder.matchAST(Clang->getASTContext(),
+                      *Clang->getASTContext().bounds(ParsedDecls));
   }
 
   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
   // has a longer lifetime.
   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
   // CompilerInstance won't run this callback, do it directly.
   ASTDiags.EndSourceFile();
   // XXX: This is messy: clang-tidy checks flush some diagnostics at EOF.

clangd/CodeComplete.cpp

 #include "Quality.h"
 #include "SourceCode.h"
 #include "TUScheduler.h"
 #include "Trace.h"
 #include "URI.h"
 #include "index/Index.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
semaCodeComplete(
       llvm::make_unique<SignatureHelpCollector>(Options, Index, Result),
       Options,
       {FileName, Command, Preamble, Contents, Pos, std::move(VFS),
        std::move(PCHs)});
   return Result;
 }
 
 bool isIndexedForCodeCompletion(const NamedDecl &ND, ASTContext &ASTCtx) {
-  using namespace clang::ast_matchers;
-  auto InTopLevelScope = hasDeclContext(
-      anyOf(namespaceDecl(), translationUnitDecl(), linkageSpecDecl()));
-  return !match(decl(anyOf(InTopLevelScope,
-                           hasDeclContext(
-                               enumDecl(InTopLevelScope, unless(isScoped()))))),
-                ND, ASTCtx)
-              .empty();
+  auto *DC = ND.getDeclContext();
+  if (auto* Enum = dyn_cast<EnumDecl>(DC))
+    if (!Enum->isScoped())
+      DC = Enum->getDeclContext();
+  switch (DC->getDeclKind()) {
+    case Decl::Namespace:
+    case Decl::TranslationUnit:
+    case Decl::LinkageSpec:
+      return true;
+    default:
+      return false;
+  }
 }
 
 CompletionItem CodeCompletion::render(const CodeCompleteOptions &Opts) const {
   CompletionItem LSP;
   const auto *InsertInclude = Includes.empty() ? nullptr : &Includes[0];
   LSP.label = ((InsertInclude && InsertInclude->Insertion)
                    ? Opts.IncludeIndicator.Insert
                    : Opts.IncludeIndicator.NoInsert) +

unittests/clang-tidy/NamespaceAliaserTest.cpp

void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::callExpr().bind("foo"), this);
   }
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     if (!Aliaser)
       Aliaser.reset(new NamespaceAliaser(*Result.SourceManager));
 
     const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo");
     assert(Call != nullptr && "Did not find node \"foo\"");
-    auto Hint = Aliaser->createAlias(*Result.Context, *Call, "::foo::bar",
-                                     {"b", "some_alias"});
+    auto Hint = Aliaser->createAlias(*Result.Context, *Result.Bounds, *Call,
+                                     "::foo::bar", {"b", "some_alias"});
     if (Hint.hasValue())
       diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
 
     diag(Call->getBeginLoc(), "insert call") << FixItHint::CreateInsertion(
         Call->getBeginLoc(),
-        Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") + "::");
+        Aliaser->getNamespaceName(*Result.Context, *Result.Bounds, *Call,
+                                  "::foo::bar") +
+            "::");
   }
 
 private:
   std::unique_ptr<NamespaceAliaser> Aliaser;
 };
 
 template <typename Check>
 std::string runChecker(StringRef Code, unsigned ExpectedWarningCount) {

unittests/clang-tidy/UsingInserterTest.cpp

public:
   }
   void
   check(const clang::ast_matchers::MatchFinder::MatchResult &Result) override {
     if (!Inserter)
       Inserter.reset(new UsingInserter(*Result.SourceManager));
 
     const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo");
     assert(Call != nullptr && "Did not find node \"foo\"");
-    auto Hint =
-        Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func");
+    auto Hint = Inserter->createUsingDeclaration(
+        *Result.Context, *Result.Bounds, *Call, "::foo::func");
 
     if (Hint.hasValue())
       diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue();
 
     diag(Call->getBeginLoc(), "insert call")
         << clang::FixItHint::CreateReplacement(
                Call->getCallee()->getSourceRange(),
-               Inserter->getShortName(*Result.Context, *Call, "::foo::func"));
+               Inserter->getShortName(*Result.Context, *Result.Bounds, *Call,
+                                      "::foo::func"));
   }
 
 private:
   std::unique_ptr<UsingInserter> Inserter;
 };
 
 template <typename Check>
 std::string runChecker(StringRef Code, unsigned ExpectedWarningCount) {