replace copy_to_operands by add_to_operands

Daniel Kroening · Daniel Kroening · commit f2e4d430063b · 2018-11-03T17:47:04.000Z
diff --git a/src/util/expr_initializer.cpp b/src/util/expr_initializer.cpp
@@ -199,15 +199,15 @@ exprt expr_initializert<nondet>::expr_initializer_rec(
       {
         constant_exprt code_value(ID_nil, c.type());
         code_value.add_source_location()=source_location;
-        value.copy_to_operands(code_value);
+        value.add_to_operands(std::move(code_value));
       }
       else
       {
         const exprt member = expr_initializer_rec(c.type(), source_location);
         if(member.is_nil())
           return nil_exprt();
 
-        value.copy_to_operands(member);
+        value.add_to_operands(std::move(member));
       }
     }
 
diff --git a/src/util/guard.cpp b/src/util/guard.cpp
@@ -55,7 +55,7 @@ void guardt::add(const exprt &expr)
   else if(id()!=ID_and)
   {
     and_exprt a;
-    a.copy_to_operands(*this);
+    a.add_to_operands(*this);
     *this=a;
   }
 
diff --git a/src/util/simplify_expr_array.cpp b/src/util/simplify_expr_array.cpp
@@ -201,7 +201,7 @@ bool simplify_exprt::simplify_index(exprt &expr)
       simplify_node(final_offset);
 
       exprt result(array.id(), expr.type());
-      result.copy_to_operands(array.op0(), final_offset);
+      result.add_to_operands(array.op0(), final_offset);
       expr.swap(result);
 
       simplify_rec(expr);
diff --git a/src/util/simplify_expr_int.cpp b/src/util/simplify_expr_int.cpp
@@ -477,7 +477,7 @@ bool simplify_exprt::simplify_plus(exprt &expr)
       exprt op0 = plus_expr.op0();
 
       if(plus_expr.op0().op1().id() == ID_plus)
-        op0.op1().copy_to_operands(expr.op1());
+        op0.op1().add_to_operands(expr.op1());
       else
         op0.op1()=plus_exprt(op0.op1(), expr.op1());
 
diff --git a/src/util/std_code.h b/src/util/std_code.h
@@ -144,7 +144,7 @@ class code_blockt:public codet
 
   void add(const codet &code)
   {
-    copy_to_operands(code);
+    add_to_operands(code);
   }
 
   void add(codet &&code)
@@ -219,7 +219,7 @@ class code_assignt:public codet
 
   code_assignt(const exprt &lhs, const exprt &rhs):codet(ID_assign)
   {
-    copy_to_operands(lhs, rhs);
+    add_to_operands(lhs, rhs);
   }
 
   exprt &lhs()
@@ -284,7 +284,7 @@ class code_declt:public codet
 
   explicit code_declt(const exprt &symbol):codet(ID_decl)
   {
-    copy_to_operands(symbol);
+    add_to_operands(symbol);
   }
 
   exprt &symbol()
@@ -400,7 +400,7 @@ class code_assumet:public codet
 
   explicit code_assumet(const exprt &expr):codet(ID_assume)
   {
-    copy_to_operands(expr);
+    add_to_operands(expr);
   }
 
   const exprt &assumption() const
@@ -447,7 +447,7 @@ class code_assertt:public codet
 
   explicit code_assertt(const exprt &expr):codet(ID_assert)
   {
-    copy_to_operands(expr);
+    add_to_operands(expr);
   }
 
   const exprt &assertion() const
@@ -1002,7 +1002,7 @@ class code_returnt:public codet
 
   explicit code_returnt(const exprt &_op):codet(ID_return)
   {
-    copy_to_operands(_op);
+    add_to_operands(_op);
   }
 
   const exprt &return_value() const
@@ -1126,7 +1126,7 @@ class code_switch_caset:public codet
   code_switch_caset(
     const exprt &_case_op, const codet &_code):codet(ID_switch_case)
   {
-    copy_to_operands(_case_op, _code);
+    add_to_operands(_case_op, _code);
   }
 
   bool is_default() const
@@ -1256,7 +1256,7 @@ class code_asmt:public codet
 
   explicit code_asmt(const exprt &expr):codet(ID_asm)
   {
-    copy_to_operands(expr);
+    add_to_operands(expr);
   }
 
   const irep_idt &get_flavor() const
@@ -1303,7 +1303,7 @@ class code_expressiont:public codet
 
   explicit code_expressiont(const exprt &expr):codet(ID_expression)
   {
-    copy_to_operands(expr);
+    add_to_operands(expr);
   }
 
   const exprt &expression() const
