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

   1 //===--- ElseAfterReturnCheck.cpp - clang-tidy-----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ElseAfterReturnCheck.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/ASTMatchers/ASTMatchFinder.h"
  12 #include "clang/Lex/Lexer.h"
  13 #include "clang/Lex/Preprocessor.h"
  14 #include "clang/Tooling/FixIt.h"
  15 #include "llvm/ADT/SmallVector.h"
  16
  17 using namespace clang::ast_matchers;
  18
  19 namespace clang {
  20 namespace tidy {
  21 namespace readability {
  22
  23 namespace {
  24
  25 class PPConditionalCollector : public PPCallbacks {
  26 public:
  27   PPConditionalCollector(
  28       ElseAfterReturnCheck::ConditionalBranchMap &Collections,
  29       const SourceManager &SM)
  30       : Collections(Collections), SM(SM) {}
  31   void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
  32     if (!SM.isWrittenInSameFile(Loc, IfLoc))
  33       return;
  34     SmallVectorImpl<SourceRange> &Collection = Collections[SM.getFileID(Loc)];
  35     assert(Collection.empty() || Collection.back().getEnd() < Loc);
  36     Collection.emplace_back(IfLoc, Loc);
  37   }
  38
  39 private:
  40   ElseAfterReturnCheck::ConditionalBranchMap &Collections;
  41   const SourceManager &SM;
  42 };
  43
  44 } // namespace
  45
  46 static const char InterruptingStr[] = "interrupting";
  47 static const char WarningMessage[] = "do not use 'else' after '%0'";
  48 static const char WarnOnUnfixableStr[] = "WarnOnUnfixable";
  49 static const char WarnOnConditionVariablesStr[] = "WarnOnConditionVariables";
  50
  51 static const DeclRefExpr *findUsage(const Stmt *Node, int64_t DeclIdentifier) {
  52   if (!Node)
  53     return nullptr;
  54   if (const auto *DeclRef = dyn_cast<DeclRefExpr>(Node)) {
  55     if (DeclRef->getDecl()->getID() == DeclIdentifier)
  56       return DeclRef;
  57   } else {
  58     for (const Stmt *ChildNode : Node->children()) {
  59       if (const DeclRefExpr *Result = findUsage(ChildNode, DeclIdentifier))
  60         return Result;
  61     }
  62   }
  63   return nullptr;
  64 }
  65
  66 static const DeclRefExpr *
  67 findUsageRange(const Stmt *Node,
  68                const llvm::ArrayRef<int64_t> &DeclIdentifiers) {
  69   if (!Node)
  70     return nullptr;
  71   if (const auto *DeclRef = dyn_cast<DeclRefExpr>(Node)) {
  72     if (llvm::is_contained(DeclIdentifiers, DeclRef->getDecl()->getID()))
  73       return DeclRef;
  74   } else {
  75     for (const Stmt *ChildNode : Node->children()) {
  76       if (const DeclRefExpr *Result =
  77               findUsageRange(ChildNode, DeclIdentifiers))
  78         return Result;
  79     }
  80   }
  81   return nullptr;
  82 }
  83
  84 static const DeclRefExpr *checkInitDeclUsageInElse(const IfStmt *If) {
  85   const auto *InitDeclStmt = dyn_cast_or_null<DeclStmt>(If->getInit());
  86   if (!InitDeclStmt)
  87     return nullptr;
  88   if (InitDeclStmt->isSingleDecl()) {
  89     const Decl *InitDecl = InitDeclStmt->getSingleDecl();
  90     assert(isa<VarDecl>(InitDecl) && "SingleDecl must be a VarDecl");
  91     return findUsage(If->getElse(), InitDecl->getID());
  92   }
  93   llvm::SmallVector<int64_t, 4> DeclIdentifiers;
  94   for (const Decl *ChildDecl : InitDeclStmt->decls()) {
  95     assert(isa<VarDecl>(ChildDecl) && "Init Decls must be a VarDecl");
  96     DeclIdentifiers.push_back(ChildDecl->getID());
  97   }
  98   return findUsageRange(If->getElse(), DeclIdentifiers);
  99 }
 100
 101 static const DeclRefExpr *checkConditionVarUsageInElse(const IfStmt *If) {
 102   if (const VarDecl *CondVar = If->getConditionVariable())
 103     return findUsage(If->getElse(), CondVar->getID());
 104   return nullptr;
 105 }
 106
 107 static bool containsDeclInScope(const Stmt *Node) {
 108   if (isa<DeclStmt>(Node))
 109     return true;
 110   if (const auto *Compound = dyn_cast<CompoundStmt>(Node))
 111     return llvm::any_of(Compound->body(), [](const Stmt *SubNode) {
 112       return isa<DeclStmt>(SubNode);
 113     });
 114   return false;
 115 }
 116
 117 static void removeElseAndBrackets(DiagnosticBuilder &Diag, ASTContext &Context,
 118                            const Stmt *Else, SourceLocation ElseLoc) {
 119   auto Remap = [&](SourceLocation Loc) {
 120     return Context.getSourceManager().getExpansionLoc(Loc);
 121   };
 122   auto TokLen = [&](SourceLocation Loc) {
 123     return Lexer::MeasureTokenLength(Loc, Context.getSourceManager(),
 124                                      Context.getLangOpts());
 125   };
 126
 127   if (const auto *CS = dyn_cast<CompoundStmt>(Else)) {
 128     Diag << tooling::fixit::createRemoval(ElseLoc);
 129     SourceLocation LBrace = CS->getLBracLoc();
 130     SourceLocation RBrace = CS->getRBracLoc();
 131     SourceLocation RangeStart =
 132         Remap(LBrace).getLocWithOffset(TokLen(LBrace) + 1);
 133     SourceLocation RangeEnd = Remap(RBrace).getLocWithOffset(-1);
 134
 135     llvm::StringRef Repl = Lexer::getSourceText(
 136         CharSourceRange::getTokenRange(RangeStart, RangeEnd),
 137         Context.getSourceManager(), Context.getLangOpts());
 138     Diag << tooling::fixit::createReplacement(CS->getSourceRange(), Repl);
 139   } else {
 140     SourceLocation ElseExpandedLoc = Remap(ElseLoc);
 141     SourceLocation EndLoc = Remap(Else->getEndLoc());
 142
 143     llvm::StringRef Repl = Lexer::getSourceText(
 144         CharSourceRange::getTokenRange(
 145             ElseExpandedLoc.getLocWithOffset(TokLen(ElseLoc) + 1), EndLoc),
 146         Context.getSourceManager(), Context.getLangOpts());
 147     Diag << tooling::fixit::createReplacement(
 148         SourceRange(ElseExpandedLoc, EndLoc), Repl);
 149   }
 150 }
 151
 152 ElseAfterReturnCheck::ElseAfterReturnCheck(StringRef Name,
 153                                            ClangTidyContext *Context)
 154     : ClangTidyCheck(Name, Context),
 155       WarnOnUnfixable(Options.get(WarnOnUnfixableStr, true)),
 156       WarnOnConditionVariables(Options.get(WarnOnConditionVariablesStr, true)) {
 157 }
 158
 159 void ElseAfterReturnCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
 160   Options.store(Opts, WarnOnUnfixableStr, WarnOnUnfixable);
 161   Options.store(Opts, WarnOnConditionVariablesStr, WarnOnConditionVariables);
 162 }
 163
 164 void ElseAfterReturnCheck::registerPPCallbacks(const SourceManager &SM,
 165                                                Preprocessor *PP,
 166                                                Preprocessor *ModuleExpanderPP) {
 167   PP->addPPCallbacks(
 168       std::make_unique<PPConditionalCollector>(this->PPConditionals, SM));
 169 }
 170
 171 void ElseAfterReturnCheck::registerMatchers(MatchFinder *Finder) {
 172   const auto InterruptsControlFlow = stmt(anyOf(
 173       returnStmt().bind(InterruptingStr), continueStmt().bind(InterruptingStr),
 174       breakStmt().bind(InterruptingStr), cxxThrowExpr().bind(InterruptingStr)));
 175   Finder->addMatcher(
 176       compoundStmt(
 177           forEach(ifStmt(unless(isConstexpr()),
 178                          hasThen(stmt(
 179                              anyOf(InterruptsControlFlow,
 180                                    compoundStmt(has(InterruptsControlFlow))))),
 181                          hasElse(stmt().bind("else")))
 182                       .bind("if")))
 183           .bind("cs"),
 184       this);
 185 }
 186
 187 static bool hasPreprocessorBranchEndBetweenLocations(
 188     const ElseAfterReturnCheck::ConditionalBranchMap &ConditionalBranchMap,
 189     const SourceManager &SM, SourceLocation StartLoc, SourceLocation EndLoc) {
 190
 191   SourceLocation ExpandedStartLoc = SM.getExpansionLoc(StartLoc);
 192   SourceLocation ExpandedEndLoc = SM.getExpansionLoc(EndLoc);
 193   if (!SM.isWrittenInSameFile(ExpandedStartLoc, ExpandedEndLoc))
 194     return false;
 195
 196   // StartLoc and EndLoc expand to the same macro.
 197   if (ExpandedStartLoc == ExpandedEndLoc)
 198     return false;
 199
 200   assert(ExpandedStartLoc < ExpandedEndLoc);
 201
 202   auto Iter = ConditionalBranchMap.find(SM.getFileID(ExpandedEndLoc));
 203
 204   if (Iter == ConditionalBranchMap.end() || Iter->getSecond().empty())
 205     return false;
 206
 207   const SmallVectorImpl<SourceRange> &ConditionalBranches = Iter->getSecond();
 208
 209   assert(llvm::is_sorted(ConditionalBranches,
 210                          [](const SourceRange &LHS, const SourceRange &RHS) {
 211                            return LHS.getEnd() < RHS.getEnd();
 212                          }));
 213
 214   // First conditional block that ends after ExpandedStartLoc.
 215   const auto *Begin =
 216       llvm::lower_bound(ConditionalBranches, ExpandedStartLoc,
 217                         [](const SourceRange &LHS, const SourceLocation &RHS) {
 218                           return LHS.getEnd() < RHS;
 219                         });
 220   const auto *End = ConditionalBranches.end();
 221   for (; Begin != End && Begin->getEnd() < ExpandedEndLoc; ++Begin)
 222     if (Begin->getBegin() < ExpandedStartLoc)
 223       return true;
 224   return false;
 225 }
 226
 227 static StringRef getControlFlowString(const Stmt &Stmt) {
 228   if (isa<ReturnStmt>(Stmt))
 229     return "return";
 230   if (isa<ContinueStmt>(Stmt))
 231     return "continue";
 232   if (isa<BreakStmt>(Stmt))
 233     return "break";
 234   if (isa<CXXThrowExpr>(Stmt))
 235     return "throw";
 236   llvm_unreachable("Unknown control flow interruptor");
 237 }
 238
 239 void ElseAfterReturnCheck::check(const MatchFinder::MatchResult &Result) {
 240   const auto *If = Result.Nodes.getNodeAs<IfStmt>("if");
 241   const auto *Else = Result.Nodes.getNodeAs<Stmt>("else");
 242   const auto *OuterScope = Result.Nodes.getNodeAs<CompoundStmt>("cs");
 243   const auto *Interrupt = Result.Nodes.getNodeAs<Stmt>(InterruptingStr);
 244   SourceLocation ElseLoc = If->getElseLoc();
 245
 246   if (hasPreprocessorBranchEndBetweenLocations(
 247           PPConditionals, *Result.SourceManager, Interrupt->getBeginLoc(),
 248           ElseLoc))
 249     return;
 250
 251   bool IsLastInScope = OuterScope->body_back() == If;
 252   StringRef ControlFlowInterruptor = getControlFlowString(*Interrupt);
 253
 254   if (!IsLastInScope && containsDeclInScope(Else)) {
 255     if (WarnOnUnfixable) {
 256       // Warn, but don't attempt an autofix.
 257       diag(ElseLoc, WarningMessage) << ControlFlowInterruptor;
 258     }
 259     return;
 260   }
 261
 262   if (checkConditionVarUsageInElse(If) != nullptr) {
 263     if (!WarnOnConditionVariables)
 264       return;
 265     if (IsLastInScope) {
 266       // If the if statement is the last statement of its enclosing statements
 267       // scope, we can pull the decl out of the if statement.
 268       DiagnosticBuilder Diag = diag(ElseLoc, WarningMessage)
 269                                << ControlFlowInterruptor
 270                                << SourceRange(ElseLoc);
 271       if (checkInitDeclUsageInElse(If) != nullptr) {
 272         Diag << tooling::fixit::createReplacement(
 273                     SourceRange(If->getIfLoc()),
 274                     (tooling::fixit::getText(*If->getInit(), *Result.Context) +
 275                      llvm::StringRef("\n"))
 276                         .str())
 277              << tooling::fixit::createRemoval(If->getInit()->getSourceRange());
 278       }
 279       const DeclStmt *VDeclStmt = If->getConditionVariableDeclStmt();
 280       const VarDecl *VDecl = If->getConditionVariable();
 281       std::string Repl =
 282           (tooling::fixit::getText(*VDeclStmt, *Result.Context) +
 283            llvm::StringRef(";\n") +
 284            tooling::fixit::getText(If->getIfLoc(), *Result.Context))
 285               .str();
 286       Diag << tooling::fixit::createReplacement(SourceRange(If->getIfLoc()),
 287                                                 Repl)
 288            << tooling::fixit::createReplacement(VDeclStmt->getSourceRange(),
 289                                                 VDecl->getName());
 290       removeElseAndBrackets(Diag, *Result.Context, Else, ElseLoc);
 291     } else if (WarnOnUnfixable) {
 292       // Warn, but don't attempt an autofix.
 293       diag(ElseLoc, WarningMessage) << ControlFlowInterruptor;
 294     }
 295     return;
 296   }
 297
 298   if (checkInitDeclUsageInElse(If) != nullptr) {
 299     if (!WarnOnConditionVariables)
 300       return;
 301     if (IsLastInScope) {
 302       // If the if statement is the last statement of its enclosing statements
 303       // scope, we can pull the decl out of the if statement.
 304       DiagnosticBuilder Diag = diag(ElseLoc, WarningMessage)
 305                                << ControlFlowInterruptor
 306                                << SourceRange(ElseLoc);
 307       Diag << tooling::fixit::createReplacement(
 308                   SourceRange(If->getIfLoc()),
 309                   (tooling::fixit::getText(*If->getInit(), *Result.Context) +
 310                    "\n" +
 311                    tooling::fixit::getText(If->getIfLoc(), *Result.Context))
 312                       .str())
 313            << tooling::fixit::createRemoval(If->getInit()->getSourceRange());
 314       removeElseAndBrackets(Diag, *Result.Context, Else, ElseLoc);
 315     } else if (WarnOnUnfixable) {
 316       // Warn, but don't attempt an autofix.
 317       diag(ElseLoc, WarningMessage) << ControlFlowInterruptor;
 318     }
 319     return;
 320   }
 321
 322   DiagnosticBuilder Diag = diag(ElseLoc, WarningMessage)
 323                            << ControlFlowInterruptor << SourceRange(ElseLoc);
 324   removeElseAndBrackets(Diag, *Result.Context, Else, ElseLoc);
 325 }
 326
 327 } // namespace readability
 328 } // namespace tidy
 329 } // namespace clang