Make copy-constructible classes copyable

Author: Your Name

.clang-tidy

@@ -18,6 +18,7 @@ Checks: >
         -objc-*,
         -openmp-*,
         -zircon-*,
+        cppcoreguidelines-avoid-const-or-ref-data-members,
         cppcoreguidelines-pro-type-static-cast-downcast,
         cppcoreguidelines-rvalue-reference-param-not-moved,
         google-explicit-constructor,

Makefile

@@ -138,7 +138,6 @@ Does not improve the readability.
 To be evaluated (need to remove exclusion).
 
 `cppcoreguidelines-missing-std-forward`<br/>
-`cppcoreguidelines-avoid-const-or-ref-data-members`<br/>
 `cppcoreguidelines-macro-usage`<br/>
 `cppcoreguidelines-pro-type-member-init`<br/>
 `cppcoreguidelines-prefer-member-initializer`<br/>

clang-tidy.md

@@ -172,8 +172,8 @@ namespace {
                 writeToPipeInternal(type, data.c_str(), len);
         }
 
-        const int mWpipe;
-        const bool mDebug;
+        int mWpipe;
+        bool mDebug;
     };
 }
 

cli/processexecutor.cpp

@@ -26,6 +26,7 @@
 #include "infer.h"
 #include "library.h"
 #include "mathlib.h"
