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/ansi-c/ansi_c_entry_point.cpp

@@ -255,14 +255,10 @@ bool generate_ansi_c_start_function(
       namespacet ns(symbol_table);
 
       {
-        symbolt argc_symbol;
-
+        symbolt argc_symbol{"argc'", signed_int_type(), ID_C};
         argc_symbol.base_name = "argc'";
-        argc_symbol.name = "argc'";
-        argc_symbol.type = signed_int_type();
         argc_symbol.is_static_lifetime = true;
         argc_symbol.is_lvalue = true;
-        argc_symbol.mode = ID_C;
 
         auto r = symbol_table.insert(argc_symbol);
         if(!r.second && r.first != argc_symbol)
@@ -284,14 +280,10 @@ bool generate_ansi_c_start_function(
         const plus_exprt size_expr(argc_symbol.symbol_expr(), one_expr);
         const array_typet argv_type(pointer_type(char_type()), size_expr);
 
-        symbolt argv_symbol;
-
+        symbolt argv_symbol{"argv'", argv_type, ID_C};
         argv_symbol.base_name = "argv'";
-        argv_symbol.name = "argv'";
-        argv_symbol.type = argv_type;
         argv_symbol.is_static_lifetime = true;
         argv_symbol.is_lvalue = true;
-        argv_symbol.mode = ID_C;
 
         auto r = symbol_table.insert(argv_symbol);
         if(!r.second && r.first != argv_symbol)
@@ -337,12 +329,9 @@ bool generate_ansi_c_start_function(
       if(parameters.size()==3)
       {
         {
-          symbolt envp_size_symbol;
+          symbolt envp_size_symbol{"envp_size'", size_type(), ID_C};
           envp_size_symbol.base_name = "envp_size'";
-          envp_size_symbol.name = "envp_size'";
-          envp_size_symbol.type = size_type();
           envp_size_symbol.is_static_lifetime = true;
-          envp_size_symbol.mode = ID_C;
 
           if(!symbol_table.insert(std::move(envp_size_symbol)).second)
           {
@@ -356,13 +345,13 @@ bool generate_ansi_c_start_function(
         const symbolt &envp_size_symbol=ns.lookup("envp_size'");
 
         {
-          symbolt envp_symbol;
+          symbolt envp_symbol{
+            "envp'",
+            array_typet(
+              pointer_type(char_type()), envp_size_symbol.symbol_expr()),
+            ID_C};
           envp_symbol.base_name = "envp'";
-          envp_symbol.name = "envp'";
-          envp_symbol.type = array_typet(
-            pointer_type(char_type()), envp_size_symbol.symbol_expr());
           envp_symbol.is_static_lifetime = true;
-          envp_symbol.mode = ID_C;
 
           if(!symbol_table.insert(std::move(envp_symbol)).second)
           {
@@ -543,13 +532,10 @@ bool generate_ansi_c_start_function(
   }
 
   // add the entry point symbol
-  symbolt new_symbol;
-
-  new_symbol.name=goto_functionst::entry_point();
+  symbolt new_symbol{
+    goto_functionst::entry_point(), code_typet{{}, void_type()}, symbol.mode};
   new_symbol.base_name = goto_functionst::entry_point();
-  new_symbol.type = code_typet({}, void_type());
   new_symbol.value.swap(init_code);
-  new_symbol.mode=symbol.mode;
 
   if(!symbol_table.insert(std::move(new_symbol)).second)
   {

src/ansi-c/c_typecheck_expr.cpp

@@ -547,11 +547,8 @@ void c_typecheck_baset::typecheck_expr_builtin_va_arg(exprt &expr)
   code_typet symbol_type=new_type;
   symbol_type.return_type()=void_type();
 
-  symbolt symbol;
+  symbolt symbol{ID_gcc_builtin_va_arg, symbol_type, ID_C};
   symbol.base_name=ID_gcc_builtin_va_arg;
-  symbol.name=ID_gcc_builtin_va_arg;
-  symbol.type=symbol_type;
-  symbol.mode = ID_C;
 
   symbol_table.insert(std::move(symbol));
 }
@@ -2175,13 +2172,10 @@ void c_typecheck_baset::typecheck_side_effect_function_call(
             symbol_table.add(new_symbol);
           }
 
-          symbolt new_symbol;
-
-          new_symbol.name = identifier_with_type;
+          symbolt new_symbol{
+            identifier_with_type, gcc_polymorphic->type(), ID_C};
           new_symbol.base_name = identifier_with_type;
           new_symbol.location = f_op.source_location();
-          new_symbol.type = gcc_polymorphic->type();
-          new_symbol.mode = ID_C;
           code_blockt implementation =
             instantiate_gcc_polymorphic_builtin(identifier, *gcc_polymorphic);
           typet parent_return_type = return_type;
@@ -2213,12 +2207,10 @@ void c_typecheck_baset::typecheck_side_effect_function_call(
           guessed_return_type = pointer_type(void_type()); // void *
         }
 
-        symbolt new_symbol;
-
-        new_symbol.name=identifier;
+        symbolt new_symbol{
+          identifier, code_typet({}, guessed_return_type), mode};
         new_symbol.base_name=identifier;
         new_symbol.location=expr.source_location();
-        new_symbol.type = code_typet({}, guessed_return_type);
         new_symbol.type.set(ID_C_incomplete, true);
 
         // TODO: should also guess some argument types

src/ansi-c/c_typecheck_gcc_polymorphic_builtins.cpp

@@ -612,11 +612,8 @@ static symbolt result_symbol(
   const source_locationt &source_location,
   symbol_table_baset &symbol_table)
 {
-  symbolt symbol;
-  symbol.name = id2string(identifier) + "::1::result";
+  symbolt symbol{id2string(identifier) + "::1::result", type, ID_C};
   symbol.base_name = "result";
-  symbol.type = type;
-  symbol.mode = ID_C;
   symbol.location = source_location;
   symbol.is_file_local = true;
   symbol.is_lvalue = true;

src/ansi-c/c_typecheck_initializer.cpp

@@ -1039,13 +1039,11 @@ exprt c_typecheck_baset::do_initializer_list(
 
         // mimic bits of typecheck_compound_type to produce a new struct tag
         actual_struct_type.remove(ID_tag);
-        type_symbolt compound_symbol{actual_struct_type};
-        compound_symbol.mode = mode;
-        compound_symbol.location = value.source_location();
-        std::string typestr = type2name(compound_symbol.type, *this);
+        std::string typestr = type2name(actual_struct_type, *this);
+        irep_idt tag_identifier = "tag-#anon#" + typestr;
+        type_symbolt compound_symbol{tag_identifier, actual_struct_type, mode};
         compound_symbol.base_name = "#anon#" + typestr;
-        compound_symbol.name = "tag-#anon#" + typestr;
-        irep_idt tag_identifier = compound_symbol.name;
+        compound_symbol.location = value.source_location();
 
         // We might already have the same anonymous struct, which is fine as it
         // will be exactly the same type.

src/ansi-c/c_typecheck_type.cpp

@@ -785,9 +785,7 @@ void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
     assert(have_body);
 
     // produce symbol
-    symbolt compound_symbol;
-    compound_symbol.is_type=true;
-    compound_symbol.type=type;
+    type_symbolt compound_symbol{irep_idt{}, type, mode};
     compound_symbol.location=type.source_location();
 
     typecheck_compound_body(to_struct_union_type(compound_symbol.type));
@@ -821,11 +819,8 @@ void c_typecheck_baset::typecheck_compound_type(struct_union_typet &type)
       type.remove(ID_tag);
       type.set(ID_tag, base_name);
 
-      symbolt compound_symbol;
-      compound_symbol.is_type=true;
-      compound_symbol.name=identifier;
+      type_symbolt compound_symbol{identifier, type, mode};
       compound_symbol.base_name=base_name;
-      compound_symbol.type=type;
       compound_symbol.location=type.source_location();
       compound_symbol.pretty_name=id2string(type.id())+" "+id2string(base_name);
 
@@ -1368,14 +1363,10 @@ void c_typecheck_baset::typecheck_c_enum_type(typet &type)
   irep_idt identifier=tag.get(ID_identifier);
 
   // Put into symbol table
-  symbolt enum_tag_symbol;
-
-  enum_tag_symbol.is_type=true;
-  enum_tag_symbol.type=type;
+  type_symbolt enum_tag_symbol{identifier, type, mode};
   enum_tag_symbol.location=source_location;
   enum_tag_symbol.is_file_local=true;
   enum_tag_symbol.base_name=base_name;
-  enum_tag_symbol.name=identifier;
 
   // throw in the enum members as 'body'
   irept::subt &body=enum_tag_symbol.type.add(ID_body).get_sub();
@@ -1478,14 +1469,10 @@ void c_typecheck_baset::typecheck_c_enum_tag_type(c_enum_tag_typet &type)
     new_type.add(ID_tag)=tag;
     new_type.make_incomplete();
 
-    symbolt enum_tag_symbol;
-
-    enum_tag_symbol.is_type=true;
-    enum_tag_symbol.type=new_type;
+    type_symbolt enum_tag_symbol{identifier, new_type, mode};
     enum_tag_symbol.location=source_location;
     enum_tag_symbol.is_file_local=true;
     enum_tag_symbol.base_name=base_name;
-    enum_tag_symbol.name=identifier;
 
     symbolt *new_symbol;
     move_symbol(enum_tag_symbol, new_symbol);

src/assembler/remove_asm.cpp

@@ -124,13 +124,8 @@ void remove_asmt::gcc_asm_function_call(
   // do we have it?
   if(!symbol_table.has_symbol(function_identifier))
   {
-    symbolt symbol;
-
-    symbol.name = function_identifier;
-    symbol.type = fkt_type;
+    symbolt symbol{function_identifier, fkt_type, ID_C};
     symbol.base_name = function_base_name;
-    symbol.value = nil_exprt();
-    symbol.mode = ID_C;
 
     symbol_table.add(symbol);
 
@@ -182,13 +177,8 @@ void remove_asmt::msc_asm_function_call(
   // do we have it?
   if(!symbol_table.has_symbol(function_identifier))
   {
-    symbolt symbol;
-
-    symbol.name = function_identifier;
-    symbol.type = fkt_type;
+    symbolt symbol{function_identifier, fkt_type, ID_C};
     symbol.base_name = function_base_name;
-    symbol.value = nil_exprt();
-    symbol.mode = ID_C;
 
     symbol_table.add(symbol);
 

src/goto-cc/linker_script_merge.cpp

@@ -461,12 +461,10 @@ int linker_script_merget::ls_data2instructions(
     CHECK_RETURN(zi.has_value());
 
     // Add the array to the symbol table.
-    symbolt array_sym;
+    symbolt array_sym{array_name.str(), array_type, ID_C};
     array_sym.is_static_lifetime = true;
     array_sym.is_lvalue = true;
     array_sym.is_state_var = true;
-    array_sym.name = array_name.str();
-    array_sym.type = array_type;
     array_sym.value = *zi;
     array_sym.location = array_loc;
 
@@ -478,12 +476,10 @@ int linker_script_merget::ls_data2instructions(
     address_of_exprt  array_start(zero_idx);
 
     // Linker-defined symbol_exprt pointing to start address
-    symbolt start_sym;
+    symbolt start_sym{d["start-symbol"].value, pointer_type(char_type()), ID_C};
     start_sym.is_static_lifetime = true;
     start_sym.is_lvalue = true;
     start_sym.is_state_var = true;
-    start_sym.name = d["start-symbol"].value;
-    start_sym.type = pointer_type(char_type());
     start_sym.value = array_start;
     linker_values.emplace(
       d["start-symbol"].value,
@@ -521,12 +517,10 @@ int linker_script_merget::ls_data2instructions(
     {
       plus_exprt array_end(array_start, array_size_expr);
 
-      symbolt end_sym;
+      symbolt end_sym{d["end-symbol"].value, pointer_type(char_type()), ID_C};
       end_sym.is_static_lifetime = true;
       end_sym.is_lvalue = true;
       end_sym.is_state_var = true;
-      end_sym.name = d["end-symbol"].value;
-      end_sym.type = pointer_type(char_type());
       end_sym.value = array_end;
       linker_values.emplace(
         d["end-symbol"].value,
@@ -639,12 +633,11 @@ int linker_script_merget::ls_data2instructions(
 
   if(!symbol_table.has_symbol(CPROVER_PREFIX "allocated_memory"))
   {
-    symbolt sym;
-    sym.name=CPROVER_PREFIX "allocated_memory";
-    sym.pretty_name=CPROVER_PREFIX "allocated_memory";
+    symbolt sym{
+      CPROVER_PREFIX "allocated_memory",
+      code_typet({}, empty_typet()),
+      ID_C} sym.pretty_name = CPROVER_PREFIX "allocated_memory";
     sym.is_lvalue=sym.is_static_lifetime=true;
-    const code_typet void_t({}, empty_typet());
-    sym.type=void_t;
     symbol_table.add(sym);
   }