0fba450b97
While the original check's purpose is to identify potentially dangerous functions based on the parameter types (as identifier names do not mean anything when it comes to the language rules), unfortunately, such a plain interface check rule can be incredibly noisy. While the previous "filtering heuristic" is able to find many similar usages, there is an entire class of parameters that should not be warned about very easily mixed by that check: parameters that have a name and their name follows a pattern, e.g. `text1, text2, text3, ...`.` This patch implements a simple, but powerful rule, that allows us to detect such cases and ensure that no warnings are emitted for parameter sequences that follow a pattern, even if their types allow for them to be potentially mixed at a call site. Given a threshold `k`, warnings about two parameters are filtered from the result set if the names of the parameters are either prefixes or suffixes of each other, with at most k letters difference on the non-common end. (Assuming that the names themselves are at least `k` long.) - The above `text1, text2` is an example of this. (Live finding from Xerces.) - `LHS` and `RHS` are also fitting the bill here. (Live finding from... virtually any project.) - So does `Qmat, Tmat, Rmat`. (Live finding from I think OpenCV.) Reviewed By: aaron.ballman Differential Revision: http://reviews.llvm.org/D97297
67 lines
2.7 KiB
C++
67 lines
2.7 KiB
C++
//===--- EasilySwappableParametersCheck.h - clang-tidy ----------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H
|
|
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H
|
|
|
|
#include "../ClangTidyCheck.h"
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace bugprone {
|
|
|
|
/// Finds function definitions where parameters of convertible types follow
|
|
/// each other directly, making call sites prone to calling the function with
|
|
/// swapped (or badly ordered) arguments.
|
|
///
|
|
/// For the user-facing documentation see:
|
|
/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-easily-swappable-parameters.html
|
|
class EasilySwappableParametersCheck : public ClangTidyCheck {
|
|
public:
|
|
EasilySwappableParametersCheck(StringRef Name, ClangTidyContext *Context);
|
|
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
|
|
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
|
|
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
|
|
|
|
/// The minimum length of an adjacent swappable parameter range required for
|
|
/// a diagnostic.
|
|
const std::size_t MinimumLength;
|
|
|
|
/// The parameter names (as written in the source text) to be ignored.
|
|
const std::vector<std::string> IgnoredParameterNames;
|
|
|
|
/// The parameter typename suffixes (as written in the source code) to be
|
|
/// ignored.
|
|
const std::vector<std::string> IgnoredParameterTypeSuffixes;
|
|
|
|
/// Whether to consider differently qualified versions of the same type
|
|
/// mixable.
|
|
const bool QualifiersMix;
|
|
|
|
/// Whether to model implicit conversions "in full" (conditions apply)
|
|
/// during analysis and consider types that are implicitly convertible to
|
|
/// one another mixable.
|
|
const bool ModelImplicitConversions;
|
|
|
|
/// If enabled, diagnostics for parameters that are used together in a
|
|
/// similar way are not emitted.
|
|
const bool SuppressParametersUsedTogether;
|
|
|
|
/// The number of characters two parameter names might be dissimilar at
|
|
/// either end for the report about the parameters to be silenced.
|
|
/// E.g. the names "LHS" and "RHS" are 1-dissimilar suffixes of each other,
|
|
/// while "Text1" and "Text2" are 1-dissimilar prefixes of each other.
|
|
const std::size_t NamePrefixSuffixSilenceDissimilarityTreshold;
|
|
};
|
|
|
|
} // namespace bugprone
|
|
} // namespace tidy
|
|
} // namespace clang
|
|
|
|
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H
|