ValueFlow: avoid unnecessary ValuePtr and Value copies [skip ci]

Co-authored-by: Paul Fultz II <paul.fultz@amd.com>

Author: firewave

lib/forwardanalyzer.cpp

@@ -44,10 +44,10 @@
 #include <vector>
 
 namespace {
-    struct ForwardTraversal {
+    struct ForwardTraversal { // FIXME: invokes copy constructor
         enum class Progress : std::uint8_t { Continue, Break, Skip };
-        ForwardTraversal(const ValuePtr<Analyzer>& analyzer, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings)
-            : analyzer(analyzer), tokenList(tokenList), errorLogger(errorLogger), settings(settings)
+        ForwardTraversal(ValuePtr<Analyzer> analyzer, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings)
+            : analyzer(std::move(analyzer)), tokenList(tokenList), errorLogger(errorLogger), settings(settings)
         {}
         ValuePtr<Analyzer> analyzer;
         const TokenList& tokenList;

lib/reverseanalyzer.cpp

@@ -37,8 +37,8 @@
 
 namespace {
     struct ReverseTraversal {
-        ReverseTraversal(const ValuePtr<Analyzer>& analyzer, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
-            : analyzer(analyzer), tokenlist(tokenlist), errorLogger(errorLogger), settings(settings)
+        ReverseTraversal(ValuePtr<Analyzer> analyzer, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+            : analyzer(std::move(analyzer)), tokenlist(tokenlist), errorLogger(errorLogger), settings(settings)
         {}
         ValuePtr<Analyzer> analyzer;
         const TokenList& tokenlist;
@@ -272,7 +272,7 @@ namespace {
                                                         tokenlist,
                                                         errorLogger,
                                                         settings);
-                                valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, a, tokenlist, errorLogger, settings);
+                                valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, std::move(a), tokenlist, errorLogger, settings);
                             }
                         }
                     }
@@ -406,10 +406,10 @@ namespace {
     };
 }
 
-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
 {
     if (a->invalid())
         return;
-    ReverseTraversal rt{a, tokenlist, errorLogger, settings};
+    ReverseTraversal rt{std::move(a), tokenlist, errorLogger, settings};
     rt.traverse(start, end);
 }

lib/reverseanalyzer.h

@@ -27,6 +27,6 @@ class TokenList;
 template<class T>
 class ValuePtr;
 
-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings);
+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings);
 
 #endif

lib/valueptr.h

@@ -26,12 +26,15 @@
 #include <memory>
 
 template<class T>
-class CPPCHECKLIB ValuePtr {
+class ValuePtr {
     template<class U>
     struct cloner {
         static T* apply(const T* x) {
             return new U(*static_cast<const U*>(x));
         }
+        static T* move(T* x) {
+            return new U(std::move(*static_cast<U*>(x)));
+        }
     };
 
 public:
@@ -42,13 +45,18 @@ class CPPCHECKLIB ValuePtr {
 
     ValuePtr() : mPtr(nullptr), mClone() {}
 
-    template<class U>
+    template<class U, REQUIRES("Must not be ValuePtr", !std::is_base_of<ValuePtr, U>)>
     // cppcheck-suppress noExplicitConstructor
     // NOLINTNEXTLINE(google-explicit-constructor)
     ValuePtr(const U& value) : mPtr(cloner<U>::apply(&value)), mClone(&cloner<U>::apply)
     {}
 
+    template<class U, REQUIRES("Must be rvalue", !std::is_lvalue_reference<U>), REQUIRES("Must not be ValuePtr", !std::is_base_of<ValuePtr, U>)>
+    explicit ValuePtr(U&& value) : mPtr(cloner<U>::move(&value)), mClone(&cloner<U>::apply)
+    {}
+
     ValuePtr(const ValuePtr& rhs) : mPtr(nullptr), mClone(rhs.mClone) {
+        static_assert(false, "");
         if (rhs) {
             mPtr.reset(mClone(rhs.get()));
         }
@@ -62,10 +70,10 @@ class CPPCHECKLIB ValuePtr {
         return mPtr.get();
     }
 
-    T& operator*() {
+    T& operator*() NOEXCEPT {
         return *get();
     }
-    const T& operator*() const {
+    const T& operator*() const NOEXCEPT {
         return *get();
     }