/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2023 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

#include "checkclass.h"

#include "astutils.h"

#include "library.h"

#include "settings.h"

#include "standards.h"

#include "symboldatabase.h"

#include "errorlogger.h"

#include "errortypes.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include <algorithm>

#include <cctype>

#include <cstring>

#include <iterator>

#include <utility>

#include <unordered_map>

#include <tinyxml2.h>

namespace CTU {

class FileInfo;

}

//---------------------------------------------------------------------------

// Register CheckClass..

namespace {

CheckClass instance;

}

static const CWE CWE398(398U); // Indicator of Poor Code Quality

static const CWE CWE404(404U); // Improper Resource Shutdown or Release

static const CWE CWE665(665U); // Improper Initialization

static const CWE CWE758(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior

static const CWE CWE762(762U); // Mismatched Memory Management Routines

static const CWE CWE_ONE_DEFINITION_RULE(758U);

static const char * getFunctionTypeName(Function::Type type)

{

switch (type) {

case Function::eConstructor:

return "constructor";

case Function::eCopyConstructor:

return "copy constructor";

case Function::eMoveConstructor:

return "move constructor";

case Function::eDestructor:

return "destructor";

case Function::eFunction:

return "function";

case Function::eOperatorEqual:

return "operator=";

case Function::eLambda:

return "lambda";

}

return "";

}

static bool isVariableCopyNeeded(const Variable &var, Function::Type type)

{

bool isOpEqual = false;

switch (type) {

case Function::eOperatorEqual:

isOpEqual = true;

break;

case Function::eCopyConstructor:

case Function::eMoveConstructor:

break;

default:

return true;

}

return (!var.hasDefault() || isOpEqual) && // default init does not matter for operator=

(var.isPointer() ||

(var.type() && var.type()->needInitialization == Type::NeedInitialization::True) ||

(var.valueType() && var.valueType()->type >= ValueType::Type::CHAR));

}

static bool isVclTypeInit(const Type *type)

{

if (!type)

return false;

return std::any_of(type->derivedFrom.begin(), type->derivedFrom.end(), [&](const Type::BaseInfo& baseInfo) {

if (!baseInfo.type)

return true;

if (isVclTypeInit(baseInfo.type))

return true;

return false;

});

}

//---------------------------------------------------------------------------

CheckClass::CheckClass(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)

: Check(myName(), tokenizer, settings, errorLogger),

mSymbolDatabase(tokenizer?tokenizer->getSymbolDatabase():nullptr)

{}

//---------------------------------------------------------------------------

// ClassCheck: Check that all class constructors are ok.

//---------------------------------------------------------------------------

void CheckClass::constructors()

{

const bool printStyle = mSettings->severity.isEnabled(Severity::style);

const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);

if (!printStyle && !printWarnings)

return;

logChecker("CheckClass::checkConstructors"); // style,warning

const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

if (mSettings->hasLib("vcl") && isVclTypeInit(scope->definedType))

continue;

const bool unusedTemplate = Token::simpleMatch(scope->classDef->previous(), ">");

const bool usedInUnion = std::any_of(mSymbolDatabase->scopeList.cbegin(), mSymbolDatabase->scopeList.cend(), [&](const Scope& unionScope) {

if (unionScope.type != Scope::eUnion)

return false;

return std::any_of(unionScope.varlist.cbegin(), unionScope.varlist.cend(), [&](const Variable& var) {

return var.type() && var.type()->classScope == scope;

});

});

// There are no constructors.

if (scope->numConstructors == 0 && printStyle && !usedInUnion) {

// If there is a private variable, there should be a constructor..

int needInit = 0, haveInit = 0;

std::vector<const Variable*> uninitVars;

for (const Variable &var : scope->varlist) {

if (var.isPrivate() && !var.isStatic() &&

(!var.isClass() || (var.type() && var.type()->needInitialization == Type::NeedInitialization::True))) {

++needInit;

if (!var.isInit() && !var.hasDefault() && var.nameToken()->scope() == scope) // don't warn for anonymous union members

uninitVars.emplace_back(&var);

else

++haveInit;

}

}

if (needInit > haveInit) {

if (haveInit == 0)

noConstructorError(scope->classDef, scope->className, scope->classDef->str() == "struct");

else

for (const Variable* uv : uninitVars)

uninitVarError(uv->typeStartToken(), uv->scope()->className, uv->name());

}

}

if (!printWarnings)

continue;

// #3196 => bailout if there are nested unions

// TODO: handle union variables better

{

const bool bailout = std::any_of(scope->nestedList.cbegin(), scope->nestedList.cend(), [](const Scope* nestedScope) {

return nestedScope->type == Scope::eUnion;

});

if (bailout)

continue;

}

std::vector<Usage> usageList = createUsageList(scope);

for (const Function &func : scope->functionList) {

if (!(func.isConstructor() && (func.hasBody() || (func.isDefault() && func.type == Function::eConstructor))) &&

!(func.type == Function::eOperatorEqual && func.hasBody()))

continue; // a defaulted constructor does not initialize primitive members

// Bail: If initializer list is not recognized as a variable or type then skip since parsing is incomplete

if (unusedTemplate && func.type == Function::eConstructor) {

const Token *initList = func.constructorMemberInitialization();

if (Token::Match(initList, ": %name% (") && initList->next()->tokType() == Token::eName)

break;

}

// Mark all variables not used

clearAllVar(usageList);

// Variables with default initializers

for (Usage &usage : usageList) {

const Variable& var = *usage.var;

// check for C++11 initializer

if (var.hasDefault() && func.type != Function::eOperatorEqual && func.type != Function::eCopyConstructor) { // variable still needs to be copied

usage.init = true;

}

}

std::list<const Function *> callstack;

initializeVarList(func, callstack, scope, usageList);

// Assign 1 union member => assign all union members

for (const Usage &usage : usageList) {

const Variable& var = *usage.var;

if (!usage.assign && !usage.init)

continue;

const Scope* varScope1 = var.nameToken()->scope();

while (varScope1->type == Scope::ScopeType::eStruct)

varScope1 = varScope1->nestedIn;

if (varScope1->type == Scope::ScopeType::eUnion) {

for (Usage &usage2 : usageList) {

const Variable& var2 = *usage2.var;

if (usage2.assign || usage2.init || var2.isStatic())

continue;

const Scope* varScope2 = var2.nameToken()->scope();

while (varScope2->type == Scope::ScopeType::eStruct)

varScope2 = varScope2->nestedIn;

if (varScope1 == varScope2)

usage2.assign = true;

}

}

}

// Check if any variables are uninitialized

for (const Usage &usage : usageList) {

const Variable& var = *usage.var;

if (usage.assign || usage.init || var.isStatic())

continue;

if (var.valueType() && var.valueType()->pointer == 0 && var.type() && var.type()->needInitialization == Type::NeedInitialization::False && var.type()->derivedFrom.empty())

continue;

if (var.isConst() && func.isOperator()) // We can't set const members in assignment operator

continue;

// Check if this is a class constructor

if (!var.isPointer() && !var.isPointerArray() && var.isClass() && func.type == Function::eConstructor) {

// Unknown type so assume it is initialized

if (!var.type()) {

if (var.isStlType() && var.valueType() && var.valueType()->containerTypeToken && var.getTypeName() == "std::array") {

const Token* ctt = var.valueType()->containerTypeToken;

if (!ctt->isStandardType() &&

(!ctt->type() || ctt->type()->needInitialization != Type::NeedInitialization::True) &&

!mSettings->library.podtype(ctt->str())) // TODO: handle complex type expression

continue;

}

else

continue;

}

// Known type that doesn't need initialization or

// known type that has member variables of an unknown type

else if (var.type()->needInitialization != Type::NeedInitialization::True)

continue;

}

// Check if type can't be copied

if (!var.isPointer() && !var.isPointerArray() && var.typeScope()) {

if (func.type == Function::eMoveConstructor) {

if (canNotMove(var.typeScope()))

continue;

} else {

if (canNotCopy(var.typeScope()))

continue;

}

}

// Is there missing member copy in copy/move constructor or assignment operator?

bool missingCopy = false;

// Don't warn about unknown types in copy constructors since we

// don't know if they can be copied or not..

if (!isVariableCopyNeeded(var, func.type)) {

if (!printInconclusive)

continue;

missingCopy = true;

}

// It's non-static and it's not initialized => error

if (func.type == Function::eOperatorEqual) {

const Token *operStart = func.arg;

bool classNameUsed = false;

for (const Token *operTok = operStart; operTok != operStart->link(); operTok = operTok->next()) {

if (operTok->str() == scope->className) {

classNameUsed = true;

break;

}

}

if (classNameUsed && mSettings->library.getTypeCheck("operatorEqVarError", var.getTypeName()) != Library::TypeCheck::suppress)

operatorEqVarError(func.token, scope->className, var.name(), missingCopy);

} else if (func.access != AccessControl::Private || mSettings->standards.cpp >= Standards::CPP11) {

// If constructor is not in scope then we maybe using a constructor from a different template specialization

if (!precedes(scope->bodyStart, func.tokenDef))

continue;

const Scope *varType = var.typeScope();

if (!varType || varType->type != Scope::eUnion) {

const bool derived = scope != var.scope();

if (func.type == Function::eConstructor &&

func.nestedIn && (func.nestedIn->numConstructors - func.nestedIn->numCopyOrMoveConstructors) > 1 &&

func.argCount() == 0 && func.functionScope &&

func.arg && func.arg->link()->next() == func.functionScope->bodyStart &&

func.functionScope->bodyStart->link() == func.functionScope->bodyStart->next()) {

// don't warn about user defined default constructor when there are other constructors

if (printInconclusive)

uninitVarError(func.token, func.access == AccessControl::Private, func.type, var.scope()->className, var.name(), derived, true);

} else if (missingCopy)

missingMemberCopyError(func.token, func.type, var.scope()->className, var.name());

else

uninitVarError(func.token, func.access == AccessControl::Private, func.type, var.scope()->className, var.name(), derived, false);

}

}

}

}

}

}

