Add sub-range validation and tests in the safe builder

Author: szuend

src/builder/safe_builder.test.ts

@@ -338,5 +338,127 @@ describe("SafeScopeInfoBuilder", () => {
 
       assertThrows(() => builder.endRange(5, 0));
     });
+
+    describe("sub-range bindings", () => {
+      beforeEach(() => {
+        builder.startScope(0, 0, { key: "test-scope", variables: ["foo"] })
+          .endScope(20, 0);
+      });
+
+      it("allows empty sub-range bindings", () => {
+        builder.startRange(0, 0, { scopeKey: "test-scope", values: [[]] })
+          .endRange(10, 0);
+      });
+
+      it("allows single item sub-range bindings", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 0, column: 0 },
+            to: { line: 10, column: 0 },
+          }]],
+        })
+          .endRange(10, 0);
+      });
+
+      it("allows multi-item sub-range bindings", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 0, column: 0 },
+            to: { line: 5, column: 0 },
+          }, {
+            value: "b",
+            from: { line: 5, column: 0 },
+            to: { line: 10, column: 0 },
+          }]],
+        })
+          .endRange(10, 0);
+      });
+
+      it("throws if the first sub-range does not start at the range start", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 1, column: 0 },
+            to: { line: 10, column: 0 },
+          }]],
+        });
+
+        assertThrows(() => builder.endRange(10, 0));
+      });
+
+      it("throws if the last sub-range does not end at the range end", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 0, column: 0 },
+            to: { line: 8, column: 0 },
+          }]],
+        });
+
+        assertThrows(() => builder.endRange(10, 0));
+      });
+
+      it("throws if sub-ranges are not sorted", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 5, column: 0 },
+            to: { line: 10, column: 0 },
+          }, {
+            value: "b",
+            from: { line: 0, column: 0 },
+            to: { line: 5, column: 0 },
+          }]],
+        });
+
+        assertThrows(() => builder.endRange(10, 0));
+      });
+
+      it("throws if sub-ranges have a gap", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 0, column: 0 },
+            to: { line: 4, column: 0 },
+          }, {
+            value: "b",
+            from: { line: 5, column: 0 },
+            to: { line: 10, column: 0 },
+          }]],
+        });
+
+        assertThrows(() => builder.endRange(10, 0));
+      });
+
+      it("throws if a sub-range 'from' does not precede 'to'", () => {
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 5, column: 0 },
+            to: { line: 5, column: 0 },
+          }]],
+        });
+        assertThrows(() => builder.endRange(10, 0));
+
+        builder.startRange(0, 0, {
+          scopeKey: "test-scope",
+          values: [[{
+            value: "a",
+            from: { line: 6, column: 0 },
+            to: { line: 5, column: 0 },
+          }]],
+        });
+        assertThrows(() => builder.endRange(10, 0));
+      });
+    });
   });
 });

src/builder/safe_builder.ts

@@ -6,6 +6,7 @@ import type {
   Binding,
   OriginalPosition,
   OriginalScope,
+  Position,
   ScopeInfo,
 } from "../scopes.d.ts";
 import { comparePositions } from "../util.ts";
@@ -268,6 +269,7 @@ export class SafeScopeInfoBuilder extends ScopeInfoBuilder {
       );
     }
 
+    this.#verifyRangeValues(range, { line, column });
     super.endRange(line, column);
     return this;
   }
@@ -306,4 +308,52 @@ export class SafeScopeInfoBuilder extends ScopeInfoBuilder {
       throw new Error(`Can't ${op} while no GeneratedRange is on the stack.`);
     }
   }
+
+  #verifyRangeValues(
+    range: { start: Position; values: Binding[] },
+    end: Position,
+  ): void {
+    for (const value of range.values) {
+      if (!Array.isArray(value)) {
+        continue;
+      }
+
+      const subRanges = value;
+      if (subRanges.length === 0) {
+        continue;
+      }
+
+      const first = subRanges.at(0)!;
+      if (comparePositions(first.from, range.start) !== 0) {
+        throw new Error(
+          `Sub-range bindings must start at the generated range's start. Expected ${range.start.line}:${range.start.column}, but got ${first.from.line}:${first.from.column}`,
+        );
+      }
+
+      const last = subRanges.at(-1)!;
+      if (comparePositions(last.to, end) !== 0) {
+        throw new Error(
+          `Sub-range bindings must end at the generated range's end. Expected ${end.line}:${end.column}, but got ${last.to.line}:${last.to.column}`,
+        );
+      }
+
+      for (let i = 0; i < subRanges.length; ++i) {
+        const current = subRanges[i];
+        if (comparePositions(current.from, current.to) >= 0) {
+          throw new Error(
+            `Sub-range binding 'from' (${current.from.line}:${current.from.column}) must precede 'to' (${current.to.line}:${current.to.column})`,
+          );
+        }
+
+        if (i > 0) {
+          const prev = subRanges[i - 1];
+          if (comparePositions(prev.to, current.from) !== 0) {
+            throw new Error(
+              `Sub-range bindings must be sorted and not overlap. Found gap between ${prev.to.line}:${prev.to.column} and ${current.from.line}:${current.from.column}`,
+            );
+          }
+        }
+      }
+    }
+  }
 }