[NFC] Skip parsing instructions in first parser pass (#8601)

The first parser pass is responsible for two things: finding the
locations of definitions of top-level module items like globals and
functions and finding the locations of implicit function type
definitions. It previously accomplished the latter by fully parsing
every instruction in each function. But the IR is not constructed in
this phase of parsing, so fully parsing every instruction was largely
wasted work. Optimize the parser by parsing only the instructions that
might have implicit type definitions and otherwise just blindly match
parentheses to skip the function body. Combined with #8597, this speeds
up parsing by 30-40%.

Author: tlively

src/parser/context-decls.cpp

@@ -15,6 +15,7 @@
  */
 
 #include "contexts.h"
+#include "parsers.h"
 
 namespace wasm::WATParser {
 
@@ -302,4 +303,36 @@ Result<> ParseDeclsCtx::addTag(Name name,
   return Ok{};
 }
 
+bool ParseDeclsCtx::skipFunctionBody() {
+  using namespace std::string_view_literals;
+  size_t depth = 1;
+  while (depth > 0 && !in.empty()) {
+    if (in.takeLParen()) {
+      ++depth;
+      continue;
+    }
+    if (in.takeRParen()) {
+      --depth;
+      continue;
+    }
+    if (auto kw = in.takeKeyword()) {
+      if (*kw == "block"sv || *kw == "loop"sv || *kw == "if"sv ||
+          *kw == "try"sv || *kw == "try_table"sv) {
+        in.takeID();
+        (void)typeuse(*this);
+        continue;
+      }
+      if (*kw == "call_indirect"sv || *kw == "return_call_indirect"sv) {
+        (void)maybeTableidx(*this);
+        (void)typeuse(*this, false);
+        continue;
+      }
+      continue;
+    }
+    in.take(1);
+    in.advance();
+  }
+  return true;
+}
+
 } // namespace wasm::WATParser

src/parser/contexts.h

@@ -1074,6 +1074,8 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
     recTypeDefs.push_back({{}, pos, Index(recTypeDefs.size()), {}});
   }
 
+  bool skipFunctionBody();
+
   Limits makeLimits(uint64_t n, std::optional<uint64_t> m) {
     return Limits{n, m};
   }

src/parser/lexer.h

@@ -82,6 +82,15 @@ struct Lexer {
     advance();
   }
 
+  // Consume the next `n` characters.
+  void take(size_t n) { pos += n; }
+  void takeAll() { pos = buffer.size(); }
+
+  // Whether the unlexed input starts with prefix `sv`.
+  size_t startsWith(std::string_view sv) const {
+    return next().starts_with(sv);
+  }
+
   std::optional<char> peekChar() const;
 
   bool peekLParen() { return !empty() && peek() == '('; }
@@ -155,15 +164,6 @@ struct Lexer {
   }
 
 private:
-  // Whether the unlexed input starts with prefix `sv`.
-  size_t startsWith(std::string_view sv) const {
-    return next().starts_with(sv);
-  }
-
-  // Consume the next `n` characters.
-  void take(size_t n) { pos += n; }
-  void takeAll() { pos = buffer.size(); }
-
   std::optional<int> getDigit(char c);
 
   std::optional<int> getHexDigit(char c);

src/parser/parsers.h

@@ -3491,6 +3491,7 @@ template<typename Ctx> MaybeResult<> func(Ctx& ctx) {
   typename Ctx::TypeUseT type;
   Exactness exact = Exact;
   std::optional<typename Ctx::LocalsT> localVars;
+  bool skipped = false;
 
   if (import) {
     auto use = exacttypeuse(ctx);
@@ -3505,13 +3506,14 @@ template<typename Ctx> MaybeResult<> func(Ctx& ctx) {
       CHECK_ERR(l);
       localVars = *l;
     }
-    if (!ctx.skipFunctionBody()) {
+    skipped = ctx.skipFunctionBody();
+    if (!skipped) {
       CHECK_ERR(instrs(ctx));
       ctx.setSrcLoc(ctx.in.takeAnnotations());
     }
   }
 
-  if (!ctx.skipFunctionBody() && !ctx.in.takeRParen()) {
+  if ((import || !skipped) && !ctx.in.takeRParen()) {
     return ctx.in.err("expected end of function");
   }