Switch source map parsing to use the JSON parser (#7467)

This is in preparation for fixing #6805.
Aside from cleaning up and reusing more code, it allows optional fields
in the
source map and random access to those fields, rather than walking
through
the whole JSON file just once. (It does keep the current behavior of
walking through the actual mappings in a single pass synchronized with
reading
the binary). It also adds some unit tests.

Author: dschuff

src/source-map.h

@@ -18,7 +18,6 @@
 #define wasm_source_map_h
 
 #include <optional>
-#include <unordered_map>
 
 #include "wasm.h"
 
@@ -32,7 +31,8 @@ struct MapParseException {
 };
 
 class SourceMapReader {
-  const std::vector<char>& buffer;
+  std::vector<char>& buffer;
+  std::string_view mappings;
 
   // Current position in the source map buffer.
   size_t pos = 0;
@@ -53,9 +53,9 @@ class SourceMapReader {
   bool hasSymbol = false;
 
 public:
-  SourceMapReader(const std::vector<char>& buffer) : buffer(buffer) {}
+  SourceMapReader(std::vector<char>& buffer) : buffer(buffer) {}
 
-  void readHeader(Module& wasm);
+  void parse(Module& wasm);
 
   std::optional<Function::DebugLocation>
   readDebugLocationAt(size_t currLocation);
@@ -65,10 +65,12 @@ class SourceMapReader {
 
 private:
   char peek() {
-    if (pos >= buffer.size()) {
+    if (pos == mappings.size()) {
+      return '"';
+    } else if (pos > mappings.size()) {
       throw MapParseException("unexpected end of source map");
     }
-    return buffer[pos];
+    return mappings[pos];
   }
 
   char get() {
@@ -77,22 +79,6 @@ class SourceMapReader {
     return c;
   }
 
-  bool maybeGet(char c) {
-    if (pos < buffer.size() && peek() == c) {
-      ++pos;
-      return true;
-    }
-    return false;
-  }
-
-  void expect(char c) {
-    using namespace std::string_literals;
-    char got = get();
-    if (got != c) {
-      throw MapParseException("expected '"s + c + "', got '" + got + "'");
-    }
-  }
-
   int32_t readBase64VLQ();
 };
 

src/wasm-binary.h

@@ -1464,7 +1464,7 @@ class WasmBinaryReader {
   WasmBinaryReader(Module& wasm,
                    FeatureSet features,
                    const std::vector<char>& input,
-                   const std::vector<char>& sourceMap = defaultEmptySourceMap);
+                   std::vector<char>& sourceMap = defaultEmptySourceMap);
 
   void setDebugInfo(bool value) { debugInfo = value; }
   void setDWARF(bool value) { DWARF = value; }

src/wasm.h

@@ -2173,6 +2173,11 @@ class Function : public Importable {
                ? columnNumber < other.columnNumber
                : symbolNameIndex < other.symbolNameIndex;
     }
+    void dump() {
+      std::cerr << (symbolNameIndex ? symbolNameIndex.value() : -1) << " @ "
+                << fileIndex << ":" << lineNumber << ":" << columnNumber
+                << "\n";
+    }
   };
   // One can explicitly set the debug location of an expression to
   // nullopt to stop the propagation of debug locations.

src/wasm/source-map.cpp

@@ -16,6 +16,7 @@
 
 #include "source-map.h"
 #include "support/colors.h"
+#include "support/json.h"
 
 namespace wasm {
 
@@ -33,96 +34,55 @@ void MapParseException::dump(std::ostream& o) const {
   Colors::normal(o);
 }
 
-void SourceMapReader::readHeader(Module& wasm) {
-  assert(pos == 0);
+void SourceMapReader::parse(Module& wasm) {
   if (buffer.empty()) {
     return;
   }
-
-  auto skipWhitespace = [&]() {
-    while (pos < buffer.size() && (buffer[pos] == ' ' || buffer[pos] == '\n')) {
-      ++pos;
+  json::Value json;
+  json.parse(buffer.data(), json::Value::ASCII);
+  if (!json.isObject()) {
+    throw MapParseException("Source map is not valid JSON");
+  }
+  if (!(json.has("version") && json["version"]->isNumber() &&
+        json["version"]->getInteger() == 3)) {
+    throw MapParseException("Source map version missing or is not 3");
+  }
+  if (!(json.has("sources") && json["sources"]->isArray())) {
+    throw MapParseException("Source map sources missing or not an array");
+  }
+  json::Ref s = json["sources"];
+  for (size_t i = 0; i < s->size(); i++) {
+    json::Ref v = s[i];
+    if (!(s[i]->isString())) {
+      throw MapParseException("Source map sources contains non-string");
     }
-  };
-
-  auto findField = [&](const char* name) {
-    bool matching = false;
-    size_t len = strlen(name);
-    size_t index = 0;
-    while (1) {
-      char ch = get();
-      if (ch == '\"') {
-        if (matching) {
-          if (index == len) {
-            // We matched a terminating quote.
-            break;
-          }
-          matching = false;
-        } else {
-          // Beginning of a new potential match.
-          matching = true;
-          index = 0;
-        }
-      } else if (matching && name[index] == ch) {
-        ++index;
-      } else if (matching) {
-        matching = false;
-      }
+    wasm.debugInfoFileNames.push_back(v->getCString());
+  }
+
+  if (json.has("names")) {
+    json::Ref n = json["names"];
+    if (!n->isArray()) {
+      throw MapParseException("Source map names is not an array");
     }
-    skipWhitespace();
-    expect(':');
-    skipWhitespace();
-    return true;
-  };
-
-  auto readString = [&](std::string& str) {
-    std::vector<char> vec;
-    skipWhitespace();
-    expect('\"');
-    while (1) {
-      if (maybeGet('\"')) {
-        break;
+    for (size_t i = 0; i < n->size(); i++) {
+      json::Ref v = n[i];
+      if (!v->isString()) {
+        throw MapParseException("Source map names contains non-string");
       }
-      vec.push_back(get());
+      wasm.debugInfoSymbolNames.push_back(v->getCString());
     }
-    skipWhitespace();
-    str = std::string(vec.begin(), vec.end());
-  };
-
-  if (!findField("sources")) {
-    throw MapParseException("cannot find the 'sources' field in map");
   }
 
-  skipWhitespace();
-  expect('[');
-  if (!maybeGet(']')) {
-    do {
-      std::string file;
-      readString(file);
-      wasm.debugInfoFileNames.push_back(file);
-    } while (maybeGet(','));
-    expect(']');
+  if (!json.has("mappings")) {
+    throw MapParseException("Source map mappings missing");
   }
-
-  if (findField("names")) {
-    skipWhitespace();
-    expect('[');
-    if (!maybeGet(']')) {
-      do {
-        std::string symbol;
-        readString(symbol);
-        wasm.debugInfoSymbolNames.push_back(symbol);
-      } while (maybeGet(','));
-      expect(']');
-    }
+  json::Ref m = json["mappings"];
+  if (!m->isString()) {
+    throw MapParseException("Source map mappings is not a string");
   }
 
-  if (!findField("mappings")) {
-    throw MapParseException("cannot find the 'mappings' field in map");
-  }
-
-  expect('\"');
-  if (maybeGet('\"')) {
+  mappings = m->getCString();
+  if (mappings.empty()) {
     // There are no mappings.
     location = 0;
     return;
@@ -134,10 +94,6 @@ void SourceMapReader::readHeader(Module& wasm) {
 
 std::optional<Function::DebugLocation>
 SourceMapReader::readDebugLocationAt(size_t currLocation) {
-  if (pos >= buffer.size()) {
-    return std::nullopt;
-  }
-
   while (location && location <= currLocation) {
     do {
       char next = peek();
@@ -164,13 +120,13 @@ SourceMapReader::readDebugLocationAt(size_t currLocation) {
     } while (false);
 
     // Check whether there is another record to read the position for.
-    char next = get();
-    if (next == '\"') {
+
+    if (peek() == '\"') {
       // End of records.
       location = 0;
       break;
     }
-    if (next != ',') {
+    if (get() != ',') {
       throw MapParseException("Expected delimiter");
     }
 
@@ -181,7 +137,6 @@ SourceMapReader::readDebugLocationAt(size_t currLocation) {
   if (!hasInfo) {
     return std::nullopt;
   }
-
   auto sym = hasSymbol ? symbol : std::optional<uint32_t>{};
   return Function::DebugLocation{file, line, col, sym};
 }

src/wasm/wasm-binary.cpp

@@ -1774,7 +1774,7 @@ void WasmBinaryWriter::writeMemoryOrder(MemoryOrder order, bool isRMW) {
 WasmBinaryReader::WasmBinaryReader(Module& wasm,
                                    FeatureSet features,
                                    const std::vector<char>& input,
-                                   const std::vector<char>& sourceMap)
+                                   std::vector<char>& sourceMap)
   : wasm(wasm), allocator(wasm.allocator), input(input), builder(wasm),
     sourceMapReader(sourceMap) {
   wasm.features = features;
@@ -1824,7 +1824,7 @@ void WasmBinaryReader::read() {
   }
 
   readHeader();
-  sourceMapReader.readHeader(wasm);
+  sourceMapReader.parse(wasm);
 
   // Read sections until the end
   while (more()) {