rea/src/domain/javascript/javascriptSemanticIterationSources.ts

import * as t from "@babel/types";

import {
  semanticObjectPatternKeys,
  runtimeFunctionParameters,
  semanticStaticPropertyKey,
  unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
import {
  semanticArrayIndex,
  type JavaScriptSemanticPropertyPath,
} from "./javascriptSemanticPropertyPaths.js";
import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import { semanticCopiedReferencePath } from "./javascriptSemanticReferenceSources.js";

interface IterationSourceValue {
  readonly node: t.Node;
  readonly projection: JavaScriptSemanticPropertyPath;
  readonly iterationSources?: readonly IterationSourceValue[];
}

/** An iterator receiver or property reference store, with default guards. */
export interface SemanticIterationSource extends IterationSourceValue {
  readonly iterationSources?: readonly IterationSourceValue[];
  readonly kind: "iteration" | "reference-store";
  readonly mutation: t.Node;
  readonly target?: t.MemberExpression;
  readonly fallbackSources?: readonly IterationSourceValue[];
  readonly requiredSources?: readonly IterationSourceValue[];
}

interface PatternSource extends IterationSourceValue {
  // A rest binding is a fresh array whose children retain their source indices.
  readonly restStartIndex?: number;
}

/** Select an assigned slot while retaining fresh rest-copy identity and offsets. */
export const semanticStoredSourceSelection = (
  source: SemanticIterationSource,
  selected: JavaScriptSemanticPropertyPath,
): {
  readonly projection: JavaScriptSemanticPropertyPath;
  readonly capturedSelectionDepth?: number;
  readonly ownEnumerable?: true;
} | null => {
  const copy = source.projection.at(-1);
  if (copy === null || typeof copy !== "object")
    return { projection: [...source.projection, ...selected] };
  const projection = semanticCopiedReferencePath(
    {
      projection: source.projection,
      copyProjectionOffset: source.projection.length - 1,
      copyKind: copy.startIndex === undefined ? "object-rest" : "array-rest",
      copyExcludedKeys: copy.excludedKeys,
      ...(copy.startIndex === undefined
        ? {}
        : { copyStartIndex: copy.startIndex }),
    },
    selected,
    "identity",
  );
  return projection === null
    ? null
    : {
        projection,
        capturedSelectionDepth: source.projection.length,
        ...(copy.startIndex === undefined
          ? { ownEnumerable: true as const }
          : {}),
      };
};

interface SourceGuards {
  readonly iterationSources?: readonly IterationSourceValue[];
  readonly fallbackSources?: readonly IterationSourceValue[];
  readonly requiredSources?: readonly IterationSourceValue[];
}

const add = (
  sources: SemanticIterationSource[],
  source: IterationSourceValue,
  mutation: t.Node,
  guards: SourceGuards,
  kind: SemanticIterationSource["kind"] = "iteration",
  target?: t.MemberExpression,
): void => {
  sources.push({
    kind,
    node: source.node,
    projection: source.projection,
    mutation,
    ...guards,
    ...(target === undefined ? {} : { target }),
  });
};
const project = (
  source: PatternSource | undefined,
  key: string | number | null,
): PatternSource | undefined => {
  if (source === undefined) return undefined;
  const index = key === null ? null : semanticArrayIndex(key);
  return {
    node: source.node,
    projection: [
      ...source.projection,
      source.restStartIndex !== undefined && index !== null
        ? source.restStartIndex + index
        : key,
    ],
  };
};
interface PatternCollection {
  readonly sources: SemanticIterationSource[];
  readonly mutation: t.Node;
}

const visit = (
  context: PatternCollection,
  pattern: t.Node,
  source: PatternSource | undefined,
  guards: SourceGuards = {},
): void => {
  pattern = unwrapJavaScriptExpression(pattern).node;
  const { sources, mutation } = context;
  if (t.isMemberExpression(pattern)) {
    // Property stores have no lexical alias binding. Preserve the selected
    // reference's escape rather than claiming later writes cannot reach it.
    if (source !== undefined)
      add(
        sources,
        source.restStartIndex === undefined
          ? source
          : {
              node: source.node,
              projection: [
                ...source.projection,
                { excludedKeys: [], startIndex: source.restStartIndex },
              ],
            },
        mutation,
        guards,
        "reference-store",
        pattern,
      );
    return;
  }
  if (t.isTSParameterProperty(pattern)) {
    visit(context, pattern.parameter, source, guards);
    return;
  }
  if (t.isAssignmentPattern(pattern)) {
    visit(context, pattern.left, source, {
      ...guards,
      requiredSources: [
        ...(guards.requiredSources ?? []),
        ...(source === undefined
          ? []
          : [
              {
                ...source,
                ...(guards.iterationSources === undefined
                  ? {}
                  : { iterationSources: guards.iterationSources }),
              },
            ]),
      ],
    });
    visit(
      context,
      pattern.left,
      { node: pattern.right, projection: [] },
      {
        ...guards,
        fallbackSources: [
          ...(guards.fallbackSources ?? []),
          ...(source === undefined
            ? []
            : [
                {
                  ...source,
                  ...(guards.iterationSources === undefined
                    ? {}
                    : { iterationSources: guards.iterationSources }),
                },
              ]),
        ],
      },
    );
    return;
  }
  if (t.isObjectPattern(pattern)) {
    for (const property of pattern.properties) {
      if (t.isRestElement(property)) {
        // A rest copy owns its scalar slots; only selected child references
        // escape when that fresh copy is stored through a member target.
        visit(
          context,
          property.argument,
          source === undefined
            ? undefined
            : {
                node: source.node,
                projection: [
                  ...source.projection,
                  {
                    excludedKeys: [
                      ...new Set(semanticObjectPatternKeys(pattern)),
                    ].sort(compareUnicodeCodePoints),
                  },
                ],
              },
          guards,
        );
        continue;
      }
      visit(
        context,
        property.value,
        project(
          source,
          semanticStaticPropertyKey(property.key, property.computed),
        ),
        guards,
      );
    }
    return;
  }
  if (t.isArrayPattern(pattern)) {
    if (source !== undefined && source.restStartIndex === undefined)
      add(sources, source, mutation, guards);
    const selectedGuards = {
      ...guards,
      iterationSources: [
        ...(guards.iterationSources ?? []),
        ...(source === undefined ? [] : [source]),
      ],
    };
    pattern.elements.forEach((element, index) => {
      if (element === null) return;
      if (t.isRestElement(element))
        visit(
          context,
          element.argument,
          source === undefined
            ? undefined
            : {
                node: source.node,
                projection: source.projection,
                restStartIndex: (source.restStartIndex ?? 0) + index,
              },
          selectedGuards,
        );
      else visit(context, element, project(source, index), selectedGuards);
    });
    return;
  }
  if (t.isRestElement(pattern))
    visit(context, pattern.argument, undefined, guards);
};

/** Describe iterator receivers and property reference stores without evaluation. */
export const semanticIterationSources = (
  node: t.Node,
  parent: t.Node | null,
): readonly SemanticIterationSource[] => {
  const sources: SemanticIterationSource[] = [];
  const context = { sources, mutation: node };
  if (t.isVariableDeclarator(node) && node.init != null)
    visit(context, node.id, { node: node.init, projection: [] });
  else if (
    t.isAssignmentExpression(node) &&
    ["=", "||=", "&&=", "??="].includes(node.operator)
  )
    visit(context, node.left, { node: node.right, projection: [] });
  else if (t.isForOfStatement(node)) {
    add(sources, { node: node.right, projection: [] }, node, {});
    const source = { node: node.right, projection: [null] };
    if (t.isVariableDeclaration(node.left)) {
      for (const declaration of node.left.declarations)
        visit(context, declaration.id, source);
    } else visit(context, node.left, source);
  } else if (t.isSpreadElement(node) && t.isArrayExpression(parent))
    add(sources, { node: node.argument, projection: [] }, node, {});
  else if (t.isYieldExpression(node) && node.delegate && node.argument != null)
    add(sources, { node: node.argument, projection: [] }, node, {});
  else if (t.isFunction(node))
    for (const parameter of runtimeFunctionParameters(node))
      visit(context, parameter, undefined);

  return sources;
};