Add initializer list constructor to struct/union typet and cleanup API use

Use the rvalue constructor and also review any other use of constructors
to avoid unnecessary copies.

Author: tautschnig

jbmc/src/java_bytecode/java_root_class.cpp

@@ -25,10 +25,8 @@ void java_root_class(symbolt &class_symbol)
 
   {
     // the class identifier is used for stuff such as 'instanceof'
-    struct_typet::componentt component;
-    component.set_name("@class_identifier");
+    struct_typet::componentt component("@class_identifier", string_typet());
     component.set_pretty_name("@class_identifier");
-    component.type()=string_typet();
 
     // add at the beginning
     components.insert(components.begin(), component);

jbmc/src/java_bytecode/java_string_library_preprocess.cpp

@@ -1257,9 +1257,9 @@ java_string_library_preprocesst::get_primitive_value_of_object(
     const auto maybe_symbol =
       symbol_table.lookup(object_type->get_identifier()))
   {
-    struct_typet struct_type=to_struct_type(maybe_symbol->type);
+    const struct_typet &struct_type = to_struct_type(maybe_symbol->type);
     // Check that the type has a value field
-    const struct_union_typet::componentt value_comp=
+    const struct_union_typet::componentt &value_comp =
       struct_type.get_component("value");
     if(!value_comp.is_nil())
     {
@@ -1457,17 +1457,16 @@ code_blockt java_string_library_preprocesst::make_string_format_code(
   // The argument can be:
   // a string, an integer, a floating point, a character, a boolean,
   // an object of which we take the hash code, or a date/time
-  struct_typet structured_type;
+  struct_typet structured_type({{"string_expr", refined_string_type},
+                                {ID_int, java_int_type()},
+                                {ID_float, java_float_type()},
+                                {ID_char, java_char_type()},
+                                {ID_boolean, java_boolean_type()},
+                                // TODO: hash_code not implemented for now
+                                {"hashcode", java_int_type()},
+                                // TODO: date_time type not implemented for now
+                                {"date_time", java_int_type()}});
   structured_type.set_tag(CPROVER_PREFIX "string_formatter_variant");
-  structured_type.components().emplace_back("string_expr", refined_string_type);
-  structured_type.components().emplace_back(ID_int, java_int_type());
-  structured_type.components().emplace_back(ID_float, java_float_type());
-  structured_type.components().emplace_back(ID_char, java_char_type());
-  structured_type.components().emplace_back(ID_boolean, java_boolean_type());
-  // TODO: hash_code not implemented for now
-  structured_type.components().emplace_back("hashcode", java_int_type());
-  // TODO: date_time type not implemented for now
-  structured_type.components().emplace_back("date_time", java_int_type());
 
   // We will process arguments so that each is converted to a `struct_exprt`
   // containing each possible type used in format specifiers.

jbmc/src/java_bytecode/java_utils.cpp

@@ -239,11 +239,8 @@ void java_add_components_to_class(
   PRECONDITION(class_symbol.type.id()==ID_struct);
   struct_typet &struct_type=to_struct_type(class_symbol.type);
   struct_typet::componentst &components=struct_type.components();
-
-  for(const struct_union_typet::componentt &component : components_to_add)
-  {
-    components.push_back(component);
-  }
+  components.insert(
+    components.end(), components_to_add.begin(), components_to_add.end());
 }
 
 /// Declare a function with the given name and type.

jbmc/unit/solvers/refinement/string_refinement/dependency_graph.cpp

@@ -30,16 +30,14 @@ typet length_type()
 /// Make a struct with a pointer content and an integer length
 struct_exprt make_string_argument(std::string name)
 {
-  struct_typet type;
   const array_typet char_array(char_type(), infinity_exprt(length_type()));
-  type.components().emplace_back("length", length_type());
-  type.components().emplace_back("content", pointer_type(char_array));
-
-  const symbol_exprt length(name + "_length", length_type());
-  const symbol_exprt content(name + "_content", pointer_type(java_char_type()));
-  struct_exprt expr(type);
-  expr.operands().push_back(length);
-  expr.operands().push_back(content);
+  struct_typet type(
+    {{"length", length_type()}, {"content", pointer_type(char_array)}});
+
+  symbol_exprt length(name + "_length", length_type());
+  symbol_exprt content(name + "_content", pointer_type(java_char_type()));
+  struct_exprt expr(std::move(type));
+  expr.add_to_operands(std::move(length), std::move(content));
   return expr;
 }
 

jbmc/unit/solvers/refinement/string_refinement/string_symbol_resolution.cpp

@@ -36,12 +36,10 @@ SCENARIO("string_identifiers_resolution_from_equations",
     constant_exprt e("e", string_typet());
     constant_exprt f("f", string_typet());
 
-    struct_typet struct_type;
-    struct_type.components().emplace_back("str1", string_typet());
-    struct_type.components().emplace_back("str2", string_typet());
-    struct_exprt struct_expr(struct_type);
-    struct_expr.operands().push_back(a);
-    struct_expr.operands().push_back(f);
+    struct_typet struct_type(
+      {{"str1", string_typet()}, {"str2", string_typet()}});
+    struct_exprt struct_expr(std::move(struct_type));
+    struct_expr.add_to_operands(a, f);
     symbol_exprt symbol_struct("sym_struct", struct_type);
 
     std::vector<equal_exprt> equations;

jbmc/unit/util/has_subtype.cpp

@@ -37,9 +37,8 @@ SCENARIO("has_subtype", "[core][utils][has_subtype]")
 
   GIVEN("a struct with char and int fields")
   {
-    struct_typet struct_type;
-    struct_type.components().emplace_back("char_field", char_type);
-    struct_type.components().emplace_back("int_field", int_type);
+    struct_typet struct_type(
+      {{"char_field", char_type}, {"int_field", int_type}});
     THEN("char and int are subtypes")
     {
       REQUIRE(has_subtype(struct_type, is_type(char_type), ns));
@@ -67,9 +66,7 @@ SCENARIO("has_subtype", "[core][utils][has_subtype]")
   GIVEN("a recursive struct definition")
   {
     struct_tag_typet struct_tag("A-struct");
-    struct_typet::componentt comp("ptr", pointer_type(struct_tag));
-    struct_typet struct_type;
-    struct_type.components().push_back(comp);
+    struct_typet struct_type({{"ptr", pointer_type(struct_tag)}});
 
     symbolt s;
     s.type = struct_type;

src/ansi-c/c_typecheck_expr.cpp

@@ -1545,7 +1545,7 @@ void c_typecheck_baset::typecheck_expr_member(exprt &expr)
     expr.get(ID_component_name);
 
   // first try to find directly
-  struct_union_typet::componentt component=
+  const struct_union_typet::componentt &component =
     struct_union_type.get_component(component_name);
 
   // if that fails, search the anonymous members

src/ansi-c/expr2c.cpp

@@ -1573,8 +1573,7 @@ std::string expr2ct::convert_member(
 
   if(component_name!="")
   {
-    const exprt comp_expr=
-      struct_union_type.get_component(component_name);
+    const exprt &comp_expr = struct_union_type.get_component(component_name);
 
     if(comp_expr.is_nil())
       return convert_norep(src, precedence);
@@ -1592,8 +1591,7 @@ std::string expr2ct::convert_member(
   if(n>=struct_union_type.components().size())
     return convert_norep(src, precedence);
 
-  const exprt comp_expr=
-    struct_union_type.components()[n];
+  const exprt &comp_expr = struct_union_type.components()[n];
 
   dest+=comp_expr.get_string(ID_pretty_name);
 

src/cpp/cpp_typecheck_compound_type.cpp

@@ -1699,14 +1699,15 @@ void cpp_typecheckt::make_ptr_typecast(
   assert(src_type.id()==  ID_pointer);
   assert(dest_type.id()== ID_pointer);
 
-  struct_typet src_struct =
-    to_struct_type(static_cast<const typet&>(follow(src_type.subtype())));
+  const struct_typet &src_struct =
+    to_struct_type(static_cast<const typet &>(follow(src_type.subtype())));
 
-  struct_typet dest_struct =
-    to_struct_type(static_cast<const typet&>(follow(dest_type.subtype())));
+  const struct_typet &dest_struct =
+    to_struct_type(static_cast<const typet &>(follow(dest_type.subtype())));
 
-  assert(subtype_typecast(src_struct, dest_struct) ||
-         subtype_typecast(dest_struct, src_struct));
+  PRECONDITION(
+    subtype_typecast(src_struct, dest_struct) ||
+    subtype_typecast(dest_struct, src_struct));
 
   expr.make_typecast(dest_type);
 }

src/cpp/cpp_typecheck_conversions.cpp

@@ -619,10 +619,10 @@ bool cpp_typecheckt::standard_conversion_pointer_to_member(
     return true;
   }
 
-  struct_typet from_struct = to_struct_type(
+  const struct_typet &from_struct = to_struct_type(
     follow(static_cast<const typet &>(expr.type().find(ID_to_member))));
 
-  struct_typet to_struct =
+  const struct_typet &to_struct =
     to_struct_type(follow(static_cast<const typet &>(type.find(ID_to_member))));
 
   if(subtype_typecast(to_struct, from_struct))
@@ -931,12 +931,6 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
     }
     else
     {
-      struct_typet from_struct;
-      from_struct.make_nil();
-
-      if(from.id()==ID_struct)
-        from_struct=to_struct_type(from);
-
       bool found=false;
 
       for(const auto &component : to_struct_type(to).components())
@@ -1020,7 +1014,7 @@ bool cpp_typecheckt::user_defined_conversion_sequence(
               rank += tmp_rank;
             }
           }
-          else if(from_struct.is_not_nil() && arg1_struct.is_not_nil())
+          else if(from.id() == ID_struct && arg1_struct.is_not_nil())
           {
             // try derived-to-base conversion
             address_of_exprt expr_pfrom(expr, pointer_type(expr.type()));
@@ -1905,8 +1899,8 @@ bool cpp_typecheckt::static_typecast(
       if(!qual_to.is_subset_of(qual_from))
         return false;
 
-      struct_typet from_struct=to_struct_type(from);
-      struct_typet subto_struct=to_struct_type(subto);
+      const struct_typet &from_struct = to_struct_type(from);
+      const struct_typet &subto_struct = to_struct_type(subto);
 
       if(subtype_typecast(subto_struct, from_struct))
       {
@@ -1989,8 +1983,8 @@ bool cpp_typecheckt::static_typecast(
             return false;
         }
 
-        struct_typet from_struct=to_struct_type(from);
-        struct_typet to_struct=to_struct_type(to);
+        const struct_typet &from_struct = to_struct_type(from);
+        const struct_typet &to_struct = to_struct_type(to);
         if(subtype_typecast(to_struct, from_struct))
         {
           make_ptr_typecast(e, type);
@@ -2008,10 +2002,10 @@ bool cpp_typecheckt::static_typecast(
       if(type.subtype()!=e.type().subtype())
         return false;
 
-      struct_typet from_struct = to_struct_type(
+      const struct_typet &from_struct = to_struct_type(
         follow(static_cast<const typet &>(e.type().find(ID_to_member))));
 
-      struct_typet to_struct = to_struct_type(
+      const struct_typet &to_struct = to_struct_type(
         follow(static_cast<const typet &>(type.find(ID_to_member))));
 
       if(subtype_typecast(from_struct, to_struct))
@@ -2028,7 +2022,7 @@ bool cpp_typecheckt::static_typecast(
       if(type.subtype() != e.type().subtype())
         return false;
 
-      struct_typet from_struct = to_struct_type(
+      const struct_typet &from_struct = to_struct_type(
         follow(static_cast<const typet &>(e.type().find(ID_to_member))));
 
       new_expr = e;

src/cpp/cpp_typecheck_expr.cpp

@@ -1180,7 +1180,7 @@ void cpp_typecheckt::typecheck_expr_member(
       else
       {
         // it must be a static component
-        const struct_typet::componentt pcomp=
+        const struct_typet::componentt &pcomp =
           type.get_component(to_symbol_expr(symbol_expr).get_identifier());
 
         if(pcomp.is_nil())

src/cpp/cpp_typecheck_resolve.cpp

@@ -230,7 +230,7 @@ exprt cpp_typecheck_resolvet::convert_identifier(
     const struct_union_typet &struct_union_type=
       to_struct_union_type(compound_symbol.type);
 
-    const exprt component=
+    const exprt &component =
       struct_union_type.get_component(identifier.identifier);
 
     const typet &type=component.type();
@@ -2209,10 +2209,9 @@ void cpp_typecheck_resolvet::filter_for_named_scopes(
 
       if(id.is_member)
       {
-        struct_typet struct_type=
-          static_cast<const struct_typet &>(
-            cpp_typecheck.lookup(id.class_identifier).type);
-        const exprt pcomp=struct_type.get_component(identifier);
+        const struct_typet &struct_type = static_cast<const struct_typet &>(
+          cpp_typecheck.lookup(id.class_identifier).type);
+        const exprt &pcomp = struct_type.get_component(identifier);
         assert(pcomp.is_not_nil());
         assert(pcomp.get_bool(ID_is_type));
         const typet &type=pcomp.type();

src/goto-programs/remove_complex.cpp

@@ -266,15 +266,11 @@ static void remove_complex(typet &type)
 
     // Replace by a struct with two members.
     // The real part goes first.
-    struct_typet struct_type;
+    struct_typet struct_type(
+      {{ID_real, type.subtype()}, {ID_imag, type.subtype()}});
     struct_type.add_source_location()=type.source_location();
-    struct_type.components().resize(2);
-    struct_type.components()[0].type()=type.subtype();
-    struct_type.components()[0].set_name(ID_real);
-    struct_type.components()[1].type()=type.subtype();
-    struct_type.components()[1].set_name(ID_imag);
 
-    type=struct_type;
+    type = std::move(struct_type);
   }
 }
 

src/goto-programs/string_abstraction.cpp

@@ -101,23 +101,14 @@ string_abstractiont::string_abstractiont(
   ns(_symbol_table),
   temporary_counter(0)
 {
-  struct_typet s;
-
-  s.components().resize(3);
-
-  s.components()[0].set_name("is_zero");
+  struct_typet s({{"is_zero", build_type(whatt::IS_ZERO)},
+                  {"length", build_type(whatt::LENGTH)},
+                  {"size", build_type(whatt::SIZE)}});
   s.components()[0].set_pretty_name("is_zero");
-  s.components()[0].type()=build_type(whatt::IS_ZERO);
-
-  s.components()[1].set_name("length");
   s.components()[1].set_pretty_name("length");
-  s.components()[1].type()=build_type(whatt::LENGTH);
-
-  s.components()[2].set_name("size");
   s.components()[2].set_pretty_name("size");
-  s.components()[2].type()=build_type(whatt::SIZE);
 
-  string_struct=s;
+  string_struct = std::move(s);
 }
 
 typet string_abstractiont::build_type(whatt what)

src/util/refined_string_type.cpp

@@ -23,8 +23,7 @@ Author: Romain Brenguier, [email protected]
 refined_string_typet::refined_string_typet(
   const typet &index_type,
   const pointer_typet &content_type)
+  : struct_typet({{"length", index_type}, {"content", content_type}})
 {
-  components().emplace_back("length", index_type);
-  components().emplace_back("content", content_type);
   set_tag(CPROVER_PREFIX"refined_string_type");
 }

src/util/std_types.h

@@ -202,6 +202,12 @@ class struct_union_typet:public typet
 
   typedef std::vector<componentt> componentst;
 
+  struct_union_typet(const irep_idt &_id, componentst &&_components)
+    : typet(_id)
+  {
+    components() = std::move(_components);
+  }
+
   const componentst &components() const
   {
     return (const componentst &)(find(ID_components).get_sub());
@@ -292,6 +298,11 @@ class struct_typet:public struct_union_typet
   {
   }
 
+  explicit struct_typet(componentst &&_components)
+    : struct_union_typet(ID_struct, std::move(_components))
+  {
+  }
+
   bool is_prefix_of(const struct_typet &other) const;
 
   /// A struct may be a class, where members may have access restrictions.
@@ -440,6 +451,11 @@ class union_typet:public struct_union_typet
   union_typet():struct_union_typet(ID_union)
   {
   }
+
+  explicit union_typet(componentst &&_components)
+    : struct_union_typet(ID_union, std::move(_components))
+  {
+  }
 };
 
 /// Check whether a reference to a typet is a \ref union_typet.