llvm/clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.cpp

//===--- SuspiciousCallArgumentCheck.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 "SuspiciousCallArgumentCheck.h"
#include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Type.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional>
#include <sstream>

usingnamespaceclang::ast_matchers;
optutils;

namespace clang::tidy::readability {

namespace {
struct DefaultHeuristicConfiguration { … };
} // namespace

static constexpr std::size_t DefaultMinimumIdentifierNameLength = …;

static constexpr StringRef HeuristicToString[] = …;

static constexpr DefaultHeuristicConfiguration Defaults[] = …;

static_assert …;
static_assert …;

namespace {
template <std::size_t I> struct HasWellConfiguredBounds { … };

template <std::size_t I> struct HasWellConfiguredBoundsFold { … };

template <> struct HasWellConfiguredBoundsFold<0> { … };

struct AllHeuristicsBoundsWellConfigured { … };

static_assert …;
} // namespace

static constexpr llvm::StringLiteral DefaultAbbreviations = …;

static constexpr std::size_t SmallVectorSize = …;

/// Returns how many % X is of Y.
static inline double percentage(double X, double Y) { … }

static bool applyEqualityHeuristic(StringRef Arg, StringRef Param) { … }

static bool applyAbbreviationHeuristic(
    const llvm::StringMap<std::string> &AbbreviationDictionary, StringRef Arg,
    StringRef Param) { … }

/// Check whether the shorter String is a prefix of the longer String.
static bool applyPrefixHeuristic(StringRef Arg, StringRef Param,
                                 int8_t Threshold) { … }

/// Check whether the shorter String is a suffix of the longer String.
static bool applySuffixHeuristic(StringRef Arg, StringRef Param,
                                 int8_t Threshold) { … }

static bool applySubstringHeuristic(StringRef Arg, StringRef Param,
                                    int8_t Threshold) { … }

static bool applyLevenshteinHeuristic(StringRef Arg, StringRef Param,
                                      int8_t Threshold) { … }

// Based on http://en.wikipedia.org/wiki/Jaro–Winkler_distance.
static bool applyJaroWinklerHeuristic(StringRef Arg, StringRef Param,
                                      int8_t Threshold) { … }

// Based on http://en.wikipedia.org/wiki/Sørensen–Dice_coefficient
static bool applyDiceHeuristic(StringRef Arg, StringRef Param,
                               int8_t Threshold) { … }

/// Checks if ArgType binds to ParamType regarding reference-ness and
/// cv-qualifiers.
static bool areRefAndQualCompatible(QualType ArgType, QualType ParamType) { … }

static bool isPointerOrArray(QualType TypeToCheck) { … }

/// Checks whether ArgType is an array type identical to ParamType's array type.
/// Enforces array elements' qualifier compatibility as well.
static bool isCompatibleWithArrayReference(QualType ArgType,
                                           QualType ParamType) { … }

static QualType convertToPointeeOrArrayElementQualType(QualType TypeToConvert) { … }

/// Checks if multilevel pointers' qualifiers compatibility continues on the
/// current pointer level. For multilevel pointers, C++ permits conversion, if
/// every cv-qualifier in ArgType also appears in the corresponding position in
/// ParamType, and if PramType has a cv-qualifier that's not in ArgType, then
/// every * in ParamType to the right of that cv-qualifier, except the last
/// one, must also be const-qualified.
static bool arePointersStillQualCompatible(QualType ArgType, QualType ParamType,
                                           bool &IsParamContinuouslyConst) { … }

/// Checks whether multilevel pointers are compatible in terms of levels,
/// qualifiers and pointee type.
static bool arePointerTypesCompatible(QualType ArgType, QualType ParamType,
                                      bool IsParamContinuouslyConst) { … }

/// Checks whether ArgType converts implicitly to ParamType.
static bool areTypesCompatible(QualType ArgType, QualType ParamType,
                               const ASTContext &Ctx) { … }

static bool isOverloadedUnaryOrBinarySymbolOperator(const FunctionDecl *FD) { … }

SuspiciousCallArgumentCheck::SuspiciousCallArgumentCheck(
    StringRef Name, ClangTidyContext *Context)
    : … { … }

void SuspiciousCallArgumentCheck::storeOptions(
    ClangTidyOptions::OptionMap &Opts) { … }

bool SuspiciousCallArgumentCheck::isHeuristicEnabled(Heuristic H) const { … }

std::optional<int8_t>
SuspiciousCallArgumentCheck::getBound(Heuristic H, BoundKind BK) const { … }

void SuspiciousCallArgumentCheck::registerMatchers(MatchFinder *Finder) { … }

void SuspiciousCallArgumentCheck::check(
    const MatchFinder::MatchResult &Result) { … }

void SuspiciousCallArgumentCheck::setParamNamesAndTypes(
    const FunctionDecl *CalleeFuncDecl) { … }

void SuspiciousCallArgumentCheck::setArgNamesAndTypes(
    const CallExpr *MatchedCallExpr, std::size_t InitialArgIndex) { … }

bool SuspiciousCallArgumentCheck::areParamAndArgComparable(
    std::size_t Position1, std::size_t Position2, const ASTContext &Ctx) const { … }

bool SuspiciousCallArgumentCheck::areArgsSwapped(std::size_t Position1,
                                                 std::size_t Position2) const { … }

bool SuspiciousCallArgumentCheck::areNamesSimilar(StringRef Arg,
                                                  StringRef Param, Heuristic H,
                                                  BoundKind BK) const { … }

} // namespace clang::tidy::readability