Merge pull request #7925 from tautschnig/cleanup/interval-exprt

tautschnig · web-flow · commit 3ce21405aa43 · 2023-09-29T14:07:40.000+02:00
Interval expressions: cleanup type hierarchy
diff --git a/src/util/interval.cpp b/src/util/interval.cpp
@@ -165,10 +165,11 @@ constant_interval_exprt::modulo(const constant_interval_exprt &o) const
 
   // If the RHS is 1, or -1 (signed only), then return zero.
   if(
-    o == constant_interval_exprt(from_integer(1, o.type())) ||
-    (o.is_signed() && o == constant_interval_exprt(from_integer(-1, o.type()))))
+    o.is_single_value_interval() &&
+    (o.get_lower() == from_integer(1, o.type()) ||
+     (o.is_signed() && o.get_lower() == from_integer(-1, o.type()))))
   {
-    return constant_interval_exprt(zero());
+    return constant_interval_exprt::singleton(zero());
   }
 
   // If other might be modulo by zero, set everything to top.
@@ -179,7 +180,7 @@ constant_interval_exprt::modulo(const constant_interval_exprt &o) const
 
   if(is_zero())
   {
-    return constant_interval_exprt(zero());
+    return constant_interval_exprt::singleton(zero());
   }
 
   exprt lower = min();
@@ -233,12 +234,12 @@ tvt constant_interval_exprt::is_definitely_false() const
     }
   }
 
-  if(equal(constant_interval_exprt(zero())).is_true())
+  if(is_single_value_interval() && get_lower() == zero())
   {
     return tvt(true);
   }
 
