Avoid codet construction without a statement set

The default constructor for codet is deprecated.

Author: tautschnig

jbmc/src/java_bytecode/java_bytecode_convert_method.cpp

@@ -1206,7 +1206,7 @@ code_blockt java_bytecode_convert_methodt::convert_instructions(
       }
     }
 
-    codet catch_instruction;
+    optionalt<codet> catch_instruction;
 
     if(catch_type!=typet())
     {
@@ -1223,8 +1223,7 @@ code_blockt java_bytecode_convert_methodt::convert_instructions(
           "caught_exception",
           java_reference_type(catch_type));
       stack.push_back(catch_var);
-      code_landingpadt catch_statement(catch_var);
-      catch_instruction=catch_statement;
+      catch_instruction = code_landingpadt(catch_var);
     }
 
     exprt::operandst op = pop(stmt_bytecode_info.pop);
@@ -1677,10 +1676,10 @@ code_blockt java_bytecode_convert_methodt::convert_instructions(
     // Finally if this is the beginning of a catch block (already determined
     // before the big bytecode switch), insert the exception 'landing pad'
     // instruction before the actual instruction:
-    if(catch_instruction!=codet())
+    if(catch_instruction.has_value())
     {
       c.make_block();
-      c.operands().insert(c.operands().begin(), catch_instruction);
+      c.operands().insert(c.operands().begin(), *catch_instruction);
     }
 
     if(!i_it->source_location.get_line().empty())

src/ansi-c/c_typecheck_base.cpp

@@ -648,7 +648,7 @@ void c_typecheck_baset::typecheck_declaration(
     // mark as 'already typechecked'
     make_already_typechecked(declaration.type());
 
-    codet contract;
+    irept contract;
 
     {
       exprt spec_requires=
@@ -738,15 +738,15 @@ void c_typecheck_baset::typecheck_declaration(
       // available
       symbolt &new_symbol=*symbol_table.get_writeable(identifier);
 
-      typecheck_spec_expr(contract, ID_C_spec_requires);
+      typecheck_spec_expr(static_cast<codet &>(contract), ID_C_spec_requires);
 
       typet ret_type=empty_typet();
       if(new_symbol.type.id()==ID_code)
         ret_type=to_code_type(new_symbol.type).return_type();
       assert(parameter_map.empty());
       if(ret_type.id()!=ID_empty)
         parameter_map[CPROVER_PREFIX "return_value"] = ret_type;
-      typecheck_spec_expr(contract, ID_C_spec_ensures);
+      typecheck_spec_expr(static_cast<codet &>(contract), ID_C_spec_ensures);
       parameter_map.clear();
 
       if(contract.find(ID_C_spec_requires).is_not_nil())

src/cpp/cpp_destructor.cpp

@@ -20,9 +20,6 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
   const source_locationt &source_location,
   const exprt &object)
 {
-  codet new_code;
-  new_code.add_source_location()=source_location;
-
   elaborate_class_template(object.type());
 
   typet tmp_type(follow(object.type()));
@@ -53,9 +50,8 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
       throw 0;
     }
 
-    new_code.type().id(ID_code);
+    code_blockt new_code;
     new_code.add_source_location()=source_location;
-    new_code.set_statement(ID_block);
 
     // for each element of the array, call the destructor
     for(mp_integer i=0; i < s; ++i)
@@ -70,6 +66,8 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
       if(i_code.has_value())
         new_code.add_to_operands(std::move(i_code.value()));
     }
+
+    return std::move(new_code);
   }
   else
   {
@@ -115,9 +113,9 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
     typecheck_side_effect_function_call(function_call);
     already_typechecked(function_call);
 
-    new_code = code_expressiont(function_call);
+    code_expressiont new_code(function_call);
     new_code.add_source_location() = source_location;
-  }
 
-  return new_code;
+    return std::move(new_code);
+  }
 }

src/cpp/cpp_typecheck.h

@@ -124,9 +124,7 @@ class cpp_typecheckt:public c_typecheck_baset
 
   void convert_pmop(exprt &expr);
 
-  void convert_anonymous_union(
-    cpp_declarationt &declaration,
-    codet &new_code);
+  codet convert_anonymous_union(cpp_declarationt &declaration);
 
   void convert_anon_struct_union_member(
     const cpp_declarationt &declaration,

src/cpp/cpp_typecheck_code.cpp

@@ -384,7 +384,7 @@ void cpp_typecheckt::typecheck_decl(codet &code)
       throw 0;
     }
 
-    convert_anonymous_union(declaration, code);
+    code = convert_anonymous_union(declaration);
     return;
   }
 

src/cpp/cpp_typecheck_declaration.cpp

@@ -31,9 +31,7 @@ void cpp_typecheckt::convert(cpp_declarationt &declaration)
     convert_non_template_declaration(declaration);
 }
 
