tools/clang/tools/extra/unittests/clang-tidy/OverlappingReplacementsTest.cpp

reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

//===---- OverlappingReplacementsTest.cpp - clang-tidy --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "ClangTidyTest.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "gtest/gtest.h"

namespace clang {
namespace tidy {
namespace test {
namespace {

const char BoundDecl[] = "decl";
const char BoundIf[] = "if";

// We define a reduced set of very small checks that allow to test different
// overlapping situations (no overlapping, replacements partially overlap, etc),
// as well as different kinds of diagnostics (one check produces several errors,
// several replacement ranges in an error, etc).
class UseCharCheck : public ClangTidyCheck {
public:
  UseCharCheck(StringRef CheckName, ClangTidyContext *Context)
      : ClangTidyCheck(CheckName, Context) {}
  void registerMatchers(ast_matchers::MatchFinder *Finder) override {
    using namespace ast_matchers;
    Finder->addMatcher(varDecl(hasType(isInteger())).bind(BoundDecl), this);
  }
  void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
    auto *VD = Result.Nodes.getNodeAs<VarDecl>(BoundDecl);
    diag(VD->getBeginLoc(), "use char") << FixItHint::CreateReplacement(
        CharSourceRange::getTokenRange(VD->getBeginLoc(), VD->getBeginLoc()),
        "char");
  }
};

class IfFalseCheck : public ClangTidyCheck {
public:
  IfFalseCheck(StringRef CheckName, ClangTidyContext *Context)
      : ClangTidyCheck(CheckName, Context) {}
  void registerMatchers(ast_matchers::MatchFinder *Finder) override {
    using namespace ast_matchers;
    Finder->addMatcher(ifStmt().bind(BoundIf), this);
  }
  void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
    auto *If = Result.Nodes.getNodeAs<IfStmt>(BoundIf);
    auto *Cond = If->getCond();
    SourceRange Range = Cond->getSourceRange();
    if (auto *D = If->getConditionVariable()) {
      Range = SourceRange(D->getBeginLoc(), D->getEndLoc());
    }
    diag(Range.getBegin(), "the cake is a lie") << FixItHint::CreateReplacement(
        CharSourceRange::getTokenRange(Range), "false");
  }
};

class RefactorCheck : public ClangTidyCheck {
public:
  RefactorCheck(StringRef CheckName, ClangTidyContext *Context)
      : ClangTidyCheck(CheckName, Context), NamePattern("::$") {}
  RefactorCheck(StringRef CheckName, ClangTidyContext *Context,
                StringRef NamePattern)
      : ClangTidyCheck(CheckName, Context), NamePattern(NamePattern) {}
  virtual std::string newName(StringRef OldName) = 0;

  void registerMatchers(ast_matchers::MatchFinder *Finder) final {
    using namespace ast_matchers;
    Finder->addMatcher(varDecl(matchesName(NamePattern)).bind(BoundDecl), this);
  }

  void check(const ast_matchers::MatchFinder::MatchResult &Result) final {
    auto *VD = Result.Nodes.getNodeAs<VarDecl>(BoundDecl);
    std::string NewName = newName(VD->getName());

    auto Diag = diag(VD->getLocation(), "refactor %0 into %1")
                << VD->getName() << NewName
                << FixItHint::CreateReplacement(
                       CharSourceRange::getTokenRange(VD->getLocation(),
                                                      VD->getLocation()),
                       NewName);

    class UsageVisitor : public RecursiveASTVisitor<UsageVisitor> {
    public:
      UsageVisitor(const ValueDecl *VD, StringRef NewName,
                   DiagnosticBuilder &Diag)
          : VD(VD), NewName(NewName), Diag(Diag) {}
      bool VisitDeclRefExpr(DeclRefExpr *E) {
        if (const ValueDecl *D = E->getDecl()) {
          if (VD->getCanonicalDecl() == D->getCanonicalDecl()) {
            Diag << FixItHint::CreateReplacement(
                CharSourceRange::getTokenRange(E->getSourceRange()), NewName);
          }
        }
        return RecursiveASTVisitor<UsageVisitor>::VisitDeclRefExpr(E);
      }

    private:
      const ValueDecl *VD;
      StringRef NewName;
      DiagnosticBuilder &Diag;
    };

    UsageVisitor(VD, NewName, Diag)
        .TraverseDecl(Result.Context->getTranslationUnitDecl());
  }

protected:
  const std::string NamePattern;
};

class StartsWithPotaCheck : public RefactorCheck {
public:
  StartsWithPotaCheck(StringRef CheckName, ClangTidyContext *Context)
      : RefactorCheck(CheckName, Context, "::pota") {}

