@fluixi/compiler 1.0.0-alpha.100

package/dist/analyze/props-destructure.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/props-destructure.ts
+var props_destructure_exports = {};
+__export(props_destructure_exports, {
+  explainBail: () => explainBail,
+  planPropsDestructure: () => planPropsDestructure
+});
+module.exports = __toCommonJS(props_destructure_exports);
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}

package/dist/analyze/props-destructure.d.cts

@@ -0,0 +1,83 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/** Why a binding was left alone. All of these change more than when the read happens. */
+export type DestructureBail = 
+/**
+ * A rest we can't serve: destructured further (`...{ a }`), or in a function with no
+ * block to put the splitProps call in (`({ a, ...rest }) => …`).
+ */
+'rest'
+/** `const { [key]: a } = props`: we don't know the property until it runs. */
+ | 'computed'
+/** The binding gets assigned to, and props are read-only, so it can't become a member. */
+ | 'reassigned'
+/** An inner scope binds the same name, so a use site could mean either one. */
+ | 'shadowed'
+/**
+ * A default we can't re-run on every read: a function hands out a new identity each
+ * time, a call runs its side effect each time.
+ */
+ | 'unsafe-default';
+export interface PropsRead {
+    /** The local name the pattern introduced. */
+    name: string;
+    /** Property path to read through instead: `['user', 'name']` for `{ user: { name } }`. */
+    path: string[];
+    /**
+     * Default from the pattern. JS only applies one for `undefined`, not for null, so
+     * codegen has to test `=== undefined` rather than reach for `??`, and re-run it on
+     * every read.
+     */
+    fallback?: Node;
+}
+export interface DestructurePlan {
+    /** Bindings we can rewrite to a property read. */
+    reads: PropsRead[];
+    /** Bindings we left alone, with the reason to report. */
+    bails: {
+        name: string;
+        reason: DestructureBail;
+    }[];
+    /**
+     * A `...rest`, and the keys it has to exclude.
+     *
+     * This is what splitProps is for: it copies the getters across rather than reading
+     * them, which is the reason a plain `...rest` can't be rewritten. So instead of
+     * refusing the pattern, we write the splitProps call the author would have written.
+     */
+    rest?: {
+        name: string;
+        keys: string[];
+    };
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export declare function planPropsDestructure(pattern: Node, body: Node | null | undefined): DestructurePlan;
+/** Reason text for the diagnostic. */
+export declare function explainBail(reason: DestructureBail): string;
+export {};

package/dist/analyze/props-destructure.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/** Why a binding was left alone. All of these change more than when the read happens. */
+export type DestructureBail = 
+/**
+ * A rest we can't serve: destructured further (`...{ a }`), or in a function with no
+ * block to put the splitProps call in (`({ a, ...rest }) => …`).
+ */
+'rest'
+/** `const { [key]: a } = props`: we don't know the property until it runs. */
+ | 'computed'
+/** The binding gets assigned to, and props are read-only, so it can't become a member. */
+ | 'reassigned'
+/** An inner scope binds the same name, so a use site could mean either one. */
+ | 'shadowed'
+/**
+ * A default we can't re-run on every read: a function hands out a new identity each
+ * time, a call runs its side effect each time.
+ */
+ | 'unsafe-default';
+export interface PropsRead {
+    /** The local name the pattern introduced. */
+    name: string;
+    /** Property path to read through instead: `['user', 'name']` for `{ user: { name } }`. */
+    path: string[];
+    /**
+     * Default from the pattern. JS only applies one for `undefined`, not for null, so
+     * codegen has to test `=== undefined` rather than reach for `??`, and re-run it on
+     * every read.
+     */
+    fallback?: Node;
+}
+export interface DestructurePlan {
+    /** Bindings we can rewrite to a property read. */
+    reads: PropsRead[];
+    /** Bindings we left alone, with the reason to report. */
+    bails: {
+        name: string;
+        reason: DestructureBail;
+    }[];
+    /**
+     * A `...rest`, and the keys it has to exclude.
+     *
+     * This is what splitProps is for: it copies the getters across rather than reading
+     * them, which is the reason a plain `...rest` can't be rewritten. So instead of
+     * refusing the pattern, we write the splitProps call the author would have written.
+     */
+    rest?: {
+        name: string;
+        keys: string[];
+    };
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export declare function planPropsDestructure(pattern: Node, body: Node | null | undefined): DestructurePlan;
+/** Reason text for the diagnostic. */
+export declare function explainBail(reason: DestructureBail): string;
+export {};
+//# sourceMappingURL=props-destructure.d.ts.map

package/dist/analyze/props-destructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props-destructure.d.ts","sourceRoot":"","sources":["../../src/analyze/props-destructure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,yFAAyF;AACzF,MAAM,MAAM,eAAe;AACzB;;;GAGG;AACD,MAAM;AACR,8EAA8E;GAC5E,UAAU;AACZ,0FAA0F;GACxF,YAAY;AACd,+EAA+E;GAC7E,UAAU;AACZ;;;GAGG;GACD,gBAAgB,CAAC;AAErB,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,yDAAyD;IACzD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,EAAE,CAAC;IACnD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACzC;AAoLD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAgDlG;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAa3D"}

package/dist/analyze/props-destructure.js

@@ -0,0 +1,272 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts), nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+/** Every name a pattern introduces, so we can check each one for shadowing and writes. */
+function patternNames(node, out) {
+    if (!node)
+        return;
+    switch (node.type) {
+        case 'Identifier':
+            out.add(node.name);
+            return;
+        case 'ObjectPattern':
+            for (const p of node.properties) {
+                if (p.type === 'RestElement')
+                    patternNames(p.argument, out);
+                else
+                    patternNames(p.value, out);
+            }
+            return;
+        case 'ArrayPattern':
+            for (const e of node.elements)
+                patternNames(e, out);
+            return;
+        case 'AssignmentPattern':
+            patternNames(node.left, out);
+            return;
+        case 'RestElement':
+            patternNames(node.argument, out);
+            return;
+    }
+}
+/**
+ * Defaults get re-run on every read now, so they have to be cheap and stable. Literals
+ * and identifiers are. A function isn't: it hands out a new identity each read, which
+ * breaks anything comparing props: and neither is a call.
+ */
+function isSafeDefault(node) {
+    switch (node.type) {
+        case 'StringLiteral':
+        case 'NumericLiteral':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+        case 'BigIntLiteral':
+        case 'RegExpLiteral':
+        case 'Identifier':
+            return true;
+        // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+        case 'Literal':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.every(isSafeDefault);
+        case 'UnaryExpression':
+            return isSafeDefault(node.argument);
+        case 'MemberExpression':
+            // Could be a getter, and we'd be running it on every read.
+            return false;
+        default:
+            return false;
+    }
+}
+/** Walk everything under `root`. No visitor API here, so it's hand-rolled. */
+function walk(root, visit) {
+    if (!root || typeof root !== 'object')
+        return;
+    visit(root);
+    for (const key of Object.keys(root)) {
+        if (key === 'loc' || key === 'range' || key === 'leadingComments' || key === 'trailingComments')
+            continue;
+        const value = root[key];
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (item && typeof item === 'object')
+                    walk(item, visit);
+        }
+        else if (value && typeof value === 'object' && typeof value.type === 'string') {
+            walk(value, visit);
+        }
+    }
+}
+/** Anything written to in the body: `name = x`, `name++`, `[name] = …`. */
+function reassignedNames(body) {
+    const written = new Set();
+    walk(body, (node) => {
+        if (node.type === 'AssignmentExpression')
+            patternNames(node.left, written);
+        else if (node.type === 'UpdateExpression') {
+            const arg = node.argument;
+            if (arg?.type === 'Identifier')
+                written.add(arg.name);
+        }
+    });
+    return written;
+}
+/** Names an inner scope re-binds, where a use site would mean something else. */
+function shadowedNames(body, candidates) {
+    const shadowed = new Set();
+    const note = (node) => {
+        const names = new Set();
+        patternNames(node, names);
+        for (const n of names)
+            if (candidates.has(n))
+                shadowed.add(n);
+    };
+    walk(body, (node) => {
+        switch (node.type) {
+            case 'VariableDeclarator':
+                note(node.id);
+                return;
+            case 'FunctionDeclaration':
+            case 'FunctionExpression':
+            case 'ArrowFunctionExpression':
+                note(node.id);
+                for (const p of node.params ?? [])
+                    note(p);
+                return;
+            case 'CatchClause':
+                note(node.param);
+                return;
+            case 'ClassDeclaration':
+            case 'ClassExpression':
+                note(node.id);
+                return;
+        }
+    });
+    return shadowed;
+}
+/** One level of an object pattern, recursing into nested ones. */
+function collect(pattern, path, plan) {
+    for (const property of pattern.properties ?? []) {
+        if (property.type === 'RestElement') {
+            const argument = property.argument;
+            // Only a plain name. `...{ a }` would need its own splitProps and its own rules.
+            if (argument?.type !== 'Identifier' || path.length > 0) {
+                const names = new Set();
+                patternNames(argument, names);
+                for (const name of names)
+                    plan.bails.push({ name, reason: 'rest' });
+                continue;
+            }
+            plan.rest = { name: argument.name, keys: [] };
+            continue;
+        }
+        if (property.computed) {
+            const names = new Set();
+            patternNames(property.value, names);
+            for (const name of names)
+                plan.bails.push({ name, reason: 'computed' });
+            continue;
+        }
+        const key = property.key;
+        const propertyName = (key.type === 'Identifier' ? key.name : key.value);
+        let value = property.value;
+        let fallback;
+        if (value.type === 'AssignmentPattern') {
+            fallback = value.right;
+            value = value.left;
+        }
+        const here = [...path, propertyName];
+        if (value.type === 'Identifier') {
+            if (fallback && !isSafeDefault(fallback)) {
+                plan.bails.push({ name: value.name, reason: 'unsafe-default' });
+                continue;
+            }
+            plan.reads.push({ name: value.name, path: here, ...(fallback ? { fallback } : {}) });
+            continue;
+        }
+        if (value.type === 'ObjectPattern') {
+            // `{ user: { name } = {} }` would have to build the default object on every read.
+            if (fallback) {
+                const names = new Set();
+                patternNames(value, names);
+                for (const name of names)
+                    plan.bails.push({ name, reason: 'unsafe-default' });
+                continue;
+            }
+            collect(value, here, plan);
+            continue;
+        }
+        // An array pattern indexes into a value we can't prove is stable, so leave it.
+        const names = new Set();
+        patternNames(value, names);
+        for (const name of names)
+            plan.bails.push({ name, reason: 'computed' });
+    }
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export function planPropsDestructure(pattern, body) {
+    const plan = { reads: [], bails: [] };
+    if (pattern?.type !== 'ObjectPattern')
+        return plan;
+    collect(pattern, [], plan);
+    if (plan.rest) {
+        // The splitProps call is a statement, so there has to be somewhere to put it.
+        if (body?.type !== 'BlockStatement') {
+            plan.bails.push({ name: plan.rest.name, reason: 'rest' });
+            delete plan.rest;
+        }
+        else {
+            // Keys the rest has to exclude: every top-level property the pattern names.
+            plan.rest.keys = (pattern.properties ?? [])
+                .filter((p) => p.type !== 'RestElement' && !p.computed)
+                .map((p) => {
+                const key = p.key;
+                return (key.type === 'Identifier' ? key.name : key.value);
+            });
+        }
+    }
+    if (plan.reads.length === 0 && !plan.rest)
+        return plan;
+    const candidates = new Set(plan.reads.map((r) => r.name));
+    if (plan.rest)
+        candidates.add(plan.rest.name);
+    const written = reassignedNames(body);
+    const shadowed = shadowedNames(body, candidates);
+    const kept = [];
+    for (const read of plan.reads) {
+        if (written.has(read.name))
+            plan.bails.push({ name: read.name, reason: 'reassigned' });
+        else if (shadowed.has(read.name))
+            plan.bails.push({ name: read.name, reason: 'shadowed' });
+        else
+            kept.push(read);
+    }
+    plan.reads = kept;
+    // The rest binding is declared by the code we emit, so it has to survive the same
+    // checks: reassigning it or shadowing the name would break what we wrote.
+    if (plan.rest && written.has(plan.rest.name)) {
+        plan.bails.push({ name: plan.rest.name, reason: 'reassigned' });
+        delete plan.rest;
+    }
+    else if (plan.rest && shadowed.has(plan.rest.name)) {
+        plan.bails.push({ name: plan.rest.name, reason: 'shadowed' });
+        delete plan.rest;
+    }
+    return plan;
+}
+/** Reason text for the diagnostic. */
+export function explainBail(reason) {
+    switch (reason) {
+        case 'rest':
+            return 'this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters';
+        case 'computed':
+            return 'the property is not known until it runs';
+        case 'reassigned':
+            return 'the binding is assigned to, and props are read-only';
+        case 'shadowed':
+            return 'an inner scope binds the same name';
+        case 'unsafe-default':
+            return 'the default would have to run again on every read';
+    }
+}