@@ -1748,7 +1748,7 @@ class code_landingpadt:public codet
   explicit code_landingpadt(const exprt &catch_expr):
   codet(ID_exception_landingpad)
   {
-    copy_to_operands(catch_expr);
+    add_to_operands(catch_expr);
   }
   const exprt &catch_expr() const
   {
@@ -1825,9 +1825,7 @@ class code_try_catcht:public codet
 
   void add_catch(const code_declt &to_catch, const codet &code_catch)
   {
-    operands().reserve(operands().size()+2);
-    copy_to_operands(to_catch);
-    copy_to_operands(code_catch);
+    add_to_operands(to_catch, code_catch);
   }
 };
 
diff --git a/src/util/std_expr.h b/src/util/std_expr.h
@@ -80,7 +80,7 @@ class ternary_exprt : public exprt
     const typet &_type)
     : exprt(_id, _type)
   {
-    copy_to_operands(_op0, _op1, _op2);
+    add_to_operands(_op0, _op1, _op2);
   }
 
   const exprt &op3() const = delete;
@@ -347,7 +347,7 @@ class unary_exprt:public exprt
     const exprt &_op):
     exprt(_id, _op.type())
   {
-    copy_to_operands(_op);
+    add_to_operands(_op);
   }
 
   unary_exprt(
@@ -363,7 +363,7 @@ class unary_exprt:public exprt
     const typet &_type):
     exprt(_id, _type)
   {
-    copy_to_operands(_op);
+    add_to_operands(_op);
   }
 
   const exprt &op() const
@@ -644,15 +644,15 @@ class predicate_exprt:public exprt
     const irep_idt &_id,
     const exprt &_op):exprt(_id, bool_typet())
   {
-    copy_to_operands(_op);
+    add_to_operands(_op);
   }
 
   predicate_exprt(
     const irep_idt &_id,
     const exprt &_op0,
     const exprt &_op1):exprt(_id, bool_typet())
   {
-    copy_to_operands(_op0, _op1);
+    add_to_operands(_op0, _op1);
   }
 };
 
@@ -758,7 +758,7 @@ class binary_exprt:public exprt
     const exprt &_rhs):
     exprt(_id, _lhs.type())
   {
-    copy_to_operands(_lhs, _rhs);
+    add_to_operands(_lhs, _rhs);
   }
 
   binary_exprt(
@@ -768,7 +768,7 @@ class binary_exprt:public exprt
     const typet &_type):
     exprt(_id, _type)
   {
-    copy_to_operands(_lhs, _rhs);
+    add_to_operands(_lhs, _rhs);
   }
 
   const exprt &op2() const = delete;
@@ -926,7 +926,7 @@ class multi_ary_exprt:public exprt
     const exprt &_rhs):
     exprt(_id, _lhs.type())
   {
-    copy_to_operands(_lhs, _rhs);
+    add_to_operands(_lhs, _rhs);
   }
 
   multi_ary_exprt(
@@ -936,7 +936,7 @@ class multi_ary_exprt:public exprt
     const typet &_type):
     exprt(_id, _type)
   {
-    copy_to_operands(_lhs, _rhs);
+    add_to_operands(_lhs, _rhs);
   }
 };
 
@@ -2326,7 +2326,7 @@ class and_exprt:public multi_ary_exprt
   and_exprt(const exprt &op0, const exprt &op1, const exprt &op2):
     multi_ary_exprt(ID_and, bool_typet())
   {
-    copy_to_operands(op0, op1, op2);
+    add_to_operands(op0, op1, op2);
   }
 
   and_exprt(
@@ -2448,7 +2448,7 @@ class or_exprt:public multi_ary_exprt
   or_exprt(const exprt &op0, const exprt &op1, const exprt &op2):
     multi_ary_exprt(ID_or, bool_typet())
   {
-    copy_to_operands(op0, op1, op2);
+    add_to_operands(op0, op1, op2);
   }
 
   or_exprt(
@@ -2615,7 +2615,7 @@ class bitor_exprt:public multi_ary_exprt
   bitor_exprt(const exprt &_op0, const exprt &_op1):
     multi_ary_exprt(ID_bitor, _op0.type())
   {
-    copy_to_operands(_op0, _op1);
+    add_to_operands(_op0, _op1);
   }
 };
 
@@ -2724,7 +2724,7 @@ class bitand_exprt:public multi_ary_exprt
   bitand_exprt(const exprt &_op0, const exprt &_op1):
     multi_ary_exprt(ID_bitand, _op0.type())
   {
-    copy_to_operands(_op0, _op1);
+    add_to_operands(_op0, _op1);
   }
 };
 
