a807e8ea9f
This commit tweaks the interface of `CheckerRegistry::addChecker` to make it more practical for plugins and tests: - The parameter `IsHidden` now defaults to `false` even in the non-templated overload (because setting it to true is unusual, especially in plugins). - The parameter `DocsUri` defaults to the dummy placeholder string `"NoDocsUri"` because (as of now) nothing queries its value from the checker registry (it's only used by the logic that generates the clang-tidy documentation, but that loads it directly from `Checkers.td` without involving the `CheckerRegistry`), so there is no reason to demand specifying this value. In addition to propagating these changes, this commit clarifies, corrects and extends lots of comments and performs various minor code quality improvements in the code of unit tests and example plugins. I originally wrote the bulk of this commit when I was planning to add an extra parameter to `addChecker` in order to implement some technical details of the CheckerFamily framework. At the end I decided against adding that extra parameter, so this cleanup was left out of the PR https://github.com/llvm/llvm-project/pull/139256 and I'm merging it now as a separate commit (after minor tweaks). This commit is mostly NFC: the only functional change is that the analyzer will be compatible with plugins that rely on the default argument values and don't specify `IsHidden` or `DocsUri`. (But existing plugin code will remain valid as well.)
124 lines
3.6 KiB
C++
124 lines
3.6 KiB
C++
//===- unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp ------===//
|
|
//
|
|
// 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 "CheckerRegistration.h"
|
|
#include "clang/StaticAnalyzer/Core/Checker.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
|
|
#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
|
|
#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
|
|
#include "clang/Tooling/Tooling.h"
|
|
#include "gtest/gtest.h"
|
|
#include <optional>
|
|
|
|
namespace clang {
|
|
namespace ento {
|
|
namespace {
|
|
|
|
class TestReturnValueUnderConstructionChecker
|
|
: public Checker<check::PostCall> {
|
|
public:
|
|
void checkPostCall(const CallEvent &Call, CheckerContext &C) const {
|
|
// Only calls with origin expression are checked. These are `returnC()`,
|
|
// `returnD()`, C::C() and D::D().
|
|
if (!Call.getOriginExpr())
|
|
return;
|
|
|
|
// Since `returnC` returns an object by value, the invocation results
|
|
// in an object of type `C` constructed into variable `c`. Thus the
|
|
// return value of `CallEvent::getReturnValueUnderConstruction()` must
|
|
// be non-empty and has to be a `MemRegion`.
|
|
std::optional<SVal> RetVal = Call.getReturnValueUnderConstruction();
|
|
ASSERT_TRUE(RetVal);
|
|
ASSERT_TRUE(RetVal->getAsRegion());
|
|
|
|
const auto *RetReg = cast<TypedValueRegion>(RetVal->getAsRegion());
|
|
const Expr *OrigExpr = Call.getOriginExpr();
|
|
ASSERT_EQ(OrigExpr->getType()->getCanonicalTypeInternal(),
|
|
RetReg->getValueType()->getCanonicalTypeInternal());
|
|
}
|
|
};
|
|
|
|
void addTestReturnValueUnderConstructionChecker(
|
|
AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
|
|
AnOpts.CheckersAndPackages =
|
|
{{"test.TestReturnValueUnderConstruction", true}};
|
|
AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
|
|
Registry.addChecker<TestReturnValueUnderConstructionChecker>(
|
|
"test.TestReturnValueUnderConstruction", "MockDescription");
|
|
});
|
|
}
|
|
|
|
TEST(TestReturnValueUnderConstructionChecker,
|
|
ReturnValueUnderConstructionChecker) {
|
|
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
|
|
R"(class C {
|
|
public:
|
|
C(int nn): n(nn) {}
|
|
virtual ~C() {}
|
|
private:
|
|
int n;
|
|
};
|
|
|
|
C returnC(int m) {
|
|
C c(m);
|
|
return c;
|
|
}
|
|
|
|
void foo() {
|
|
C c = returnC(1);
|
|
})"));
|
|
|
|
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
|
|
R"(class C {
|
|
public:
|
|
C(int nn): n(nn) {}
|
|
explicit C(): C(0) {}
|
|
virtual ~C() {}
|
|
private:
|
|
int n;
|
|
};
|
|
|
|
C returnC() {
|
|
C c;
|
|
return c;
|
|
}
|
|
|
|
void foo() {
|
|
C c = returnC();
|
|
})"));
|
|
|
|
EXPECT_TRUE(runCheckerOnCode<addTestReturnValueUnderConstructionChecker>(
|
|
R"(class C {
|
|
public:
|
|
C(int nn): n(nn) {}
|
|
virtual ~C() {}
|
|
private:
|
|
int n;
|
|
};
|
|
|
|
class D: public C {
|
|
public:
|
|
D(int nn): C(nn) {}
|
|
virtual ~D() {}
|
|
};
|
|
|
|
D returnD(int m) {
|
|
D d(m);
|
|
return d;
|
|
}
|
|
|
|
void foo() {
|
|
D d = returnD(1);
|
|
})"));
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace ento
|
|
} // namespace clang
|