void CheckClass::checkExplicitConstructors()

{

if (!mSettings->severity.isEnabled(Severity::style))

return;

logChecker("CheckClass::checkExplicitConstructors"); // style

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

// Do not perform check, if the class/struct has not any constructors

if (scope->numConstructors == 0)

continue;

// Is class abstract? Maybe this test is over-simplification, but it will suffice for simple cases,

// and it will avoid false positives.

const bool isAbstractClass = std::any_of(scope->functionList.cbegin(), scope->functionList.cend(), [](const Function& func) {

return func.isPure();

});

// Abstract classes can't be instantiated. But if there is C++11

// "misuse" by derived classes then these constructors must be explicit.

if (isAbstractClass && mSettings->standards.cpp >= Standards::CPP11)

continue;

for (const Function &func : scope->functionList) {

// We are looking for constructors, which are meeting following criteria:

// 1) Constructor is declared with a single parameter

// 2) Constructor is not declared as explicit

// 3) It is not a copy/move constructor of non-abstract class

// 4) Constructor is not marked as delete (programmer can mark the default constructor as deleted, which is ok)

if (!func.isConstructor() || func.isDelete() || (!func.hasBody() && func.access == AccessControl::Private))

continue;

if (!func.isExplicit() &&

func.argCount() > 0 && func.minArgCount() < 2 &&

func.type != Function::eCopyConstructor &&

func.type != Function::eMoveConstructor &&

!(func.templateDef && Token::simpleMatch(func.argumentList.front().typeEndToken(), "...")) &&

func.argumentList.front().getTypeName() != "std::initializer_list") {

noExplicitConstructorError(func.tokenDef, scope->className, scope->type == Scope::eStruct);

}

}

}

}

