diff --git a/src/util/simplify_expr.cpp b/src/util/simplify_expr.cpp
index 4d0ace7918c..55286fa9740 100644
--- a/src/util/simplify_expr.cpp
+++ b/src/util/simplify_expr.cpp
@@ -571,8 +571,7 @@ simplify_exprt::simplify_typecast(const typecast_exprt &expr)
       op_type.id() == ID_floatbv ? ID_ieee_float_notequal : ID_notequal,
       from_integer(0, op_type));
     inequality.add_source_location()=expr.source_location();
-    simplify_node(inequality);
-    return std::move(inequality);
+    return changed(simplify_node(inequality));
   }
 
   // eliminate casts from proper bool
@@ -611,9 +610,8 @@ simplify_exprt::simplify_typecast(const typecast_exprt &expr)
   {
     // rewrite (_Bool)x to (_Bool)(x!=0)
     exprt inequality = is_not_zero(expr.op(), ns);
-    simplify_node(inequality);
     auto new_expr = expr;
-    new_expr.op() = std::move(inequality);
+    new_expr.op() = simplify_node(std::move(inequality));
     return changed(simplify_typecast(new_expr)); // recursive call
   }
 
@@ -724,9 +722,7 @@ simplify_exprt::simplify_typecast(const typecast_exprt &expr)
             *it = simplify_typecast(new_operand); // recursive call
           }
 
-          simplify_node(result); // possibly recursive call
-
-          return std::move(result);
+          return changed(simplify_node(result)); // possibly recursive call
         }
       }
       else if(op_id==ID_ashr || op_id==ID_lshr || op_id==ID_shl)
@@ -1978,10 +1974,9 @@ simplify_exprt::simplify_byte_update(const byte_update_exprt &expr)
           {
             exprt compo_offset = from_integer(*i, offset.type());
             plus_exprt new_offset(offset, compo_offset);
-            simplify_node(new_offset);
             exprt new_value(with.new_value());
             auto tmp = expr;
-            tmp.set_offset(std::move(new_offset));
+            tmp.set_offset(simplify_node(std::move(new_offset)));
             tmp.set_value(std::move(new_value));
             return changed(simplify_byte_update(tmp)); // recursive call
           }
@@ -1993,22 +1988,20 @@ simplify_exprt::simplify_byte_update(const byte_update_exprt &expr)
         if(i.has_value())
         {
           const exprt &index=with.where();
-          mult_exprt index_offset(index, from_integer(*i, index.type()));
-          simplify_node(index_offset);
+          exprt index_offset =
+            simplify_node(mult_exprt(index, from_integer(*i, index.type())));
 
           // index_offset may need a typecast
           if(offset.type() != index.type())
           {
-            typecast_exprt tmp(index_offset, offset.type());
-            simplify_node(tmp);
-            index_offset.swap(tmp);
+            index_offset =
+              simplify_node(typecast_exprt(index_offset, offset.type()));
           }
 
           plus_exprt new_offset(offset, index_offset);
-          simplify_node(new_offset);
           exprt new_value(with.new_value());
           auto tmp = expr;
-          tmp.set_offset(std::move(new_offset));
+          tmp.set_offset(simplify_node(std::move(new_offset)));
           tmp.set_value(std::move(new_value));
           return changed(simplify_byte_update(tmp)); // recursive call
         }
@@ -2226,20 +2219,19 @@ bool simplify_exprt::simplify_node_preorder(exprt &expr)
   return result;
 }
 
-bool simplify_exprt::simplify_node(exprt &expr)
+simplify_exprt::resultt<> simplify_exprt::simplify_node(exprt node)
 {
-  if(!expr.has_operands())
-    return true; // no change
+  if(!node.has_operands())
+    return unchanged(node); // no change
 
     // #define DEBUGX
 
 #ifdef DEBUGX
-  exprt old(expr);
+  exprt old(node);
 #endif
 
-  bool no_change = true;
-
-  no_change = sort_and_join(expr) && no_change;
+  exprt expr = node;
+  bool no_change_sort_and_join = sort_and_join(expr);
 
   resultt<> r = unchanged(expr);
 
@@ -2440,26 +2432,23 @@ bool simplify_exprt::simplify_node(exprt &expr)
     r = simplify_complex(to_unary_expr(expr));
   }
 
