Merge pull request #158 from ethdebug/rename-pointer-template-variables

Add template yields and inline template definitions

Author: gnidan

packages/format/src/types/pointer/pointer.ts

@@ -130,15 +130,17 @@ export namespace Pointer {
     | Collection.List
     | Collection.Conditional
     | Collection.Scope
-    | Collection.Reference;
+    | Collection.Reference
+    | Collection.Templates;
 
   export const isCollection = (value: unknown): value is Collection =>
     [
       Collection.isGroup,
       Collection.isList,
       Collection.isConditional,
       Collection.isScope,
-      Collection.isReference
+      Collection.isReference,
+      Collection.isTemplates
     ].some(guard => guard(value));
 
   export namespace Collection {
@@ -208,13 +210,38 @@ export namespace Pointer {
 
     export interface Reference {
       template: string;
+      yields?: Record<string, string>;
     }
 
     export const isReference = (value: unknown): value is Reference =>
       !!value &&
         typeof value === "object" &&
         "template" in value &&
-        typeof value.template === "string" && !!value.template
+        typeof value.template === "string" && !!value.template &&
+        (!("yields" in value) || (
+          typeof value.yields === "object" &&
+          value.yields !== null &&
+          Object.entries(value.yields as Record<string, unknown>).every(
+            ([k, v]) => isIdentifier(k) && isIdentifier(v)
+          )
+        ))
+
+    export interface Templates {
+      templates: {
+        [identifier: string]: Pointer.Template;
+      };
+      in: Pointer;
+    }
+
+    export const isTemplates = (value: unknown): value is Templates =>
+      !!value &&
+        typeof value === "object" &&
+        "templates" in value &&
+        typeof value.templates === "object" && !!value.templates &&
+        Object.keys(value.templates).every(isIdentifier) &&
+        Object.values(value.templates).every(isTemplate) &&
+        "in" in value &&
+        isPointer(value.in);
   }
 
   export type Expression =

packages/pointers/src/dereference/generate.ts

@@ -35,24 +35,85 @@ export async function* generateRegions(
     variables
   } = options;
 
+  // Stack of rename mappings for template references with yields
+  const renameStack: Array<Record<string, string>> = [];
+
+  // Stack of template definitions for inline templates
+  const templatesStack: Array<Pointer.Templates> = [];
+
   const stack: Memo[] = [Memo.dereferencePointer(pointer)];
   while (stack.length > 0) {
     const memo: Memo = stack.pop() as Memo;
 
     let memos: Memo[] = [];
     switch (memo.kind) {
       case "dereference-pointer": {
-        memos = yield* processPointer(memo.pointer, options);
+        // Merge inline templates with base templates (inline takes precedence)
+        const currentTemplates = templatesStack.reduce(
+          (acc, templates) => ({ ...acc, ...templates }),
+          options.templates
+        );
+
+        // Process the pointer, intercepting yielded regions to apply renames
+        const process = processPointer(memo.pointer, {
+          ...options,
+          templates: currentTemplates
+        });
+        let result = await process.next();
+        while (!result.done) {
+          let region = result.value;
+
+          // Apply rename if in context and region has a name in mapping
+          const currentMapping = renameStack[renameStack.length - 1];
+          if (currentMapping && region.name) {
+            const newName = currentMapping[region.name];
+            if (newName && newName !== region.name) {
+              region = { ...region, name: newName };
+            }
+          }
+
+          yield region;
+          result = await process.next();
+        }
+        memos = result.value;
         break;
       }
       case "save-regions": {
-        Object.assign(regions, memo.regions);
+        for (const [name, region] of Object.entries(memo.regions)) {
+          // Save under original name for internal reference resolution
+          regions[name] = region;
+        }
         break;
       }
       case "save-variables": {
         Object.assign(variables, memo.variables);
         break;
       }
+      case "push-region-renames": {
+        renameStack.push(memo.mapping);
+        break;
+      }
+      case "pop-region-renames": {
+        // Apply renames when exiting the context: add mappings from
+        // original names to new names for external reference resolution
+        const mapping = renameStack.pop();
+        if (mapping) {
+          for (const [originalName, newName] of Object.entries(mapping)) {
+            if (originalName in regions && newName !== originalName) {
+              regions[newName] = { ...regions[originalName], name: newName };
+            }
+          }
+        }
+        break;
+      }
+      case "push-templates": {
+        templatesStack.push(memo.templates);
+        break;
+      }
+      case "pop-templates": {
+        templatesStack.pop();
+        break;
+      }
     }
 
     // add new memos to the stack in reverse order