FE-514: Fix .map() compilation to use proper variable names

Destructured .map(({ x, y }) => ...) now emits propertyAccess nodes
(token.x, token.y) instead of prefixed symbols (_iter_x, _iter_y).
The iteration variable is derived from the collection name by
singularizing it (tokens → token). Simple .map((token) => ...) uses
the user's parameter name directly.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kube

libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.test.ts

@@ -361,7 +361,7 @@ describe("compileToIR", () => {
   });
 
   describe(".map() list comprehension", () => {
-    it("should compile .map with destructured params", () => {
+    it("should compile .map with destructured params as propertyAccess", () => {
       const result = compileToIR(
         `export default Lambda((tokens, parameters) => tokens.map(({ x }) => x * parameters.infection_rate))`,
         defaultContext,
@@ -370,12 +370,16 @@ describe("compileToIR", () => {
       if (result.ok) {
         expect(result.ir).toEqual({
           type: "listComprehension",
-          variable: "_iter",
+          variable: "token",
           collection: { type: "symbol", name: "tokens" },
           body: {
             type: "binary",
             op: "*",
-            left: { type: "symbol", name: "_iter_x" },
+            left: {
+              type: "propertyAccess",
+              object: { type: "symbol", name: "token" },
+              property: "x",
+            },
             right: { type: "parameter", name: "infection_rate" },
           },
         });
@@ -391,9 +395,9 @@ describe("compileToIR", () => {
       if (result.ok) {
         expect(result.ir).toEqual({
           type: "listComprehension",
-          variable: "_iter",
+          variable: "token",
           collection: { type: "symbol", name: "tokens" },
-          body: { type: "symbol", name: "_iter" },
+          body: { type: "symbol", name: "token" },
         });
       }
     });

libs/@hashintel/petrinaut/src/expression/ts-to-ir/compile-to-ir.ts

@@ -285,31 +285,57 @@ function compileBlockToIR(
 /**
  * Compiles `collection.map(callback)` to a list comprehension IR node.
  */
+/**
+ * Derives a singular iteration variable name from the collection expression.
+ * `tokens` → `token`, `items` → `item`, fallback → `item`.
+ */
+function deriveIterVarName(
+  collection: ts.Expression,
+  sourceFile: ts.SourceFile,
+): string {
+  const text = collection.getText(sourceFile);
+  if (text.endsWith("s") && text.length > 1) {
+    return text.slice(0, -1);
+  }
+  return "item";
+}
+
 function compileMapCallToIR(
   collection: ts.Expression,
   callback: ts.ArrowFunction | ts.FunctionExpression,
   context: CompilationContext,
   outerScope: Scope,
   sourceFile: ts.SourceFile,
 ): IRResult {
-  const iterVar = "_iter";
   const mapScope: Scope = {
     localBindingNames: new Set(outerScope.localBindingNames),
     symbolOverrides: new Map(outerScope.symbolOverrides),
     distributionBindings: new Set(outerScope.distributionBindings),
   };
 
   const param = callback.parameters[0];
+  let iterVar: string;
+
   if (param) {
     const paramName = param.name;
     if (ts.isObjectBindingPattern(paramName)) {
+      // Destructured: ({ x, y }) => ...
+      // Use a derived name and map fields to propertyAccess on it
+      iterVar = deriveIterVarName(collection, sourceFile);
       for (const element of paramName.elements) {
         const fieldName = element.name.getText(sourceFile);
-        mapScope.symbolOverrides.set(fieldName, `${iterVar}_${fieldName}`);
+        mapScope.symbolOverrides.set(
+          fieldName,
+          `\0propAccess:${iterVar}:${fieldName}`,
+        );
       }
     } else {
-      mapScope.symbolOverrides.set(paramName.getText(sourceFile), iterVar);
+      // Simple: (token) => ...
+      iterVar = paramName.getText(sourceFile);
+      mapScope.symbolOverrides.set(iterVar, iterVar);
     }
+  } else {
+    iterVar = deriveIterVarName(collection, sourceFile);
   }
 
   // Compile the body
@@ -529,9 +555,22 @@ function emitIR(
       return { ok: true, ir: { type: "infinity" } };
     }
     if (scope.symbolOverrides.has(name)) {
+      const override = scope.symbolOverrides.get(name)!;
+      // Destructured .map() fields are encoded as propertyAccess sentinels
+      if (override.startsWith("\0propAccess:")) {
+        const [, objName, property] = override.split(":");
+        return {
+          ok: true,
+          ir: {
+            type: "propertyAccess",
+            object: { type: "symbol", name: objName! },
+            property: property!,
+          },
+        };
+      }
       return {
         ok: true,
-        ir: { type: "symbol", name: scope.symbolOverrides.get(name)! },
+        ir: { type: "symbol", name: override },
       };
     }
     if (scope.localBindingNames.has(name)) {