  std::string newName(StringRef OldName) override {
    return "toma" + OldName.substr(4).str();
  }
};

class EndsWithTatoCheck : public RefactorCheck {
public:
  EndsWithTatoCheck(StringRef CheckName, ClangTidyContext *Context)
      : RefactorCheck(CheckName, Context, "tato$") {}

  std::string newName(StringRef OldName) override {
    return OldName.substr(0, OldName.size() - 4).str() + "melo";
  }
};

} // namespace

TEST(OverlappingReplacementsTest, UseCharCheckTest) {
  const char Code[] =
      R"(void f() {
  int a = 0;
  if (int b = 0) {
    int c = a;
  }
})";

  const char CharFix[] =
      R"(void f() {
  char a = 0;
  if (char b = 0) {
    char c = a;
  }
})";
  EXPECT_EQ(CharFix, runCheckOnCode<UseCharCheck>(Code));
}

TEST(OverlappingReplacementsTest, IfFalseCheckTest) {
  const char Code[] =
      R"(void f() {
  int potato = 0;
  if (int b = 0) {
    int c = potato;
  } else if (true) {
    int d = 0;
  }
})";

  const char IfFix[] =
      R"(void f() {
  int potato = 0;
  if (false) {
    int c = potato;
  } else if (false) {
    int d = 0;
  }
})";
  EXPECT_EQ(IfFix, runCheckOnCode<IfFalseCheck>(Code));
}

TEST(OverlappingReplacementsTest, StartsWithCheckTest) {
  const char Code[] =
      R"(void f() {
  int a = 0;
  int potato = 0;
  if (int b = 0) {
    int c = potato;
  } else if (true) {
    int d = 0;
  }
})";

  const char StartsFix[] =
      R"(void f() {
  int a = 0;
  int tomato = 0;
  if (int b = 0) {
    int c = tomato;
  } else if (true) {
    int d = 0;
  }
})";
  EXPECT_EQ(StartsFix, runCheckOnCode<StartsWithPotaCheck>(Code));
}

TEST(OverlappingReplacementsTest, EndsWithCheckTest) {
  const char Code[] =
      R"(void f() {
  int a = 0;
  int potato = 0;
  if (int b = 0) {
    int c = potato;
  } else if (true) {
    int d = 0;
  }
})";

  const char EndsFix[] =
      R"(void f() {
  int a = 0;
  int pomelo = 0;
  if (int b = 0) {
    int c = pomelo;
  } else if (true) {
    int d = 0;
  }
})";
  EXPECT_EQ(EndsFix, runCheckOnCode<EndsWithTatoCheck>(Code));
}

TEST(OverlappingReplacementTest, ReplacementsDoNotOverlap) {
  std::string Res;
  const char Code[] =
      R"(void f() {
  int potassium = 0;
  if (true) {
    int Potato = potassium;
  }
})";

  const char CharIfFix[] =
      R"(void f() {
  char potassium = 0;
  if (false) {
    char Potato = potassium;
  }
})";
  Res = runCheckOnCode<UseCharCheck, IfFalseCheck>(Code);
  EXPECT_EQ(CharIfFix, Res);

  const char StartsEndsFix[] =
      R"(void f() {
  int tomassium = 0;
  if (true) {
    int Pomelo = tomassium;
  }
})";
  Res = runCheckOnCode<StartsWithPotaCheck, EndsWithTatoCheck>(Code);
  EXPECT_EQ(StartsEndsFix, Res);

  const char CharIfStartsEndsFix[] =
      R"(void f() {
  char tomassium = 0;
  if (false) {
    char Pomelo = tomassium;
  }
})";
  Res = runCheckOnCode<UseCharCheck, IfFalseCheck, StartsWithPotaCheck,
                       EndsWithTatoCheck>(Code);
  EXPECT_EQ(CharIfStartsEndsFix, Res);
}

