eslint-plugin-no-mistakes 0.96.0 → 0.98.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.96.0",
+  "version": "0.98.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {

package/src/rules/async-call-disposition.js

@@ -14,18 +14,19 @@ const {
   promiseAllDisposed,
   mappedPromise,
 } = require("./async-disposition-expressions");
-const { targetOptionsSchema } = require("./async-schema");
+const { dispositionOptionsSchema } = require("./async-schema");
 const { createTargetMatcher } = require("./async-targets");
+const { createAwaitingConsumers } = require("./async-disposition-consumers");
 
-function isDisposed(node, context, seen = new Set()) {
+function isDisposed(node, context, returnsThroughConsumer, seen = new Set()) {
   if (seen.has(node)) return false;
   seen.add(node);
   const observed = observedExpression(node, context);
-  const disposed = (value) => isDisposed(value, context, seen);
+  const disposed = (value) => isDisposed(value, context, returnsThroughConsumer, seen);
   return (
-    directlyDisposed(node, context) ||
-    directlyDisposed(observed, context) ||
-    promiseAllDisposed(observed, context) ||
+    directlyDisposed(node, context, returnsThroughConsumer) ||
+    directlyDisposed(observed, context, returnsThroughConsumer) ||
+    promiseAllDisposed(observed, context, returnsThroughConsumer) ||
     retainedPromise(observed, context, disposed) ||
     mappedPromise(observed, (value) =>
       retainedCollection(
@@ -53,7 +54,7 @@ module.exports = rule(
       recommended: false,
     },
     hasSuggestions: true,
-    schema: targetOptionsSchema,
+    schema: dispositionOptionsSchema,
     messages: {
       disposition:
         "Handle this async promise explicitly with await, return, Promise.all(...), or void.",
@@ -62,13 +63,27 @@ module.exports = rule(
   },
   (context) => {
     const matcher = createTargetMatcher(context);
+    const consumers = createAwaitingConsumers(context);
     const suppressed = ruleSuppression(context, "async-call-disposition");
     if (!matcher.hasTargets) return {};
 
     return {
-      ...matcher.visitors,
+      ...Object.fromEntries(
+        Object.keys(matcher.visitors).map((key) => [
+          key,
+          (node) => {
+            matcher.visitors[key](node);
+            consumers.visitors[key](node);
+          },
+        ]),
+      ),
       CallExpression(node) {
-        if (!matcher.isTargetCall(node) || suppressed(node) || isDisposed(node, context)) return;
+        if (
+          !matcher.isTargetCall(node) ||
+          suppressed(node) ||
+          isDisposed(node, context, consumers.returnsThroughConsumer)
+        )
+          return;
         context.report({
           node,
           messageId: "disposition",

package/src/rules/async-disposition-consumers.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const { unwrapTransparentParent } = require("./async-ast");
+const { compileTargets, targetMatches } = require("./async-patterns");
+const { propertiesWritten } = require("./async-disposition-mocks");
+const { createTargetMatcher } = require("./async-targets");
+
+function createAwaitingConsumers(context) {
+  const matcher = createTargetMatcher(
+    context,
+    "awaitingConsumers",
+    (id) => !propertiesWritten(id, context, new Set(), null, true),
+    true,
+  );
+  const consumers = (context.options?.[0]?.awaitingConsumers || []).map((consumer) => ({
+    targets: compileTargets({ targets: [consumer] }, "targets"),
+    indexes: consumer.callbackArgumentIndexes,
+  }));
+  return {
+    visitors: matcher.visitors,
+    returnsThroughConsumer(fn) {
+      const callback = unwrapTransparentParent(fn);
+      const target = matcher.resolveCallTarget(callback.parent);
+      if (!target) return false;
+      const index = target.arguments.indexOf(callback);
+      if (
+        index < 0 ||
+        target.arguments.slice(0, index).some((arg) => arg.type === "SpreadElement")
+      ) {
+        return false;
+      }
+      return consumers.some(
+        (consumer) =>
+          consumer.indexes.includes(index) &&
+          targetMatches(consumer.targets, target.source, target.calleeName),
+      );
+    },
+  };
+}
+
+module.exports = { createAwaitingConsumers };

package/src/rules/async-disposition-expressions.js

@@ -11,16 +11,21 @@ const {
 } = require("./async-ast");
 const { memberPropertyName } = require("./async-targets");
 
-function directlyDisposed(node, context) {
+function directlyDisposed(node, context, returnsThroughConsumer) {
   const expression = unwrapTransparentParent(node);
   const parent = expression.parent;
   if (parent?.type === "ReturnStatement") {
     const fn = findContainingFunction(parent);
-    return !isCallArgument(fn) || returnsThroughMock(fn, context);
+    return !isCallArgument(fn) || returnsThroughMock(fn, context) || returnsThroughConsumer(fn);
   }
   if (parent?.type === "ArrowFunctionExpression" && parent.body === expression) {
-    if (isCallCallee(parent)) return directlyDisposed(parent.parent, context);
-    return !isCallArgument(parent) || returnsThroughMock(parent, context);
+    if (isCallCallee(parent))
+      return directlyDisposed(parent.parent, context, returnsThroughConsumer);
+    return (
+      !isCallArgument(parent) ||
+      returnsThroughMock(parent, context) ||
+      returnsThroughConsumer(parent)
+    );
   }
   return (
     parent?.type === "AwaitExpression" ||
@@ -130,14 +135,14 @@ function observedExpression(node, context) {
   return current;
 }
 
-function promiseAllDisposed(node, context) {
+function promiseAllDisposed(node, context, returnsThroughConsumer) {
   let current = node.parent;
   while (current) {
     if (isPromiseAllCall(current, context) && canReachPromiseAll(node, current)) {
       return (
-        directlyDisposed(current, context) ||
-        directlyDisposed(observedExpression(current, context), context) ||
-        promiseAllDisposed(current, context)
+        directlyDisposed(current, context, returnsThroughConsumer) ||
+        directlyDisposed(observedExpression(current, context), context, returnsThroughConsumer) ||
+        promiseAllDisposed(current, context, returnsThroughConsumer)
       );
     }
     current = current.parent;

package/src/rules/async-disposition-mocks.js

@@ -9,9 +9,34 @@ const {
 const { mockInitializer } = require("./async-disposition-mock-bindings");
 const { memberPropertyName } = require("./async-targets");
 
+// Destructuring and loop targets also replace a consumer method's identity.
+function propertyTargetWritten(value) {
+  if (value.type !== "MemberExpression") return false;
+  let target = value;
+  while (
+    ["ObjectPattern", "ArrayPattern", "RestElement"].includes(target.parent.type) ||
+    (target.parent.type === "Property" && target.parent.value === target) ||
+    (target.parent.type === "AssignmentPattern" && target.parent.left === target)
+  )
+    target = target.parent;
+  const parent = target.parent;
+  return (
+    (["AssignmentExpression", "ForOfStatement", "ForInStatement"].includes(parent.type) &&
+      parent.left === target) ||
+    parent.type === "UpdateExpression" ||
+    (parent.type === "UnaryExpression" && parent.operator === "delete")
+  );
+}
+
 // Property writes invalidate provenance, including writes through stable local aliases.
 // This follows syntax in this file, not arbitrary callees' side effects.
-function propertiesWritten(node, context, seen = new Set(), initialization = null) {
+function propertiesWritten(
+  node,
+  context,
+  seen = new Set(),
+  initialization = null,
+  propertiesOnly = false,
+) {
   const variable = resolveVariable(node, context);
   const key = variable || node.name;
   if (seen.has(key)) return false;
@@ -40,9 +65,11 @@ function propertiesWritten(node, context, seen = new Set(), initialization = nul
     const parent = value.parent;
     if (parent === initialization && parent.left === value) return false;
     if (
-      (parent.type === "AssignmentExpression" && parent.left === value) ||
-      parent.type === "UpdateExpression" ||
-      (parent.type === "UnaryExpression" && parent.operator === "delete")
+      propertiesOnly
+        ? propertyTargetWritten(value)
+        : (parent.type === "AssignmentExpression" && parent.left === value) ||
+          parent.type === "UpdateExpression" ||
+          (parent.type === "UnaryExpression" && parent.operator === "delete")
     )
       return true;
     if (
@@ -51,13 +78,13 @@ function propertiesWritten(node, context, seen = new Set(), initialization = nul
       parent.id.type === "Identifier" &&
       ["const", "let"].includes(parent.parent.kind)
     )
-      return propertiesWritten(parent.id, context, seen, initialization);
+      return propertiesWritten(parent.id, context, seen, initialization, propertiesOnly);
     if (
       parent.type === "AssignmentExpression" &&
       parent.right === value &&
       parent.left.type === "Identifier"
     )
-      return propertiesWritten(parent.left, context, seen, parent);
+      return propertiesWritten(parent.left, context, seen, parent, propertiesOnly);
     return false;
   });
 }

package/src/rules/async-schema.js

@@ -25,4 +25,22 @@ function optionsSchema(propertyName) {
 const handlerOptionsSchema = optionsSchema("handlers");
 const targetOptionsSchema = optionsSchema("targets");
 
-module.exports = { handlerOptionsSchema, targetOptionsSchema };
+const dispositionOptionsSchema = optionsSchema("targets");
+dispositionOptionsSchema[0].properties.awaitingConsumers = {
+  type: "array",
+  items: {
+    ...targetOptionsSchema[0].properties.targets.items,
+    properties: {
+      ...targetOptionsSchema[0].properties.targets.items.properties,
+      callbackArgumentIndexes: {
+        type: "array",
+        minItems: 1,
+        uniqueItems: true,
+        items: { type: "integer", minimum: 0 },
+      },
+    },
+    required: ["sourceSpecifierPatterns", "calleeNamePatterns", "callbackArgumentIndexes"],
+  },
+};
+
+module.exports = { handlerOptionsSchema, targetOptionsSchema, dispositionOptionsSchema };

package/src/rules/async-targets.js

@@ -33,7 +33,12 @@ function requireSource(node, context) {
   return source;
 }
 
-function createTargetMatcher(context, optionKey = "targets") {
+function createTargetMatcher(
+  context,
+  optionKey = "targets",
+  bindingIsStable = null,
+  strictLogicalCalls = false,
+) {
   const targets = compileTargets(context.options?.[0] || {}, optionKey);
   const sourceSpecifierPatterns = targets.flatMap((target) => target.sourceSpecifierPatterns);
   const directBindings = new Map();
@@ -43,6 +48,7 @@ function createTargetMatcher(context, optionKey = "targets") {
     if (
       id?.type !== "Identifier" ||
       isReassigned(id, context) ||
+      (bindingIsStable && !bindingIsStable(id)) ||
       !targetMatches(targets, source, calleeName)
     ) {
       return;
@@ -55,6 +61,7 @@ function createTargetMatcher(context, optionKey = "targets") {
     if (
       id.type !== "Identifier" ||
       isReassigned(id, context) ||
+      (bindingIsStable && !bindingIsStable(id)) ||
       !matchesAny(source, sourceSpecifierPatterns)
     ) {
       return;
@@ -153,6 +160,7 @@ function createTargetMatcher(context, optionKey = "targets") {
     if (!name) return null;
     let object = unwrapExpression(node.object);
     for (;;) {
+      if (object?.type === "Identifier" && bindingIsStable && !bindingIsStable(object)) return null;
       const source =
         requireSource(object, context) ||
         (object?.type === "Identifier"
@@ -181,7 +189,7 @@ function createTargetMatcher(context, optionKey = "targets") {
     if (node?.type !== "CallExpression") return null;
     const direct = resolveCallee(node.callee);
     if (direct) return { ...direct, arguments: node.arguments };
-    const invoked = logicalCall(node);
+    const invoked = logicalCall(node, strictLogicalCalls ? resolveCallee : undefined);
     if (!invoked) return null;
     const forwarded = resolveCallee(invoked.callee);
     return forwarded ? { ...forwarded, arguments: invoked.arguments } : null;

package/src/rules/no-object-mutation-call.js

@@ -79,13 +79,15 @@ function visitCall(state, node, scope, role) {
     return unknown();
   }
   const known = visitKnownCall(state, node, scope, role);
-  if (known !== undefined) {
+  if (known !== undefined && !known.fallbackCalleeTag) {
     return known;
   }
   const callee = unwrap(node.callee);
   const forward = callee.type === "MemberExpression" ? memberKey(callee) : null;
   const forwarded = forward === "call" || forward === "apply";
-  const calleeTag = api.visit(state, forwarded ? callee.object : node.callee, scope, "read");
+  const calleeTag =
+    known?.fallbackCalleeTag ||
+    api.visit(state, forwarded ? callee.object : node.callee, scope, "read");
   if (calleeTag.mutator) {
     return visitAliasedMutation(state, node, scope, calleeTag.mutator, forwarded ? forward : null);
   }

package/src/rules/no-object-mutation-expr.js

@@ -104,7 +104,7 @@ function visitExpression(state, node, scope, role) {
         memberKey(node),
         node.object,
       );
-      if (role === "escape" && member.mutator) api.releaseEscaping(state, member);
+      if (role === "escape") api.releaseEscaping(state, member);
       return member;
     }
     case "ObjectExpression":

package/src/rules/no-object-mutation-fn.js

@@ -76,8 +76,13 @@ function walkFunctionBody(state, node, scope, tag) {
   fnEnv.inClass = arrow ? Boolean(scope.inClass) : classMethod;
   fnEnv.hasArguments = arrow ? Boolean(scope.hasArguments) : true;
   fnEnv.receiver = arrow ? scope.receiver || null : tag.receiver || null;
-  for (const param of node.params) {
-    bindPattern(state, param, shared("parameter"), fnEnv, "param");
+  if (tag.reduceSeed) tag.reduceSeed.ownerEnv = fnEnv;
+  for (const [index, param] of node.params.entries()) {
+    if (index === 0 && tag.reduceSeed) {
+      bindName(param.name, tag.reduceSeed, fnEnv, "param");
+    } else {
+      bindPattern(state, param, shared("parameter"), fnEnv, "param");
+    }
   }
   const body = functionStatements(node);
   if (Array.isArray(body)) {

package/src/rules/no-object-mutation-invoke.js

@@ -1,13 +1,16 @@
 "use strict";
 
 const api = require("./no-object-mutation-runtime");
+const { callFunction } = require("./no-object-mutation-fn");
+const { reducerCallback } = require("./no-object-mutation-reduce");
 const { iteratedContents } = require("./no-object-mutation-read");
-const { methodName, unwrap } = require("./no-object-mutation-syntax");
+const { methodName, staticKey, unwrap } = require("./no-object-mutation-syntax");
 const {
   callable,
   createFresh,
   joinValues,
   lookup,
+  readMember,
   remember,
   unknown,
 } = require("./no-object-mutation-values");
@@ -21,6 +24,38 @@ function memberCall(node, name) {
 }
 
 function visitKnownCall(state, node, scope, role) {
+  const reducer = reducerCallback(node);
+  if (reducer) {
+    const callee = unwrap(node.callee);
+    const receiver = api.visit(state, callee.object, scope, "read");
+    const method = readMember(receiver, methodName(callee));
+    if (
+      callable(method) ||
+      (receiver.type === "fresh" &&
+        (receiver.fields.has(methodName(callee)) ||
+          receiver.items.some(
+            (item) =>
+              item.node?.parent?.key && staticKey(item.node.parent.key) === methodName(callee),
+          )))
+    ) {
+      // Reuse the evaluated receiver in the ordinary call path. A custom
+      // method may supply a shared accumulator or retain its callback.
+      return { fallbackCalleeTag: method };
+    }
+    const seed = api.visit(state, node.arguments[1], scope, "read");
+    const callback = api.visit(state, reducer, scope, "read");
+    callback.reduceSeed = seed;
+    const escapeEpoch = state.escapeEpoch;
+    callFunction(state, callback);
+    if (state.escapeEpoch !== escapeEpoch) {
+      // A leak at the end of one iteration is visible at the next entry.
+      callback.walked = false;
+      callFunction(state, callback);
+    }
+    seed.ownerEnv = scope.ownerEnv;
+    if (role === "escape") api.releaseEscaping(state, seed);
+    return seed;
+  }
   const values = memberCall(node, "values");
   if (values && isGlobalObject(values.object, scope)) {
     const target = node.arguments[0];

package/src/rules/no-object-mutation-reduce.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { methodName, unwrap } = require("./no-object-mutation-syntax");
+const { ARRAY_METHODS } = require("./no-object-mutation-ast");
+
+// Limit the exemption to an inline, synchronous accumulator builder. Every
+// callback exit must preserve the same accumulator for the next iteration.
+function reducerCallback(node) {
+  const callee = unwrap(node.callee);
+  if (callee?.type !== "MemberExpression" || node.arguments.length !== 2) return null;
+  if (!["reduce", "reduceRight"].includes(methodName(callee))) return null;
+  const seed = unwrap(node.arguments[1]);
+  if (!["ObjectExpression", "ArrayExpression"].includes(seed?.type)) return null;
+  const callback = unwrap(node.arguments[0]);
+  if (!["ArrowFunctionExpression", "FunctionExpression"].includes(callback?.type)) return null;
+  if (callback.async || callback.generator || callback.params[0]?.type !== "Identifier")
+    return null;
+  const name = callback.params[0].name;
+  const body = callback.body;
+  if (body.type !== "BlockStatement") return null;
+  if (body.body.at(-1)?.type !== "ReturnStatement") return null;
+  return preservesAccumulator(body, name) ? callback : null;
+}
+
+function preservesAccumulator(node, name, nested = false) {
+  if (!node || typeof node.type !== "string") return true;
+  if (
+    ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].includes(node.type)
+  ) {
+    // Returns in nested closures do not define the reduction result. Still
+    // reject rebinding there: a closure can change the next accumulator.
+    nested = true;
+  }
+  if (node.type === "ReturnStatement" && !nested) {
+    const value = unwrap(node.argument);
+    return value?.type === "Identifier" && value.name === name;
+  }
+  // Rebinding could pass a shared value into the following iteration. Keep
+  // destructuring and shadowing conservative rather than prove control flow.
+  if (
+    [
+      "AssignmentExpression",
+      "UpdateExpression",
+      "VariableDeclarator",
+      "ForInStatement",
+      "ForOfStatement",
+    ].includes(node.type)
+  ) {
+    const target = node.left || node.argument || node.id;
+    if (target.type !== "MemberExpression" && mentions(target, name)) return false;
+  }
+  if (node.type === "Identifier" && node.name === name && !directAccumulatorUse(node)) return false;
+  if (node.type === "CatchClause" && mentions(node.param, name)) return false;
+  for (const [key, value] of Object.entries(node)) {
+    if (["parent", "loc", "range", "tokens"].includes(key)) continue;
+    if (Array.isArray(value)) {
+      if (!value.every((part) => preservesAccumulator(part, name, nested))) return false;
+    } else if (value && typeof value === "object" && !preservesAccumulator(value, name, nested))
+      return false;
+  }
+  return true;
+}
+
+// Only direct container writes are exempt. Member reads and aliases can carry
+// shared nested provenance across arbitrarily many iterations, so abstain.
+function directAccumulatorUse(node) {
+  const parent = node.parent;
+  if (parent.type === "ReturnStatement") return true;
+  if (parent.type === "CallExpression") return parent.arguments.includes(node);
+  if (parent.type !== "MemberExpression") return false;
+  if (parent.property === node && !parent.computed) return true;
+  if (parent.object !== node) return false;
+  const use = parent.parent;
+  if (use.type === "AssignmentExpression" && use.left === parent) return true;
+  if (use.type === "UpdateExpression" && use.argument === parent) return true;
+  return (
+    use.type === "CallExpression" && use.callee === parent && ARRAY_METHODS.has(methodName(parent))
+  );
+}
+
+function mentions(node, name) {
+  if (!node || typeof node.type !== "string") return false;
+  if (node.type === "Identifier") return node.name === name;
+  return Object.entries(node).some(([key, value]) => {
+    if (["parent", "loc", "range", "tokens"].includes(key)) return false;
+    return Array.isArray(value)
+      ? value.some((part) => mentions(part, name))
+      : mentions(value, name);
+  });
+}
+
+module.exports = { reducerCallback };

package/src/rules/no-object-mutation-scan.js

@@ -113,7 +113,7 @@ function visit(state, node, scope, role) {
       return unknown();
     case "ReturnStatement":
       if (node.argument) {
-        visit(state, node.argument, scope, "escape");
+        visit(state, node.argument, scope, scope.fnTag?.reduceSeed ? "read" : "escape");
       }
       return unknown();
     case "LabeledStatement":

package/src/rules/no-vitest-sequential.js

@@ -2,6 +2,7 @@
 
 const { rule } = require("../helpers");
 const { ruleSuppression } = require("../rule-suppression");
+const { unwrapExpression, unwrapSequence: unwrap } = require("./async-ast");
 const { literalString } = require("./module-mock-helpers");
 const { resolveVariable } = require("./test-no-shared-state-aliases");
 
@@ -13,20 +14,13 @@ function isTestFile(filename) {
 }
 
 function staticName(node, computed) {
+  node = unwrapExpression(node);
   if (!node) return null;
   if (computed && node.type === "Identifier") return null;
   if (!computed && typeof node.name === "string" && node.type !== "Literal") return node.name;
   return literalString(node);
 }
 
-function unwrap(node) {
-  while (node?.type === "ChainExpression") node = node.expression;
-  if (node?.type === "SequenceExpression" && node.expressions?.length) {
-    return unwrap(node.expressions.at(-1));
-  }
-  return node;
-}
-
 function constInit(node, context, seen) {
   if (!context || node?.type !== "Identifier" || seen.has(node.name)) return null;
   const variable = resolveVariable(node, context);
@@ -72,14 +66,9 @@ function hasSequentialOption(node) {
       value?.type === "ObjectExpression" &&
       value.properties.some((property) => {
         if (property.type !== "Property") return false;
-        const key = property.computed
-          ? literalString(property.key)
-          : staticName(property.key, false);
-        return (
-          key === "sequential" &&
-          property.value?.type === "Literal" &&
-          property.value.value === true
-        );
+        const key = staticName(property.key, property.computed);
+        const option = unwrapExpression(property.value);
+        return key === "sequential" && option?.type === "Literal" && option.value === true;
       })
     );
   });

package/src/rules/nullable-option-defaults-meta.js

@@ -0,0 +1,25 @@
+"use strict";
+
+module.exports = {
+  type: "problem",
+  docs: {
+    description: "preserve explicit null in nullable option defaults",
+    recommended: false,
+  },
+  schema: [
+    {
+      type: "object",
+      properties: {
+        includePathPatterns: { type: "array", items: { type: "string" } },
+        excludePathPatterns: { type: "array", items: { type: "string" } },
+        optionObjectNames: { type: "array", items: { type: "string" } },
+        optionObjectNamePatterns: { type: "array", items: { type: "string" } },
+      },
+      additionalProperties: false,
+    },
+  ],
+  messages: {
+    default:
+      "Do not default nullable option '{{name}}' with ??, ||, ??=, or ||=. Preserve explicit null and check undefined explicitly.",
+  },
+};

package/src/rules/nullable-option-scalar-alias.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const { resolveVariable } = require("./async-target-bindings");
+
+// Scope facts are sequential: consult real bindings to reject hoisted/TDZ shadows.
+function scalarConstAlias(node, context) {
+  if (node.parent.kind !== "const" || node.init.type !== "Identifier") return false;
+  const variable = resolveVariable(node.init, context);
+  if (
+    !variable ||
+    variable.defs.length !== 1 ||
+    variable.references.some((reference) => reference.isWrite() && !reference.init)
+  )
+    return false;
+  const def = variable.defs[0];
+  // Parameter initializers can run before a later binding is initialized.
+  // Follow known nullable parameters only from their function body.
+  if (def.type === "Parameter") return def.node.body.range[0] < node.init.range[0];
+  return (
+    def.type === "Variable" && def.parent.kind === "const" && def.node.range[1] < node.init.range[0]
+  );
+}
+
+module.exports = { scalarConstAlias };

package/src/rules/playwright-interactive-names.js

@@ -120,6 +120,7 @@ module.exports = {
   isInteractiveElement,
   jsxCandidateNames,
   mappedImport,
+  matchesAny,
   rememberAlias,
   rememberImport,
 };

package/src/rules/playwright-interactive-slots.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const { attributeName, isStaticString, literalString, selectorValueNode } = require("../helpers");
+const { unwrapExpression } = require("./async-ast");
+
+// A spread invalidates earlier props; a later explicit prop establishes its value again.
+function effectiveAttribute(opening, name) {
+  let found = null;
+  for (const attribute of opening.attributes) {
+    if (attribute.type === "JSXSpreadAttribute") found = null;
+    else if (attributeName(attribute) === name) found = attribute;
+  }
+  return found;
+}
+
+function hasSlotProp(opening, names) {
+  return names.some((name) => {
+    const attribute = effectiveAttribute(opening, name);
+    if (!attribute) return false;
+    if (!attribute.value) return true;
+    const value = unwrapExpression(selectorValueNode(attribute));
+    if (value?.type === "Literal") return Boolean(value.value);
+    return isStaticString(value) && Boolean(literalString(value));
+  });
+}
+
+function literalSelectors(opening, names) {
+  return names.filter((name) => {
+    const attribute = effectiveAttribute(opening, name);
+    return attribute && isStaticString(unwrapExpression(selectorValueNode(attribute)));
+  });
+}
+
+function singleElementChild(element) {
+  const children = element.children.filter((child) => {
+    if (child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression")
+      return false;
+    if (child.type !== "JSXText") return true;
+    // JSX drops indentation around newlines. Same-line spaces and nonbreaking
+    // spaces are actual text siblings, so a Slot cannot merge onto one element.
+    return child.value !== "" && !(/^[ \t\r\n]*$/.test(child.value) && /[\r\n]/.test(child.value));
+  });
+  return children.length === 1 && children[0].type === "JSXElement" ? children[0] : null;
+}
+
+function childKeepsSelector(opening, names) {
+  return names.some(
+    (name) =>
+      !opening.attributes.some(
+        (attribute) => attribute.type === "JSXSpreadAttribute" || attributeName(attribute) === name,
+      ),
+  );
+}
+
+module.exports = { childKeepsSelector, hasSlotProp, literalSelectors, singleElementChild };