-  if(r.has_changed())
-  {
-    expr = r.expr;
-    no_change = false;
-  }
+  if(!no_change_sort_and_join)
+    r = changed(r);
 
 #ifdef DEBUGX
   if(
-    !no_change
+    r.has_changed()
 #  ifdef DEBUG_ON_DEMAND
     && debug_on
 #  endif
   )
   {
-    std::cout << "===== " << old.id() << ": " << format(old) << '\n'
-              << " ---> " << format(expr) << '\n';
+    std::cout << "===== " << node.id() << ": " << format(node) << '\n'
+              << " ---> " << format(r.expr) << '\n';
   }
 #endif
 
-  return no_change;
+  return r;
 }
 
 simplify_exprt::resultt<> simplify_exprt::simplify_rec(const exprt &expr)
@@ -2485,10 +2474,15 @@ simplify_exprt::resultt<> simplify_exprt::simplify_rec(const exprt &expr)
 
   // We work on a copy to prevent unnecessary destruction of sharing.
   exprt tmp=expr;
-  bool result = simplify_node_preorder(tmp);
+  bool no_change = simplify_node_preorder(tmp);
 
-  if(!simplify_node(tmp))
-    result=false;
+  auto simplify_node_result = simplify_node(tmp);
+
+  if(simplify_node_result.has_changed())
+  {
+    no_change = false;
+    tmp = simplify_node_result.expr;
+  }
 
 #ifdef USE_LOCAL_REPLACE_MAP
   #if 1
@@ -2496,19 +2490,19 @@ simplify_exprt::resultt<> simplify_exprt::simplify_rec(const exprt &expr)
   if(it!=local_replace_map.end())
   {
     tmp=it->second;
-    result=false;
+    no_change = false;
   }
   #else
   if(!local_replace_map.empty() &&
      !replace_expr(local_replace_map, tmp))
   {
     simplify_rec(tmp);
-    result=false;
+    no_change = false;
   }
   #endif
 #endif
 
-  if(result) // no change
+  if(no_change) // no change
   {
     return unchanged(expr);
   }
diff --git a/src/util/simplify_expr_array.cpp b/src/util/simplify_expr_array.cpp
index f40b412c489..c66afd27f67 100644
--- a/src/util/simplify_expr_array.cpp
+++ b/src/util/simplify_expr_array.cpp
@@ -184,8 +184,8 @@ simplify_exprt::simplify_index(const index_exprt &expr)
       // add offset to index
       mult_exprt offset(
         from_integer(*sub_size, byte_extract_expr.offset().type()), index);
-      plus_exprt final_offset(byte_extract_expr.offset(), offset);
-      simplify_node(final_offset);
+      exprt final_offset =
+        simplify_node(plus_exprt(byte_extract_expr.offset(), offset));
 
       exprt result_expr(array.id(), expr.type());
       result_expr.add_to_operands(byte_extract_expr.op(), final_offset);
diff --git a/src/util/simplify_expr_boolean.cpp b/src/util/simplify_expr_boolean.cpp
index 6c31a65e52e..e1c45d68dba 100644
--- a/src/util/simplify_expr_boolean.cpp
+++ b/src/util/simplify_expr_boolean.cpp
@@ -41,8 +41,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_boolean(const exprt &expr)
     binary_exprt new_expr = implies_expr;
     new_expr.id(ID_or);
     new_expr.op0() = boolean_negate(new_expr.op0());
-    simplify_node(new_expr);
-    return std::move(new_expr);
+    return changed(simplify_node(new_expr));
   }
   else if(expr.id()==ID_xor)
   {
@@ -192,8 +191,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_not(const not_exprt &expr)
 
     Forall_operands(it, tmp)
     {
-      *it = boolean_negate(*it);
-      simplify_node(*it);
+      *it = simplify_node(boolean_negate(*it));
     }
 
     tmp.id(tmp.id() == ID_and ? ID_or : ID_and);
@@ -211,7 +209,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_not(const not_exprt &expr)
     auto const &op_as_exists = to_exists_expr(op);
     forall_exprt rewritten_op(
       op_as_exists.symbol(), not_exprt(op_as_exists.where()));
-    simplify_node(rewritten_op.where());
+    rewritten_op.where() = simplify_node(rewritten_op.where());
     return std::move(rewritten_op);
   }
   else if(op.id() == ID_forall) // !(forall: a) <-> exists: not a
@@ -219,7 +217,7 @@ simplify_exprt::resultt<> simplify_exprt::simplify_not(const not_exprt &expr)
     auto const &op_as_forall = to_forall_expr(op);
     exists_exprt rewritten_op(
       op_as_forall.symbol(), not_exprt(op_as_forall.where()));