@@ -3073,7 +3073,7 @@ class extractbits_exprt:public exprt
     const exprt &_lower,
     const typet &_type):exprt(ID_extractbits, _type)
   {
-    copy_to_operands(_src, _upper, _lower);
+    add_to_operands(_src, _upper, _lower);
   }
 
   extractbits_exprt(
@@ -3417,7 +3417,7 @@ class with_exprt:public exprt
     const exprt &_new_value):
     exprt(ID_with, _old.type())
   {
-    copy_to_operands(_old, _where, _new_value);
+    add_to_operands(_old, _where, _new_value);
   }
 
   DEPRECATED("use with_exprt(old, where, new_value) instead")
@@ -3501,7 +3501,7 @@ class index_designatort:public exprt
   explicit index_designatort(const exprt &_index):
     exprt(ID_index_designator)
   {
-    copy_to_operands(_index);
+    add_to_operands(_index);
   }
 
   const exprt &index() const
@@ -3707,7 +3707,7 @@ class array_update_exprt:public exprt
     const exprt &_new_value):
     exprt(ID_array_update, _array.type())
   {
-    copy_to_operands(_array, _index, _new_value);
+    add_to_operands(_array, _index, _new_value);
   }
 
   array_update_exprt():exprt(ID_array_update)
@@ -4184,7 +4184,7 @@ class ieee_float_op_exprt:public exprt
     const exprt &_rm):
     exprt(_id)
   {
-    copy_to_operands(_lhs, _rhs, _rm);
+    add_to_operands(_lhs, _rhs, _rm);
   }
 
   exprt &lhs()
@@ -4464,7 +4464,7 @@ class concatenation_exprt:public exprt
     const exprt &_op0, const exprt &_op1, const typet &_type):
     exprt(ID_concatenation, _type)
   {
-    copy_to_operands(_op0, _op1);
+    add_to_operands(_op0, _op1);
   }
 };
 
diff --git a/src/util/string_expr.h b/src/util/string_expr.h
@@ -191,7 +191,7 @@ class refined_string_exprt : public struct_exprt,
     const typet &type)
     : struct_exprt(type)
   {
-    copy_to_operands(_length, _content);
+    add_to_operands(_length, _content);
   }
 
   refined_string_exprt(const exprt &_length, const exprt &_content)

Original file line number	Diff line number	Diff line change
`@@ -199,15 +199,15 @@ exprt expr_initializert<nondet>::expr_initializer_rec(`
`199`	`199`	`{`
`200`	`200`	`constant_exprt code_value(ID_nil, c.type());`
`201`	`201`	`code_value.add_source_location()=source_location;`
`202`		`- value.copy_to_operands(code_value);`
	`202`	`+ value.add_to_operands(std::move(code_value));`
`203`	`203`	`}`
`204`	`204`	`else`
`205`	`205`	`{`
`206`	`206`	`const exprt member = expr_initializer_rec(c.type(), source_location);`
`207`	`207`	`if(member.is_nil())`
`208`	`208`	`return nil_exprt();`
`209`	`209`
`210`		`- value.copy_to_operands(member);`
	`210`	`+ value.add_to_operands(std::move(member));`
`211`	`211`	`}`
`212`	`212`	`}`
`213`	`213`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ void guardt::add(const exprt &expr)`
`55`	`55`	`else if(id()!=ID_and)`
`56`	`56`	`{`
`57`	`57`	`and_exprt a;`
`58`		`- a.copy_to_operands(*this);`
	`58`	`+ a.add_to_operands(*this);`
`59`	`59`	`*this=a;`
`60`	`60`	`}`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ class code_blockt:public codet`
`144`	`144`
`145`	`145`	`void add(const codet &code)`
`146`	`146`	`{`
`147`		`- copy_to_operands(code);`
	`147`	`+ add_to_operands(code);`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`void add(codet &&code)`
`@@ -219,7 +219,7 @@ class code_assignt:public codet`
`219`	`219`
`220`	`220`	`code_assignt(const exprt &lhs, const exprt &rhs):codet(ID_assign)`
`221`	`221`	`{`
`222`		`- copy_to_operands(lhs, rhs);`
	`222`	`+ add_to_operands(lhs, rhs);`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`exprt &lhs()`
