Merge pull request #3691 from tautschnig/move_to_operands

Replace all uses of move_to_operands

Author: tautschnig

jbmc/src/java_bytecode/character_refine_preprocess.cpp

@@ -1191,9 +1191,8 @@ exprt character_refine_preprocesst::expr_of_to_chars(
   array_exprt case2(array_type);
   exprt low_surrogate=expr_of_low_surrogate(chr, char_type);
   case1.copy_to_operands(low_surrogate);
-  case2.move_to_operands(low_surrogate);
-  exprt high_surrogate=expr_of_high_surrogate(chr, char_type);
-  case2.move_to_operands(high_surrogate);
+  case2.add_to_operands(
+    std::move(low_surrogate), expr_of_high_surrogate(chr, char_type));
   return if_exprt(expr_of_is_bmp_code_point(chr, type), case1, case2);
 }
 

jbmc/src/java_bytecode/java_bytecode_convert_class.cpp

@@ -879,9 +879,8 @@ void java_bytecode_convert_classt::add_array_types(symbol_tablet &symbol_table)
       // TODO use this instead of a loop.
     codet array_copy;
     array_copy.set_statement(ID_array_copy);
-    array_copy.move_to_operands(new_data);
-    array_copy.move_to_operands(old_data);
-    clone_body.move_to_operands(array_copy);
+    array_copy.add_to_operands(std::move(new_data), std::move(old_data));
+    clone_body.add_to_operands(std::move(array_copy));
     */
 
     // Begin for-loop to replace:

jbmc/src/java_bytecode/java_string_literals.cpp