static bool hasNonCopyableBase(const Scope *scope, bool *unknown)

{

// check if there is base class that is not copyable

for (const Type::BaseInfo &baseInfo : scope->definedType->derivedFrom) {

if (!baseInfo.type || !baseInfo.type->classScope) {

*unknown = true;

continue;

}

if (hasNonCopyableBase(baseInfo.type->classScope, unknown))

return true;

for (const Function &func : baseInfo.type->classScope->functionList) {

if (func.type != Function::eCopyConstructor)

continue;

if (func.access == AccessControl::Private || func.isDelete()) {

*unknown = false;

return true;

}

}

}

return false;

}

void CheckClass::copyconstructors()

{

if (!mSettings->severity.isEnabled(Severity::warning))

return;

logChecker("CheckClass::checkCopyConstructors"); // warning

for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

std::map<int, const Token*> allocatedVars;

for (const Function &func : scope->functionList) {

if (func.type != Function::eConstructor || !func.functionScope)

continue;

const Token* tok = func.token->linkAt(1);

for (const Token* const end = func.functionScope->bodyStart; tok != end; tok = tok->next()) {

if (Token::Match(tok, "%var% ( new") ||

(Token::Match(tok, "%var% ( %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {

const Variable* var = tok->variable();

if (var && var->isPointer() && var->scope() == scope)

allocatedVars[tok->varId()] = tok;

}

}

for (const Token* const end = func.functionScope->bodyEnd; tok != end; tok = tok->next()) {

if (Token::Match(tok, "%var% = new") ||

(Token::Match(tok, "%var% = %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {

const Variable* var = tok->variable();

if (var && var->isPointer() && var->scope() == scope && !var->isStatic())

allocatedVars[tok->varId()] = tok;

}

}

}

if (!allocatedVars.empty()) {

const Function *funcCopyCtor = nullptr;

const Function *funcOperatorEq = nullptr;

const Function *funcDestructor = nullptr;

for (const Function &func : scope->functionList) {

if (func.type == Function::eCopyConstructor)

funcCopyCtor = &func;

else if (func.type == Function::eOperatorEqual)

funcOperatorEq = &func;

else if (func.type == Function::eDestructor)

funcDestructor = &func;

}

if (!funcCopyCtor || funcCopyCtor->isDefault()) {

bool unknown = false;

if (!hasNonCopyableBase(scope, &unknown) && !unknown)

noCopyConstructorError(scope, funcCopyCtor, allocatedVars.cbegin()->second, unknown);

}

if (!funcOperatorEq || funcOperatorEq->isDefault()) {

bool unknown = false;

if (!hasNonCopyableBase(scope, &unknown) && !unknown)

noOperatorEqError(scope, funcOperatorEq, allocatedVars.cbegin()->second, unknown);

}

if (!funcDestructor || funcDestructor->isDefault()) {

const Token * mustDealloc = nullptr;

for (std::map<int, const Token*>::const_iterator it = allocatedVars.cbegin(); it != allocatedVars.cend(); ++it) {

if (!Token::Match(it->second, "%var% [(=] new %type%")) {

mustDealloc = it->second;

break;

}

if (it->second->valueType() && it->second->valueType()->isIntegral()) {

mustDealloc = it->second;

break;

}

const Variable *var = it->second->variable();

if (var && var->typeScope() && var->typeScope()->functionList.empty() && var->type()->derivedFrom.empty()) {

mustDealloc = it->second;

break;

}

}

if (mustDealloc)

noDestructorError(scope, funcDestructor, mustDealloc);

}

}

std::set<const Token*> copiedVars;

const Token* copyCtor = nullptr;

for (const Function &func : scope->functionList) {

if (func.type != Function::eCopyConstructor)

continue;

copyCtor = func.tokenDef;

if (!func.functionScope) {

allocatedVars.clear();

break;

}

const Token* tok = func.tokenDef->linkAt(1)->next();

if (tok->str()==":") {

tok=tok->next();

while (Token::Match(tok, "%name% (")) {

if (allocatedVars.find(tok->varId()) != allocatedVars.end()) {

if (tok->varId() && Token::Match(tok->tokAt(2), "%name% . %name% )"))

copiedVars.insert(tok);

else if (!Token::Match(tok->tokAt(2), "%any% )"))

allocatedVars.erase(tok->varId()); // Assume memory is allocated

}

tok = tok->linkAt(1)->tokAt(2);

}

}

for (tok = func.functionScope->bodyStart; tok != func.functionScope->bodyEnd; tok = tok->next()) {

if ((mTokenizer->isCPP() && Token::Match(tok, "%var% = new")) ||

(Token::Match(tok, "%var% = %name% (") && (mSettings->library.getAllocFuncInfo(tok->tokAt(2)) || mSettings->library.getReallocFuncInfo(tok->tokAt(2))))) {

allocatedVars.erase(tok->varId());

} else if (Token::Match(tok, "%var% = %name% . %name% ;") && allocatedVars.find(tok->varId()) != allocatedVars.end()) {

copiedVars.insert(tok);

}

}

break;

}

if (copyCtor && !copiedVars.empty()) {

for (const Token *cv : copiedVars)

copyConstructorShallowCopyError(cv, cv->str());

// throw error if count mismatch

/* FIXME: This doesn't work. See #4154

for (std::map<int, const Token*>::const_iterator i = allocatedVars.begin(); i != allocatedVars.end(); ++i) {

copyConstructorMallocError(copyCtor, i->second, i->second->str());

}

*/

}

}

}

/* This doesn't work. See #4154

void CheckClass::copyConstructorMallocError(const Token *cctor, const Token *alloc, const std::string& varname)

{

std::list<const Token*> callstack;

callstack.push_back(cctor);

callstack.push_back(alloc);

reportError(callstack, Severity::warning, "copyCtorNoAllocation", "Copy constructor does not allocate memory for member '" + varname + "' although memory has been allocated in other constructors.");

}

*/

void CheckClass::copyConstructorShallowCopyError(const Token *tok, const std::string& varname)

{

reportError(tok, Severity::warning, "copyCtorPointerCopying",

"$symbol:" + varname + "\nValue of pointer '$symbol', which points to allocated memory, is copied in copy constructor instead of allocating new memory.", CWE398, Certainty::normal);

}

static std::string noMemberErrorMessage(const Scope *scope, const char function[], bool isdefault)

{

const std::string &classname = scope ? scope->className : "class";

const std::string type = (scope && scope->type == Scope::eStruct) ? "Struct" : "Class";

const bool isDestructor = (function[0] == 'd');

std::string errmsg = "$symbol:" + classname + '\n';

if (isdefault) {

errmsg += type + " '$symbol' has dynamic memory/resource allocation(s). The " + function + " is explicitly defaulted but the default " + function + " does not work well.";

if (isDestructor)

errmsg += " It is recommended to define the " + std::string(function) + '.';

else

errmsg += " It is recommended to define or delete the " + std::string(function) + '.';

} else {

errmsg += type + " '$symbol' does not have a " + function + " which is recommended since it has dynamic memory/resource allocation(s).";

}

return errmsg;

}

void CheckClass::noCopyConstructorError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive)

{

reportError(alloc, Severity::warning, "noCopyConstructor", noMemberErrorMessage(scope, "copy constructor", isdefault), CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);

}

void CheckClass::noOperatorEqError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive)

{

reportError(alloc, Severity::warning, "noOperatorEq", noMemberErrorMessage(scope, "operator=", isdefault), CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);

}

void CheckClass::noDestructorError(const Scope *scope, bool isdefault, const Token *alloc)

{

reportError(alloc, Severity::warning, "noDestructor", noMemberErrorMessage(scope, "destructor", isdefault), CWE398, Certainty::normal);

}

bool CheckClass::canNotCopy(const Scope *scope)

{

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

for (const Function &func : scope->functionList) {

if (func.isConstructor())

constructor = true;

if (func.access != AccessControl::Public)

continue;

if (func.type == Function::eCopyConstructor) {

publicCopy = true;

break;

}

if (func.type == Function::eOperatorEqual) {

publicAssign = true;

break;

}

}

return constructor && !(publicAssign || publicCopy);

}

bool CheckClass::canNotMove(const Scope *scope)

{

bool constructor = false;

bool publicAssign = false;

bool publicCopy = false;

bool publicMove = false;

for (const Function &func : scope->functionList) {

if (func.isConstructor())

constructor = true;

if (func.access != AccessControl::Public)

continue;

if (func.type == Function::eCopyConstructor) {

publicCopy = true;

break;

}

if (func.type == Function::eMoveConstructor) {

publicMove = true;

break;

}

if (func.type == Function::eOperatorEqual) {

publicAssign = true;

break;

}

}

return constructor && !(publicAssign || publicCopy || publicMove);

}

static void getAllVariableMembers(const Scope *scope, std::vector<const Variable *>& varList)

{

std::transform(scope->varlist.cbegin(), scope->varlist.cend(), std::back_inserter(varList), [](const Variable& var) {

return &var;

});

if (scope->definedType) {

for (const Type::BaseInfo& baseInfo: scope->definedType->derivedFrom) {

if (scope->definedType == baseInfo.type)

continue;

const Scope *baseClass = baseInfo.type ? baseInfo.type->classScope : nullptr;

if (baseClass && baseClass->isClassOrStruct() && baseClass->numConstructors == 0)

getAllVariableMembers(baseClass, varList);

}

}

}

std::vector<CheckClass::Usage> CheckClass::createUsageList(const Scope *scope)

{

std::vector<Usage> ret;

std::vector<const Variable *> varlist;

getAllVariableMembers(scope, varlist);

ret.reserve(varlist.size());

std::transform(varlist.cbegin(), varlist.cend(), std::back_inserter(ret), [](const Variable* var) {

return Usage(var);

});

return ret;

}

void CheckClass::assignVar(std::vector<Usage> &usageList, nonneg int varid)

{

auto it = std::find_if(usageList.begin(), usageList.end(), [varid](const Usage& usage) {

return usage.var->declarationId() == varid;

});

if (it != usageList.end())

it->assign = true;

}

void CheckClass::assignVar(std::vector<Usage> &usageList, const Token* vartok)

{

if (vartok->varId() > 0) {

assignVar(usageList, vartok->varId());

return;

}

auto it = std::find_if(usageList.begin(), usageList.end(), [vartok](const Usage& usage) {

// FIXME: This is a workaround when varid is not set for a derived member

return usage.var->name() == vartok->str();

});

if (it != usageList.end())

it->assign = true;

}

void CheckClass::initVar(std::vector<Usage> &usageList, nonneg int varid)

{

auto it = std::find_if(usageList.begin(), usageList.end(), [varid](const Usage& usage) {

return usage.var->declarationId() == varid;

});

if (it != usageList.end())

it->init = true;

}

void CheckClass::assignAllVar(std::vector<Usage> &usageList)

{

for (Usage & i : usageList)

i.assign = true;

}

void CheckClass::assignAllVarsVisibleFromScope(std::vector<Usage>& usageList, const Scope* scope)

{

for (Usage& usage : usageList) {

if (usage.var->scope() == scope)

usage.assign = true;

}

// Iterate through each base class...

for (const Type::BaseInfo& i : scope->definedType->derivedFrom) {

const Type *derivedFrom = i.type;

if (derivedFrom && derivedFrom->classScope)

assignAllVarsVisibleFromScope(usageList, derivedFrom->classScope);

}

}

void CheckClass::clearAllVar(std::vector<Usage> &usageList)

{

for (Usage & i : usageList) {

i.assign = false;

i.init = false;

}

}

bool CheckClass::isBaseClassMutableMemberFunc(const Token *tok, const Scope *scope)

{

// Iterate through each base class...

for (const Type::BaseInfo & i : scope->definedType->derivedFrom) {

const Type *derivedFrom = i.type;

// Check if base class exists in database

if (derivedFrom && derivedFrom->classScope) {

const std::list<Function>& functionList = derivedFrom->classScope->functionList;

if (std::any_of(functionList.cbegin(), functionList.cend(), [&](const Function& func) {

return func.tokenDef->str() == tok->str() && !func.isStatic() && !func.isConst();

}))

return true;

if (isBaseClassMutableMemberFunc(tok, derivedFrom->classScope))

return true;

}

// Base class not found so assume it is in it.

else

return true;

}

return false;

}

void CheckClass::initializeVarList(const Function &func, std::list<const Function *> &callstack, const Scope *scope, std::vector<Usage> &usage) const

{

if (!func.functionScope)

return;

bool initList = func.isConstructor();

const Token *ftok = func.arg->link()->next();

int level = 0;

for (; ftok && ftok != func.functionScope->bodyEnd; ftok = ftok->next()) {

// Class constructor.. initializing variables like this

// clKalle::clKalle() : var(value) { }

if (initList) {

if (level == 0 && Token::Match(ftok, "%name% {|(") && Token::Match(ftok->linkAt(1), "}|) ,|{")) {

if (ftok->str() != func.name()) {

if (ftok->varId())

initVar(usage, ftok->varId());

else { // base class constructor

for (Usage& u : usage) {

if (u.var->scope() != scope) // assume that all variables are initialized in base class

u.init = true;

}

}

} else { // c++11 delegate constructor

const Function *member = ftok->function();

// member function not found => assume it initializes all members

if (!member) {

assignAllVar(usage);

return;

}

// recursive call

// assume that all variables are initialized

if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {

/** @todo false negative: just bail */

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

initializeVarList(*member, callstack, scope, usage);

callstack.pop_back();

}

// there is a called member function, but it has no implementation, so we assume it initializes everything

else {

assignAllVar(usage);

}

}

} else if (level != 0 && Token::Match(ftok, "%name% =")) // assignment in the initializer: var(value = x)

assignVar(usage, ftok->varId());

// Level handling

if (ftok->link() && Token::Match(ftok, "(|<"))

level++;

else if (ftok->str() == "{") {

if (level != 0 ||

(Token::Match(ftok->previous(), "%name%|>") && Token::Match(ftok->link(), "} ,|{")))

level++;

else

initList = false;

} else if (ftok->link() && Token::Match(ftok, ")|>|}"))

level--;

}

if (initList)

continue;

// Variable getting value from stream?

if (Token::Match(ftok, ">>|& %name%") && isLikelyStreamRead(true, ftok)) {

assignVar(usage, ftok->next()->varId());

}

// If assignment comes after an && or || this is really inconclusive because of short circuiting

if (Token::Match(ftok, "%oror%|&&"))

continue;

if (Token::simpleMatch(ftok, "( !"))

ftok = ftok->next();

// Using the operator= function to initialize all variables..

if (Token::Match(ftok->next(), "return| (| * this )| =")) {

assignAllVar(usage);

break;

}

// Using swap to assign all variables..

if (func.type == Function::eOperatorEqual && Token::Match(ftok, "[;{}] %name% (") && Token::Match(ftok->linkAt(2), ") . %name% ( *| this ) ;")) {

assignAllVar(usage);

break;

}

// Calling member variable function?

if (Token::Match(ftok->next(), "%var% . %name% (") && !(ftok->next()->valueType() && ftok->next()->valueType()->pointer)) {

if (std::any_of(scope->varlist.cbegin(), scope->varlist.cend(), [&](const Variable& var) {

return var.declarationId() == ftok->next()->varId();

}))

/** @todo false negative: we assume function changes variable state */

assignVar(usage, ftok->next()->varId());

ftok = ftok->tokAt(2);

}

if (!Token::Match(ftok->next(), "::| %name%") &&

!Token::Match(ftok->next(), "*| this . %name%") &&

!Token::Match(ftok->next(), "* %name% =") &&

!Token::Match(ftok->next(), "( * this ) . %name%"))

continue;

// Goto the first token in this statement..

ftok = ftok->next();

// skip "return"

if (ftok->str() == "return")

ftok = ftok->next();

// Skip "( * this )"

if (Token::simpleMatch(ftok, "( * this ) .")) {

ftok = ftok->tokAt(5);

}

// Skip "this->"

if (Token::simpleMatch(ftok, "this ."))

ftok = ftok->tokAt(2);

// Skip "classname :: "

if (Token::Match(ftok, ":: %name%"))

ftok = ftok->next();

while (Token::Match(ftok, "%name% ::"))

ftok = ftok->tokAt(2);

// Clearing all variables..

if (Token::Match(ftok, "::| memset ( this ,")) {

assignAllVar(usage);

return;

}

// Ticket #7068

if (Token::Match(ftok, "::| memset ( &| this . %name%")) {

if (ftok->str() == "::")

ftok = ftok->next();

int offsetToMember = 4;

if (ftok->strAt(2) == "&")

++offsetToMember;

assignVar(usage, ftok->tokAt(offsetToMember)->varId());

ftok = ftok->linkAt(1);

continue;

}

// Clearing array..

if (Token::Match(ftok, "::| memset ( %name% ,")) {

if (ftok->str() == "::")

ftok = ftok->next();

assignVar(usage, ftok->tokAt(2)->varId());

ftok = ftok->linkAt(1);

continue;

}

// Calling member function?

if (Token::simpleMatch(ftok, "operator= (")) {

if (ftok->function()) {

const Function *member = ftok->function();

// recursive call

// assume that all variables are initialized

if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {

/** @todo false negative: just bail */

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

initializeVarList(*member, callstack, scope, usage);

callstack.pop_back();

}

// assume that a base class call to operator= assigns all its base members (but not more)

else if (func.tokenDef->str() == ftok->str() && isBaseClassMutableMemberFunc(ftok, scope)) {

if (member->nestedIn)

assignAllVarsVisibleFromScope(usage, member->nestedIn->definedType->classScope);

}

// there is a called member function, but it has no implementation, so we assume it initializes everything

else {

assignAllVar(usage);

}

}

// using default operator =, assume everything initialized

else {

assignAllVar(usage);

}

} else if (Token::Match(ftok, "::| %name% (") && !Token::Match(ftok, "if|while|for")) {

if (ftok->str() == "::")

ftok = ftok->next();

// Passing "this" => assume that everything is initialized

for (const Token *tok2 = ftok->next()->link(); tok2 && tok2 != ftok; tok2 = tok2->previous()) {

if (tok2->str() == "this") {

assignAllVar(usage);

return;

}

}

// check if member function

if (ftok->function() && ftok->function()->nestedIn == scope &&

!ftok->function()->isConstructor()) {

const Function *member = ftok->function();

// recursive call

// assume that all variables are initialized

if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {

assignAllVar(usage);

return;

}

// member function has implementation

if (member->hasBody()) {

// initialize variable use list using member function

callstack.push_back(member);

initializeVarList(*member, callstack, scope, usage);

callstack.pop_back();

// Assume that variables that are passed to it are initialized..

for (const Token *tok2 = ftok; tok2; tok2 = tok2->next()) {

if (Token::Match(tok2, "[;{}]"))

break;

if (Token::Match(tok2, "[(,] &| %name% [,)]")) {

tok2 = tok2->next();

if (tok2->str() == "&")

tok2 = tok2->next();

if (isVariableChangedByFunctionCall(tok2, tok2->previous()->str() == "&", tok2->varId(), mSettings, nullptr))

assignVar(usage, tok2->varId());

}

}

}

// there is a called member function, but it has no implementation, so we assume it initializes everything (if it can mutate state)

else if (!member->isConst() && !member->isStatic()) {

assignAllVar(usage);

}

// const method, assume it assigns all mutable members

else if (member->isConst()) {

for (Usage& i: usage) {

if (i.var->isMutable())

i.assign = true;

}