Replace wabt::*vector with std::vector (#366)

This propagates through a lot of code since std::vector will call
constructors and destructors. In particular, this CL adds many default
constructors and destructors to previously POD types. Many of them are
only there to construct `Var` and `StringSlice` types, so they likely
can be removed when those have their own constructors.

Since unions members cannot contain constructors or destructors
(without additional implementation), this CL changes those members to
pointers instead. (Perhaps in a future CL these will be std::variant
instead of union, so the members can be value types again.)

1 files changed, 43 insertions, 43 deletions

diff --git a/src/binary-writer-spec.cc b/src/binary-writer-spec.cc
index 252ff99d..dac091a3 100644
--- a/src/binary-writer-spec.cc
+++ b/src/binary-writer-spec.cc
@@ -135,7 +135,7 @@ static void write_escaped_string_slice(Context* ctx, StringSlice ss) {
   write_char(&ctx->json_stream, '"');
 }
 
-static void write_command_type(Context* ctx, const Command* command) {
+static void write_command_type(Context* ctx, const Command& command) {
   static const char* s_command_names[] = {
       "module", "action", "register", "assert_malformed", "assert_invalid",
       nullptr, /* ASSERT_INVALID_NON_BINARY, this command will never be
@@ -146,8 +146,8 @@ static void write_command_type(Context* ctx, const Command* command) {
   WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_command_names) == kCommandTypeCount);
 
   write_key(ctx, "type");
-  assert(s_command_names[static_cast<size_t>(command->type)]);
-  write_string(ctx, s_command_names[static_cast<size_t>(command->type)]);
+  assert(s_command_names[static_cast<size_t>(command.type)]);
+  write_string(ctx, s_command_names[static_cast<size_t>(command.type)]);
 }
 
 static void write_location(Context* ctx, const Location* loc) {
@@ -215,12 +215,12 @@ static void write_const(Context* ctx, const Const* const_) {
   writef(&ctx->json_stream, "}");
 }
 
-static void write_const_vector(Context* ctx, const ConstVector* consts) {
+static void write_const_vector(Context* ctx, const ConstVector& consts) {
   writef(&ctx->json_stream, "[");
-  for (size_t i = 0; i < consts->size; ++i) {
-    const Const* const_ = &consts->data[i];
+  for (size_t i = 0; i < consts.size(); ++i) {
+    const Const* const_ = &consts[i];
     write_const(ctx, const_);
-    if (i != consts->size - 1)
+    if (i != consts.size() - 1)
       write_separator(ctx);
   }
   writef(&ctx->json_stream, "]");
@@ -244,13 +244,13 @@ static void write_action(Context* ctx, const Action* action) {
   }
   if (action->type == ActionType::Invoke) {
     write_key(ctx, "field");
-    write_escaped_string_slice(ctx, action->invoke.name);
+    write_escaped_string_slice(ctx, action->name);
     write_separator(ctx);
     write_key(ctx, "args");
-    write_const_vector(ctx, &action->invoke.args);
+    write_const_vector(ctx, action->invoke->args);
   } else {
     write_key(ctx, "field");
-    write_escaped_string_slice(ctx, action->get.name);
+    write_escaped_string_slice(ctx, action->name);
   }
   writef(&ctx->json_stream, "}");
 }
@@ -263,7 +263,7 @@ static void write_action_result_type(Context* ctx,
   writef(&ctx->json_stream, "[");
   switch (action->type) {
     case ActionType::Invoke: {
-      export_ = get_export_by_name(module, &action->invoke.name);
+      export_ = get_export_by_name(module, &action->name);
       assert(export_->kind == ExternalKind::Func);
       Func* func = get_func_by_var(module, &export_->var);
       size_t num_results = get_num_results(func);
@@ -273,7 +273,7 @@ static void write_action_result_type(Context* ctx,
     }
 
     case ActionType::Get: {
-      export_ = get_export_by_name(module, &action->get.name);
+      export_ = get_export_by_name(module, &action->name);
       assert(export_->kind == ExternalKind::Global);
       Global* global = get_global_by_var(module, &export_->var);
       write_type_object(ctx, global->type);
@@ -335,10 +335,10 @@ static void write_commands(Context* ctx, Script* script) {
   write_escaped_string_slice(ctx, ctx->source_filename);
   writef(&ctx->json_stream, ",\n \"commands\": [\n");
   int last_module_index = -1;
-  for (size_t i = 0; i < script->commands.size; ++i) {
-    Command* command = &script->commands.data[i];
+  for (size_t i = 0; i < script->commands.size(); ++i) {
+    const Command& command = *script->commands[i].get();
 
-    if (command->type == CommandType::AssertInvalidNonBinary)
+    if (command.type == CommandType::AssertInvalidNonBinary)
       continue;
 
     if (i != 0)
@@ -349,9 +349,9 @@ static void write_commands(Context* ctx, Script* script) {
     write_command_type(ctx, command);
     write_separator(ctx);
 
-    switch (command->type) {
+    switch (command.type) {
       case CommandType::Module: {
-        Module* module = command->module;
+        Module* module = command.module;
         char* filename = get_module_filename(ctx);
         write_location(ctx, &module->loc);
         write_separator(ctx);
@@ -370,84 +370,84 @@ static void write_commands(Context* ctx, Script* script) {
       }
 
       case CommandType::Action:
-        write_location(ctx, &command->action.loc);
+        write_location(ctx, &command.action->loc);
         write_separator(ctx);
-        write_action(ctx, &command->action);
+        write_action(ctx, command.action);
         break;
 
       case CommandType::Register:
-        write_location(ctx, &command->register_.var.loc);
+        write_location(ctx, &command.register_.var.loc);
         write_separator(ctx);
-        if (command->register_.var.type == VarType::Name) {
+        if (command.register_.var.type == VarType::Name) {
           write_key(ctx, "name");
-          write_var(ctx, &command->register_.var);
+          write_var(ctx, &command.register_.var);
           write_separator(ctx);
         } else {
           /* If we're not registering by name, then we should only be
            * registering the last module. */
           WABT_USE(last_module_index);
-          assert(command->register_.var.index == last_module_index);
+          assert(command.register_.var.index == last_module_index);
         }
         write_key(ctx, "as");
-        write_escaped_string_slice(ctx, command->register_.module_name);
+        write_escaped_string_slice(ctx, command.register_.module_name);
         break;
 
       case CommandType::AssertMalformed:
-        write_invalid_module(ctx, &command->assert_malformed.module,
-                             command->assert_malformed.text);
+        write_invalid_module(ctx, command.assert_malformed.module,
+                             command.assert_malformed.text);
         ctx->num_modules++;
         break;
 
       case CommandType::AssertInvalid:
-        write_invalid_module(ctx, &command->assert_invalid.module,
-                             command->assert_invalid.text);
+        write_invalid_module(ctx, command.assert_invalid.module,
+                             command.assert_invalid.text);
         ctx->num_modules++;
         break;
 
       case CommandType::AssertUnlinkable:
-        write_invalid_module(ctx, &command->assert_unlinkable.module,
-                             command->assert_unlinkable.text);
+        write_invalid_module(ctx, command.assert_unlinkable.module,
+                             command.assert_unlinkable.text);
         ctx->num_modules++;
         break;
 
       case CommandType::AssertUninstantiable:
-        write_invalid_module(ctx, &command->assert_uninstantiable.module,
-                             command->assert_uninstantiable.text);
+        write_invalid_module(ctx, command.assert_uninstantiable.module,
+                             command.assert_uninstantiable.text);
         ctx->num_modules++;
         break;
 
       case CommandType::AssertReturn:
-        write_location(ctx, &command->assert_return.action.loc);
+        write_location(ctx, &command.assert_return.action->loc);
         write_separator(ctx);
-        write_action(ctx, &command->assert_return.action);
+        write_action(ctx, command.assert_return.action);
         write_separator(ctx);
         write_key(ctx, "expected");
-        write_const_vector(ctx, &command->assert_return.expected);
+        write_const_vector(ctx, *command.assert_return.expected);
         break;
 
       case CommandType::AssertReturnNan:
-        write_location(ctx, &command->assert_return_nan.action.loc);
+        write_location(ctx, &command.assert_return_nan.action->loc);
         write_separator(ctx);
-        write_action(ctx, &command->assert_return_nan.action);
+        write_action(ctx, command.assert_return_nan.action);
         write_separator(ctx);
         write_key(ctx, "expected");
         write_action_result_type(ctx, script,
-                                 &command->assert_return_nan.action);
+                                 command.assert_return_nan.action);
         break;
 
       case CommandType::AssertTrap:
-        write_location(ctx, &command->assert_trap.action.loc);
+        write_location(ctx, &command.assert_trap.action->loc);
         write_separator(ctx);
-        write_action(ctx, &command->assert_trap.action);
+        write_action(ctx, command.assert_trap.action);
         write_separator(ctx);
         write_key(ctx, "text");
-        write_escaped_string_slice(ctx, command->assert_trap.text);
+        write_escaped_string_slice(ctx, command.assert_trap.text);
         break;
 
       case CommandType::AssertExhaustion:
-        write_location(ctx, &command->assert_trap.action.loc);
+        write_location(ctx, &command.assert_trap.action->loc);
         write_separator(ctx);
-        write_action(ctx, &command->assert_trap.action);
+        write_action(ctx, command.assert_trap.action);
         break;
 
       case CommandType::AssertInvalidNonBinary: