llvm-project

1
//===--- OptionalValueConversionCheck.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 "OptionalValueConversionCheck.h"
10
#include "../utils/LexerUtils.h"
11
#include "../utils/Matchers.h"
12
#include "../utils/OptionsUtils.h"
13
#include "clang/AST/ASTContext.h"
14
#include "clang/ASTMatchers/ASTMatchFinder.h"
15

16
using namespace clang::ast_matchers;
17

18
namespace clang::tidy::bugprone {
19

20
namespace {
21

22
AST_MATCHER_P(QualType, hasCleanType, ast_matchers::internal::Matcher<QualType>,
23
              InnerMatcher) {
24
  return InnerMatcher.matches(
25
      Node.getNonReferenceType().getUnqualifiedType().getCanonicalType(),
26
      Finder, Builder);
27
}
28

29
} // namespace
30

31
OptionalValueConversionCheck::OptionalValueConversionCheck(
32
    StringRef Name, ClangTidyContext *Context)
33
    : ClangTidyCheck(Name, Context),
34
      OptionalTypes(utils::options::parseStringList(
35
          Options.get("OptionalTypes",
36
                      "::std::optional;::absl::optional;::boost::optional"))),
37
      ValueMethods(utils::options::parseStringList(
38
          Options.get("ValueMethods", "::value$;::get$"))) {}
39

40
std::optional<TraversalKind>
41
OptionalValueConversionCheck::getCheckTraversalKind() const {
42
  return TK_AsIs;
43
}
44

45
void OptionalValueConversionCheck::registerMatchers(MatchFinder *Finder) {
46
  auto ConstructTypeMatcher =
47
      qualType(hasCleanType(qualType().bind("optional-type")));
48

49
  auto CallTypeMatcher =
50
      qualType(hasCleanType(equalsBoundNode("optional-type")));
51

52
  auto OptionalDereferenceMatcher = callExpr(
53
      anyOf(
54
          cxxOperatorCallExpr(hasOverloadedOperatorName("*"),
55
                              hasUnaryOperand(hasType(CallTypeMatcher)))
56
              .bind("op-call"),
57
          cxxMemberCallExpr(thisPointerType(CallTypeMatcher),
58
                            callee(cxxMethodDecl(anyOf(
59
                                hasOverloadedOperatorName("*"),
60
                                matchers::matchesAnyListedName(ValueMethods)))))
61
              .bind("member-call")),
62
      hasType(qualType().bind("value-type")));
63

64
  auto StdMoveCallMatcher =
65
      callExpr(argumentCountIs(1), callee(functionDecl(hasName("::std::move"))),
66
               hasArgument(0, ignoringImpCasts(OptionalDereferenceMatcher)));
67
  Finder->addMatcher(
68
      cxxConstructExpr(
69
          argumentCountIs(1U),
70
          hasDeclaration(cxxConstructorDecl(
71
              ofClass(matchers::matchesAnyListedName(OptionalTypes)))),
72
          hasType(ConstructTypeMatcher),
73
          hasArgument(0U, ignoringImpCasts(anyOf(OptionalDereferenceMatcher,
74
                                                 StdMoveCallMatcher))),
75
          unless(anyOf(hasAncestor(typeLoc()),
76
                       hasAncestor(expr(matchers::hasUnevaluatedContext())))))
77
          .bind("expr"),
78
      this);
79
}
80

81
void OptionalValueConversionCheck::storeOptions(
82
    ClangTidyOptions::OptionMap &Opts) {
83
  Options.store(Opts, "OptionalTypes",
84
                utils::options::serializeStringList(OptionalTypes));
85
  Options.store(Opts, "ValueMethods",
86
                utils::options::serializeStringList(ValueMethods));
87
}
88

89
void OptionalValueConversionCheck::check(
90
    const MatchFinder::MatchResult &Result) {
91
  const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
92
  const auto *OptionalType = Result.Nodes.getNodeAs<QualType>("optional-type");
93
  const auto *ValueType = Result.Nodes.getNodeAs<QualType>("value-type");
94

95
  diag(MatchedExpr->getExprLoc(),
96
       "conversion from %0 into %1 and back into %0, remove potentially "
97
       "error-prone optional dereference")
98
      << *OptionalType << ValueType->getUnqualifiedType();
99

100
  if (const auto *OperatorExpr =
101
          Result.Nodes.getNodeAs<CXXOperatorCallExpr>("op-call")) {
102
    diag(OperatorExpr->getExprLoc(), "remove '*' to silence this warning",
103
         DiagnosticIDs::Note)
104
        << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
105
               OperatorExpr->getBeginLoc(), OperatorExpr->getExprLoc()));
106
    return;
107
  }
108
  if (const auto *CallExpr =
109
          Result.Nodes.getNodeAs<CXXMemberCallExpr>("member-call")) {
110
    const SourceLocation Begin =
111
        utils::lexer::getPreviousToken(CallExpr->getExprLoc(),
112
                                       *Result.SourceManager, getLangOpts())
113
            .getLocation();
114
    auto Diag =
115
        diag(CallExpr->getExprLoc(),
116
             "remove call to %0 to silence this warning", DiagnosticIDs::Note);
117
    Diag << CallExpr->getMethodDecl()
118
         << FixItHint::CreateRemoval(
119
                CharSourceRange::getTokenRange(Begin, CallExpr->getEndLoc()));
120
    if (const auto *Member =
121
            llvm::dyn_cast<MemberExpr>(CallExpr->getCallee()->IgnoreImplicit());
122
        Member && Member->isArrow())
123
      Diag << FixItHint::CreateInsertion(CallExpr->getBeginLoc(), "*");
124
    return;
125
  }
126
}
127

128
} // namespace clang::tidy::bugprone
129