`@@ -284,7 +284,7 @@ class code_declt:public codet`
`284`	`284`
`285`	`285`	`explicit code_declt(const exprt &symbol):codet(ID_decl)`
`286`	`286`	`{`
`287`		`- copy_to_operands(symbol);`
	`287`	`+ add_to_operands(symbol);`
`288`	`288`	`}`
`289`	`289`
`290`	`290`	`exprt &symbol()`
`@@ -400,7 +400,7 @@ class code_assumet:public codet`
`400`	`400`
`401`	`401`	`explicit code_assumet(const exprt &expr):codet(ID_assume)`
`402`	`402`	`{`
`403`		`- copy_to_operands(expr);`
	`403`	`+ add_to_operands(expr);`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`const exprt &assumption() const`
`@@ -447,7 +447,7 @@ class code_assertt:public codet`
`447`	`447`
`448`	`448`	`explicit code_assertt(const exprt &expr):codet(ID_assert)`
`449`	`449`	`{`
`450`		`- copy_to_operands(expr);`
	`450`	`+ add_to_operands(expr);`
`451`	`451`	`}`
`452`	`452`
`453`	`453`	`const exprt &assertion() const`
`@@ -1002,7 +1002,7 @@ class code_returnt:public codet`
`1002`	`1002`
`1003`	`1003`	`explicit code_returnt(const exprt &_op):codet(ID_return)`
`1004`	`1004`	`{`
`1005`		`- copy_to_operands(_op);`
	`1005`	`+ add_to_operands(_op);`
`1006`	`1006`	`}`
`1007`	`1007`
`1008`	`1008`	`const exprt &return_value() const`
`@@ -1126,7 +1126,7 @@ class code_switch_caset:public codet`
`1126`	`1126`	`code_switch_caset(`
`1127`	`1127`	`const exprt &_case_op, const codet &_code):codet(ID_switch_case)`
`1128`	`1128`	`{`
`1129`		`- copy_to_operands(_case_op, _code);`
	`1129`	`+ add_to_operands(_case_op, _code);`
`1130`	`1130`	`}`
`1131`	`1131`
`1132`	`1132`	`bool is_default() const`
`@@ -1256,7 +1256,7 @@ class code_asmt:public codet`
`1256`	`1256`
`1257`	`1257`	`explicit code_asmt(const exprt &expr):codet(ID_asm)`
`1258`	`1258`	`{`
`1259`		`- copy_to_operands(expr);`
	`1259`	`+ add_to_operands(expr);`
`1260`	`1260`	`}`
`1261`	`1261`
`1262`	`1262`	`const irep_idt &get_flavor() const`
`@@ -1303,7 +1303,7 @@ class code_expressiont:public codet`
`1303`	`1303`
`1304`	`1304`	`explicit code_expressiont(const exprt &expr):codet(ID_expression)`
`1305`	`1305`	`{`
`1306`		`- copy_to_operands(expr);`
	`1306`	`+ add_to_operands(expr);`
`1307`	`1307`	`}`
`1308`	`1308`
`1309`	`1309`	`const exprt &expression() const`
`@@ -1748,7 +1748,7 @@ class code_landingpadt:public codet`
`1748`	`1748`	`explicit code_landingpadt(const exprt &catch_expr):`
`1749`	`1749`	`codet(ID_exception_landingpad)`
`1750`	`1750`	`{`
`1751`		`- copy_to_operands(catch_expr);`
	`1751`	`+ add_to_operands(catch_expr);`
`1752`	`1752`	`}`
`1753`	`1753`	`const exprt &catch_expr() const`
`1754`	`1754`	`{`
`@@ -1825,9 +1825,7 @@ class code_try_catcht:public codet`
`1825`	`1825`
`1826`	`1826`	`void add_catch(const code_declt &to_catch, const codet &code_catch)`
`1827`	`1827`	`{`
`1828`		`- operands().reserve(operands().size()+2);`
`1829`		`- copy_to_operands(to_catch);`
`1830`		`- copy_to_operands(code_catch);`
	`1828`	`+ add_to_operands(to_catch, code_catch);`
