compilerplugins/clang/store/comparisonwithconstant.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <cassert>
  11 #include <string>
  12 #include <iostream>
  13 #include <fstream>
  14 #include <set>
  15
  16 #include "compat.hxx"
  17 #include "plugin.hxx"
  18
  19 /**
  20   Look for comparisons where the constant is on the left, it should be on the right.
  21  */
  22
  23 namespace {
  24
  25 class ComparisonWithConstant :
  26     public loplugin::FilteringRewritePlugin<ComparisonWithConstant>
  27 {
  28 public:
  29     explicit ComparisonWithConstant(loplugin::InstantiationData const & data): FilteringRewritePlugin(data) {}
  30
  31     virtual void run() override
  32     {
  33         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
  34     }
  35
  36     // Deliberately drop RecursiveASTVisitor::TraverseBinaryOperator's DataRecursionQueue
  37     // parameter; TraverseBinaryOperator must use stack instead of data recursion for any
  38     // children's VisitBinaryOperator to see changes to occurrence_ by a parent
  39     // VisitBinaryOperator:
  40     bool TraverseBinaryOperator(BinaryOperator * S)
  41     {
  42         auto const op = S->getOpcode();
  43         if (op != BO_EQ && op != BO_NE) {
  44             return RecursiveASTVisitor::TraverseBinaryOperator(S);
  45         }
  46         auto const saved = occurrence_;
  47         auto const ret = RecursiveASTVisitor::TraverseBinaryOperator(S);
  48         occurrence_ = saved;
  49         return ret;
  50     }
  51
  52     bool VisitBinaryOperator(const BinaryOperator *);
  53 private:
  54     bool rewrite(const BinaryOperator *);
  55     std::string getExprAsString(SourceRange range);
  56     SourceRange ignoreMacroExpansions(SourceRange range);
  57
  58     bool occurrence_ = false;
  59 };
  60
  61 bool ComparisonWithConstant::VisitBinaryOperator(const BinaryOperator* binaryOp)
  62 {
  63     if (ignoreLocation(binaryOp)) {
  64         return true;
  65     }
  66     if (!(binaryOp->getOpcode() == BO_EQ || binaryOp->getOpcode() == BO_NE)) {
  67         return true;
  68     }
  69     // protect against clang assert
  70     if (binaryOp->getLHS()->isValueDependent() || binaryOp->getRHS()->isValueDependent()) {
  71         return true;
  72     }
  73     if (!binaryOp->getLHS()->isEvaluatable(compiler.getASTContext())) {
  74         return true;
  75     }
  76     if (binaryOp->getRHS()->isEvaluatable(compiler.getASTContext())) {
  77         return true;
  78     }
  79     if (occurrence_ || !rewrite(binaryOp))
  80     {
  81         report(
  82             DiagnosticsEngine::Warning, "Rather put constant on right when comparing",
  83             binaryOp->getSourceRange().getBegin())
  84             << binaryOp->getSourceRange();
  85     }
  86     occurrence_ = true;
  87     return true;
  88 }
  89
  90
  91 bool ComparisonWithConstant::rewrite(const BinaryOperator * binaryOp) {
  92     if (rewriter == nullptr) {
  93         return false;
  94     }
  95
  96     auto lhsRange = ignoreMacroExpansions(binaryOp->getLHS()->getSourceRange());
  97     if (!lhsRange.isValid()) {
  98         return false;
  99     }
 100     auto rhsRange = ignoreMacroExpansions(binaryOp->getRHS()->getSourceRange());
 101     if (!rhsRange.isValid()) {
 102         return false;
 103     }
 104
 105     const std::string lhsString = getExprAsString(lhsRange);
 106     const std::string rhsString = getExprAsString(rhsRange);
 107
 108     // switch LHS and RHS
 109     if (!replaceText(lhsRange, rhsString)) {
 110         return false;
 111     }
 112     if (!replaceText(rhsRange, lhsString)) {
 113         return false;
 114     }
 115
 116     return true;
 117 }
 118
 119 // get the expression contents
 120 std::string ComparisonWithConstant::getExprAsString(SourceRange range)
 121 {
 122     SourceManager& SM = compiler.getSourceManager();
 123     SourceLocation startLoc = range.getBegin();
 124     SourceLocation endLoc = range.getEnd();
 125     const char *p1 = SM.getCharacterData( startLoc );
 126     const char *p2 = SM.getCharacterData( endLoc );
 127     unsigned n = Lexer::MeasureTokenLength( endLoc, SM, compiler.getLangOpts());
 128     return std::string( p1, p2 - p1 + n);
 129 }
 130
 131 SourceRange ComparisonWithConstant::ignoreMacroExpansions(SourceRange range) {
 132     while (compiler.getSourceManager().isMacroArgExpansion(range.getBegin())) {
 133         range.setBegin(
 134             compiler.getSourceManager().getImmediateMacroCallerLoc(
 135                 range.getBegin()));
 136     }
 137     if (range.getBegin().isMacroID()) {
 138         SourceLocation loc;
 139         if (Lexer::isAtStartOfMacroExpansion(
 140                 range.getBegin(), compiler.getSourceManager(),
 141                 compiler.getLangOpts(), &loc))
 142         {
 143             range.setBegin(loc);
 144         }
 145     }
 146     while (compiler.getSourceManager().isMacroArgExpansion(range.getEnd())) {
 147         range.setEnd(
 148             compiler.getSourceManager().getImmediateMacroCallerLoc(
 149                 range.getEnd()));
 150     }
 151     if (range.getEnd().isMacroID()) {
 152         SourceLocation loc;
 153         if (Lexer::isAtEndOfMacroExpansion(
 154                 range.getEnd(), compiler.getSourceManager(),
 155                 compiler.getLangOpts(), &loc))
 156         {
 157             range.setEnd(loc);
 158         }
 159     }
 160     return range.getBegin().isMacroID() || range.getEnd().isMacroID()
 161         ? SourceRange() : range;
 162 }
 163
 164 loplugin::Plugin::Registration< ComparisonWithConstant > X("comparisonwithconstant", false);
 165
 166 }
 167
 168 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */