Merge pull request #3913 from tautschnig/irept-opt-move

Encapsulate ID_already_typechecked in a proper API

Author: tautschnig

src/ansi-c/c_typecheck_base.cpp

@@ -643,7 +643,7 @@ void c_typecheck_baset::typecheck_declaration(
     typecheck_type(declaration.type());
 
     // mark as 'already typechecked'
-    make_already_typechecked(declaration.type());
+    already_typechecked_typet::make_already_typechecked(declaration.type());
 
     irept contract;
 

src/ansi-c/c_typecheck_base.h

@@ -225,13 +225,6 @@ class c_typecheck_baset:
     const mp_integer &min, const mp_integer &max,
     bool is_packed) const;
 
-  void make_already_typechecked(typet &dest)
-  {
-    typet result(ID_already_typechecked);
-    result.subtype().swap(dest);
-    result.swap(dest);
-  }
-
   // this cleans expressions in array types
   std::list<codet> clean_code;
 
@@ -272,4 +265,60 @@ class c_typecheck_baset:
   void apply_asm_label(const irep_idt &asm_label, symbolt &symbol);
 };
 
+class already_typechecked_exprt : public expr_protectedt
+{
+public:
+  explicit already_typechecked_exprt(exprt expr)
+    : expr_protectedt(ID_already_typechecked, typet{}, {std::move(expr)})
+  {
+  }
+
+  static void make_already_typechecked(exprt &expr)
+  {
+    already_typechecked_exprt a{expr};
+    expr.swap(a);
+  }
+
+  exprt &get_expr()
+  {
+    return op0();
+  }
+};
+
+class already_typechecked_typet : public type_with_subtypet
+{
+public:
+  explicit already_typechecked_typet(typet type)
+    : type_with_subtypet(ID_already_typechecked, std::move(type))
+  {
+  }
+
+  static void make_already_typechecked(typet &type)
+  {
+    already_typechecked_typet a{type};
+    type.swap(a);
+  }
+
+  typet &get_type()
+  {
+    return subtype();
+  }
+};
+
+inline already_typechecked_exprt &to_already_typechecked_expr(exprt &expr)
+{
+  PRECONDITION(expr.id() == ID_already_typechecked);
+  PRECONDITION(expr.operands().size() == 1);
+
+  return static_cast<already_typechecked_exprt &>(expr);
+}
+
+inline already_typechecked_typet &to_already_typechecked_type(typet &type)
+{
+  PRECONDITION(type.id() == ID_already_typechecked);
+  PRECONDITION(type.has_subtype());
+
+  return static_cast<already_typechecked_typet &>(type);
+}
+
 #endif // CPROVER_ANSI_C_C_TYPECHECK_BASE_H

src/ansi-c/c_typecheck_expr.cpp