-    simplify_node(rewritten_op.where());
+    rewritten_op.where() = simplify_node(rewritten_op.where());
     return std::move(rewritten_op);
   }
 
diff --git a/src/util/simplify_expr_class.h b/src/util/simplify_expr_class.h
index fabeef6114c..9af95ccc954 100644
--- a/src/util/simplify_expr_class.h
+++ b/src/util/simplify_expr_class.h
@@ -210,7 +210,7 @@ class simplify_exprt
   NODISCARD resultt<> simplify_inequality_pointer_object(const exprt &);
 
   // main recursion
-  bool simplify_node(exprt &expr);
+  NODISCARD resultt<> simplify_node(exprt);
   bool simplify_node_preorder(exprt &expr);
   NODISCARD resultt<> simplify_rec(const exprt &);
 
diff --git a/src/util/simplify_expr_if.cpp b/src/util/simplify_expr_if.cpp
index e019cff7e34..231ac75113f 100644
--- a/src/util/simplify_expr_if.cpp
+++ b/src/util/simplify_expr_if.cpp
@@ -350,41 +350,29 @@ simplify_exprt::resultt<> simplify_exprt::simplify_if(const if_exprt &expr)
       else if(truevalue.is_false() && falsevalue.is_true())
       {
         // a?0:1 <-> !a
-        exprt tmp = boolean_negate(cond);
-        simplify_node(tmp);
-        return std::move(tmp);
+        return changed(simplify_node(boolean_negate(cond)));
       }
       else if(falsevalue.is_false())
       {
         // a?b:0 <-> a AND b
-        and_exprt tmp(cond, truevalue);
-        simplify_node(tmp);
-        return std::move(tmp);
+        return changed(simplify_node(and_exprt(cond, truevalue)));
       }
       else if(falsevalue.is_true())
       {
         // a?b:1 <-> !a OR b
-        exprt tmp_not_cond = boolean_negate(cond);
-        simplify_node(tmp_not_cond);
-        or_exprt tmp(tmp_not_cond, truevalue);
-        simplify_node(tmp);
-        return std::move(tmp);
+        return changed(simplify_node(
+          or_exprt(simplify_node(boolean_negate(cond)), truevalue)));
       }
       else if(truevalue.is_true())
       {
         // a?1:b <-> a||(!a && b) <-> a OR b
-        or_exprt tmp(cond, falsevalue);
-        simplify_node(tmp);
-        return std::move(tmp);
+        return changed(simplify_node(or_exprt(cond, falsevalue)));
       }
       else if(truevalue.is_false())
       {
         // a?0:b <-> !a && b
-        exprt tmp_not_cond = boolean_negate(cond);
-        simplify_node(tmp_not_cond);
-        and_exprt tmp(tmp_not_cond, falsevalue);
-        simplify_node(tmp);
-        return std::move(tmp);
+        return changed(simplify_node(
+          and_exprt(simplify_node(boolean_negate(cond)), falsevalue)));
       }
     }
   }
diff --git a/src/util/simplify_expr_int.cpp b/src/util/simplify_expr_int.cpp
index 0f66c76b3df..cd260d51219 100644
--- a/src/util/simplify_expr_int.cpp
+++ b/src/util/simplify_expr_int.cpp
@@ -568,9 +568,7 @@ simplify_exprt::simplify_minus(const minus_exprt &expr)
     // rewrite "a-b" to "a+(-b)"
     unary_minus_exprt rhs_negated(operands[1]);
     plus_exprt plus_expr(operands[0], simplify_unary_minus(rhs_negated));
-    simplify_node(plus_expr);
-
-    return std::move(plus_expr);
+    return changed(simplify_node(plus_expr));
   }
   else if(
     minus_expr.type().id() == ID_pointer &&
@@ -649,12 +647,10 @@ simplify_exprt::resultt<> simplify_exprt::simplify_bitwise(const exprt &expr)
       }
 
       new_expr.type()=bool_typet();
-      simplify_node(new_expr);
+      new_expr = simplify_node(new_expr);
 
       new_expr = typecast_exprt(new_expr, expr.type());
-      simplify_node(new_expr);
-
-      return std::move(new_expr);
+      return changed(simplify_node(new_expr));
     }
   }
 
@@ -1486,8 +1482,7 @@ simplify_exprt::simplify_inequality_no_constant(const exprt &expr)
     new_expr.id(ID_equal);
     new_expr = simplify_inequality_no_constant(new_expr);
     new_expr = boolean_negate(new_expr);
