[NFC] Extract out function for parseModuleBody (#8080)

For use in #8058. In some cases (e.g. for parsing `(module definition
...)`), we want to parse the body of a module without the initial
`(module name? ...)` S-expression. `parseModule` parses *either* the
full `(module ...)` S-expression or just the module body since some
cases consist only of a module body. Add `parseModuleBody` which only
parses the module body.

Author: stevenfontanella

src/parser/parse-1-decls.cpp

@@ -18,6 +18,8 @@
 
 namespace wasm::WATParser {
 
-Result<> parseDecls(ParseDeclsCtx& decls) { return module(decls); }
+Result<> parseModule(ParseDeclsCtx& decls) { return module(decls); }
+
+Result<> parseModuleBody(ParseDeclsCtx& decls) { return moduleBody(decls); }
 
 } // namespace wasm::WATParser

src/parser/parsers.h

@@ -3882,6 +3882,15 @@ template<typename Ctx> MaybeResult<> modulefield(Ctx& ctx) {
   return ctx.in.err("unrecognized module field");
 }
 
+// (m:modulefield)*
+template<typename Ctx> Result<> moduleBody(Ctx& ctx) {
+  while (auto field = modulefield(ctx)) {
+    CHECK_ERR(field);
+  }
+
+  return Ok{};
+}
+
 // module ::= '(' 'module' id? (m:modulefield)* ')'
 //          | (m:modulefield)* eof
 template<typename Ctx> Result<> module(Ctx& ctx) {
@@ -3893,9 +3902,7 @@ template<typename Ctx> Result<> module(Ctx& ctx) {
     }
   }
 
-  while (auto field = modulefield(ctx)) {
-    CHECK_ERR(field);
-  }
+  CHECK_ERR(moduleBody(ctx));
 
   if (outer && !ctx.in.takeRParen()) {
     return ctx.in.err("expected end of module");

src/parser/wat-parser-internal.h

@@ -22,7 +22,9 @@
 
 namespace wasm::WATParser {
 
-Result<> parseDecls(ParseDeclsCtx& decls);
+Result<> parseModule(ParseDeclsCtx& decls);
+
+Result<> parseModuleBody(ParseDeclsCtx& decls);
 
 Result<> parseTypeDefs(
   ParseDeclsCtx& decls,

src/parser/wat-parser.cpp

@@ -83,58 +83,75 @@ void propagateDebugLocations(Module& wasm) {
   runner.run();
 }
 
-// Parse module-level declarations.
-
-// Parse type definitions.
-
-// Parse implicit type definitions and map typeuses without explicit types to
-// the correct types.
-
-Result<> doParseModule(Module& wasm, Lexer& input, bool allowExtra) {
-  ParseDeclsCtx decls(input, wasm);
-  CHECK_ERR(parseDecls(decls));
-  if (!allowExtra && !decls.in.empty()) {
-    return decls.in.err("Unexpected tokens after module");
-  }
-
+// After doing the initial pass, parse types, imports, etc.
+Result<> parseModuleWithDecls(ParseDeclsCtx& decls) {
   auto typeIndices = createIndexMap(decls.in, decls.typeDefs);
   CHECK_ERR(typeIndices);
 
   std::vector<HeapType> types;
   std::unordered_map<HeapType, std::unordered_map<Name, Index>> typeNames;
-  CHECK_ERR(parseTypeDefs(decls, input, *typeIndices, types, typeNames));
+  CHECK_ERR(parseTypeDefs(decls, decls.in, *typeIndices, types, typeNames));
 
+  // Parse implicit type definitions and map typeuses without explicit types to
+  // the correct types.
   std::unordered_map<Index, HeapType> implicitTypes;
   CHECK_ERR(
-    parseImplicitTypeDefs(decls, input, *typeIndices, types, implicitTypes));
+    parseImplicitTypeDefs(decls, decls.in, *typeIndices, types, implicitTypes));
 
-  CHECK_ERR(parseModuleTypes(decls, input, *typeIndices, types, implicitTypes));
+  CHECK_ERR(
+    parseModuleTypes(decls, decls.in, *typeIndices, types, implicitTypes));
 
   CHECK_ERR(parseDefinitions(
-    decls, input, *typeIndices, types, implicitTypes, typeNames));
+    decls, decls.in, *typeIndices, types, implicitTypes, typeNames));
 
-  propagateDebugLocations(wasm);
-  input = decls.in;
+  propagateDebugLocations(decls.wasm);
 
   return Ok{};
 }
 
+Result<> doParseModule(Module& wasm, Lexer& input, bool allowExtra) {
+  ParseDeclsCtx decls(input, wasm);
+  CHECK_ERR(parseModule(decls));
+  if (!allowExtra && !decls.in.empty()) {
+    return decls.in.err("Unexpected tokens after module");
+  }
+
+  CHECK_ERR(parseModuleWithDecls(decls));
+
+  // decls / parseModule made a copy of `input`. Advance `input` past the parsed
+  // module.
+  input = decls.in;
+  return Ok{};
+}
+
 } // anonymous namespace
 
 Result<> parseModule(Module& wasm,
                      std::string_view in,
                      std::optional<std::string> filename) {
   Lexer lexer(in, filename);
-  return doParseModule(wasm, lexer, false);
+  return doParseModule(wasm, lexer, /*allowExtra=*/false);
 }
 
 Result<> parseModule(Module& wasm, std::string_view in) {
   Lexer lexer(in);
-  return doParseModule(wasm, lexer, false);
+  return doParseModule(wasm, lexer, /*allowExtra=*/false);
 }
 
 Result<> parseModule(Module& wasm, Lexer& lexer) {
-  return doParseModule(wasm, lexer, true);
+  return doParseModule(wasm, lexer, /*allowExtra=*/true);
+}
+
+Result<> parseModuleBody(Module& wasm, Lexer& lexer) {
+  ParseDeclsCtx decls(lexer, wasm);
+  CHECK_ERR(parseModuleBody(decls));
+  CHECK_ERR(parseModuleWithDecls(decls));
+
+  // decls / parseModuleBody made a copy of `input`. Advance `input` past the
+  // parsed module.
+  lexer = decls.in;
+
+  return Ok{};
 }
 
 } // namespace wasm::WATParser

src/parser/wat-parser.h

@@ -34,6 +34,11 @@ Result<> parseModule(Module& wasm,
 // file.
 Result<> parseModule(Module& wasm, Lexer& lexer);
 
+// Similar to `parseModule`, parse the fields of a single WAT module (after the
+// initial module definition including its name) and stop at the ending right
+// paren.
+Result<> parseModuleBody(Module& wasm, Lexer& lexer);
+
 Result<Literal> parseConst(Lexer& lexer);
 
 #pragma GCC diagnostic push