[Parser] Propagate debug locations like the old parser

Add a pass that propagates debug locations to unannotated child and sibling
expressions after parsing. The new parser on its own only attaches debug
locations to directly annotated instructions, but this pass, which we run
unconditionally, emulates the behavior of the previous parser for compatibility
with existing programs. It does unintuitive things to programs using the
non-nested format because it runs on nested Binaryen IR, so we may want to
rethink this at some point.

Author: tlively

src/parser/wat-parser.cpp

@@ -19,6 +19,7 @@
 #include "ir/names.h"
 #include "lexer.h"
 #include "parsers.h"
+#include "pass.h"
 #include "wasm-type.h"
 #include "wasm.h"
 
@@ -90,6 +91,57 @@ Result<> parseDefs(Ctx& ctx,
   return Ok{};
 }
 
+void propagateDebugLocations(Module& wasm) {
+  // Copy debug locations from parents to children that do not already have
+  // their own debug locations.
+  struct Propagator : WalkerPass<ExpressionStackWalker<Propagator>> {
+    using Super = WalkerPass<ExpressionStackWalker<Propagator>>;
+    bool isFunctionParallel() override { return true; }
+    bool modifiesBinaryenIR() override { return false; }
+    bool requiresNonNullableLocalFixups() override { return false; }
+    void runOnFunction(Module* module, Function* func) override {
+      if (!func->debugLocations.empty()) {
+        Super::runOnFunction(module, func);
+      }
+    }
+
+    // Unannotated instructions inherit either their previous sibling's location
+    // or their parent's location. Look up whichever is current for a given
+    // parent.
+    std::unordered_map<Expression*, Function::DebugLocation> parentDefaults;
+
+    static void doPreVisit(Propagator* self, Expression** currp) {
+      Super::doPreVisit(self, currp);
+      auto& locs = self->getFunction()->debugLocations;
+      auto& parentDefaults = self->parentDefaults;
+      if (auto it = locs.find(*currp); it != locs.end()) {
+        // Children will inherit this location.
+        parentDefaults[*currp] = it->second;
+        if (auto* parent = self->getParent()) {
+          // Subsequent siblings will inherit this location.
+          parentDefaults[parent] = it->second;
+        }
+      } else {
+        // No annotation, see if we should inherit one.
+        if (auto* parent = self->getParent()) {
+          if (auto defaultIt = parentDefaults.find(parent);
+              defaultIt != parentDefaults.end()) {
+            // We have a default to inherit. Our children will inherit it, too.
+            locs[*currp] = parentDefaults[*currp] = defaultIt->second;
+          }
+        }
+      }
+    }
+
+    std::unique_ptr<Pass> create() override {
+      return std::make_unique<Propagator>();
+    }
+  };
+  PassRunner runner(&wasm);
+  runner.add(std::make_unique<Propagator>());
+  runner.run();
+}
+
 // ================
 // Parser Functions
 // ================
@@ -212,6 +264,8 @@ Result<> parseModule(Module& wasm, std::string_view input) {
     }
   }
 
+  propagateDebugLocations(wasm);
+
   return Ok{};
 }
 

test/lit/wat-kitchen-sink.wast

@@ -5192,6 +5192,32 @@
   end
  )
 
+ ;; CHECK:      (func $source-map-propagation (type $void)
+ ;; CHECK-NEXT:  ;;@ src.cpp:20:1
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i32.add
+ ;; CHECK-NEXT:    ;;@ src.cpp:10:1
+ ;; CHECK-NEXT:    (i32.const 0)
+ ;; CHECK-NEXT:    ;;@ src.cpp:10:1
+ ;; CHECK-NEXT:    (i32.const 1)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT:  ;;@ src.cpp:20:1
+ ;; CHECK-NEXT:  (drop
+ ;; CHECK-NEXT:   (i32.const 2)
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $source-map-propagation
+  ;;@ src.cpp:10:1
+  i32.const 0
+  i32.const 1
+  i32.add
+  ;;@ src.cpp:20:1
+  drop
+  i32.const 2
+  drop
+ )
+
  ;; CHECK:      (func $use-types (type $104) (param $0 (ref $s0)) (param $1 (ref $s1)) (param $2 (ref $s2)) (param $3 (ref $s3)) (param $4 (ref $s4)) (param $5 (ref $s5)) (param $6 (ref $s6)) (param $7 (ref $s7)) (param $8 (ref $s8)) (param $9 (ref $a0)) (param $10 (ref $a1)) (param $11 (ref $a2)) (param $12 (ref $a3)) (param $13 (ref $subvoid)) (param $14 (ref $submany)) (param $15 (ref $all-types))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT: )