@@ -173,8 +173,8 @@ symbol_exprt get_or_create_string_literal_symbol(
     // _return_value global for its side-effects.
     exprt init_comma_expr(ID_comma);
     init_comma_expr.type() = literal_init.type();
-    init_comma_expr.copy_to_operands(return_symbol.symbol_expr());
-    init_comma_expr.move_to_operands(literal_init);
+    init_comma_expr.add_to_operands(
+      return_symbol.symbol_expr(), std::move(literal_init));
     new_symbol.value = init_comma_expr;
   }
   else if(jls_struct.components().size()>=1 &&

jbmc/unit/util/expr_iterator.cpp

@@ -176,8 +176,8 @@ SCENARIO("depth_iterator_mutate_root", "[core][utils][depth_iterator]")
     exprt test_root;
     // This is the expression we might mutate when we find it
     exprt test_operand(ID_1);
-    test_root.move_to_operands(test_operand);
-    test_expr.move_to_operands(test_root);
+    test_root.add_to_operands(std::move(test_operand));
+    test_expr.add_to_operands(std::move(test_root));
     WHEN("Iteration occurs without mutation")
     {
       // Create shared copies

src/analyses/goto_check.cpp

@@ -1413,10 +1413,7 @@ void goto_checkt::add_guarded_claim(
   if(guard.is_true())
     new_expr.swap(expr);
   else
-  {
-    new_expr=exprt(ID_implies, bool_typet());
-    new_expr.add_to_operands(guard.as_expr(), std::move(expr));
-  }
+    new_expr = implies_exprt(guard.as_expr(), std::move(expr));
 
   if(assertions.insert(new_expr).second)
   {

src/ansi-c/c_typecheck_expr.cpp

@@ -943,7 +943,7 @@ void c_typecheck_baset::typecheck_side_effect_statement_expression(
     {
       side_effect_exprt assign(
         ID_assign, sideeffect.type(), fc.source_location());
-      assign.move_to_operands(fc.lhs(), sideeffect);
+      assign.add_to_operands(fc.lhs(), std::move(sideeffect));
 
       code_expressiont code_expr(assign);
       code_expr.add_source_location() = fc.source_location();
@@ -1302,7 +1302,7 @@ void c_typecheck_baset::typecheck_expr_index(exprt &expr)
     typecheck_arithmetic_pointer(expr.op0());
     exprt addition(ID_plus, array_expr.type());
     addition.operands().swap(expr.operands());
-    expr.move_to_operands(addition);
+    expr.add_to_operands(std::move(addition));
     expr.id(ID_dereference);
     expr.set(ID_C_lvalue, true);
     expr.type() = final_array_type.subtype();

src/ansi-c/parser.y

@@ -442,8 +442,7 @@ offsetof_member_designator:
         {
           $$=$1;
           set($2, ID_index);
-          exprt tmp=convert_integer_literal("0");
-          stack($2).move_to_operands(tmp);
+          stack($2).add_to_operands(convert_integer_literal("0"));
           mto($$, $2);
           set($2, ID_member);
           stack($2).set(ID_component_name, stack($3).get(ID_C_base_name));
@@ -574,7 +573,7 @@ postfix_expression:
           tmp.operands().swap(stack($5).operands());
           $$=$1;
           set($$, ID_typecast);
-          stack($$).move_to_operands(tmp);
+          stack($$).add_to_operands(std::move(tmp));
           stack($$).type().swap(stack($2));
         }
         | '(' type_name ')' '{' initializer_list ',' '}'
@@ -585,7 +584,7 @@ postfix_expression:
           tmp.operands().swap(stack($5).operands());
           $$=$1;
           set($$, ID_typecast);
-          stack($$).move_to_operands(tmp);
+          stack($$).add_to_operands(std::move(tmp));
           stack($$).type().swap(stack($2));
         }
         ;
@@ -2080,7 +2079,7 @@ initializer_list:
           exprt tmp;
           tmp.swap(stack($$));
           stack($$).clear();
-          stack($$).move_to_operands(tmp);
+          stack($$).add_to_operands(std::move(tmp));
         }
         | initializer_list ',' designated_initializer
         {
@@ -2123,7 +2122,7 @@ designated_initializer:
           exprt designator;
           exprt member(ID_member);
           member.set(ID_component_name, stack($1).get(ID_C_base_name));
-          designator.move_to_operands(member);
+          designator.add_to_operands(std::move(member));
           stack($$).add(ID_designator).swap(designator);
           mto($$, $3);
         }
@@ -2638,14 +2637,14 @@ gcc_asm_output:
         {
           $$=$2;
           stack($$).id(ID_gcc_asm_output);
-          stack($$).move_to_operands(stack($1), stack($3)); 
+          stack($$).add_to_operands(std::move(stack($1)), std::move(stack($3)));
         }
         | '[' identifier_or_typedef_name ']'
           string '(' comma_expression ')'
         {
           $$=$5;
           stack($$).id(ID_gcc_asm_output);
-          stack($$).move_to_operands(stack($4), stack($6)); 
+          stack($$).add_to_operands(std::move(stack($4)), std::move(stack($6)));
         }
         ;
 
@@ -2675,14 +2674,14 @@ gcc_asm_input:
         {
           $$=$2;
           stack($$).id(ID_gcc_asm_input);
-          stack($$).move_to_operands(stack($1), stack($3)); 
+          stack($$).add_to_operands(std::move(stack($1)), std::move(stack($3)));
         }
         | '[' identifier_or_typedef_name ']'
           string '(' comma_expression ')'
         {
           $$=$5;
           stack($$).id(ID_gcc_asm_input);
-          stack($$).move_to_operands(stack($4), stack($6)); 
+          stack($$).add_to_operands(std::move(stack($4)), std::move(stack($6)));
         }
         ;
 

src/ansi-c/parser_static.inc

@@ -9,7 +9,7 @@
 #define YYSTYPE unsigned
 #define YYSTYPE_IS_TRIVIAL 1
 
-#define mto(x, y) stack(x).move_to_operands(stack(y))
+#define mto(x, y) stack(x).add_to_operands(std::move(stack(y)))
 #define mts(x, y) (to_type_with_subtypes(stack_type(x)).move_to_subtypes(stack_type(y)))
 #define binary(x, y, l, id, z) { init(x, id); \
   stack(x).add_source_location()=stack(l).source_location(); \

src/cpp/cpp_constructor.cpp

@@ -190,7 +190,7 @@ optionalt<codet> cpp_typecheckt::cpp_constructor(
         val=true_exprt();
 
       side_effect_exprt assign(ID_assign, typet(), source_location);
-      assign.move_to_operands(member, val);
+      assign.add_to_operands(std::move(member), std::move(val));
       typecheck_side_effect_assignment(assign);
       block.add(code_expressiont(std::move(assign)));
     }
@@ -285,7 +285,7 @@ void cpp_typecheckt::new_temporary(
   if(new_code.has_value())
   {
     if(new_code->get_statement() == ID_assign)
-      tmp_object_expr.move_to_operands(new_code->op1());
+      tmp_object_expr.add_to_operands(std::move(new_code->op1()));
     else
       tmp_object_expr.add(ID_initializer) = *new_code;
   }

src/cpp/cpp_destructor.cpp

@@ -68,7 +68,7 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
 
       auto i_code = cpp_destructor(source_location, index);
       if(i_code.has_value())
-        new_code.move_to_operands(i_code.value());
+        new_code.add_to_operands(std::move(i_code.value()));
     }
   }
   else