TEST(OverlappingReplacementsTest, ReplacementInsideOtherReplacement) {
  std::string Res;
  const char Code[] =
      R"(void f() {
  if (char potato = 0) {
  } else if (int a = 0) {
    char potato = 0;
    if (potato) potato;
  }
})";

  // Apply the UseCharCheck together with the IfFalseCheck.
  //
  // The 'If' fix contains the other, so that is the one that has to be applied.
  // } else if (int a = 0) {
  //            ^^^ -> char
  //            ~~~~~~~~~ -> false
  const char CharIfFix[] =
      R"(void f() {
  if (false) {
  } else if (false) {
    char potato = 0;
    if (false) potato;
  }
})";
  Res = runCheckOnCode<UseCharCheck, IfFalseCheck>(Code);
  EXPECT_EQ(CharIfFix, Res);
  Res = runCheckOnCode<IfFalseCheck, UseCharCheck>(Code);
  EXPECT_EQ(CharIfFix, Res);

  // Apply the IfFalseCheck with the StartsWithPotaCheck.
  //
  // The 'If' replacement is bigger here.
  // if (char potato = 0) {
  //          ^^^^^^ -> tomato
  //     ~~~~~~~~~~~~~~~ -> false
  //
  // But the refactoring is the one that contains the other here:
  // char potato = 0;
  //      ^^^^^^ -> tomato
  // if (potato) potato;
  //     ^^^^^^  ^^^^^^ -> tomato, tomato
  //     ~~~~~~ -> false
  const char IfStartsFix[] =
      R"(void f() {
  if (false) {
  } else if (false) {
    char tomato = 0;
    if (tomato) tomato;
  }
})";
  Res = runCheckOnCode<IfFalseCheck, StartsWithPotaCheck>(Code);
  EXPECT_EQ(IfStartsFix, Res);
  Res = runCheckOnCode<StartsWithPotaCheck, IfFalseCheck>(Code);
  EXPECT_EQ(IfStartsFix, Res);
}

TEST(OverlappingReplacements, TwoReplacementsInsideOne) {
  std::string Res;
  const char Code[] =
      R"(void f() {
  if (int potato = 0) {
    int a = 0;
  }
})";

  // The two smallest replacements should not be applied.
  // if (int potato = 0) {
  //         ^^^^^^ -> tomato
  //     *** -> char
  //     ~~~~~~~~~~~~~~ -> false
  // But other errors from the same checks should not be affected.
  //   int a = 0;
  //   *** -> char
  const char Fix[] =
      R"(void f() {
  if (false) {
    char a = 0;
  }
})";
  Res = runCheckOnCode<UseCharCheck, IfFalseCheck, StartsWithPotaCheck>(Code);
  EXPECT_EQ(Fix, Res);
  Res = runCheckOnCode<StartsWithPotaCheck, IfFalseCheck, UseCharCheck>(Code);
  EXPECT_EQ(Fix, Res);
}

TEST(OverlappingReplacementsTest,
     ApplyAtMostOneOfTheChangesWhenPartialOverlapping) {
  std::string Res;
  const char Code[] =
      R"(void f() {
  if (int potato = 0) {
    int a = potato;
  }
})";

  // These two replacements overlap, but none of them is completely contained
  // inside the other.
  // if (int potato = 0) {
  //         ^^^^^^ -> tomato
  //     ~~~~~~~~~~~~~~ -> false
  //   int a = potato;
  //           ^^^^^^ -> tomato
  //
  // The 'StartsWithPotaCheck' fix has endpoints inside the 'IfFalseCheck' fix,
  // so it is going to be set as inapplicable. The 'if' fix will be applied.
  const char IfFix[] =
      R"(void f() {
  if (false) {
    int a = potato;
  }
})";
  Res = runCheckOnCode<IfFalseCheck, StartsWithPotaCheck>(Code);
  EXPECT_EQ(IfFix, Res);
}

TEST(OverlappingReplacementsTest, TwoErrorsHavePerfectOverlapping) {
  std::string Res;
  const char Code[] =
      R"(void f() {
  int potato = 0;
  potato += potato * potato;
  if (char a = potato) potato;
})";

  // StartsWithPotaCheck will try to refactor 'potato' into 'tomato', and
  // EndsWithTatoCheck will try to use 'pomelo'. Both fixes have the same set of
  // ranges. This is a corner case of one error completely containing another:
  // the other completely contains the first one as well. Both errors are
  // discarded.

  Res = runCheckOnCode<StartsWithPotaCheck, EndsWithTatoCheck>(Code);
  EXPECT_EQ(Code, Res);
}

} // namespace test
} // namespace tidy
} // namespace clang