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

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/test-wast-parser.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/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,20 @@ 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 +3871,9 @@ Result WastParser::ParseScriptModule(
   EXPECT(Lpar);
   Location loc = GetLocation();
   EXPECT(Module);
+
+  bool is_definition = ParseDefinitionOpt();
+
   std::string name;
   ParseBindVarOpt(&name);
 
@@ -3867,6 +3889,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 +3905,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 +3914,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)) {