got rid of unnecessary ExprIdToken constructors

lib/programmemory.cpp

@@ -75,9 +75,10 @@ void ProgramMemory::setValue(const Token* expr, const ValueFlow::Value& value) {
     if (subexpr)
         (*mValues)[subexpr] = std::move(subvalue);
 }
+
 const ValueFlow::Value* ProgramMemory::getValue(nonneg int exprid, bool impossible) const
 {
-    const auto it = utils::as_const(*mValues).find(exprid);
+    const auto it = find(exprid);
     const bool found = it != mValues->cend() && (impossible || !it->second.isImpossible());
     if (found)
         return &it->second;
@@ -154,18 +155,28 @@ void ProgramMemory::setUnknown(const Token* expr) {
     (*mValues)[expr].valueType = ValueFlow::Value::ValueType::UNINIT;
 }
 
-bool ProgramMemory::hasValue(nonneg int exprid)
+bool ProgramMemory::hasValue(nonneg int exprid) const
 {
-    return mValues->find(exprid) != mValues->end();
+    const auto it = find(exprid);
+    return it != mValues->cend();
 }
 
 const ValueFlow::Value& ProgramMemory::at(nonneg int exprid) const {
-    return mValues->at(exprid);
+    const auto it = find(exprid);
+    if (it == mValues->cend()) {
+        throw std::out_of_range("ProgramMemory::at");
+    }
+    return it->second;
 }
+
 ValueFlow::Value& ProgramMemory::at(nonneg int exprid) {
     copyOnWrite();
 
-    return mValues->at(exprid);
+    const auto it = find(exprid);
+    if (it == mValues->end()) {
+        throw std::out_of_range("ProgramMemory::at");
+    }
+    return it->second;
 }
 
 void ProgramMemory::erase_if(const std::function<bool(const ExprIdToken&)>& pred)
@@ -225,6 +236,21 @@ void ProgramMemory::copyOnWrite()
     mValues = std::make_shared<Map>(*mValues);
 }
 
+ProgramMemory::Map::const_iterator ProgramMemory::find(nonneg int exprid) const
+{
+    const auto& cvalues = utils::as_const(*mValues);
+    return std::find_if(cvalues.cbegin(), cvalues.cend(), [&exprid](const Map::value_type& entry) {
+        return entry.first.getExpressionId() == exprid;
+    });
+}
+
+ProgramMemory::Map::iterator ProgramMemory::find(nonneg int exprid)
+{
+    return std::find_if(mValues->begin(), mValues->end(), [&exprid](const Map::value_type& entry) {
+        return entry.first.getExpressionId() == exprid;
+    });
+}
+
 static ValueFlow::Value execute(const Token* expr, ProgramMemory& pm, const Settings& settings);
 
 static bool evaluateCondition(MathLib::bigint r, const Token* condition, ProgramMemory& pm, const Settings& settings)
@@ -395,7 +421,7 @@ static void fillProgramMemoryFromAssignments(ProgramMemory& pm, const Token* tok
             bool setvar = false;
             const Token* vartok = tok2->astOperand1();
             for (const auto& p:vars) {
-                if (p.first != vartok->exprId())
+                if (p.first.getExpressionId() != vartok->exprId())
                     continue;
                 if (vartok == tok)
                     continue;

lib/programmemory.h

@@ -41,14 +41,9 @@ struct ExprIdToken {
     const Token* tok = nullptr;
     nonneg int exprid = 0;
 
-    ExprIdToken() = default;
     // cppcheck-suppress noExplicitConstructor
     // NOLINTNEXTLINE(google-explicit-constructor)
     ExprIdToken(const Token* tok);
-    // TODO: Make this constructor only available from ProgramMemory
-    // cppcheck-suppress noExplicitConstructor
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    ExprIdToken(nonneg int exprid) : exprid(exprid) {}
 
     nonneg int getExpressionId() const;
 
@@ -117,7 +112,7 @@ struct CPPCHECKLIB ProgramMemory {
     void setUnknown(const Token* expr);
 
     bool getTokValue(nonneg int exprid, const Token*& result) const;
-    bool hasValue(nonneg int exprid);
+    bool hasValue(nonneg int exprid) const;
 
     const ValueFlow::Value& at(nonneg int exprid) const;
     ValueFlow::Value& at(nonneg int exprid);
@@ -150,6 +145,8 @@ struct CPPCHECKLIB ProgramMemory {
 
 private:
     void copyOnWrite();
+    Map::const_iterator find(nonneg int exprid) const;
+    Map::iterator find(nonneg int exprid);
 
     std::shared_ptr<Map> mValues;
 };

test/testprogrammemory.cpp

@@ -30,6 +30,9 @@ class TestProgramMemory : public TestFixture {
 private:
     void run() override {
         TEST_CASE(copyOnWrite);
+        TEST_CASE(hasValue);
+        TEST_CASE(getValue);
+        TEST_CASE(at);
     }
 
     void copyOnWrite() const {
@@ -79,6 +82,22 @@ class TestProgramMemory : public TestFixture {
         ASSERT(v);
         ASSERT_EQUALS(41, v->intvalue);
     }
+
+    void hasValue() const {
+        ProgramMemory pm;
+        ASSERT(!pm.hasValue(123));
+    }
+
+    void getValue() const {
+        ProgramMemory pm;
+        ASSERT(!pm.getValue(123));
+    }
+
+    void at() const {
+        ProgramMemory pm;
+        ASSERT_THROW_EQUALS_2(pm.at(123), std::out_of_range, "ProgramMemory::at");
+        ASSERT_THROW_EQUALS_2(utils::as_const(pm).at(123), std::out_of_range, "ProgramMemory::at");
+    }
 };
 
 REGISTER_TEST(TestProgramMemory)