Handle decoding of simple bindings

Author: szuend

src/codec.ts

@@ -6,16 +6,18 @@ export const enum Tag {
   ORIGINAL_SCOPE_START = 0x1,
   ORIGINAL_SCOPE_END = 0x2,
   ORIGINAL_SCOPE_VARIABLES = 0x3,
-  GENERATED_RANGE_START = 0x4,
-  GENERATED_RANGE_END = 0x5,
+  GENERATED_RANGE_START = 0x5,
+  GENERATED_RANGE_END = 0x6,
+  GENERATED_RANGE_BINDINGS = 0x7,
 }
 
 export const enum EncodedTag {
   ORIGINAL_SCOPE_START = "B", // 0x1
   ORIGINAL_SCOPE_END = "C", // 0x2
   ORIGINAL_SCOPE_VARIABLES = "D", // 0x3
-  GENERATED_RANGE_START = "E", // 0x4
-  GENERATED_RANGE_END = "F", // 0x5
+  GENERATED_RANGE_START = "F", // 0x5
+  GENERATED_RANGE_END = "G", // 0x6
+  GENERATED_RANGE_BINDINGS = "H", // 0x7
 }
 
 export const enum OriginalScopeFlags {
@@ -39,7 +41,8 @@ export type Item =
   | OriginalScopeEndItem
   | OriginalScopeVariablesItem
   | GeneratedRangeStartItem
-  | GeneratedRangeEndItem;
+  | GeneratedRangeEndItem
+  | GeneratedRangeBindingsItem;
 
 export interface OriginalScopeStartItem {
   tag: Tag.ORIGINAL_SCOPE_START;
@@ -74,3 +77,8 @@ interface GeneratedRangeEndItem {
   line?: number;
   column: number;
 }
+
+interface GeneratedRangeBindingsItem {
+  tag: Tag.GENERATED_RANGE_BINDINGS;
+  valueIdxs: number[];
+}

src/decode/decode.ts

@@ -181,7 +181,7 @@ class Decoder {
           const range = this.#rangeStack.pop();
           if (!range) {
             throw new Error(
-              "Encountered GENERATED_RANGE_END wtihout matching GENERATED_RANGE_START!",
+              "Encountered GENERATED_RANGE_END without matching GENERATED_RANGE_START!",
             );
           }
 
@@ -200,6 +200,25 @@ class Decoder {
           }
           break;
         }
+        case Tag.GENERATED_RANGE_BINDINGS: {
+          const range = this.#rangeStack.at(-1);
+          if (!range) {
+            throw new Error(
+              "Encountered GENERATED_RANGE_BINDINGS without surrounding GENERATED_RANGE_START",
+            );
+          }
+
+          for (const valueIdx of item.valueIdxs) {
+            if (valueIdx === -1) {
+              range.values.push(null);
+            } else {
+              range.values.push(this.#names[valueIdx]);
+            }
+
+            // TODO: Potentially throw if we decode an illegal index.
+          }
+          break;
+        }
       }
     }
 
@@ -294,6 +313,16 @@ class Decoder {
           }
           break;
         }
+        case Tag.GENERATED_RANGE_BINDINGS: {
+          const valueIdxs: number[] = [];
+
+          while (iter.hasNext() && iter.peek() !== ",") {
+            valueIdxs.push(iter.nextSignedVLQ());
+          }
+
+          yield { tag, valueIdxs };
+          break;
+        }
       }
 
       // Consume any trailing VLQ and the the ","

src/encode/encode.test.ts

@@ -77,7 +77,7 @@ describe("encode", () => {
     assertThrows(() => encode(info));
   });
 
-  it("throws when a ranges' definition scope has not known to the encoder", () => {
+  it("throws when a ranges' definition scope is not known to the encoder", () => {
     const scope = builder.startScope(0, 0).endScope(10, 0).lastScope()!;
     const info = builder.startRange(0, 10).endRange(0, 20).build();
 
@@ -86,4 +86,25 @@ describe("encode", () => {
 
     assertThrows(() => encode(info));
   });
+
+  it("throws when a range has bindings but no definition scope", () => {
+    const info = builder.startRange(0, 0, { values: ["a", null] }).endRange(
+      0,
+      10,
+    ).build();
+
+    assertThrows(() => encode(info));
+  });
+
+  it("throws when range bindings don't match with scope variables", () => {
+    const info = builder.startScope(0, 0, {
+      key: "key",
+      variables: ["foo", "bar"],
+    }).endScope(10, 0).startRange(0, 0, {
+      scopeKey: "key",
+      values: ["a", null, "b"],
+    }).endRange(0, 10).build();
+
+    assertThrows(() => encode(info));
+  });
 });

src/encode/encoder.ts

@@ -135,6 +135,7 @@ export class Encoder {
 
   #encodeGeneratedRange(range: GeneratedRange): void {
     this.#encodeGeneratedRangeStart(range);
+    this.#encodeGeneratedRangeBindings(range);
     range.children.forEach((child) => this.#encodeGeneratedRange(child));
     this.#encodeGeneratedRangeEnd(range);
   }
@@ -177,6 +178,30 @@ export class Encoder {
     this.#finishItem();
   }
 
+  #encodeGeneratedRangeBindings(range: GeneratedRange) {
+    if (range.values.length === 0) return;
+
+    if (!range.originalScope) {
+      throw new Error("Range has binding expressions but no OriginalScope");
+    } else if (range.originalScope.variables.length !== range.values.length) {
+      throw new Error(
+        "Range's binding expressions don't match OriginalScopes' variables",
+      );
+    }
+
+    this.#encodeTag(EncodedTag.GENERATED_RANGE_BINDINGS);
+    for (const val of range.values) {
+      if (val === null) {
+        this.#encodeSigned(-1);
+      } else if (typeof val === "string") {
+        this.#encodeSigned(this.#resolveNamesIdx(val));
+      } else {
+        throw new Error("Sub-range bindings not implemented yet!");
+      }
+    }
+    this.#finishItem();
+  }
+
   #encodeGeneratedRangeEnd(range: GeneratedRange) {
     const { line, column } = range.end;
     this.#verifyPositionWithRangeState(line, column);

src/roundtrip.test.ts

@@ -144,4 +144,17 @@ describe("round trip", () => {
 
     assertCodec(builder.build());
   });
+
+  it("handles value bindings expressions", () => {
+    builder.startScope(0, 0, { variables: ["foo", "bar"], key: "outer" })
+      .startScope(10, 0, { variables: ["local1", "local2"], key: "inner" })
+      .endScope(20, 0).endScope(30, 0)
+      .startRange(0, 0, { scopeKey: "outer", values: ["f", "b"] }).startRange(
+        0,
+        10,
+        { scopeKey: "inner", values: [null, "g"] },
+      ).endRange(0, 20).endRange(0, 30);
+
+    assertCodec(builder.build());
+  });
 });