wast-parser: add support for '(module definition ...)'

WASM v3 spec tests added the '(module definition ...)' construct to
WAST. This tells the test runner that the module should not be
instantiated immediately. The '(module instance ...)' construct (not yet
supported in wabt) instructs the test runner to instantiate the module.

This change adds an `is_definition` field to ScriptModule. The field
reflects whether the `definition` keyword was encountered after the
`module` keyword.

When WastParser encounters a TextModule in a script command, it now
returns a ScriptModule with the corresponding ScriptTextModule if the
module is definition-only.

Author: sjamesr

include/wabt/ir.h

@@ -1368,6 +1368,8 @@ class ScriptModule {
   ScriptModuleType type() const { return type_; }
   virtual const Location& location() const = 0;
 
+  bool is_definition = false;
+
  protected:
   explicit ScriptModule(ScriptModuleType type) : type_(type) {}
 

include/wabt/token.def

@@ -34,6 +34,7 @@ WABT_TOKEN(Bin, "bin")
 WABT_TOKEN(Item, "item")
 WABT_TOKEN(Data, "data")
 WABT_TOKEN(Declare, "declare")
+WABT_TOKEN(Definition, "definition")
 WABT_TOKEN(Delegate, "delegate")
 WABT_TOKEN(Do, "do")
 WABT_TOKEN(Either, "either")

include/wabt/wast-parser.h

@@ -160,6 +160,7 @@ class WastParser {
   Result Synchronize(SynchronizeFunc);
 
   bool ParseBindVarOpt(std::string* name);
+  bool ParseDefinitionOpt();
   Result ParseVar(Var* out_var);
   bool ParseVarOpt(Var* out_var, Var default_var = Var());
   Result ParseOffsetExpr(ExprList* out_expr_list);

src/lexer-keywords.txt

@@ -46,6 +46,7 @@ code, TokenType::Code
 data.drop, TokenType::DataDrop, Opcode::DataDrop
 data, TokenType::Data
 declare, TokenType::Declare
+definition, TokenType::Definition
 delegate, TokenType::Delegate
 do, TokenType::Do
 drop, TokenType::Drop, Opcode::Drop

src/prebuilt/lexer-keywords.cc

@@ -117,3 +117,22 @@ TEST(WastParser, InvalidBinaryModule) {
 
   EXPECT_EQ(expected_data, binary_mod->data);
 }
+
+TEST(WastParser, ModuleDefinition) {
+  std::string text = "(module definition)";
+
+  Errors errors;
+  auto lexer =
+      WastLexer::CreateBufferLexer("test", text.c_str(), text.size(), &errors);
+  Features features;
+  WastParseOptions options(features);
+
+  std::unique_ptr<Script> script;
+  Result result = ParseWastScript(lexer.get(), &script, &errors, &options);
+  ASSERT_EQ(result, Result::Ok);
+  ASSERT_EQ(script->commands.size(), 1U);
+  Command* cmd = script->commands[0].get();
+  auto* mod_cmd = cast<ScriptModuleCommand>(cmd);
+  ASSERT_NE(mod_cmd, nullptr);
+  ASSERT_TRUE(mod_cmd->script_module->is_definition);
+}

src/test-wast-parser.cc

@@ -749,6 +749,15 @@ bool WastParser::ParseBindVarOpt(std::string* name) {
   return true;
 }
 
+bool WastParser::ParseDefinitionOpt() {
+  WABT_TRACE(ParseDefinitionOpt);
+  if (!PeekMatch(TokenType::Definition)) {
+    return false;
+  }
+  (void)Consume();
+  return true;
+}
+
 Result WastParser::ParseVar(Var* out_var) {
   WABT_TRACE(ParseVar);
   if (PeekMatch(TokenType::Nat)) {
@@ -3664,10 +3673,18 @@ Result WastParser::ParseModuleCommand(Script* script, CommandPtr* out_command) {
 
   switch (script_module->type()) {
     case ScriptModuleType::Text: {
-      auto command = std::make_unique<ModuleCommand>();
-      module = &command->module;
-      *module = std::move(cast<TextScriptModule>(script_module.get())->module);
-      *out_command = std::move(command);
+      if (script_module->is_definition) {
+        auto command = std::make_unique<ScriptModuleCommand>();
+        module = &command->module;
+        *module = std::move(cast<TextScriptModule>(script_module.get())->module);
+        command->script_module = std::move(script_module);
+        *out_command = std::move(command);
+      } else {
+        auto command = std::make_unique<ModuleCommand>();
+        module = &command->module;
+        *module = std::move(cast<TextScriptModule>(script_module.get())->module);
+        *out_command = std::move(command);
+      }
       break;
     }
 
@@ -3852,6 +3869,9 @@ Result WastParser::ParseScriptModule(
   EXPECT(Lpar);
   Location loc = GetLocation();
   EXPECT(Module);
+
+  bool is_definition = ParseDefinitionOpt();
+
   std::string name;
   ParseBindVarOpt(&name);
 
@@ -3867,6 +3887,7 @@ Result WastParser::ParseScriptModule(
       bsm->name = name;
       bsm->loc = loc;
       bsm->data = std::move(data);
+      bsm->is_definition = is_definition;
       *out_module = std::move(bsm);
       break;
     }
@@ -3882,6 +3903,7 @@ Result WastParser::ParseScriptModule(
       qsm->name = name;
       qsm->loc = loc;
       qsm->data = std::move(data);
+      qsm->is_definition = is_definition;
       *out_module = std::move(qsm);
       break;
     }
@@ -3890,6 +3912,7 @@ Result WastParser::ParseScriptModule(
       auto tsm = std::make_unique<TextScriptModule>();
       tsm->module.name = name;
       tsm->module.loc = loc;
+      tsm->is_definition = is_definition;
       if (IsModuleField(PeekPair()) || PeekIsCustom()) {
         CHECK_RESULT(ParseModuleFieldList(&tsm->module));
       } else if (!PeekMatch(TokenType::Rpar)) {