diff --git a/ConstantExpression.cpp b/ConstantExpression.cpp
index 002bf56..6badf57 100644
--- a/ConstantExpression.cpp
+++ b/ConstantExpression.cpp
@@ -164,17 +164,19 @@
     return std::make_unique<LiteralConstantExpression>(kind, value);
 }
 
+ConstantExpression::ConstantExpression(const std::string& expr) : mExpr(expr) {}
+
 bool ConstantExpression::isEvaluated() const {
     return mIsEvaluated;
 }
 
-LiteralConstantExpression::LiteralConstantExpression(
-    ScalarType::Kind kind, uint64_t value, const std::string& expr) {
-
+LiteralConstantExpression::LiteralConstantExpression(ScalarType::Kind kind, uint64_t value,
+                                                     const std::string& expr)
+    : ConstantExpression(expr) {
     CHECK(!expr.empty());
     CHECK(isSupported(kind));
+
     mTrivialDescription = std::to_string(value) == expr;
-    mExpr = expr;
     mValueKind = kind;
     mValue = value;
     mIsEvaluated = true;
@@ -254,7 +256,6 @@
     CHECK(mUnary->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mOp + mUnary->mExpr + ")";
     mValueKind = mUnary->mValueKind;
 
 #define CASE_UNARY(__type__)                                          \
@@ -270,8 +271,6 @@
     CHECK(mRval->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mLval->mExpr + " " + mOp + " " + mRval->mExpr + ")";
-
     bool isArithmeticOrBitflip = OP_IS_BIN_ARITHMETIC || OP_IS_BIN_BITFLIP;
 
     // CASE 1: + - *  / % | ^ & < > <= >= == !=
@@ -330,8 +329,6 @@
     CHECK(mFalseVal->isEvaluated());
     mIsEvaluated = true;
 
-    mExpr = std::string("(") + mCond->mExpr + "?" + mTrueVal->mExpr + ":" + mFalseVal->mExpr + ")";
-
     // note: for ?:, unlike arithmetic ops, integral promotion is not processed.
     mValueKind = usualArithmeticConversion(mTrueVal->mValueKind, mFalseVal->mValueKind);
 
@@ -466,7 +463,6 @@
 }
 
 const std::string& ConstantExpression::expression() const {
-    CHECK(isEvaluated());
     return mExpr;
 }
 
@@ -683,7 +679,7 @@
 }
 
 UnaryConstantExpression::UnaryConstantExpression(const std::string& op, ConstantExpression* value)
-    : mUnary(value), mOp(op) {}
+    : ConstantExpression(std::string("(") + op + value->mExpr + ")"), mUnary(value), mOp(op) {}
 
 std::vector<const ConstantExpression*> UnaryConstantExpression::getConstantExpressions() const {
     return {mUnary};
@@ -691,7 +687,10 @@
 
 BinaryConstantExpression::BinaryConstantExpression(ConstantExpression* lval, const std::string& op,
                                                    ConstantExpression* rval)
-    : mLval(lval), mRval(rval), mOp(op) {}
+    : ConstantExpression(std::string("(") + lval->mExpr + " " + op + " " + rval->mExpr + ")"),
+      mLval(lval),
+      mRval(rval),
+      mOp(op) {}
 
 std::vector<const ConstantExpression*> BinaryConstantExpression::getConstantExpressions() const {
     return {mLval, mRval};
@@ -700,7 +699,11 @@
 TernaryConstantExpression::TernaryConstantExpression(ConstantExpression* cond,
                                                      ConstantExpression* trueVal,
                                                      ConstantExpression* falseVal)
-    : mCond(cond), mTrueVal(trueVal), mFalseVal(falseVal) {}
+    : ConstantExpression(std::string("(") + cond->mExpr + "?" + trueVal->mExpr + ":" +
+                         falseVal->mExpr + ")"),
+      mCond(cond),
+      mTrueVal(trueVal),
+      mFalseVal(falseVal) {}
 
 std::vector<const ConstantExpression*> TernaryConstantExpression::getConstantExpressions() const {
     return {mCond, mTrueVal, mFalseVal};
@@ -708,8 +711,7 @@
 
 ReferenceConstantExpression::ReferenceConstantExpression(const Reference<LocalIdentifier>& value,
                                                          const std::string& expr)
-    : mReference(value) {
-    mExpr = expr;
+    : ConstantExpression(expr), mReference(value) {
     mTrivialDescription = mExpr.empty();
 }
 
@@ -729,9 +731,7 @@
 AttributeConstantExpression::AttributeConstantExpression(const Reference<Type>& value,
                                                          const std::string& fqname,
                                                          const std::string& tag)
-    : mReference(value), mTag(tag) {
-    mExpr = fqname + "#" + tag;
-}
+    : ConstantExpression(fqname + "#" + tag), mReference(value), mTag(tag) {}
 
 std::vector<const ConstantExpression*> AttributeConstantExpression::getConstantExpressions() const {
     // Returns reference instead