void (*MockCheckedActualCall::returnFunctionPointerValueOrDefault(void (*default_value)()))()
{
if (!hasReturnValue()) {
return default_value;
}
return returnFunctionPointerValue();
}
const void * MockCheckedActualCall::returnConstPointerValueOrDefault(const void * default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnConstPointerValue();
}
unsigned int MockCheckedActualCall::returnUnsignedIntValueOrDefault(unsigned int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnUnsignedIntValue();
}
double MockCheckedActualCall::returnDoubleValueOrDefault(double default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnDoubleValue();
}
const char * MockCheckedActualCall::returnStringValueOrDefault(const char * default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnStringValue();
}
double MockSupport::returnDoubleValueOrDefault(double defaultValue)
{
if (hasReturnValue()) {
return doubleReturnValue();
}
return defaultValue;
}
bool MockCheckedActualCall::returnBoolValueOrDefault(bool default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnBoolValue();
}
void (*MockSupport::returnFunctionPointerValueOrDefault(void (*defaultValue)()))()
{
if (hasReturnValue()) {
return functionPointerReturnValue();
}
return defaultValue;
}
void * MockSupport::returnPointerValueOrDefault(void * defaultValue)
{
if (hasReturnValue()) {
return pointerReturnValue();
}
return defaultValue;
}
const void* MockSupport::returnConstPointerValueOrDefault(const void * defaultValue)
{
if (hasReturnValue()) {
return constPointerReturnValue();
}
return defaultValue;
}
int MockSupport::returnIntValueOrDefault(int defaultValue)
{
if (hasReturnValue()) {
return intReturnValue();
}
return defaultValue;
}
unsigned long int MockSupport::returnUnsignedLongIntValueOrDefault(unsigned long int defaultValue)
{
if (hasReturnValue()) {
return unsignedLongIntReturnValue();
}
return defaultValue;
}
bool MockSupport::returnBoolValueOrDefault(bool defaultValue)
{
if (hasReturnValue()) {
return boolReturnValue();
}
return defaultValue;
}
long int MockSupport::returnLongIntValueOrDefault(long int defaultValue)
{
if (hasReturnValue()) {
return longIntReturnValue();
}
return defaultValue;
}
long int MockCheckedActualCall::returnLongIntValueOrDefault(long int default_value)
{
if (!hasReturnValue()) {
return default_value;
}
return returnLongIntValue();
}
const char * MockSupport::returnStringValueOrDefault(const char * defaultValue)
{
if (hasReturnValue()) {
return stringReturnValue();
}
return defaultValue;
}
void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++.
if (!getLangOpts().CPlusPlus11)
return;
// Skip list initialization and constructors with an initializer list.
auto ConstructExpr =
cxxConstructExpr(
unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())),
isListInitialization(), hasDescendant(initListExpr()),
isInTemplateInstantiation())))
.bind("ctor");
auto CtorAsArgument = materializeTemporaryExpr(anyOf(
has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr)))));
Finder->addMatcher(
functionDecl(isDefinition(), // Declarations don't have return statements.
returns(unless(anyOf(builtinType(), autoType()))),
hasDescendant(returnStmt(hasReturnValue(
has(cxxConstructExpr(has(CtorAsArgument)))))))
.bind("fn"),
this);
}
void MisplacedWideningCastCheck::registerMatchers(MatchFinder *Finder) {
const auto Calc =
expr(anyOf(binaryOperator(
anyOf(hasOperatorName("+"), hasOperatorName("-"),
hasOperatorName("*"), hasOperatorName("<<"))),
unaryOperator(hasOperatorName("~"))),
hasType(isInteger()))
.bind("Calc");
const auto ExplicitCast = explicitCastExpr(hasDestinationType(isInteger()),
has(ignoringParenImpCasts(Calc)));
const auto ImplicitCast =
implicitCastExpr(hasImplicitDestinationType(isInteger()),
has(ignoringParenImpCasts(Calc)));
const auto Cast = expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast");
Finder->addMatcher(varDecl(hasInitializer(Cast)), this);
Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this);
Finder->addMatcher(callExpr(hasAnyArgument(Cast)), this);
Finder->addMatcher(binaryOperator(hasOperatorName("="), hasRHS(Cast)), this);
Finder->addMatcher(
binaryOperator(matchers::isComparisonOperator(), hasEitherOperand(Cast)),
this);
}
