Interval evaluation wants expressions rather than objects

Prevent repeated calls to obj->to_interval() by returning a list of
expressions in the first place. Removes a level of indirection in the
subsequent code.

Author: jezhiggins

src/analyses/variable-sensitivity/abstract_value_object.cpp

@@ -362,16 +362,16 @@ class interval_evaluator
       return make_top<interval_abstract_valuet>(expression.type());
 
     if(expression.id() == ID_if)
-      return interval_evaluate_conditional(interval_operands);
+      return evaluate_conditional(interval_operands);
 
     if(num_operands == 1)
-      return interval_evaluate_unary_expr(interval_operands);
+      return evaluate_unary_expr(interval_operands);
 
-    constant_interval_exprt result = interval_operands[0]->to_interval();
+    constant_interval_exprt result = interval_operands[0];
 
     for(size_t opIndex = 1; opIndex != interval_operands.size(); ++opIndex)
     {
-      auto &interval_next = interval_operands[opIndex]->to_interval();
+      auto &interval_next = interval_operands[opIndex];
       result = result.eval(expression.id(), interval_next);
     }
 
@@ -381,22 +381,22 @@ class interval_evaluator
     return make_interval(result);
   }
 
-  std::vector<interval_abstract_value_pointert> operands_as_intervals() const
+  std::vector<constant_interval_exprt> operands_as_intervals() const
   {
-    std::vector<interval_abstract_value_pointert> interval_operands;
+    std::vector<constant_interval_exprt> interval_operands;
 
     for(const auto &op : operands)
     {
       auto iav = std::dynamic_pointer_cast<const interval_abstract_valuet>(op);
       if(!iav)
       {
-        // The operand isn't an interval - if it's an integral constant we can
-        // convert it into an interval.
+        // The operand isn't an interval
+        // if it's an integral constant we can convert it into an interval.
         if(constant_interval_exprt::is_int(op->type()))
         {
           const auto op_as_constant = op->to_constant();
           if(op_as_constant.is_nil())
-            return std::vector<interval_abstract_value_pointert>();
+            return std::vector<constant_interval_exprt>();
 
           iav = make_interval(op_as_constant);
         }
@@ -405,19 +405,18 @@ class interval_evaluator
       }
 
       if(iav)
-        interval_operands.push_back(iav);
+        interval_operands.push_back(iav->to_interval());
     }
 
     return interval_operands;
   }
 
-  abstract_object_pointert interval_evaluate_conditional(
-    const std::vector<interval_abstract_value_pointert> &interval_operands)
-    const
+  abstract_object_pointert evaluate_conditional(
+    const std::vector<constant_interval_exprt> &interval_operands) const
   {
-    auto const &condition_interval = interval_operands[0]->to_interval();
-    auto const &true_interval = interval_operands[1]->to_interval();
-    auto const &false_interval = interval_operands[2]->to_interval();
+    auto const &condition_interval = interval_operands[0];
+    auto const &true_interval = interval_operands[1];
+    auto const &false_interval = interval_operands[2];
 
     auto condition_result = condition_interval.is_definitely_true();
 
@@ -436,12 +435,10 @@ class interval_evaluator
                                       : make_interval(false_interval);
   }
 
