[clang-tidy] Update checks to play nicely with limited traversal scope added in r346847

[sammccall]

Summary

(See D54204 for original review)

[sammccall]

Address comments from the last round of review in D54204.

[hokein]

LGTM

clang-tidy/readability/SimplifyBooleanExprCheck.cpp

567 ↗

(On Diff #174203)

Ah, what I mean is assert(MatchedOnce).

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

return FixItHint::CreateRemoval(removeNode(
       Result, Index > 0 ? Call->getArg(Index - 1) : nullptr,
       Call->getArg(Index),
       Index + 1 < Call->getNumArgs() ? Call->getArg(Index + 1) : nullptr));
 }
 
 class UnusedParametersCheck::IndexerVisitor
     : public RecursiveASTVisitor<IndexerVisitor> {
 public:
-  IndexerVisitor(TranslationUnitDecl *Top) { TraverseDecl(Top); }
+  IndexerVisitor(ASTContext &Ctx) { TraverseAST(Ctx); }
 
   const std::unordered_set<const CallExpr *> &
   getFnCalls(const FunctionDecl *Fn) {
     return Index[Fn->getCanonicalDecl()].Calls;
   }
 
   const std::unordered_set<const DeclRefExpr *> &
   getOtherRefs(const FunctionDecl *Fn) {

 
 void UnusedParametersCheck::warnOnUnusedParameter(
     const MatchFinder::MatchResult &Result, const FunctionDecl *Function,
     unsigned ParamIndex) {
   const auto *Param = Function->getParamDecl(ParamIndex);
   auto MyDiag = diag(Param->getLocation(), "parameter %0 is unused") << Param;
 
   if (!Indexer) {
-    Indexer = llvm::make_unique<IndexerVisitor>(
-        Result.Context->getTranslationUnitDecl());
+    Indexer = llvm::make_unique<IndexerVisitor>(*Result.Context);
   }
 
   // Comment out parameter name for non-local functions.
   if (Function->isExternallyVisible() ||
       !Result.SourceManager->isInMainFile(Function->getLocation()) ||
       !Indexer->getOtherRefs(Function).empty() || isOverrideMethod(Function)) {
     SourceRange RemovalRange(Param->getLocation());
     // Note: We always add a space before the '/*' to not accidentally create a

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

void LoopConvertCheck::check(const MatchFinder::MatchResult &Result) {
   const UsageResult &Usages = Finder.getUsages();
   determineRangeDescriptor(Context, 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());
+  TUInfo->getParentFinder().gatherAncestors(*Context);
   DependencyFinderASTVisitor DependencyFinder(
       &TUInfo->getParentFinder().getStmtToParentStmtMap(),
       &TUInfo->getParentFinder().getDeclToParentStmtMap(),
       &TUInfo->getReplacedVars(), Loop);
 
   if (DependencyFinder.dependsOnInsideVariable(ContainerExpr) ||
       Descriptor.ContainerString.empty() || Usages.empty() ||
       ConfidenceLevel.getLevel() < MinConfidence)

clang-tools-extra/trunk/clang-tidy/modernize/LoopConvertUtils.h

 
 /// \brief Class used build the reverse AST properties needed to detect
 /// name conflicts and free variables.
 class StmtAncestorASTVisitor
     : public clang::RecursiveASTVisitor<StmtAncestorASTVisitor> {
 public:
   StmtAncestorASTVisitor() { StmtStack.push_back(nullptr); }
 
-  /// \brief Run the analysis on the TranslationUnitDecl.
+  /// \brief Run the analysis on the AST.
   ///
   /// In case we're running this analysis multiple times, don't repeat the work.
-  void gatherAncestors(const clang::TranslationUnitDecl *T) {
+  void gatherAncestors(ASTContext &Ctx) {
     if (StmtAncestors.empty())
-      TraverseDecl(const_cast<clang::TranslationUnitDecl *>(T));
+      TraverseAST(Ctx);
   }
 
   /// Accessor for StmtAncestors.
   const StmtParentMap &getStmtToParentStmtMap() { return StmtAncestors; }
 
   /// Accessor for DeclParents.
   const DeclParentMap &getDeclToParentStmtMap() { return DeclParents; }
 

clang-tools-extra/trunk/clang-tidy/readability/SimplifyBooleanExprCheck.h

private:
   void replaceCompoundReturnWithCondition(
       const ast_matchers::MatchFinder::MatchResult &Result,
       const CompoundStmt *Compound, bool Negated = false);
 
   void issueDiag(const ast_matchers::MatchFinder::MatchResult &Result,
                  SourceLocation Loc, StringRef Description,
                  SourceRange ReplacementRange, StringRef Replacement);
 
+  bool MatchedOnce = false;
   const bool ChainedConditionalReturn;
   const bool ChainedConditionalAssignment;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFY_BOOLEAN_EXPR_H

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

 }
 
 void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
   Options.store(Opts, "ChainedConditionalAssignment",
                 ChainedConditionalAssignment);
 }
 
+// This is a silly hack to let us run a RecursiveASTVisitor on the Context.
+// We want to match exactly one node in the AST, doesn't matter which.
+AST_MATCHER_P(Decl, matchOnce, bool *, Matched) {
+  if (*Matched)
+    return false;
+  return *Matched = true;
+}
+
 void SimplifyBooleanExprCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(translationUnitDecl().bind("top"), this);
+  Finder->addMatcher(matchOnce(&MatchedOnce), this);
 
   matchBoolCondition(Finder, true, ConditionThenStmtId);
   matchBoolCondition(Finder, false, ConditionElseStmtId);
 
   matchTernaryResult(Finder, true, TernaryId);
   matchTernaryResult(Finder, false, TernaryNegatedId);
 
   matchIfReturnsBool(Finder, true, IfReturnsBoolId);
else if (const auto *IfAssignNot =
                Result.Nodes.getNodeAs<IfStmt>(IfAssignNotBoolId))
     replaceWithAssignment(Result, IfAssignNot, true);
   else if (const auto *Compound =
                Result.Nodes.getNodeAs<CompoundStmt>(CompoundBoolId))
     replaceCompoundReturnWithCondition(Result, Compound);
   else if (const auto *Compound =
                Result.Nodes.getNodeAs<CompoundStmt>(CompoundNotBoolId))
     replaceCompoundReturnWithCondition(Result, Compound, true);
-  else if (const auto TU = Result.Nodes.getNodeAs<Decl>("top"))
-    Visitor(this, Result).TraverseDecl(const_cast<Decl*>(TU));
+  else { // MatchOnce matcher
+    assert(MatchedOnce);
+    Visitor(this, Result).TraverseAST(*Result.Context);
+  }
 }
 
 void SimplifyBooleanExprCheck::issueDiag(
     const ast_matchers::MatchFinder::MatchResult &Result, SourceLocation Loc,
     StringRef Description, SourceRange ReplacementRange,
     StringRef Replacement) {
   CharSourceRange CharRange =
       Lexer::makeFileCharRange(CharSourceRange::getTokenRange(ReplacementRange),