Add and cleanup 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. Constructors are now consistent in what they do,
and do not set the base_name in addition to the name.

Author: tautschnig

src/goto-instrument/dump_c.cpp

@@ -91,14 +91,14 @@ void dump_ct::operator()(std::ostream &os)
       (symbol.type.id() == ID_union || symbol.type.id() == ID_struct) &&
       !symbol.is_type)
     {
-      type_symbolt ts{symbol.type};
-      ts.mode = symbol.mode;
+      std::string tag_name;
       if(mode == ID_C)
-        ts.name = "tag-" + type2name(symbol.type, ns);
+        tag_name = "tag-" + type2name(symbol.type, ns);
       else if(mode == ID_cpp)
-        ts.name = "tag-" + cpp_type2name(symbol.type);
+        tag_name = "tag-" + cpp_type2name(symbol.type);
       else
         UNREACHABLE;
+      type_symbolt ts{tag_name, symbol.type, symbol.mode};
       typet &type =
         copied_symbol_table.get_writeable_ref(named_symbol.first).type;
       if(ts.type.id() == ID_union)

src/util/fresh_symbol.cpp

@@ -48,10 +48,9 @@ symbolt &get_fresh_aux_symbol(
   identifier = get_new_name(identifier, ns, '$');
   std::string basename = id2string(identifier).substr(prefix_size);
 
-  auxiliary_symbolt new_symbol(basename, type);
-  new_symbol.name = identifier;
+  auxiliary_symbolt new_symbol(identifier, type, symbol_mode);
+  new_symbol.base_name = basename;
   new_symbol.location = source_location;
-  new_symbol.mode = symbol_mode;
   std::pair<symbolt &, bool> res = symbol_table.insert(std::move(new_symbol));
   CHECK_RETURN(res.second);
 

src/util/symbol.h

@@ -58,17 +58,39 @@ class symbolt
   }
 
   // global use
-  bool is_type, is_macro, is_exported,
-       is_input, is_output, is_state_var, is_property;
+  bool is_type = false;
+  bool is_macro = false;
+  bool is_exported = false;
+  bool is_input = false;
+  bool is_output = false;
+  bool is_state_var = false;
+  bool is_property = false;
 
   // ANSI-C
-  bool is_static_lifetime, is_thread_local;
-  bool is_lvalue, is_file_local, is_extern, is_volatile,
-       is_parameter, is_auxiliary, is_weak;
+  bool is_static_lifetime = false;
+  bool is_thread_local = false;
+  bool is_lvalue = false;
+  bool is_file_local = false;
+  bool is_extern = false;
+  bool is_volatile = false;
+  bool is_parameter = false;
+  bool is_auxiliary = false;
+  bool is_weak = false;
 
   symbolt()
+    : type(static_cast<const typet &>(get_nil_irep())),
+      value(static_cast<const exprt &>(get_nil_irep())),
+      location(source_locationt::nil())
+  {
+  }
+
+  symbolt(const irep_idt &_name, typet _type, const irep_idt &_mode)
+    : type(std::move(_type)),
+      value(static_cast<const exprt &>(get_nil_irep())),
+      location(source_locationt::nil()),
+      name(_name),
+      mode(_mode)
   {
-    clear();
   }
 
   /// Zero initialise a symbol object.
@@ -132,10 +154,10 @@ std::ostream &operator<<(std::ostream &out, const symbolt &symbol);
 class type_symbolt:public symbolt
 {
 public:
-  explicit type_symbolt(const typet &_type)
+  type_symbolt(const irep_idt &_name, typet _type, const irep_idt &_mode)
+    : symbolt(_name, _type, _mode)
   {
-    type=_type;
-    is_type=true;
+    is_type = true;
   }
 };
 
@@ -155,12 +177,14 @@ class auxiliary_symbolt:public symbolt
     is_auxiliary=true;
   }
 
-  auxiliary_symbolt(const irep_idt &name, const typet &type):
-    auxiliary_symbolt()
+  auxiliary_symbolt(const irep_idt &name, typet type, const irep_idt &mode)
+    : symbolt(name, type, mode)
   {
-    this->name=name;
-    this->base_name=name;
-    this->type=type;
+    is_lvalue = true;
+    is_state_var = true;
+    is_thread_local = true;
+    is_file_local = true;
+    is_auxiliary = true;
   }
 };