-  abstract_object_pointert interval_evaluate_unary_expr(
-    const std::vector<interval_abstract_value_pointert> &interval_operands)
-    const
+  abstract_object_pointert evaluate_unary_expr(
+    const std::vector<constant_interval_exprt> &interval_operands) const
   {
-    const constant_interval_exprt &operand_expr =
-      interval_operands[0]->to_interval();
+    const constant_interval_exprt &operand_expr = interval_operands[0];
 
     if(expression.id() == ID_typecast)
     {
@@ -509,12 +506,12 @@ class value_set_evaluator
 private:
   abstract_object_pointert transform() const
   {
-    auto collective_operands = unwrap_operands();
+    auto ranges = operands_as_ranges();
 
     if(expression.id() == ID_if)
-      return value_set_evaluate_conditional(collective_operands);
+      return evaluate_conditional(ranges);
 
-    auto resulting_objects = evaluate_each_combination(collective_operands);
+    auto resulting_objects = evaluate_each_combination(ranges);
 
     return resolve_values(resulting_objects);
   }
@@ -565,7 +562,7 @@ class value_set_evaluator
     return rewritten_expr;
   }
 
-  std::vector<value_ranget> unwrap_operands() const
+  std::vector<value_ranget> operands_as_ranges() const
   {
     auto unwrapped = std::vector<value_ranget>{};
 
@@ -633,7 +630,7 @@ class value_set_evaluator
   }
 
   static abstract_object_pointert
-  value_set_evaluate_conditional(const std::vector<value_ranget> &ops)
+  evaluate_conditional(const std::vector<value_ranget> &ops)
   {
     auto const &condition = ops[0];
 

src/analyses/variable-sensitivity/interval_abstract_value.cpp

@@ -427,11 +427,6 @@ interval_abstract_valuet::index_range_implementation(const namespacet &ns) const
   return make_interval_index_range(interval, ns);
 }
 
-const constant_interval_exprt &interval_abstract_valuet::get_interval() const
-{
-  return interval;
-}
-
 void interval_abstract_valuet::get_statistics(
   abstract_object_statisticst &statistics,
   abstract_object_visitedt &visited,

src/analyses/variable-sensitivity/interval_abstract_value.h

@@ -49,8 +49,6 @@ class interval_abstract_valuet : public abstract_value_objectt
     const class ai_baset &ai,
     const class namespacet &ns) const override;
 
-  const constant_interval_exprt &get_interval() const;
-
   void get_statistics(
     abstract_object_statisticst &statistics,
     abstract_object_visitedt &visited,

unit/analyses/variable-sensitivity/eval.cpp

@@ -56,10 +56,10 @@ SCENARIO(
           std::dynamic_pointer_cast<const interval_abstract_valuet>(unwrapped);
         REQUIRE(result_as_interval);
         REQUIRE(
-          result_as_interval->get_interval().get_lower() ==
+          result_as_interval->to_interval().get_lower() ==
           from_integer(0, number_type));
         REQUIRE(
-          result_as_interval->get_interval().get_upper() ==
+          result_as_interval->to_interval().get_upper() ==
           from_integer(1, number_type));
       }
 

unit/analyses/variable-sensitivity/interval_abstract_value/meet.cpp

@@ -76,7 +76,7 @@ SCENARIO(
         REQUIRE_FALSE(modified);
         REQUIRE_FALSE(cast_result->is_top());
         REQUIRE_FALSE(cast_result->is_bottom());
-        REQUIRE(cast_result->get_interval() == interval1_10);
+        REQUIRE(cast_result->to_interval() == interval1_10);
 
         // Is optimal
         REQUIRE(result == op1);
@@ -143,7 +143,7 @@ SCENARIO(
         REQUIRE_FALSE(cast_result->is_bottom());
 
         // Intersection should have this exact value
-        REQUIRE(cast_result->get_interval() == interval2_10);
+        REQUIRE(cast_result->to_interval() == interval2_10);
       }
     }
     WHEN(
@@ -178,7 +178,7 @@ SCENARIO(
         REQUIRE_FALSE(cast_result->is_bottom());
 
         // Intersection should have this exact value
-        REQUIRE(cast_result->get_interval() == interval2_10);
+        REQUIRE(cast_result->to_interval() == interval2_10);
       }
     }
     WHEN(
@@ -213,7 +213,7 @@ SCENARIO(
         REQUIRE_FALSE(cast_result->is_bottom());
 
         // Intersection should have this exact value
-        REQUIRE(cast_result->get_interval() == interval11_15);
+        REQUIRE(cast_result->to_interval() == interval11_15);
       }
     }
     WHEN(
@@ -249,7 +249,7 @@ SCENARIO(
         REQUIRE_FALSE(cast_result->is_bottom());
 
         // Intersection should have this exact value
-        REQUIRE(cast_result->get_interval() == intervalmax_max);
+        REQUIRE(cast_result->to_interval() == intervalmax_max);
       }
     }
     WHEN(