-void cpp_typecheckt::convert_anonymous_union(
-  cpp_declarationt &declaration,
-  codet &code)
+codet cpp_typecheckt::convert_anonymous_union(cpp_declarationt &declaration)
 {
   codet new_code(ID_decl_block);
   new_code.reserve_operands(declaration.declarators().size());
@@ -93,7 +91,7 @@ void cpp_typecheckt::convert_anonymous_union(
   symbol_table.get_writeable_ref(union_symbol.name)
     .type.set(ID_C_unnamed_object, symbol.base_name);
 
-  code.swap(new_code);
+  return new_code;
 }
 
 void cpp_typecheckt::convert_non_template_declaration(
@@ -135,8 +133,7 @@ void cpp_typecheckt::convert_non_template_declaration(
       throw 0;
     }
 
-    codet dummy;
-    convert_anonymous_union(declaration, dummy);
+    convert_anonymous_union(declaration);
   }
 
   // do the declarators (optional)

src/goto-instrument/goto_program2code.cpp

@@ -620,14 +620,13 @@ goto_programt::const_targett goto_program2codet::convert_goto_while(
   if(w.body().has_operands() &&
      to_code(w.body().operands().back()).get_statement()==ID_assign)
   {
-    code_fort f(nil_exprt(), w.cond(), w.body().operands().back(), codet());
-
+    exprt increment = w.body().operands().back();
     w.body().operands().pop_back();
-    f.iter().id(ID_side_effect);
+    increment.id(ID_side_effect);
 
-    copy_source_location(target, f);
+    code_fort f(nil_exprt(), w.cond(), increment, w.body());
 
-    f.body().swap(w.body());
+    copy_source_location(target, f);
 
     f.swap(w);
   }
@@ -1523,8 +1522,7 @@ void goto_program2codet::cleanup_code(
 
     if(labels_in_use.find(label)==labels_in_use.end())
     {
-      codet tmp;
-      tmp.swap(cl.code());
+      codet tmp = cl.code();
       code.swap(tmp);
     }
   }
@@ -1624,8 +1622,7 @@ void goto_program2codet::cleanup_code_block(
           parent_stmt!=ID_nil &&
           to_code(code.op0()).get_statement()!=ID_decl)
   {
-    codet tmp;
-    tmp.swap(code.op0());
+    codet tmp = to_code(code.op0());
     code.swap(tmp);
   }
 }
@@ -1717,8 +1714,7 @@ void goto_program2codet::cleanup_code_ifthenelse(
     cond.is_true() &&
     (i_t_e.else_case().is_nil() || !has_labels(i_t_e.else_case())))
   {
-    codet tmp;
-    tmp.swap(i_t_e.then_case());
+    codet tmp = i_t_e.then_case();
     code.swap(tmp);
   }
   else if(cond.is_false() && !has_labels(i_t_e.then_case()))
@@ -1727,8 +1723,7 @@ void goto_program2codet::cleanup_code_ifthenelse(
       code=code_skipt();
     else
     {
-      codet tmp;
-      tmp.swap(i_t_e.else_case());
+      codet tmp = i_t_e.else_case();
       code.swap(tmp);
     }
   }

src/goto-programs/goto_convert.cpp

@@ -563,7 +563,10 @@ void goto_convertt::convert_block(
     unwind_destructor_stack(end_location, old_stack_size, dest, mode);
 
   // remove those destructors
-  targets.destructor_stack.resize(old_stack_size);
+  PRECONDITION(old_stack_size <= targets.destructor_stack.size());
+  targets.destructor_stack.erase(
+    targets.destructor_stack.begin() + old_stack_size,
+    targets.destructor_stack.end());
 }
 
 void goto_convertt::convert_expression(

src/goto-programs/goto_convert_side_effect.cpp

@@ -453,8 +453,6 @@ void goto_convertt::remove_malloc(
   const irep_idt &mode,
   bool result_is_used)
 {
-  codet call;
-
   if(result_is_used)
   {
     const symbolt &new_symbol = get_fresh_aux_symbol(
@@ -469,17 +467,17 @@ void goto_convertt::remove_malloc(
     decl.add_source_location()=new_symbol.location;
     convert_decl(decl, dest, mode);
 
-    call=code_assignt(new_symbol.symbol_expr(), expr);
+    code_assignt call(new_symbol.symbol_expr(), expr);
     call.add_source_location()=expr.source_location();
 
     static_cast<exprt &>(expr)=new_symbol.symbol_expr();
+
+    convert(call, dest, mode);
   }
   else
   {
-    call = code_expressiont(std::move(expr));
+    convert(code_expressiont(std::move(expr)), dest, mode);
   }
-
-  convert(call, dest, mode);
 }
 
 void goto_convertt::remove_temporary_object(

src/goto-programs/goto_program.h

@@ -422,13 +422,14 @@ class goto_programt
     {
     }
 
-    explicit instructiont(goto_program_instruction_typet _type):
-      source_location(static_cast<const source_locationt &>(get_nil_irep())),
-      type(_type),
-      guard(true_exprt()),
-      location_number(0),
-      loop_number(0),
-      target_number(nil_target)
+    explicit instructiont(goto_program_instruction_typet _type)
+      : code(static_cast<const codet &>(get_nil_irep())),
+        source_location(static_cast<const source_locationt &>(get_nil_irep())),
+        type(_type),
+        guard(true_exprt()),
+        location_number(0),
+        loop_number(0),
+        target_number(nil_target)
     {
     }