`1831`	`1829`	`}`
`1832`	`1830`	`};`
`1833`	`1831`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ class ternary_exprt : public exprt`
`80`	`80`	`const typet &_type)`
`81`	`81`	`: exprt(_id, _type)`
`82`	`82`	`{`
`83`		`- copy_to_operands(_op0, _op1, _op2);`
	`83`	`+ add_to_operands(_op0, _op1, _op2);`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`const exprt &op3() const = delete;`
`@@ -347,7 +347,7 @@ class unary_exprt:public exprt`
`347`	`347`	`const exprt &_op):`
`348`	`348`	`exprt(_id, _op.type())`
`349`	`349`	`{`
`350`		`- copy_to_operands(_op);`
	`350`	`+ add_to_operands(_op);`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`unary_exprt(`
`@@ -363,7 +363,7 @@ class unary_exprt:public exprt`
`363`	`363`	`const typet &_type):`
`364`	`364`	`exprt(_id, _type)`
`365`	`365`	`{`
`366`		`- copy_to_operands(_op);`
	`366`	`+ add_to_operands(_op);`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`const exprt &op() const`
`@@ -644,15 +644,15 @@ class predicate_exprt:public exprt`
`644`	`644`	`const irep_idt &_id,`
`645`	`645`	`const exprt &_op):exprt(_id, bool_typet())`
`646`	`646`	`{`
`647`		`- copy_to_operands(_op);`
	`647`	`+ add_to_operands(_op);`
`648`	`648`	`}`
`649`	`649`
`650`	`650`	`predicate_exprt(`
`651`	`651`	`const irep_idt &_id,`
`652`	`652`	`const exprt &_op0,`
`653`	`653`	`const exprt &_op1):exprt(_id, bool_typet())`
`654`	`654`	`{`
`655`		`- copy_to_operands(_op0, _op1);`
	`655`	`+ add_to_operands(_op0, _op1);`
`656`	`656`	`}`
`657`	`657`	`};`
`658`	`658`
`@@ -758,7 +758,7 @@ class binary_exprt:public exprt`
`758`	`758`	`const exprt &_rhs):`
`759`	`759`	`exprt(_id, _lhs.type())`
`760`	`760`	`{`
`761`		`- copy_to_operands(_lhs, _rhs);`
	`761`	`+ add_to_operands(_lhs, _rhs);`
`762`	`762`	`}`
`763`	`763`
`764`	`764`	`binary_exprt(`
`@@ -768,7 +768,7 @@ class binary_exprt:public exprt`
`768`	`768`	`const typet &_type):`
`769`	`769`	`exprt(_id, _type)`
`770`	`770`	`{`
`771`		`- copy_to_operands(_lhs, _rhs);`
	`771`	`+ add_to_operands(_lhs, _rhs);`
`772`	`772`	`}`
`773`	`773`
`774`	`774`	`const exprt &op2() const = delete;`
`@@ -926,7 +926,7 @@ class multi_ary_exprt:public exprt`
`926`	`926`	`const exprt &_rhs):`
`927`	`927`	`exprt(_id, _lhs.type())`
`928`	`928`	`{`
`929`		`- copy_to_operands(_lhs, _rhs);`
	`929`	`+ add_to_operands(_lhs, _rhs);`
`930`	`930`	`}`
`931`	`931`
`932`	`932`	`multi_ary_exprt(`
`@@ -936,7 +936,7 @@ class multi_ary_exprt:public exprt`
`936`	`936`	`const typet &_type):`
`937`	`937`	`exprt(_id, _type)`
`938`	`938`	`{`
`939`		`- copy_to_operands(_lhs, _rhs);`
	`939`	`+ add_to_operands(_lhs, _rhs);`
`940`	`940`	`}`
`941`	`941`	`};`
`942`	`942`
`@@ -2326,7 +2326,7 @@ class and_exprt:public multi_ary_exprt`
`2326`	`2326`	`and_exprt(const exprt &op0, const exprt &op1, const exprt &op2):`
`2327`	`2327`	`multi_ary_exprt(ID_and, bool_typet())`
`2328`	`2328`	`{`
`2329`		`- copy_to_operands(op0, op1, op2);`
	`2329`	`+ add_to_operands(op0, op1, op2);`
`2330`	`2330`	`}`
`2331`	`2331`
`2332`	`2332`	`and_exprt(`
`@@ -2448,7 +2448,7 @@ class or_exprt:public multi_ary_exprt`
`2448`	`2448`	`or_exprt(const exprt &op0, const exprt &op1, const exprt &op2):`
`2449`	`2449`	`multi_ary_exprt(ID_or, bool_typet())`
`2450`	`2450`	`{`
`2451`		`- copy_to_operands(op0, op1, op2);`
	`2451`	`+ add_to_operands(op0, op1, op2);`
`2452`	`2452`	`}`
`2453`	`2453`
`2454`	`2454`	`or_exprt(`
`@@ -2615,7 +2615,7 @@ class bitor_exprt:public multi_ary_exprt`
`2615`	`2615`	`bitor_exprt(const exprt &_op0, const exprt &_op1):`
`2616`	`2616`	`multi_ary_exprt(ID_bitor, _op0.type())`
`2617`	`2617`	`{`
`2618`		`- copy_to_operands(_op0, _op1);`
	`2618`	`+ add_to_operands(_op0, _op1);`
`2619`	`2619`	`}`
`2620`	`2620`	`};`
`2621`	`2621`
`@@ -2724,7 +2724,7 @@ class bitand_exprt:public multi_ary_exprt`
`2724`	`2724`	`bitand_exprt(const exprt &_op0, const exprt &_op1):`
`2725`	`2725`	`multi_ary_exprt(ID_bitand, _op0.type())`
`2726`	`2726`	`{`
`2727`		`- copy_to_operands(_op0, _op1);`
	`2727`	`+ add_to_operands(_op0, _op1);`
`2728`	`2728`	`}`
`2729`	`2729`	`};`
`2730`	`2730`
`@@ -3073,7 +3073,7 @@ class extractbits_exprt:public exprt`
`3073`	`3073`	`const exprt &_lower,`
`3074`	`3074`	`const typet &_type):exprt(ID_extractbits, _type)`
`3075`	`3075`	`{`
`3076`		`- copy_to_operands(_src, _upper, _lower);`
	`3076`	`+ add_to_operands(_src, _upper, _lower);`
`3077`	`3077`	`}`
`3078`	`3078`
`3079`	`3079`	`extractbits_exprt(`
`@@ -3417,7 +3417,7 @@ class with_exprt:public exprt`
`3417`	`3417`	`const exprt &_new_value):`
`3418`	`3418`	`exprt(ID_with, _old.type())`
`3419`	`3419`	`{`
`3420`		`- copy_to_operands(_old, _where, _new_value);`
	`3420`	`+ add_to_operands(_old, _where, _new_value);`
`3421`	`3421`	`}`
`3422`	`3422`
`3423`	`3423`	`DEPRECATED("use with_exprt(old, where, new_value) instead")`
`@@ -3501,7 +3501,7 @@ class index_designatort:public exprt`
`3501`	`3501`	`explicit index_designatort(const exprt &_index):`
`3502`	`3502`	`exprt(ID_index_designator)`
`3503`	`3503`	`{`
`3504`		`- copy_to_operands(_index);`
	`3504`	`+ add_to_operands(_index);`
`3505`	`3505`	`}`
`3506`	`3506`
`3507`	`3507`	`const exprt &index() const`
`@@ -3707,7 +3707,7 @@ class array_update_exprt:public exprt`
`3707`	`3707`	`const exprt &_new_value):`
`3708`	`3708`	`exprt(ID_array_update, _array.type())`
`3709`	`3709`	`{`
`3710`		`- copy_to_operands(_array, _index, _new_value);`
	`3710`	`+ add_to_operands(_array, _index, _new_value);`
`3711`	`3711`	`}`
`3712`	`3712`
`3713`	`3713`	`array_update_exprt():exprt(ID_array_update)`
`@@ -4184,7 +4184,7 @@ class ieee_float_op_exprt:public exprt`
`4184`	`4184`	`const exprt &_rm):`
`4185`	`4185`	`exprt(_id)`
`4186`	`4186`	`{`
`4187`		`- copy_to_operands(_lhs, _rhs, _rm);`
	`4187`	`+ add_to_operands(_lhs, _rhs, _rm);`
`4188`	`4188`	`}`
`4189`	`4189`
`4190`	`4190`	`exprt &lhs()`
`@@ -4464,7 +4464,7 @@ class concatenation_exprt:public exprt`
`4464`	`4464`	`const exprt &_op0, const exprt &_op1, const typet &_type):`
`4465`	`4465`	`exprt(ID_concatenation, _type)`
`4466`	`4466`	`{`
`4467`		`- copy_to_operands(_op0, _op1);`
	`4467`	`+ add_to_operands(_op0, _op1);`
`4468`	`4468`	`}`
`4469`	`4469`	`};`
`4470`	`4470`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ class refined_string_exprt : public struct_exprt,`
`191`	`191`	`const typet &type)`
`192`	`192`	`: struct_exprt(type)`
`193`	`193`	`{`
`194`		`- copy_to_operands(_length, _content);`
	`194`	`+ add_to_operands(_length, _content);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`refined_string_exprt(const exprt &_length, const exprt &_content)`