-    simplify_node(new_expr);
-    return std::move(new_expr);
+    return changed(simplify_node(new_expr));
   }
   else if(expr.id()==ID_gt)
   {
@@ -1497,8 +1492,7 @@ simplify_exprt::simplify_inequality_no_constant(const exprt &expr)
     new_expr.op0().swap(new_expr.op1());
     new_expr = simplify_inequality_no_constant(new_expr);
     new_expr = boolean_negate(new_expr);
-    simplify_node(new_expr);
-    return std::move(new_expr);
+    return changed(simplify_node(new_expr));
   }
   else if(expr.id()==ID_lt)
   {
@@ -1506,8 +1500,7 @@ simplify_exprt::simplify_inequality_no_constant(const exprt &expr)
     new_expr.id(ID_ge);
     new_expr = simplify_inequality_no_constant(new_expr);
     new_expr = boolean_negate(new_expr);
-    simplify_node(new_expr);
-    return std::move(new_expr);
+    return changed(simplify_node(new_expr));
   }
   else if(expr.id()==ID_le)
   {
@@ -1588,10 +1581,9 @@ simplify_exprt::simplify_inequality_no_constant(const exprt &expr)
     if(!eliminate_common_addends(new_expr.op0(), new_expr.op1()))
     {
       // remove zeros
-      simplify_node(new_expr.op0());
-      simplify_node(new_expr.op1());
-      new_expr = simplify_inequality(new_expr); // recursive call
-      return std::move(new_expr);
+      new_expr.op0() = simplify_node(new_expr.op0());
+      new_expr.op1() = simplify_node(new_expr.op1());
+      return changed(simplify_inequality(new_expr)); // recursive call
     }
   }
 
@@ -1625,8 +1617,7 @@ simplify_exprt::simplify_inequality_rhs_is_constant(const exprt &expr)
       new_expr.id(ID_equal);
       new_expr = simplify_inequality_rhs_is_constant(new_expr);
       new_expr = boolean_negate(new_expr);
-      simplify_node(new_expr);
-      return std::move(new_expr);
+      return changed(simplify_node(new_expr));
     }
 
     // very special case for pointers
@@ -1839,8 +1830,7 @@ simplify_exprt::simplify_inequality_rhs_is_constant(const exprt &expr)
       new_expr.id(ID_equal);
       new_expr = simplify_inequality_rhs_is_constant(new_expr);
       new_expr = boolean_negate(new_expr);
-      simplify_node(new_expr);
-      return std::move(new_expr);
+      return changed(simplify_node(new_expr));
     }
     else if(expr.id()==ID_gt)
     {
@@ -1863,8 +1853,7 @@ simplify_exprt::simplify_inequality_rhs_is_constant(const exprt &expr)
       new_expr.id(ID_ge);
       new_expr = simplify_inequality_rhs_is_constant(new_expr);
       new_expr = boolean_negate(new_expr);
-      simplify_node(new_expr);
-      return std::move(new_expr);
+      return changed(simplify_node(new_expr));
     }
     else if(expr.id()==ID_le)
     {
@@ -1881,8 +1870,7 @@ simplify_exprt::simplify_inequality_rhs_is_constant(const exprt &expr)
       new_expr.op1() = from_integer(i, new_expr.op1().type());
       new_expr = simplify_inequality_rhs_is_constant(new_expr);
       new_expr = boolean_negate(new_expr);
-      simplify_node(new_expr);
-      return std::move(new_expr);
+      return changed(simplify_node(new_expr));
     }
   }
 #endif
diff --git a/src/util/simplify_expr_pointer.cpp b/src/util/simplify_expr_pointer.cpp
index 3902ed10fc5..583d512f01b 100644
--- a/src/util/simplify_expr_pointer.cpp
+++ b/src/util/simplify_expr_pointer.cpp
@@ -285,8 +285,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
       auto new_expr = expr;
       new_expr.op() = ptr.op0();
 
-      simplify_node(new_expr); // recursive call
-      return new_expr;
+      return changed(simplify_node(new_expr)); // recursive call
     }
     else if(op_type.id()==ID_signedbv ||
             op_type.id()==ID_unsignedbv)