+#include "nonnullptr.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
@@ -3142,7 +3143,7 @@ namespace {
     };
 
     struct ExpressionChangedSkipDeadCode {
-        const Library& library;
+        NonNullPtr<const Library> library;
         const std::function<std::vector<MathLib::bigint>(const Token* tok)>* evaluate;
         ExpressionChangedSkipDeadCode(const Library& library,
                                       const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate)

lib/astutils.cpp

@@ -24,6 +24,7 @@
 #include "fwdanalysis.h"
 #include "library.h"
 #include "mathlib.h"
+#include "nonnullptr.h"
 #include "platform.h"
 #include "settings.h"
 #include "standards.h"
@@ -4513,7 +4514,7 @@ struct UnionMember {
         : name(name)
         , size(size) {}
 
-    const std::string &name;
+    NonNullPtr<const std::string> name;
     size_t size;
 };
 
@@ -4523,7 +4524,7 @@ struct Union {
         , name(scope.className) {}
 
     const Scope *scope;
-    const std::string &name;
+    NonNullPtr<const std::string> name;
     std::vector<UnionMember> members;
 
     const UnionMember *largestMember() const {
@@ -4632,7 +4633,7 @@ void CheckOtherImpl::unionZeroInitError(const Token *tok,
                 "Zero initializing union '$symbol' does not guarantee " +
                 "its complete storage to be zero initialized as its largest member " +
                 "is not declared as the first member. Consider making " +
-                largestMember.name + " the first member or favor memset().");
+                *largestMember.name + " the first member or favor memset().");
 }
 
 //-----------------------------------------------------------------------------

lib/checkother.cpp

@@ -22,6 +22,7 @@
 #include "errortypes.h"
 #include "library.h"
 #include "mathlib.h"
+#include "nonnullptr.h"
 #include "pathanalysis.h"
 #include "settings.h"
 #include "standards.h"
@@ -2872,7 +2873,7 @@ namespace {
     private:
         const Token* mBodyTok;
         const Token* mLoopVar{};
-        const Settings& mSettings;
+        NonNullPtr<const Settings> mSettings;
         std::set<nonneg int> mVarsChanged;
 
     public:
@@ -2895,7 +2896,7 @@ namespace {
             int n = 1 + (astIsPointer(tok) ? 1 : 0);
             for (int i = 0; i < n; i++) {
                 bool inconclusive = false;
-                if (isVariableChangedByFunctionCall(tok, i, mSettings.library, &inconclusive))
+                if (isVariableChangedByFunctionCall(tok, i, mSettings->library, &inconclusive))
                     return true;
                 if (inconclusive)
                     return true;

lib/checkstl.cpp

@@ -20,6 +20,7 @@
 
 #include "errortypes.h"
 #include "mathlib.h"
+#include "nonnullptr.h"
 #include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
@@ -233,8 +234,8 @@ namespace clangimport {
             , mSymbolDatabase(symbolDatabase)
         {}
 
-        const Settings &mSettings;
-        SymbolDatabase &mSymbolDatabase;
+        NonNullPtr<const Settings> mSettings;
+        NonNullPtr<SymbolDatabase> mSymbolDatabase;
 
         int enumValue = 0;
 
@@ -672,7 +673,7 @@ void clangimport::AstNode::addFullScopeNameTokens(TokenList &tokenList, const Sc
 const Scope *clangimport::AstNode::getNestedInScope(TokenList &tokenList)
 {
     if (!tokenList.back())
-        return &mData->mSymbolDatabase.scopeList.front();
+        return &mData->mSymbolDatabase->scopeList.front();
     if (tokenList.back()->str() == "}" && mData->mNotScope.find(tokenList.back()) == mData->mNotScope.end())
         return tokenList.back()->scope()->nestedIn;
     return tokenList.back()->scope();
@@ -1071,8 +1072,8 @@ Token *clangimport::AstNode::createTokens(TokenList &tokenList)
             const_cast<Token *>(enumscope->bodyEnd)->deletePrevious();
 
         // Create enum type
-        mData->mSymbolDatabase.typeList.emplace_back(enumtok, enumscope, enumtok->scope());
-        enumscope->definedType = &mData->mSymbolDatabase.typeList.back();
+        mData->mSymbolDatabase->typeList.emplace_back(enumtok, enumscope, enumtok->scope());
+        enumscope->definedType = &mData->mSymbolDatabase->typeList.back();
         if (nametok)
             const_cast<Scope *>(enumtok->scope())->definedTypesMap[nametok->str()] = enumscope->definedType;
 
@@ -1238,8 +1239,8 @@ Token *clangimport::AstNode::createTokens(TokenList &tokenList)
         }
 
         Scope *recordScope = createScope(tokenList, ScopeType::eStruct, children, classDef);
-        mData->mSymbolDatabase.typeList.emplace_back(classDef, recordScope, classDef->scope());
-        recordScope->definedType = &mData->mSymbolDatabase.typeList.back();
+        mData->mSymbolDatabase->typeList.emplace_back(classDef, recordScope, classDef->scope());
+        recordScope->definedType = &mData->mSymbolDatabase->typeList.back();
         if (!recordName.empty()) {
             recordScope->className = recordName;
             const_cast<Scope *>(classDef->scope())->definedTypesMap[recordName] = recordScope->definedType;
@@ -1520,8 +1521,8 @@ void clangimport::AstNode::createTokensForCXXRecord(TokenList &tokenList)
         const std::string addr = mExtTokens[0];
         mData->scopeDecl(addr, scope);
         scope->className = className;
-        mData->mSymbolDatabase.typeList.emplace_back(classToken, scope, classToken->scope());
-        scope->definedType = &mData->mSymbolDatabase.typeList.back();
+        mData->mSymbolDatabase->typeList.emplace_back(classToken, scope, classToken->scope());
+        scope->definedType = &mData->mSymbolDatabase->typeList.back();
         const_cast<Scope *>(classToken->scope())->definedTypesMap[className] = scope->definedType;
     }
     addtoken(tokenList, ";");

lib/clangimport.cpp

@@ -159,6 +159,7 @@
     <ClInclude Include="library.h" />
     <ClInclude Include="matchcompiler.h" />
     <ClInclude Include="mathlib.h" />
+    <ClInclude Include="nonnullptr.h" />
     <ClInclude Include="path.h" />
     <ClInclude Include="pathanalysis.h" />
     <ClInclude Include="pathmatch.h" />

lib/cppcheck.vcxproj

@@ -24,6 +24,7 @@
 #include "errorlogger.h"
 #include "errortypes.h"
 #include "mathlib.h"
+#include "nonnullptr.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
@@ -50,9 +51,9 @@ namespace {
             : analyzer(analyzer), tokenList(tokenList), errorLogger(errorLogger), settings(settings)
         {}
         ValuePtr<Analyzer> analyzer;
-        const TokenList& tokenList;
-        ErrorLogger& errorLogger;
-        const Settings& settings;
+        NonNullPtr<const TokenList> tokenList;
+        NonNullPtr<ErrorLogger> errorLogger;
+        NonNullPtr<const Settings> settings;
         Analyzer::Action actions;
         bool analyzeOnly{};
         bool analyzeTerminate{};
@@ -148,7 +149,7 @@ namespace {
                 traverseRecursive(tok->astOperand2(), f, traverseUnknown);
                 traverseRecursive(tok->astOperand1(), f, traverseUnknown);
                 return Break(Analyzer::Terminate::Escape);
-            } else if (Token::Match(tok, "%name% (") && isEscapeFunction(tok, settings.library)) {
+            } else if (Token::Match(tok, "%name% (") && isEscapeFunction(tok, settings->library)) {
                 // Traverse the parameters of the function before escaping
                 traverseRecursive(tok->next()->astOperand2(), f, traverseUnknown);
                 return Break(Analyzer::Terminate::Escape);
@@ -356,7 +357,7 @@ namespace {
 
         bool isEscapeScope(const Token* endBlock, bool& unknown) const {
             const Token* ftok = nullptr;
-            const bool r = isReturnScope(endBlock, settings.library, &ftok);
+            const bool r = isReturnScope(endBlock, settings->library, &ftok);
             if (!r && ftok)
                 unknown = true;
             return r;
@@ -690,9 +691,9 @@ namespace {
                     }
                 } else if (tok->isControlFlowKeyword() && Token::Match(tok, "if|while|for (") &&
                            Token::simpleMatch(tok->linkAt(1), ") {")) {
-                    if ((settings.vfOptions.maxForwardBranches > 0) && (++branchCount > settings.vfOptions.maxForwardBranches)) {
+                    if ((settings->vfOptions.maxForwardBranches > 0) && (++branchCount > settings->vfOptions.maxForwardBranches)) {
                         // TODO: should be logged on function-level instead of file-level
-                        if (settings.severity.isEnabled(Severity::information)) {
+                        if (settings->severity.isEnabled(Severity::information)) {
                             reportError(Severity::information, "normalCheckLevelMaxBranches", "Limiting analysis of branches. Use --check-level=exhaustive to analyze all branches.");
                         }
                         return Break(Analyzer::Terminate::Bail);
@@ -802,8 +803,8 @@ namespace {
                             // Carry the then-fork forward, unless a limit is hit - then only the linear main
                             // path continues (no bail). forkDepth bounds nesting, forkBudget total. <0 = off.
                             assert(forkBudget != nullptr);
-                            const int forkDepthLimit = settings.vfOptions.maxForwardConditionForkDepth;
-                            const int forkBudgetLimit = settings.vfOptions.maxForwardConditionForks;
+                            const int forkDepthLimit = settings->vfOptions.maxForwardConditionForkDepth;
+                            const int forkBudgetLimit = settings->vfOptions.maxForwardConditionForks;
                             const bool depthOk = forkDepthLimit < 0 || forkDepth < forkDepthLimit;
                             const bool budgetOk = forkBudgetLimit < 0 || *forkBudget < forkBudgetLimit;
                             if (pThen != Progress::Break && !thenBranch.isEscape() && depthOk && budgetOk) {
@@ -890,10 +891,10 @@ namespace {
             return Progress::Continue;
         }
 
-        void reportError(Severity severity, const std::string& id, const std::string& msg) {
-            ErrorMessage::FileLocation loc(tokenList.getSourceFilePath(), 0, 0);
-            const ErrorMessage errmsg({std::move(loc)}, tokenList.getSourceFilePath(), severity, msg, id, Certainty::normal);
-            errorLogger.reportErr(errmsg);
+        void reportError(Severity severity, const std::string& id, const std::string& msg) const {
+            ErrorMessage::FileLocation loc(tokenList->getSourceFilePath(), 0, 0);
+            const ErrorMessage errmsg({std::move(loc)}, tokenList->getSourceFilePath(), severity, msg, id, Certainty::normal);
+            errorLogger->reportErr(errmsg);
         }
 
         static bool isFunctionCall(const Token* tok)