8a944d82cd
(this was originally part of https://reviews.llvm.org/D96281 and has been split off into its own patch) If a macro is used within a function, the code inside the macro doesn't make the code less readable. Instead, for a reader a macro is more like a function that is called. Thus the code inside a macro shouldn't increase the complexity of the function in which it is called. Thus the flag 'IgnoreMacros' is added. If set to 'true' code inside macros isn't considered during analysis. This isn't perfect, as now the code of a macro isn't considered at all, even if it has a high cognitive complexity itself. It might be better if a macro is considered in the analysis like a function and gets its own cognitive complexity. Implementing such an analysis seems to be very complex (if possible at all with the given AST), so we give the user the option to either ignore macros completely or to let the expanded code count to the calling function's complexity. See the code example from vgeof (originally added as note in https://reviews.llvm.org/D96281) bool doStuff(myClass* objectPtr){ if(objectPtr == nullptr){ LOG_WARNING("empty object"); return false; } if(objectPtr->getAttribute() == nullptr){ LOG_WARNING("empty object"); return false; } use(objectPtr->getAttribute()); } The LOG_WARNING macro itself might have a high complexity, but it do not make the the function more complex to understand like e.g. a 'printf'. By default 'IgnoreMacros' is set to 'false', which is the original behavior of the check. Reviewed By: lebedev.ri, alexfh Differential Revision: https://reviews.llvm.org/D98070
56 lines
2.1 KiB
C++
56 lines
2.1 KiB
C++
//===--- FunctionCognitiveComplexityCheck.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_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
|
|
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
|
|
|
|
#include "../ClangTidyCheck.h"
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
namespace readability {
|
|
|
|
/// Checks function Cognitive Complexity metric.
|
|
///
|
|
/// There are the following configuration option:
|
|
///
|
|
/// * `Threshold` - flag functions with Cognitive Complexity exceeding
|
|
/// this number. The default is `25`.
|
|
/// * `DescribeBasicIncrements`- if set to `true`, then for each function
|
|
/// exceeding the complexity threshold the check will issue additional
|
|
/// diagnostics on every piece of code (loop, `if` statement, etc.) which
|
|
/// contributes to that complexity.
|
|
// Default is `true`
|
|
/// * `IgnoreMacros` - if set to `true`, the check will ignore code inside
|
|
/// macros. Default is `false`.
|
|
///
|
|
/// For the user-facing documentation see:
|
|
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-function-cognitive-complexity.html
|
|
class FunctionCognitiveComplexityCheck : public ClangTidyCheck {
|
|
public:
|
|
FunctionCognitiveComplexityCheck(StringRef Name, ClangTidyContext *Context);
|
|
|
|
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
|
|
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
|
|
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
|
|
llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
|
|
return TK_IgnoreUnlessSpelledInSource;
|
|
}
|
|
|
|
private:
|
|
const unsigned Threshold;
|
|
const bool DescribeBasicIncrements;
|
|
const bool IgnoreMacros;
|
|
};
|
|
|
|
} // namespace readability
|
|
} // namespace tidy
|
|
} // namespace clang
|
|
|
|
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
|