-  if(contains(constant_interval_exprt(zero())))
+  if(contains(constant_interval_exprt::singleton(zero())))
   {
     INVARIANT(
       is_positive(get_upper()) || is_negative(get_lower()),
@@ -457,12 +458,14 @@ tvt constant_interval_exprt::not_equal(const constant_interval_exprt &o) const
 
 constant_interval_exprt constant_interval_exprt::increment() const
 {
-  return plus(constant_interval_exprt(from_integer(mp_integer(1), type())));
+  return plus(
+    constant_interval_exprt::singleton(from_integer(mp_integer(1), type())));
 }
 
 constant_interval_exprt constant_interval_exprt::decrement() const
 {
-  return minus(constant_interval_exprt(from_integer(mp_integer(1), type())));
+  return minus(
+    constant_interval_exprt::singleton(from_integer(mp_integer(1), type())));
 }
 
 constant_interval_exprt constant_interval_exprt::get_extremes(
@@ -939,7 +942,7 @@ constant_interval_exprt::handle_constant_unary_expression(
   if(is_single_value_interval())
   {
     auto expr = unary_exprt(op, get_lower());
-    return constant_interval_exprt(simplified_expr(expr));
+    return constant_interval_exprt::singleton(simplified_expr(expr));
   }
   return top();
 }
@@ -951,7 +954,7 @@ constant_interval_exprt::handle_constant_binary_expression(
 {
   PRECONDITION(is_single_value_interval() && other.is_single_value_interval());
   auto expr = binary_exprt(get_lower(), op, other.get_lower());
-  return constant_interval_exprt(simplified_expr(expr));
+  return constant_interval_exprt::singleton(simplified_expr(expr));
 }
 
 exprt constant_interval_exprt::get_max(const exprt &a, const exprt &b)
@@ -1964,11 +1967,11 @@ constant_interval_exprt constant_interval_exprt::tvt_to_interval(const tvt &val)
 {
   if(val.is_true())
   {
-    return constant_interval_exprt(true_exprt());
+    return constant_interval_exprt::singleton(true_exprt());
   }
   else if(val.is_false())
   {
-    return constant_interval_exprt(false_exprt());
+    return constant_interval_exprt::singleton(false_exprt());
   }
   else
   {
diff --git a/src/util/interval.h b/src/util/interval.h
@@ -11,30 +11,30 @@
 #include <util/std_expr.h>
 #include <util/threeval.h>
 
-#include <iostream>
+#include <iosfwd>
 
 /// +∞ upper bound for intervals
-class max_exprt : public exprt
+class max_exprt : public nullary_exprt
 {
 public:
-  explicit max_exprt(const typet &_type) : exprt(ID_max, _type)
+  explicit max_exprt(const typet &_type) : nullary_exprt(ID_max, _type)
   {
   }
 
-  explicit max_exprt(const exprt &_expr) : exprt(ID_max, _expr.type())
+  explicit max_exprt(const exprt &_expr) : nullary_exprt(ID_max, _expr.type())
   {
   }
 };
 
 /// -∞ upper bound for intervals
-class min_exprt : public exprt
+class min_exprt : public nullary_exprt
 {
 public:
-  explicit min_exprt(const typet &_type) : exprt(ID_min, _type)
+  explicit min_exprt(const typet &_type) : nullary_exprt(ID_min, _type)
   {
   }
 
-  explicit min_exprt(const exprt &_expr) : exprt(ID_min, _expr.type())
+  explicit min_exprt(const exprt &_expr) : nullary_exprt(ID_min, _expr.type())
   {
   }
 };
@@ -47,25 +47,16 @@ class min_exprt : public exprt
 class constant_interval_exprt : public binary_exprt
 {
 public:
-  constant_interval_exprt(
-    const exprt &lower,
-    const exprt &upper,
-    const typet type)
-    : binary_exprt(lower, ID_constant_interval, upper, type)
+  constant_interval_exprt(exprt lower, exprt upper, typet type)
+    : binary_exprt(
+        std::move(lower),
+        ID_constant_interval,
+        std::move(upper),
+        std::move(type))
   {
     PRECONDITION(is_well_formed());
   }
 
-  constant_interval_exprt(const constant_interval_exprt &x)
-    : constant_interval_exprt(x.get_lower(), x.get_upper(), x.type())
-  {
-  }
-
-  explicit constant_interval_exprt(const exprt &x)
-    : constant_interval_exprt(x, x, x.type())
-  {
-  }
-
   explicit constant_interval_exprt(const typet &type)
     : constant_interval_exprt(min_exprt(type), max_exprt(type), type)
   {
@@ -74,6 +65,7 @@ class constant_interval_exprt : public binary_exprt
   constant_interval_exprt(const exprt &lower, const exprt &upper)
     : constant_interval_exprt(lower, upper, lower.type())
   {
+    PRECONDITION(is_well_formed());
   }
 
   bool is_well_formed() const
@@ -97,6 +89,11 @@ class constant_interval_exprt : public binary_exprt
     return b;
   }
 
+  static constant_interval_exprt singleton(const exprt &x)
+  {
+    return constant_interval_exprt{x, x, x.type()};
+  }
+
   static bool is_valid_bound(const exprt &expr)
   {
     const irep_idt &id = expr.id();
diff --git a/unit/util/interval/bitwise.cpp b/unit/util/interval/bitwise.cpp
@@ -15,9 +15,9 @@ SCENARIO("bitwise interval domain", "[core][analyses][interval][bitwise]")
   {
     const unsignedbv_typet &unsigned_int = unsignedbv_typet(32);
     constant_interval_exprt five =
-      constant_interval_exprt(from_integer(5, unsigned_int));
+      constant_interval_exprt::singleton(from_integer(5, unsigned_int));
     constant_interval_exprt nine =
-      constant_interval_exprt(from_integer(9, unsigned_int));
+      constant_interval_exprt::singleton(from_integer(9, unsigned_int));
 
     constant_interval_exprt five_to_nine(
       from_integer(5, unsigned_int), from_integer(9, unsigned_int));
@@ -26,7 +26,7 @@ SCENARIO("bitwise interval domain", "[core][analyses][interval][bitwise]")
     {
       REQUIRE(
         constant_interval_exprt::bitwise_or(five, nine) ==
-        constant_interval_exprt(from_integer(13, unsigned_int)));
+        constant_interval_exprt::singleton(from_integer(13, unsigned_int)));
 
       REQUIRE(constant_interval_exprt::bitwise_or(five_to_nine, nine).is_top());
     }
@@ -35,10 +35,10 @@ SCENARIO("bitwise interval domain", "[core][analyses][interval][bitwise]")
     {
       REQUIRE(
         constant_interval_exprt::bitwise_and(five, nine) ==
-        constant_interval_exprt(from_integer(1, unsigned_int)));
+        constant_interval_exprt::singleton(from_integer(1, unsigned_int)));
       REQUIRE(
         (five & nine) ==
-        constant_interval_exprt(from_integer(1, unsigned_int)));
+        constant_interval_exprt::singleton(from_integer(1, unsigned_int)));
 
       REQUIRE(
         constant_interval_exprt::bitwise_and(five_to_nine, nine).is_top());
@@ -48,7 +48,7 @@ SCENARIO("bitwise interval domain", "[core][analyses][interval][bitwise]")
     {
       REQUIRE(
         constant_interval_exprt::bitwise_xor(five, nine) ==
-        constant_interval_exprt(from_integer(12, unsigned_int)));
+        constant_interval_exprt::singleton(from_integer(12, unsigned_int)));
 
       REQUIRE(
         constant_interval_exprt::bitwise_xor(five_to_nine, nine).is_top());
diff --git a/unit/util/interval/comparisons.cpp b/unit/util/interval/comparisons.cpp
@@ -121,7 +121,8 @@ SCENARIO("comparison interval domain", "[core][analyses][interval][comparison]")
           constant_interval_exprt(CEV(10), CEV(20)) >
           constant_interval_exprt(CEV(30), CEV(40)));
         REQUIRE(
-          constant_interval_exprt(CEV(10)) < constant_interval_exprt(CEV(30)));
+          constant_interval_exprt::singleton(CEV(10)) <
+          constant_interval_exprt::singleton(CEV(30)));
       }
 
       THEN(
@@ -186,8 +187,8 @@ SCENARIO("comparison interval domain", "[core][analyses][interval][comparison]")
           constant_interval_exprt(CEV(10), CEV(31))
             .less_than_or_equal(constant_interval_exprt(CEV(30), CEV(40))) ==
           tvt::unknown());
-        CHECK(constant_interval_exprt(CEV(10))
-                .less_than_or_equal(constant_interval_exprt(CEV(30)))
+        CHECK(constant_interval_exprt::singleton(CEV(10))
+                .less_than_or_equal(constant_interval_exprt::singleton(CEV(30)))
                 .is_true());
       }
 
@@ -222,7 +223,8 @@ SCENARIO("comparison interval domain", "[core][analyses][interval][comparison]")
         REQUIRE(includes_zero_negative.is_definitely_true().is_unknown());
         REQUIRE(includes_zero_negative.is_definitely_false().is_unknown());
 
-        constant_interval_exprt zero(CEV(0));
+        constant_interval_exprt zero =
+          constant_interval_exprt::singleton(CEV(0));
         REQUIRE(zero.is_definitely_false().is_true());
         REQUIRE(zero.is_definitely_true().is_false());
 
@@ -242,8 +244,8 @@ TEST_CASE("interval::equality", "[core][analyses][interval]")
 {
   SECTION("Single element intervals")
   {
-    constant_interval_exprt two(CEV(2));
-    constant_interval_exprt four(CEV(4));
+    constant_interval_exprt two = constant_interval_exprt::singleton(CEV(2));
+    constant_interval_exprt four = constant_interval_exprt::singleton(CEV(4));
 
     REQUIRE_FALSE(two.equal(four).is_true());
     REQUIRE(two.equal(two).is_true());
diff --git a/unit/util/interval/divide.cpp b/unit/util/interval/divide.cpp
@@ -38,11 +38,16 @@ TEST_CASE("interval::divide", "[core][util][interval][divide]")
 
   SECTION("Single element intervals")
   {
-    const constant_interval_exprt zero_interval(zero);
-    const constant_interval_exprt one_interval(one);
-    const constant_interval_exprt four_interval(four);
-    const constant_interval_exprt eight_interval(eight);
-    const constant_interval_exprt negative_twelve_interval(negative_twelve);
+    const constant_interval_exprt zero_interval =
+      constant_interval_exprt::singleton(zero);
+    const constant_interval_exprt one_interval =
+      constant_interval_exprt::singleton(one);
+    const constant_interval_exprt four_interval =
+      constant_interval_exprt::singleton(four);
+    const constant_interval_exprt eight_interval =
+      constant_interval_exprt::singleton(eight);
+    const constant_interval_exprt negative_twelve_interval =
+      constant_interval_exprt::singleton(negative_twelve);
 
     REQUIRE(value_of(zero_interval.divide(four_interval)) == 0);
     REQUIRE(value_of(four_interval.divide(four_interval)) == 1);
@@ -61,8 +66,10 @@ TEST_CASE("interval::divide", "[core][util][interval][divide]")
 
     SECTION("Max & Min")
     {
-      const constant_interval_exprt min_interval{min_exprt{signed_int_type}};
-      const constant_interval_exprt max_interval{max_exprt{signed_int_type}};
+      const constant_interval_exprt min_interval =
+        constant_interval_exprt::singleton(min_exprt{signed_int_type});
+      const constant_interval_exprt max_interval =
+        constant_interval_exprt::singleton(max_exprt{signed_int_type});
       // TODO: division of single max or min don't work as expected
       // CHECK(max_interval.divide(max_interval).is_top());
       // CHECK(max_interval.divide(min_interval).is_top());
@@ -82,7 +89,8 @@ TEST_CASE("interval::divide", "[core][util][interval][divide]")
     const constant_interval_exprt negative_range(
       negative_sixteen, negative_twelve);
     const constant_interval_exprt range_containing_zero(negative_twelve, four);
-    const constant_interval_exprt zero_interval(zero);
+    const constant_interval_exprt zero_interval =
+      constant_interval_exprt::singleton(zero);
 
     const constant_exprt &two = from_integer(2, signed_int_type);
     REQUIRE(matching_range(
diff --git a/unit/util/interval/eval.cpp b/unit/util/interval/eval.cpp
@@ -14,9 +14,9 @@ SCENARIO("Unary eval on intervals", "[core][analyses][interval][eval]")
   WHEN("Negating a boolean interval")
   {
     constant_interval_exprt true_interval =
-      constant_interval_exprt(true_exprt());
+      constant_interval_exprt::singleton(true_exprt());
     constant_interval_exprt false_interval =
-      constant_interval_exprt(false_exprt());
+      constant_interval_exprt::singleton(false_exprt());
     constant_interval_exprt bool_top_interval =
       constant_interval_exprt(bool_typet());
 
@@ -37,11 +37,11 @@ SCENARIO("Unary eval on intervals", "[core][analyses][interval][eval]")
   WHEN("Unary operations to an single element interval")
   {
     constant_interval_exprt five =
-      constant_interval_exprt(from_integer(5, signedbv_typet(32)));
+      constant_interval_exprt::singleton(from_integer(5, signedbv_typet(32)));
     const constant_interval_exprt &max_interval =
-      constant_interval_exprt(max_exprt{signedbv_typet(32)});
+      constant_interval_exprt::singleton(max_exprt{signedbv_typet(32)});
     const constant_interval_exprt &min_interval =
-      constant_interval_exprt(min_exprt{signedbv_typet(32)});
+      constant_interval_exprt::singleton(min_exprt{signedbv_typet(32)});
 
     THEN("When we apply unary addition to it, nothing should happen")
     {
@@ -102,7 +102,8 @@ SCENARIO("Unary eval on intervals", "[core][analyses][interval][eval]")
 TEST_CASE("binary eval switch", "[core][analyses][interval]")
 {
   const auto interval_of = [](const int value) {
-    return constant_interval_exprt(from_integer(value, signedbv_typet(32)));
+    return constant_interval_exprt::singleton(
+      from_integer(value, signedbv_typet(32)));
   };
 
   const auto interval_from_to = [](const int lower, const int upper) {
diff --git a/unit/util/interval/modulo.cpp b/unit/util/interval/modulo.cpp
@@ -19,9 +19,9 @@ SCENARIO("modulo interval domain", "[core][analyses][interval][modulo]")
 {
   GIVEN("Two single element internvals")
   {
-    constant_interval_exprt a(CEV(5));
-    constant_interval_exprt b(CEV(10));
-    constant_interval_exprt zero(CEV(0));
+    constant_interval_exprt a = constant_interval_exprt::singleton(CEV(5));
+    constant_interval_exprt b = constant_interval_exprt::singleton(CEV(10));
+    constant_interval_exprt zero = constant_interval_exprt::singleton(CEV(0));
     const auto a_mod_b = a.modulo(b);
     REQUIRE(V(a_mod_b.get_upper()) == 5);
 
@@ -30,7 +30,7 @@ SCENARIO("modulo interval domain", "[core][analyses][interval][modulo]")
     REQUIRE(V(b_mod_a.get_upper()) == 4);
 
     const auto zero_mod_a = zero.modulo(a);
-    REQUIRE(zero_mod_a == constant_interval_exprt(CEV(0)));
+    REQUIRE(zero_mod_a == constant_interval_exprt::singleton(CEV(0)));
 
     // TODO: this causes an invariant as it is unable to simplify the
     // TODO: simplify(a % 0) == a % 0
@@ -95,7 +95,7 @@ SCENARIO("modulo interval domain", "[core][analyses][interval][modulo]")
           constant_interval_exprt::modulo(
             constant_interval_exprt(CEV(-20), CEV(-10)),
             constant_interval_exprt(CEV(1), CEV(1))) ==
-          constant_interval_exprt(CEV(0)));
+          constant_interval_exprt::singleton(CEV(0)));
 
         REQUIRE(
           constant_interval_exprt::modulo(
diff --git a/unit/util/interval/multiply.cpp b/unit/util/interval/multiply.cpp
@@ -24,8 +24,8 @@ SCENARIO("multiply interval domain", "[core][analyses][interval][multiply]")
 
     WHEN("Single element multiplication")
     {
-      constant_interval_exprt a(CEV(5));
-      constant_interval_exprt b(CEV(10));
+      constant_interval_exprt a = constant_interval_exprt::singleton(CEV(5));
+      constant_interval_exprt b = constant_interval_exprt::singleton(CEV(10));
       const auto a_times_b = a.multiply(b);
       REQUIRE(a_times_b == constant_interval_exprt(CEV(50), CEV(50)));
     }
diff --git a/unit/util/interval/shift.cpp b/unit/util/interval/shift.cpp
diff --git a/unit/util/interval/subtract.cpp b/unit/util/interval/subtract.cpp
diff --git a/unit/util/interval/to_string.cpp b/unit/util/interval/to_string.cpp

Original file line number	Diff line number	Diff line change
`@@ -165,10 +165,11 @@ constant_interval_exprt::modulo(const constant_interval_exprt &o) const`
`165`	`165`
`166`	`166`	`// If the RHS is 1, or -1 (signed only), then return zero.`
`167`	`167`	`if(`
`168`		`- o == constant_interval_exprt(from_integer(1, o.type())) \|\|`
`169`		`- (o.is_signed() && o == constant_interval_exprt(from_integer(-1, o.type()))))`
	`168`	`+ o.is_single_value_interval() &&`
	`169`	`+ (o.get_lower() == from_integer(1, o.type()) \|\|`
	`170`	`+ (o.is_signed() && o.get_lower() == from_integer(-1, o.type()))))`
`170`	`171`	`{`
`171`		`- return constant_interval_exprt(zero());`
	`172`	`+ return constant_interval_exprt::singleton(zero());`
`172`	`173`	`}`
`173`	`174`
`174`	`175`	`// If other might be modulo by zero, set everything to top.`
`@@ -179,7 +180,7 @@ constant_interval_exprt::modulo(const constant_interval_exprt &o) const`
`179`	`180`
`180`	`181`	`if(is_zero())`
`181`	`182`	`{`
`182`		`- return constant_interval_exprt(zero());`
	`183`	`+ return constant_interval_exprt::singleton(zero());`
`183`	`184`	`}`
`184`	`185`
`185`	`186`	`exprt lower = min();`
`@@ -233,12 +234,12 @@ tvt constant_interval_exprt::is_definitely_false() const`
`233`	`234`	`}`
`234`	`235`	`}`
`235`	`236`
`236`		`- if(equal(constant_interval_exprt(zero())).is_true())`
	`237`	`+ if(is_single_value_interval() && get_lower() == zero())`
`237`	`238`	`{`
`238`	`239`	`return tvt(true);`
`239`	`240`	`}`
`240`	`241`
`241`		`- if(contains(constant_interval_exprt(zero())))`
	`242`	`+ if(contains(constant_interval_exprt::singleton(zero())))`
`242`	`243`	`{`
`243`	`244`	`INVARIANT(`
`244`	`245`	`is_positive(get_upper()) \|\| is_negative(get_lower()),`
`@@ -457,12 +458,14 @@ tvt constant_interval_exprt::not_equal(const constant_interval_exprt &o) const`
`457`	`458`
`458`	`459`	`constant_interval_exprt constant_interval_exprt::increment() const`
`459`	`460`	`{`
`460`		`- return plus(constant_interval_exprt(from_integer(mp_integer(1), type())));`
	`461`	`+ return plus(`
	`462`	`+ constant_interval_exprt::singleton(from_integer(mp_integer(1), type())));`
`461`	`463`	`}`
`462`	`464`
`463`	`465`	`constant_interval_exprt constant_interval_exprt::decrement() const`
`464`	`466`	`{`
`465`		`- return minus(constant_interval_exprt(from_integer(mp_integer(1), type())));`
	`467`	`+ return minus(`
	`468`	`+ constant_interval_exprt::singleton(from_integer(mp_integer(1), type())));`
`466`	`469`	`}`
`467`	`470`
`468`	`471`	`constant_interval_exprt constant_interval_exprt::get_extremes(`
`@@ -939,7 +942,7 @@ constant_interval_exprt::handle_constant_unary_expression(`
`939`	`942`	`if(is_single_value_interval())`
`940`	`943`	`{`
`941`	`944`	`auto expr = unary_exprt(op, get_lower());`
`942`		`- return constant_interval_exprt(simplified_expr(expr));`
	`945`	`+ return constant_interval_exprt::singleton(simplified_expr(expr));`
`943`	`946`	`}`
`944`	`947`	`return top();`
`945`	`948`	`}`
`@@ -951,7 +954,7 @@ constant_interval_exprt::handle_constant_binary_expression(`
`951`	`954`	`{`
`952`	`955`	`PRECONDITION(is_single_value_interval() && other.is_single_value_interval());`
`953`	`956`	`auto expr = binary_exprt(get_lower(), op, other.get_lower());`
`954`		`- return constant_interval_exprt(simplified_expr(expr));`
	`957`	`+ return constant_interval_exprt::singleton(simplified_expr(expr));`
`955`	`958`	`}`
`956`	`959`
`957`	`960`	`exprt constant_interval_exprt::get_max(const exprt &a, const exprt &b)`
`@@ -1964,11 +1967,11 @@ constant_interval_exprt constant_interval_exprt::tvt_to_interval(const tvt &val)`
`1964`	`1967`	`{`
`1965`	`1968`	`if(val.is_true())`
`1966`	`1969`	`{`
`1967`		`- return constant_interval_exprt(true_exprt());`
	`1970`	`+ return constant_interval_exprt::singleton(true_exprt());`
`1968`	`1971`	`}`
`1969`	`1972`	`else if(val.is_false())`
`1970`	`1973`	`{`
`1971`		`- return constant_interval_exprt(false_exprt());`
	`1974`	`+ return constant_interval_exprt::singleton(false_exprt());`
`1972`	`1975`	`}`
`1973`	`1976`	`else`
`1974`	`1977`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,30 +11,30 @@`
`11`	`11`	`#include <util/std_expr.h>`
`12`	`12`	`#include <util/threeval.h>`
`13`	`13`
`14`		`-#include <iostream>`
	`14`	`+#include <iosfwd>`
`15`	`15`
`16`	`16`	`/// +∞ upper bound for intervals`
`17`		`-class max_exprt : public exprt`
	`17`	`+class max_exprt : public nullary_exprt`
`18`	`18`	`{`
`19`	`19`	`public:`
`20`		`- explicit max_exprt(const typet &_type) : exprt(ID_max, _type)`
	`20`	`+ explicit max_exprt(const typet &_type) : nullary_exprt(ID_max, _type)`
`21`	`21`	`{`
`22`	`22`	`}`
`23`	`23`
`24`		`- explicit max_exprt(const exprt &_expr) : exprt(ID_max, _expr.type())`
	`24`	`+ explicit max_exprt(const exprt &_expr) : nullary_exprt(ID_max, _expr.type())`
`25`	`25`	`{`
`26`	`26`	`}`
`27`	`27`	`};`
`28`	`28`
`29`	`29`	`/// -∞ upper bound for intervals`
`30`		`-class min_exprt : public exprt`
	`30`	`+class min_exprt : public nullary_exprt`
`31`	`31`	`{`
`32`	`32`	`public:`
`33`		`- explicit min_exprt(const typet &_type) : exprt(ID_min, _type)`
	`33`	`+ explicit min_exprt(const typet &_type) : nullary_exprt(ID_min, _type)`
`34`	`34`	`{`
`35`	`35`	`}`
`36`	`36`
`37`		`- explicit min_exprt(const exprt &_expr) : exprt(ID_min, _expr.type())`
	`37`	`+ explicit min_exprt(const exprt &_expr) : nullary_exprt(ID_min, _expr.type())`
`38`	`38`	`{`
`39`	`39`	`}`
`40`	`40`	`};`
`@@ -47,25 +47,16 @@ class min_exprt : public exprt`
`47`	`47`	`class constant_interval_exprt : public binary_exprt`
`48`	`48`	`{`
`49`	`49`	`public:`
`50`		`- constant_interval_exprt(`
`51`		`- const exprt &lower,`
`52`		`- const exprt &upper,`
`53`		`- const typet type)`
`54`		`- : binary_exprt(lower, ID_constant_interval, upper, type)`
	`50`	`+ constant_interval_exprt(exprt lower, exprt upper, typet type)`
	`51`	`+ : binary_exprt(`
	`52`	`+ std::move(lower),`
	`53`	`+ ID_constant_interval,`
	`54`	`+ std::move(upper),`
	`55`	`+ std::move(type))`
`55`	`56`	`{`
`56`	`57`	`PRECONDITION(is_well_formed());`
`57`	`58`	`}`
`58`	`59`
`59`		`- constant_interval_exprt(const constant_interval_exprt &x)`
`60`		`- : constant_interval_exprt(x.get_lower(), x.get_upper(), x.type())`
`61`		`- {`
`62`		`- }`
`63`		`-`
`64`		`- explicit constant_interval_exprt(const exprt &x)`
`65`		`- : constant_interval_exprt(x, x, x.type())`
`66`		`- {`
`67`		`- }`
`68`		`-`
`69`	`60`	`explicit constant_interval_exprt(const typet &type)`
`70`	`61`	`: constant_interval_exprt(min_exprt(type), max_exprt(type), type)`
`71`	`62`	`{`
`@@ -74,6 +65,7 @@ class constant_interval_exprt : public binary_exprt`
`74`	`65`	`constant_interval_exprt(const exprt &lower, const exprt &upper)`
`75`	`66`	`: constant_interval_exprt(lower, upper, lower.type())`
`76`	`67`	`{`
	`68`	`+ PRECONDITION(is_well_formed());`
`77`	`69`	`}`
`78`	`70`
`79`	`71`	`bool is_well_formed() const`
`@@ -97,6 +89,11 @@ class constant_interval_exprt : public binary_exprt`
`97`	`89`	`return b;`
`98`	`90`	`}`
`99`	`91`
	`92`	`+ static constant_interval_exprt singleton(const exprt &x)`
	`93`	`+ {`
	`94`	`+ return constant_interval_exprt{x, x, x.type()};`
	`95`	`+ }`
	`96`	`+`
`100`	`97`	`static bool is_valid_bound(const exprt &expr)`
`101`	`98`	`{`
`102`	`99`	`const irep_idt &id = expr.id();`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ SCENARIO("multiply interval domain", "[core][analyses][interval][multiply]")`
`24`	`24`
`25`	`25`	`WHEN("Single element multiplication")`
`26`	`26`	`{`
`27`		`- constant_interval_exprt a(CEV(5));`
`28`		`- constant_interval_exprt b(CEV(10));`
	`27`	`+ constant_interval_exprt a = constant_interval_exprt::singleton(CEV(5));`
	`28`	`+ constant_interval_exprt b = constant_interval_exprt::singleton(CEV(10));`
`29`	`29`	`const auto a_times_b = a.multiply(b);`
`30`	`30`	`REQUIRE(a_times_b == constant_interval_exprt(CEV(50), CEV(50)));`
`31`	`31`	`}`