Unit tests: 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

unit/analyses/ai/ai.cpp

@@ -146,28 +146,16 @@ SCENARIO(
 
   // g:
 
-  symbolt gy;
-  gy.name = "gy";
-  gy.mode = ID_C;
-  gy.type = signed_int_type();
-
-  symbolt g;
-  g.name = "g";
-  g.mode = ID_C;
-  g.type = code_typet({}, empty_typet());
+  symbolt gy{"gy", signed_int_type(), ID_C};
+
+  symbolt g{"g", code_typet({}, empty_typet()), ID_C};
   g.value = code_assignt(gy.symbol_expr(), from_integer(0, signed_int_type()));
 
   // h:
 
-  symbolt hy;
-  hy.name = "hy";
-  hy.mode = ID_C;
-  hy.type = signed_int_type();
+  symbolt hy{"hy", signed_int_type(), ID_C};
 
-  symbolt h;
-  h.name = "h";
-  h.mode = ID_C;
-  h.type = code_typet({}, empty_typet());
+  symbolt h{"h", code_typet({}, empty_typet()), ID_C};
   h.value = code_assignt(hy.symbol_expr(), from_integer(0, signed_int_type()));
 
   goto_model.symbol_table.add(g);
@@ -177,15 +165,9 @@ SCENARIO(
 
   // f:
 
-  symbolt x;
-  x.name = "x";
-  x.mode = ID_C;
-  x.type = signed_int_type();
+  symbolt x{"x", signed_int_type(), ID_C};
 
-  symbolt y;
-  y.name = "y";
-  y.mode = ID_C;
-  y.type = signed_int_type();
+  symbolt y{"y", signed_int_type(), ID_C};
 
   goto_model.symbol_table.add(x);
   goto_model.symbol_table.add(y);
@@ -221,21 +203,16 @@ SCENARIO(
 
   f_body.copy_to_operands(make_void_call(g.symbol_expr()));
 
-  symbolt f;
-  f.name = "f";
-  f.mode = ID_C;
-  f.type = code_typet({}, empty_typet());
+  symbolt f{"f", code_typet({}, empty_typet()), ID_C};
   f.value = f_body;
 
   goto_model.symbol_table.add(f);
 
   // __CPROVER_start:
 
-  symbolt start;
-  start.name = goto_functionst::entry_point();
+  symbolt start{
+    goto_functionst::entry_point(), code_typet{{}, empty_typet{}}, ID_C};
   start.base_name = goto_functionst::entry_point();
-  start.mode = ID_C;
-  start.type = code_typet({}, empty_typet());
   start.value = make_void_call(f.symbol_expr());
 
   goto_model.symbol_table.add(start);

unit/analyses/constant_propagator.cpp

@@ -36,14 +36,8 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     // int x = 1;
     // int y = 2;
 
-    symbolt local_x;
-    symbolt local_y;
-    local_x.name = "x";
-    local_x.type = integer_typet();
-    local_x.mode = ID_C;
-    local_y.name = "y";
-    local_y.type = integer_typet();
-    local_y.mode = ID_C;
+    symbolt local_x{"x", integer_typet(), ID_C};
+    symbolt local_y{"y", integer_typet(), ID_C};
 
     code_blockt code(
       {code_declt(local_x.symbol_expr()),
@@ -53,11 +47,8 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
        code_assignt(
          local_y.symbol_expr(), constant_exprt("2", integer_typet()))});
 
-    symbolt main_function_symbol;
-    main_function_symbol.name = "main";
-    main_function_symbol.type = code_typet({}, empty_typet());
+    symbolt main_function_symbol{"main", code_typet({}, empty_typet()), ID_C};
     main_function_symbol.value = code;
-    main_function_symbol.mode = ID_C;
 
     goto_model.symbol_table.add(local_x);
     goto_model.symbol_table.add(local_y);
@@ -120,14 +111,8 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     goto_modelt goto_model;
     namespacet ns(goto_model.symbol_table);
 
-    symbolt bool_local;
-    symbolt c_bool_local;
-    bool_local.name = "bool_local";
-    bool_local.type = bool_typet();
-    bool_local.mode = ID_C;
-    c_bool_local.name = "c_bool_local";
-    c_bool_local.type = c_bool_typet(8);
-    c_bool_local.mode = ID_C;
+    symbolt bool_local{"bool_local", bool_typet(), ID_C};
+    symbolt c_bool_local{"c_bool_local", c_bool_typet(8), ID_C};
 
     code_blockt code({code_declt(bool_local.symbol_expr()),
                       code_declt(c_bool_local.symbol_expr())});
@@ -144,11 +129,8 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     code.add(std::move(bool_cond_block));
     code.add(std::move(c_bool_cond_block));
 
-    symbolt main_function_symbol;
-    main_function_symbol.name = "main";
-    main_function_symbol.type = code_typet({}, empty_typet());
+    symbolt main_function_symbol{"main", code_typet({}, empty_typet()), ID_C};
     main_function_symbol.value = code;
-    main_function_symbol.mode = ID_C;
 
     goto_model.symbol_table.add(bool_local);
     goto_model.symbol_table.add(c_bool_local);
@@ -216,19 +198,13 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
 
     for(size_t i = 0; i < n_bool_locals; ++i)
     {
-      symbolt bool_local;
-      bool_local.name = "b" + std::to_string(i);
-      bool_local.type = bool_typet();
-      bool_local.mode = ID_C;
+      symbolt bool_local{"b" + std::to_string(i), bool_typet(), ID_C};
       bool_locals.push_back(bool_local);
     }
 
     for(size_t i = 0; i < n_c_bool_locals; ++i)
     {
-      symbolt c_bool_local;
-      c_bool_local.name = "cb" + std::to_string(i);
-      c_bool_local.type = c_bool_typet(8);
-      c_bool_local.mode = ID_C;
+      symbolt c_bool_local{"cb" + std::to_string(i), c_bool_typet(8), ID_C};
       c_bool_locals.push_back(c_bool_local);
     }
 
@@ -272,10 +248,7 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     const bool c_bool_expectations[n_c_bool_locals] = {
       true, true, true, false, false, true, false, true};
 
-    symbolt marker_symbol;
-    marker_symbol.type = signedbv_typet(32);
-    marker_symbol.name = "marker";
-    marker_symbol.mode = ID_C;
+    symbolt marker_symbol{"marker", signedbv_typet(32), ID_C};
 
     codet program = code_assignt(
       marker_symbol.symbol_expr(), from_integer(1234, marker_symbol.type));
@@ -294,11 +267,8 @@ SCENARIO("constant_propagator", "[core][analyses][constant_propagator]")
     for(const symbolt &symbol : c_bool_locals)
       goto_model.symbol_table.add(symbol);
 
-    symbolt main_function_symbol;
-    main_function_symbol.name = "main";
-    main_function_symbol.type = code_typet({}, empty_typet());
+    symbolt main_function_symbol{"main", code_typet({}, empty_typet()), ID_C};
     main_function_symbol.value = program;
-    main_function_symbol.mode = ID_C;
 
     goto_model.symbol_table.add(marker_symbol);
     goto_model.symbol_table.add(main_function_symbol);

unit/analyses/dependence_graph.cpp

@@ -53,10 +53,9 @@ SCENARIO("dependence_graph", "[core][analyses][dependence_graph]")
 
     typet int_type = signed_int_type();
 
-    symbolt x_symbol;
-    x_symbol.name = id2string(goto_functionst::entry_point()) + "::x";
+    symbolt x_symbol{
+      id2string(goto_functionst::entry_point()) + "::x", int_type, ID_C};
     x_symbol.base_name = "x";
-    x_symbol.type = int_type;
     x_symbol.is_lvalue = true;
     x_symbol.is_state_var = true;
     x_symbol.is_thread_local = true;

unit/analyses/variable-sensitivity/eval.cpp

@@ -14,9 +14,8 @@
 
 static symbolt simple_symbol(const irep_idt &identifier, const typet &type)
 {
-  symbolt b1;
-  b1.name = b1.base_name = b1.pretty_name = identifier;
-  b1.type = type;
+  symbolt b1{identifier, type, irep_idt{}};
+  b1.base_name = b1.pretty_name = identifier;
   return b1;
 }
 

unit/goto-programs/goto_program_assume.cpp

@@ -23,21 +23,18 @@ SCENARIO(
   {
     symbol_tablet symbol_table;
     const typet type1 = signedbv_typet(32);
-    symbolt symbol;
-    symbolt fun_symbol;
+    symbolt symbol{"a", type1, ID_C};
     irep_idt fun_name = "foo";
+    symbolt fun_symbol;
     fun_symbol.name = fun_name;
-    irep_idt symbol_name = "a";
-    symbol.name = symbol_name;
-    symbol_exprt varx(symbol_name, type1);
+    symbol_exprt varx = symbol.symbol_expr();
     exprt val10 = from_integer(10, type1);
     binary_relation_exprt x_le_10(varx, ID_le, val10);
 
     goto_functiont goto_function;
     auto assertion =
       goto_function.body.add(goto_programt::make_assertion(x_le_10));
 
-    symbol.type = type1;
     symbol_table.insert(symbol);
     symbol_table.insert(fun_symbol);
     namespacet ns(symbol_table);

unit/goto-programs/goto_program_dead.cpp

@@ -27,11 +27,8 @@ SCENARIO(
     irep_idt fun_name = "foo";
     fun_symbol.name = fun_name;
 
-    symbolt var_symbol;
-    irep_idt var_symbol_name = "a";
-    var_symbol.type = type1;
-    var_symbol.name = var_symbol_name;
-    symbol_exprt var_a(var_symbol_name, type1);
+    symbolt var_symbol{"a", type1, irep_idt{}};
+    symbol_exprt var_a = var_symbol.symbol_expr();
 
     goto_functiont goto_function;
     auto &instructions = goto_function.body.instructions;

unit/goto-programs/goto_program_declaration.cpp

@@ -27,11 +27,8 @@ SCENARIO(
     irep_idt fun_name = "foo";
     fun_symbol.name = fun_name;
 
-    symbolt var_symbol;
-    irep_idt var_symbol_name = "a";
-    var_symbol.type = type1;
-    var_symbol.name = var_symbol_name;
-    symbol_exprt var_a(var_symbol_name, type1);
+    symbolt var_symbol{"a", type1, irep_idt{}};
+    symbol_exprt var_a = var_symbol.symbol_expr();
 
     goto_functiont goto_function;
     goto_function.body.add(goto_programt::make_decl(var_a));

unit/goto-programs/goto_program_function_call.cpp

@@ -25,28 +25,19 @@ SCENARIO(
     const signedbv_typet type2(64);
     const code_typet code_type({}, type1);
 
-    symbolt var_symbol;
-    irep_idt var_symbol_name = "a";
-    var_symbol.name = var_symbol_name;
-    symbol_exprt var_a(var_symbol_name, type1);
-
-    symbolt var_symbol2;
-    irep_idt var_symbol_name2 = "b";
-    var_symbol2.name = var_symbol_name2;
-    symbol_exprt var_b(var_symbol_name2, type2);
-
-    symbolt fun_symbol;
-    irep_idt fun_symbol_name = "foo";
-    fun_symbol.name = fun_symbol_name;
-    fun_symbol.type = code_type;
-    symbol_exprt fun_foo(fun_symbol_name, code_type);
+    symbolt var_symbol{"a", type1, irep_idt{}};
+    symbol_exprt var_a = var_symbol.symbol_expr();
+
+    symbolt var_symbol2{"b", type2, irep_idt{}};
+    symbol_exprt var_b = var_symbol2.symbol_expr();
+
+    symbolt fun_symbol{"foo", code_type, irep_idt{}};
+    symbol_exprt fun_foo = fun_symbol.symbol_expr();
 
     goto_functiont goto_function;
     auto &instructions = goto_function.body.instructions;
     instructions.emplace_back(goto_program_instruction_typet::FUNCTION_CALL);
 
-    var_symbol.type = type1;
-    var_symbol2.type = type2;
     symbol_table.insert(var_symbol);
     symbol_table.insert(var_symbol2);
     symbol_table.insert(fun_symbol);

unit/goto-programs/goto_program_goto_target.cpp

@@ -27,10 +27,8 @@ SCENARIO(
     irep_idt fun_name = "foo";
     fun_symbol.name = fun_name;
 
-    symbolt symbol;
-    irep_idt symbol_name = "a";
-    symbol.name = symbol_name;
-    symbol_exprt varx(symbol_name, type1);
+    symbolt symbol{"a", type1, irep_idt{}};
+    symbol_exprt varx = symbol.symbol_expr();
     exprt val10 = from_integer(10, type1);
     binary_relation_exprt x_le_10(varx, ID_le, val10);
 
@@ -41,7 +39,6 @@ SCENARIO(
     instructions.emplace_back(
       goto_programt::make_goto(instructions.begin(), true_exprt()));
 
-    symbol.type = type1;
     symbol_table.insert(symbol);
     symbol_table.insert(fun_symbol);
     namespacet ns(symbol_table);

unit/goto-programs/goto_program_validate.cpp

@@ -28,60 +28,38 @@ SCENARIO("Validation of a goto program", "[core][goto-programs][validate]")
   goto_modelt goto_model;
 
   // void f(){int x = 1;}
-  symbolt x;
-  x.name = "x";
-  x.mode = ID_C;
-  x.type = signed_int_type();
+  symbolt x{"x", signed_int_type(), ID_C};
   goto_model.symbol_table.add(x);
 
-  symbolt f;
-  f.name = "f";
-  f.mode = ID_C;
-  f.type = code_typet({}, empty_typet()); // void rtn, take no params
+  // void rtn, take no params
+  symbolt f{"f", code_typet({}, empty_typet()), ID_C};
   code_blockt f_body{
     {code_declt(x.symbol_expr()),
      code_assignt(x.symbol_expr(), from_integer(1, signed_int_type()))}};
-
   f.value = f_body;
   goto_model.symbol_table.add(f);
 
   // void g(){int y = 2;}
-  symbolt y;
-  y.name = "y";
-  y.mode = ID_C;
-  y.type = signed_int_type();
+  symbolt y{"y", signed_int_type(), ID_C};
   goto_model.symbol_table.add(y);
 
-  symbolt g;
-  g.name = "g";
-  g.mode = ID_C;
-  g.type = code_typet({}, empty_typet());
-
+  symbolt g{"g", code_typet({}, empty_typet()), ID_C};
   code_blockt g_body{
     {code_declt{y.symbol_expr()},
      code_assignt{y.symbol_expr(), from_integer(2, signed_int_type())}}};
-
   g.value = g_body;
   goto_model.symbol_table.add(g);
 
-  symbolt z;
-  z.name = "z";
-  z.mode = ID_C;
-  z.type = signed_int_type();
+  symbolt z{"z", signed_int_type(), ID_C};
   goto_model.symbol_table.add(z);
 
-  symbolt fn_ptr;
-  fn_ptr.name = "fn_ptr";
-  fn_ptr.mode = ID_C;
-
   // pointer to fn call
-  fn_ptr.type = pointer_typet(code_typet{{}, empty_typet()}, 64);
+  symbolt fn_ptr{
+    "fn_ptr", pointer_typet(code_typet{{}, empty_typet()}, 64), ID_C};
   goto_model.symbol_table.add(fn_ptr);
 
-  symbolt entry_point;
-  entry_point.name = goto_functionst::entry_point();
-  entry_point.mode = ID_C;
-  entry_point.type = code_typet({}, empty_typet{});
+  symbolt entry_point{
+    goto_functionst::entry_point(), code_typet({}, empty_typet{}), ID_C};
   code_blockt entry_point_body{
     {code_declt{z.symbol_expr()},
      code_assignt{z.symbol_expr(), from_integer(3, signed_int_type())},