@@ -38,10 +38,7 @@ void c_typecheck_baset::typecheck_expr(exprt &expr)
 {
   if(expr.id()==ID_already_typechecked)
   {
-    assert(expr.operands().size()==1);
-    exprt tmp;
-    tmp.swap(expr.op0());
-    expr.swap(tmp);
+    expr.swap(to_already_typechecked_expr(expr).get_expr());
     return;
   }
 

src/ansi-c/c_typecheck_type.cpp

@@ -40,14 +40,17 @@ void c_typecheck_baset::typecheck_type(typet &type)
 
   if(type.id()==ID_already_typechecked)
   {
+    already_typechecked_typet &already_typechecked =
+      to_already_typechecked_type(type);
+
     // need to preserve any qualifiers
     c_qualifierst c_qualifiers(type);
-    c_qualifiers+=c_qualifierst(type.subtype());
+    c_qualifiers += c_qualifierst(already_typechecked.get_type());
     bool packed=type.get_bool(ID_C_packed);
     exprt alignment=static_cast<const exprt &>(type.find(ID_C_alignment));
     irept _typedef=type.find(ID_C_typedef);
 
-    type=type.subtype();
+    type = already_typechecked.get_type();
 
     c_qualifiers.write(type);
     if(packed)
@@ -896,7 +899,7 @@ void c_typecheck_baset::typecheck_compound_body(
     {
       // do first half of type
       typecheck_type(declaration.type());
-      make_already_typechecked(declaration.type());
+      already_typechecked_typet::make_already_typechecked(declaration.type());
 
       for(const auto &declarator : declaration.declarators())
       {

src/cpp/cpp_constructor.cpp

@@ -276,7 +276,7 @@ void cpp_typecheckt::new_temporary(
   new_object.set(ID_C_lvalue, true);
   new_object.type()=tmp_object_expr.type();
 
-  already_typechecked(new_object);
+  already_typechecked_exprt::make_already_typechecked(new_object);
 
   auto new_code = cpp_constructor(source_location, new_object, ops);
 

src/cpp/cpp_destructor.cpp

@@ -109,7 +109,7 @@ optionalt<codet> cpp_typecheckt::cpp_destructor(
       std::move(member), {}, uninitialized_typet{}, source_location);
 
     typecheck_side_effect_function_call(function_call);
-    already_typechecked(function_call);
+    already_typechecked_exprt::make_already_typechecked(function_call);
 
     code_expressiont new_code(function_call);
     new_code.add_source_location() = source_location;

src/cpp/cpp_typecheck_code.cpp

@@ -359,7 +359,7 @@ void cpp_typecheckt::typecheck_member_initializer(codet &code)
       else
       {
         // it's a data member
-        already_typechecked(symbol_expr);
+        already_typechecked_exprt::make_already_typechecked(symbol_expr);
 
         auto call =
           cpp_constructor(code.source_location(), symbol_expr, code.operands());
@@ -423,7 +423,7 @@ void cpp_typecheckt::typecheck_decl(codet &code)
   }
 
   // mark as 'already typechecked'
-  make_already_typechecked(type);
+  already_typechecked_typet::make_already_typechecked(type);
 
   codet new_code(ID_decl_block);
   new_code.reserve_operands(declaration.declarators().size());
@@ -469,7 +469,7 @@ void cpp_typecheckt::typecheck_decl(codet &code)
     {
       exprt object_expr=cpp_symbol_expr(symbol);
 
-      already_typechecked(object_expr);
+      already_typechecked_exprt::make_already_typechecked(object_expr);
 
       auto constructor_call = cpp_constructor(
         symbol.location, object_expr, declarator.init_args().operands());

src/cpp/cpp_typecheck_compound_type.cpp

@@ -668,17 +668,16 @@ void cpp_typecheckt::typecheck_compound_declarator(
            code_type.return_type().id()!=ID_destructor)
         {
           expr_call.type()=to_code_type(component.type()).return_type();
-          exprt already_typechecked(ID_already_typechecked);
-          already_typechecked.add_to_operands(std::move(expr_call));
 
-          func_symb.value = code_returnt(already_typechecked).make_block();
+          func_symb.value =
+            code_returnt(already_typechecked_exprt{std::move(expr_call)})
+              .make_block();
         }
         else
         {
-          exprt already_typechecked(ID_already_typechecked);
-          already_typechecked.add_to_operands(std::move(expr_call));
-
-          func_symb.value = code_expressiont(already_typechecked).make_block();
+          func_symb.value =
+            code_expressiont(already_typechecked_exprt{std::move(expr_call)})
+              .make_block();
         }
 
         // add this new function to the list of components

src/cpp/cpp_typecheck_constructor.cpp

@@ -235,7 +235,7 @@ void cpp_typecheckt::default_cpctor(
       address_of_exprt address(var);
       assert(address.type() == mem_c.type());
 
-      already_typechecked(address);
+      already_typechecked_exprt::make_already_typechecked(address);
 
       exprt ptrmember(ID_ptrmember);
       ptrmember.set(ID_component_name, mem_c.get_name());
@@ -690,7 +690,7 @@ void cpp_typecheckt::full_member_initialization(
       address_of_exprt address(var);
       assert(address.type() == c.type());
 
-      already_typechecked(address);
+      already_typechecked_exprt::make_already_typechecked(address);
 
       exprt ptrmember(ID_ptrmember);
       ptrmember.set(ID_component_name, c.get_name());

src/cpp/cpp_typecheck_conversions.cpp

@@ -971,11 +971,7 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
 
               exprt func_symb = cpp_symbol_expr(lookup(component.get_name()));
               func_symb.type()=comp_type;
-              {
-                exprt tmp(ID_already_typechecked);
-                tmp.copy_to_operands(func_symb);
-                func_symb.swap(func_symb);
-              }
+              already_typechecked_exprt::make_already_typechecked(func_symb);
 
               // create temporary object
               side_effect_expr_function_callt ctor_expr(
@@ -1023,11 +1019,7 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
 
               exprt func_symb = cpp_symbol_expr(lookup(component.get_name()));
               func_symb.type()=comp_type;
-              {
-                exprt tmp(ID_already_typechecked);
-                tmp.copy_to_operands(func_symb);
-                func_symb.swap(func_symb);
-              }
+              already_typechecked_exprt::make_already_typechecked(func_symb);
 
               side_effect_expr_function_callt ctor_expr(
                 std::move(func_symb),
@@ -1086,9 +1078,7 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
 
         exprt member_func(ID_member);
         member_func.add(ID_component_cpp_name)=cpp_func_name;
-        exprt ac(ID_already_typechecked);
-        ac.copy_to_operands(expr);
-        member_func.copy_to_operands(ac);
+        member_func.copy_to_operands(already_typechecked_exprt{expr});
 
         side_effect_expr_function_callt func_expr(
           std::move(member_func),
@@ -1326,9 +1316,7 @@ bool cpp_typecheckt::reference_binding(
 
         exprt member_func(ID_member);
         member_func.add(ID_component_cpp_name)=cpp_func_name;
-        exprt ac(ID_already_typechecked);
-        ac.copy_to_operands(expr);
-        member_func.copy_to_operands(ac);
+        member_func.copy_to_operands(already_typechecked_exprt{expr});
 
         side_effect_expr_function_callt func_expr(
           std::move(member_func),
@@ -1932,10 +1920,12 @@ bool cpp_typecheckt::static_typecast(
   {
     if(!cpp_is_pod(type))
     {
-      exprt tc(ID_already_typechecked);
-      tc.copy_to_operands(new_expr);
       exprt temporary;
-      new_temporary(e.source_location(), type, tc, temporary);
+      new_temporary(
+        e.source_location(),
+        type,
+        already_typechecked_exprt{new_expr},
+        temporary);
       new_expr.swap(temporary);
     }
     else

src/cpp/cpp_typecheck_declaration.cpp

@@ -116,7 +116,7 @@ void cpp_typecheckt::convert_non_template_declaration(
 
   // mark as 'already typechecked'
   if(!declaration.declarators().empty())
-    make_already_typechecked(declaration_type);
+    already_typechecked_typet::make_already_typechecked(declaration_type);
 
   // Special treatment for anonymous unions
   if(declaration.declarators().empty() &&

src/cpp/cpp_typecheck_destructor.cpp

@@ -81,7 +81,7 @@ codet cpp_typecheckt::dtor(const symbolt &symbol, const symbol_exprt &this_expr)
       address_of_exprt address(var);
       assert(address.type() == c.type());
 
-      already_typechecked(address);
+      already_typechecked_exprt::make_already_typechecked(address);
 
       exprt ptrmember(ID_ptrmember);
       ptrmember.set(ID_component_name, c.get_name());