C++ front-end: use new symbolt constructors

To the extent possible, apply resource-acquisition-is-initialisation.
The constructors ensure that at least the most essential fields (name,
type, mode) are set.

Author: tautschnig

src/cpp/cpp_declarator_converter.cpp

@@ -441,18 +441,16 @@ symbolt &cpp_declarator_convertert::convert_new_symbol(
 {
   irep_idt pretty_name=get_pretty_name();
 
-  symbolt symbol;
-
-  symbol.name=final_identifier;
+  symbolt symbol{final_identifier,
+                 final_type,
+                 linkage_spec == ID_auto ? ID_cpp : linkage_spec};
   symbol.base_name=base_name;
   symbol.value=declarator.value();
   symbol.location=declarator.name().source_location();
   symbol.is_extern = storage_spec.is_extern();
   symbol.is_parameter = declarator.get_is_parameter();
   symbol.is_weak = storage_spec.is_weak();
-  symbol.mode=linkage_spec==ID_auto?ID_cpp:linkage_spec;
   symbol.module=cpp_typecheck.module;
-  symbol.type=final_type;
   symbol.is_type=is_typedef;
   symbol.is_macro=is_typedef && !is_template_parameter;
   symbol.pretty_name=pretty_name;

src/cpp/cpp_instantiate_template.cpp

@@ -182,11 +182,9 @@ const symbolt &cpp_typecheckt::class_template_symbol(
 
   // Create as incomplete struct, but mark as
   // "template_class_instance", to be elaborated later.
-  symbolt new_symbol;
-  new_symbol.name=identifier;
+  type_symbolt new_symbol{identifier, struct_typet(), template_symbol.mode};
   new_symbol.pretty_name=template_symbol.pretty_name;
   new_symbol.location=template_symbol.location;
-  new_symbol.type = struct_typet();
   to_struct_type(new_symbol.type).make_incomplete();
   new_symbol.type.set(ID_tag, template_symbol.type.find(ID_tag));
   if(template_symbol.type.get_bool(ID_C_class))
@@ -197,9 +195,7 @@ const symbolt &cpp_typecheckt::class_template_symbol(
     ID_specialization_template_args, specialization_template_args);
   new_symbol.type.set(ID_full_template_args, full_template_args);
   new_symbol.type.set(ID_identifier, template_symbol.name);
-  new_symbol.mode=template_symbol.mode;
   new_symbol.base_name=template_symbol.base_name;
-  new_symbol.is_type=true;
 
   symbolt *s_ptr;
   symbol_table.move(new_symbol, s_ptr);

src/cpp/cpp_typecheck.cpp

@@ -194,16 +194,12 @@ void cpp_typecheckt::static_and_dynamic_initialization()
   dynamic_initializations.clear();
 
   // Create the dynamic initialization procedure
-  symbolt init_symbol;
-
-  init_symbol.name="#cpp_dynamic_initialization#"+id2string(module);
+  symbolt init_symbol{"#cpp_dynamic_initialization#" + id2string(module),
+                      code_typet({}, typet(ID_constructor)),
+                      ID_cpp};
   init_symbol.base_name="#cpp_dynamic_initialization#"+id2string(module);
   init_symbol.value.swap(init_block);
-  init_symbol.mode=ID_cpp;
   init_symbol.module=module;
-  init_symbol.type = code_typet({}, typet(ID_constructor));
-  init_symbol.is_type=false;
-  init_symbol.is_macro=false;
 
   symbol_table.insert(std::move(init_symbol));
 

src/cpp/cpp_typecheck_compound_type.cpp

@@ -228,17 +228,10 @@ void cpp_typecheckt::typecheck_compound_type(
   else
   {
     // produce new symbol
-    symbolt symbol;
-
-    symbol.name=symbol_name;
+    type_symbolt symbol{symbol_name, type, ID_cpp};
     symbol.base_name=base_name;
-    symbol.value.make_nil();
     symbol.location=type.source_location();
-    symbol.mode=ID_cpp;
     symbol.module=module;
-    symbol.type.swap(type);
-    symbol.is_type=true;
-    symbol.is_macro=false;
     symbol.pretty_name=
       cpp_scopes.current_scope().prefix+
       id2string(symbol.base_name)+
@@ -575,16 +568,12 @@ void cpp_typecheckt::typecheck_compound_declarator(
       if(!symbol_table.has_symbol(vt_name))
       {
         // first time: create a virtual-table symbol type
-        symbolt vt_symb_type;
-        vt_symb_type.name= vt_name;
+        type_symbolt vt_symb_type{vt_name, struct_typet(), ID_cpp};
         vt_symb_type.base_name="virtual_table::"+id2string(symbol.base_name);
         vt_symb_type.pretty_name=vt_symb_type.base_name;
-        vt_symb_type.mode=ID_cpp;
         vt_symb_type.module=module;
         vt_symb_type.location=symbol.location;
-        vt_symb_type.type=struct_typet();
         vt_symb_type.type.set(ID_name, vt_symb_type.name);
-        vt_symb_type.is_type=true;
 
         const bool failed=!symbol_table.insert(std::move(vt_symb_type)).second;
         CHECK_RETURN(!failed);
@@ -624,15 +613,14 @@ void cpp_typecheckt::typecheck_compound_declarator(
         irep_idt virtual_base=*virtual_bases.begin();
 
         // a new function that does 'late casting' of the 'this' parameter
-        symbolt func_symb;
-        func_symb.name=
-          id2string(component.get_name())+"::"+id2string(virtual_base);
+        symbolt func_symb{id2string(component.get_name()) +
+                            "::" + id2string(virtual_base),
+                          component.type(),
+                          symbol.mode};
         func_symb.base_name = component.get_base_name();
         func_symb.pretty_name = component.get_base_name();
-        func_symb.mode = symbol.mode;
         func_symb.module=module;
         func_symb.location=component.source_location();
-        func_symb.type=component.type();
 
         // change the type of the 'this' pointer
         code_typet &code_type=to_code_type(func_symb.type);
@@ -649,14 +637,13 @@ void cpp_typecheckt::typecheck_compound_declarator(
           if(param_base_name.empty())
             param_base_name = "arg" + std::to_string(i++);
 
-          symbolt arg_symb;
-          arg_symb.name =
-            id2string(func_symb.name) + "::" + id2string(param_base_name);
+          symbolt arg_symb{id2string(func_symb.name) +
+                             "::" + id2string(param_base_name),
+                           arg.type(),
+                           symbol.mode};
           arg_symb.base_name = param_base_name;
           arg_symb.pretty_name = param_base_name;
-          arg_symb.mode = symbol.mode;
           arg_symb.location=func_symb.location;
-          arg_symb.type=arg.type();
 
           arg.set_identifier(arg_symb.name);
 
@@ -721,10 +708,7 @@ void cpp_typecheckt::typecheck_compound_declarator(
   if(is_static && !is_method) // static non-method member
   {
     // add as global variable to symbol_table
-    symbolt static_symbol;
-    static_symbol.mode=symbol.mode;
-    static_symbol.name=identifier;
-    static_symbol.type=component.type();
+    symbolt static_symbol{identifier, component.type(), symbol.mode};
     static_symbol.base_name = component.get_base_name();
     static_symbol.is_lvalue=true;
     static_symbol.is_static_lifetime=true;
@@ -1278,8 +1262,6 @@ void cpp_typecheckt::typecheck_member_function(
   const typet &method_qualifier,
   exprt &value)
 {
-  symbolt symbol;
-
   code_typet &type = to_code_type(component.type());
 
   if(component.get_bool(ID_is_static))
@@ -1318,14 +1300,10 @@ void cpp_typecheckt::typecheck_member_function(
   if(value.is_not_nil())
     to_code_type(type).set_inlined(true);
 
-  symbol.name=identifier;
+  symbolt symbol{identifier, type, compound_symbol.mode};
   symbol.base_name=component.get_base_name();
   symbol.value.swap(value);
-  symbol.mode = compound_symbol.mode;
   symbol.module=module;
-  symbol.type=type;
-  symbol.is_type=false;
-  symbol.is_macro=false;
   symbol.location=component.source_location();
 
   // move early, it must be visible before doing any value

src/cpp/cpp_typecheck_enum_type.cpp

@@ -51,17 +51,14 @@ void cpp_typecheckt::typecheck_enum_body(symbolt &enum_symbol)
     exprt value_expr=from_integer(i, c_enum_type.subtype());
     value_expr.type()=enum_tag_type; // override type
 
-    symbolt symbol;
-
-    symbol.name=id2string(enum_symbol.name)+"::"+id2string(name);
+    symbolt symbol{id2string(enum_symbol.name) + "::" + id2string(name),
+                   enum_tag_type,
+                   enum_symbol.mode};
     symbol.base_name=name;
     symbol.value=value_expr;
     symbol.location = static_cast<const source_locationt &>(
       component.find(ID_C_source_location));
-    symbol.mode = enum_symbol.mode;
     symbol.module=module;
-    symbol.type=enum_tag_type;
-    symbol.is_type=false;
     symbol.is_macro=true;
     symbol.is_file_local = true;
     symbol.is_thread_local = true;
@@ -167,17 +164,11 @@ void cpp_typecheckt::typecheck_enum_type(typet &type)
       }
     }
 
-    symbolt symbol;
-
-    symbol.name=symbol_name;
+    type_symbolt symbol{symbol_name, type, ID_cpp};
     symbol.base_name=base_name;
     symbol.value.make_nil();
     symbol.location=type.source_location();
-    symbol.mode=ID_cpp;
     symbol.module=module;
-    symbol.type.swap(type);
-    symbol.is_type=true;
-    symbol.is_macro=false;
     symbol.pretty_name=pretty_name;
 
     // move early, must be visible before doing body

src/cpp/cpp_typecheck_namespace.cpp

@@ -61,15 +61,10 @@ void cpp_typecheckt::convert(cpp_namespace_spect &namespace_spec)
   }
   else
   {
-    symbolt symbol;
-
-    symbol.name=identifier;
+    symbolt symbol{identifier, typet(ID_namespace), ID_cpp};
     symbol.base_name=final_name;
-    symbol.value.make_nil();
     symbol.location=namespace_spec.source_location();
-    symbol.mode=ID_cpp;
     symbol.module=module;
-    symbol.type=typet(ID_namespace);
 
     if(!symbol_table.insert(std::move(symbol)).second)
     {

src/cpp/cpp_typecheck_template.cpp

@@ -166,15 +166,11 @@ void cpp_typecheckt::typecheck_class_template(
 
   // it's not there yet
 
-  symbolt symbol;
-
-  symbol.name=symbol_name;
+  symbolt symbol{symbol_name, typet{}, ID_cpp};
   symbol.base_name=base_name;
   symbol.location=cpp_name.source_location();
-  symbol.mode=ID_cpp;
   symbol.module=module;
   symbol.type.swap(declaration);
-  symbol.is_macro=false;
   symbol.value = exprt(ID_template_decls);
 
   symbol.pretty_name=
@@ -274,14 +270,10 @@ void cpp_typecheckt::typecheck_function_template(
     return;
   }
 
-  symbolt symbol;
-  symbol.name=symbol_name;
+  symbolt symbol{symbol_name, typet{}, ID_cpp};
   symbol.base_name=base_name;
   symbol.location=cpp_name.source_location();
-  symbol.mode=ID_cpp;
   symbol.module=module;
-  symbol.value.make_nil();
-
   symbol.type.swap(declaration);
   symbol.pretty_name=
     cpp_scopes.current_scope().prefix+id2string(symbol.base_name);

src/cpp/cpp_typecheck_virtual_table.cpp

@@ -67,15 +67,14 @@ void cpp_typecheckt::do_virtual_table(const symbolt &symbol)
     const symbolt &vt_symb_type =
       lookup("virtual_table::" + id2string(late_cast_symb.name));
 
-    symbolt vt_symb_var;
-    vt_symb_var.name=
-      id2string(vt_symb_type.name) + "@"+ id2string(symbol.name);
+    symbolt vt_symb_var{id2string(vt_symb_type.name) + "@" +
+                          id2string(symbol.name),
+                        struct_tag_typet(vt_symb_type.name),
+                        symbol.mode};
     vt_symb_var.base_name=
       id2string(vt_symb_type.base_name) + "@" + id2string(symbol.base_name);
-    vt_symb_var.mode = symbol.mode;
     vt_symb_var.module=module;
     vt_symb_var.location=vt_symb_type.location;
-    vt_symb_var.type = struct_tag_typet(vt_symb_type.name);
     vt_symb_var.is_lvalue=true;
     vt_symb_var.is_static_lifetime=true;