@@ -297,8 +296,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
       {
         // (T *)0x1234 -> 0x1234
         exprt tmp = typecast_exprt(ptr.op0(), expr.type());
-        simplify_node(tmp);
-        return tmp;
+        return changed(simplify_node(tmp));
       }
       else
       {
@@ -316,8 +314,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
             auto new_expr =
               typecast_exprt::conditional_cast(to_plus_expr(tmp).op1(), type);
 
-            simplify_node(new_expr);
-            return new_expr;
+            return changed(simplify_node(new_expr));
           }
           else if(tmp.op1().id()==ID_typecast &&
                   tmp.op1().operands().size()==1 &&
@@ -325,8 +322,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
           {
             auto new_expr = typecast_exprt::conditional_cast(tmp.op0(), type);
 
-            simplify_node(new_expr);
-            return new_expr;
+            return changed(simplify_node(new_expr));
           }
         }
       }
@@ -345,10 +341,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
       {
         exprt tmp=op;
         if(tmp.type()!=expr.type())
-        {
-          tmp = typecast_exprt(tmp, expr.type());
-          simplify_node(tmp);
-        }
+          tmp = simplify_node(typecast_exprt(tmp, expr.type()));
 
         int_expr.push_back(tmp);
       }
@@ -367,8 +360,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
       return unchanged(expr);
 
     // this might change the type of the pointer!
-    exprt pointer_offset_expr=pointer_offset(ptr_expr.front());
-    simplify_node(pointer_offset_expr);
+    exprt pointer_offset_expr = simplify_node(pointer_offset(ptr_expr.front()));
 
     exprt sum;
 
@@ -380,20 +372,17 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
       sum.operands()=int_expr;
     }
 
-    simplify_node(sum);
+    sum = simplify_node(sum);
 
     exprt size_expr = from_integer(*element_size, expr.type());
 
-    binary_exprt product(sum, ID_mult, size_expr, expr.type());
+    exprt product = mult_exprt(sum, size_expr);
 
-    simplify_node(product);
+    product = simplify_node(product);
 
-    auto new_expr =
-      binary_exprt(pointer_offset_expr, ID_plus, product, expr.type());
+    auto new_expr = plus_exprt(pointer_offset_expr, product);
 
-    simplify_node(new_expr);
-
-    return new_expr;
+    return changed(simplify_node(new_expr));
   }
   else if(ptr.id()==ID_constant)
   {
@@ -403,10 +392,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
        c_ptr.value_is_zero_string())
     {
       auto new_expr = from_integer(0, expr.type());
-
-      simplify_node(new_expr);
-
-      return new_expr;
+      return changed(simplify_node(new_expr));
     }
     else
     {
@@ -425,9 +411,7 @@ simplify_exprt::simplify_pointer_offset(const unary_exprt &expr)
 
       auto new_expr = from_integer(number, expr.type());
 
-      simplify_node(new_expr);
-
-      return new_expr;
+      return changed(simplify_node(new_expr));
     }
   }
 
@@ -523,9 +507,9 @@ simplify_exprt::simplify_inequality_pointer_object(const exprt &expr)
       new_inequality_ops.push_back(op);
     else
     {
-      new_inequality_ops.push_back(typecast_exprt::conditional_cast(
-        op, new_inequality_ops.front().type()));
-      simplify_node(new_inequality_ops.back());
+      new_inequality_ops.push_back(
+        simplify_node(typecast_exprt::conditional_cast(
+          op, new_inequality_ops.front().type())));
     }
   }
 
@@ -739,7 +723,7 @@ simplify_exprt::simplify_object_size(const unary_exprt &expr)
         if(size.type() != expr_type)
         {
           size = typecast_exprt(size, expr_type);
-          simplify_node(size);
+          size = simplify_node(size);
         }
 
         return size;
@@ -766,7 +750,5 @@ simplify_exprt::simplify_good_pointer(const unary_exprt &expr)
   exprt def = good_pointer_def(expr.op(), ns);
 
   // recursive call
-  simplify_node(def);
-
-  return std::move(def);
+  return changed(simplify_node(def));
 }
diff --git a/src/util/simplify_expr_struct.cpp b/src/util/simplify_expr_struct.cpp
index 7b679a153fa..8237d0565a2 100644
--- a/src/util/simplify_expr_struct.cpp
+++ b/src/util/simplify_expr_struct.cpp
@@ -155,8 +155,8 @@ simplify_exprt::simplify_member(const member_exprt &expr)
 
       const exprt &struct_offset = byte_extract_expr.offset();
       exprt member_offset = from_integer(*offset_int, struct_offset.type());
-      plus_exprt final_offset(struct_offset, member_offset);
-      simplify_node(final_offset);
+      exprt final_offset =
+        simplify_node(plus_exprt(struct_offset, member_offset));
 
       byte_extract_exprt result(
         op.id(), byte_extract_expr.op(), final_offset, expr.type());