@sarj/eslint-plugin 19.15.0 → 19.16.0

package/dist/catalog.js

@@ -2,7 +2,7 @@ import {
   publicDocumentation,
   ruleSpec,
   src_default
-} from "./chunk-SIHWYU24.js";
+} from "./chunk-F6SYEJAW.js";
 
 // src/docs/directive-disable-enable-pair.ts
 var DIRECTIVE_DISABLE_ENABLE_PAIR_DOCUMENTATION = {
@@ -6223,14 +6223,15 @@ var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
 
 // src/docs/require-assert-never.ts
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
-  summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
+  summary: "Require a never witness in empty switch defaults so discriminated unions remain exhaustive at compile time.",
   rationale: "An empty default silently accepts new union members instead of making the compiler identify the missing case.",
-  remediation: "Call `assertNever` with the discriminant in the exhaustive switch default.",
+  remediation: "Use `void (value satisfies never)` or a helper accepting never, preserving the intended runtime fallback.",
   category: "correctness",
   autofix: "safe",
   limitations: [
     "Requires type information and singleton case values covering the current union. The helper must accept never to provide a compile-time check; its spelling alone is not a proof of that contract. Review the desired runtime behavior for unexpected external values.",
-    "Automatic fixes reuse only an existing private ordinary assertNever function with one never parameter, explicit void return and an exactly empty body. The complete comment-free module must otherwise contain only one exported ordinary function with an explicit primitive return type, one string-literal-union parameter, a complete switch with primitive literal returns and a final empty or break default, followed by a primitive fallback return. The existing helper is called in that default, preserving unexpected-value continuation while adding the never compile guard. Throwing helpers, other statements or exports, imports, defaults, aliases and dynamic behavior remain manual."
+    "Unique-symbol alternatives are compared by native compiler type identity. Distinct symbols can share the same printed type name; a handled symbol or its typed alias covers only that identity. Unavailable literal names do not establish coverage.",
+    "Automatic fixes add void (parameter satisfies never), which only reads the existing parameter at runtime and introduces no helper dependency when the exported function is serialized on its own. The complete comment-free module must contain one exported ordinary function, optionally preceded by an exactly empty private ordinary assertNever helper with one never parameter and explicit void return. The dispatcher needs one string-literal-union parameter, an explicit primitive return type, a complete switch with primitive literal returns and a final empty or break default, followed by a primitive fallback return. Other module statements, imports, defaults, aliases, async functions and dynamic behavior remain manual."
   ],
   examples: [
     {
@@ -6263,18 +6264,18 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
     },
     {
       id: "safe-autofix",
-      title: "Reuse the existing no-op never guard",
+      title: "Keep the never witness local to the dispatcher",
       outcome: "match",
       files: [
         {
           path: "src/render.ts",
-          source: "function assertNever(_value: never): void {}\nexport function render(kind: 'a' | 'b'): number { switch (kind) { case 'a': return 1; case 'b': return 2; default: break; } return 0; }"
+          source: "export function render(kind: 'a' | 'b'): number { switch (kind) { case 'a': return 1; case 'b': return 2; default: break; } return 0; }"
         }
       ],
       fixedFiles: [
         {
           path: "src/render.ts",
-          source: "function assertNever(_value: never): void {}\nexport function render(kind: 'a' | 'b'): number { switch (kind) { case 'a': return 1; case 'b': return 2; default: assertNever(kind); break; } return 0; }"
+          source: "export function render(kind: 'a' | 'b'): number { switch (kind) { case 'a': return 1; case 'b': return 2; default: void (kind satisfies never); break; } return 0; }"
         }
       ],
       focusPath: "src/render.ts",

package/dist/{chunk-SIHWYU24.js → chunk-F6SYEJAW.js}

@@ -31723,22 +31723,23 @@ var repeated_static_call_cases_default = defineRule({
 
 // src/rules/_empty-assertion-fix.ts
 function emptyAssertionFix(sourceCode2, node, defaultCase) {
-  if (sourceCode2.ast.body.length !== 2 || sourceCode2.getAllComments().length > 0) return null;
-  const [helper, statement] = sourceCode2.ast.body;
-  if (helper?.type !== "FunctionDeclaration" || !isEmptyAssertion(helper) || statement?.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "FunctionDeclaration") {
+  if (sourceCode2.getAllComments().length > 0) return null;
+  const body3 = sourceCode2.ast.body;
+  const statement = body3.at(-1);
+  if (body3.length !== 1 && (body3.length !== 2 || body3[0]?.type !== "FunctionDeclaration" || !isEmptyAssertion(body3[0]))) {
+    return null;
+  }
+  if (statement?.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "FunctionDeclaration") {
     return null;
   }
   const owner = statement.declaration;
   if (!isLiteralDispatch(owner, node, defaultCase)) return null;
   const parameter = owner.params[0];
-  if (parameter?.type !== "Identifier" || helper.id === null) return null;
-  const helperName = helper.id.name;
-  const binding3 = findVariable(sourceCode2.getScope(defaultCase), helperName);
-  if (binding3?.defs.length !== 1 || binding3.defs[0]?.node !== helper) return null;
+  if (parameter?.type !== "Identifier") return null;
   const first = sourceCode2.getFirstToken(defaultCase);
   const colon = first === null ? null : sourceCode2.getTokenAfter(first);
   if (colon?.value !== ":") return null;
-  return (fixer) => fixer.insertTextAfter(colon, ` ${helperName}(${parameter.name});`);
+  return (fixer) => fixer.insertTextAfter(colon, ` void (${parameter.name} satisfies never);`);
 }
 function isEmptyAssertion(node) {
   const parameter = node.params[0];
@@ -31834,15 +31835,25 @@ function exhaustiveSwitches(file, candidates2) {
     ...constituents.flatMap((members2, i) => open[i] === true ? [] : members2 ?? []),
     ...finiteTests.filter((type) => type !== void 0)
   ])];
-  const names = file.batch(named3.map((type) => file.checker.typeToString.gen(type)));
-  const nameOf2 = new Map(named3.map((type, i) => [type, names[i]]));
+  const printable = named3.filter((type) => (type.flags & file.flags.UniqueESSymbol) === 0);
+  const names = printable.length === 0 ? [] : file.batch(printable.map((type) => file.checker.typeToString.gen(type)));
+  const nameOf2 = new Map(printable.map((type, i) => [type, names[i]]));
   let offset = 0;
   return candidates2.map((_candidate, i) => {
     const caseTypes = finiteTests.slice(offset, offset + (tests[i]?.length ?? 0));
     offset += tests[i]?.length ?? 0;
     if (open[i] === true) return false;
-    const handled = new Set(caseTypes.flatMap((type) => type === void 0 ? [] : [nameOf2.get(type)]));
-    return (constituents[i] ?? []).every((member3) => handled.has(nameOf2.get(member3)));
+    const symbols = new Set(caseTypes.flatMap((type) => type !== void 0 && (type.flags & file.flags.UniqueESSymbol) !== 0 ? [type.id] : []));
+    const handled = new Set(caseTypes.flatMap((type) => {
+      if (type === void 0 || (type.flags & file.flags.UniqueESSymbol) !== 0) return [];
+      const name = nameOf2.get(type);
+      return name === void 0 ? [] : [name];
+    }));
+    return (constituents[i] ?? []).every((member3) => {
+      if ((member3.flags & file.flags.UniqueESSymbol) !== 0) return symbols.has(member3.id);
+      const name = nameOf2.get(member3);
+      return name !== void 0 && handled.has(name);
+    });
   });
 }
 function finiteFlags(flags) {
@@ -31853,12 +31864,12 @@ var require_assert_never_default = defineRule({
     type: "problem",
     fixable: "code",
     docs: {
-      description: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
+      description: "Require a never witness in empty switch defaults so discriminated unions remain exhaustive at compile time.",
       url: docsUrl(NAME128)
     },
     schema: [],
     messages: {
-      missingAssertNever: "Empty switch `default` case \u2014 add runtime handling or call `assertNever()` so the discriminated union is exhaustively checked at compile time."
+      missingAssertNever: "Empty switch `default` case \u2014 add runtime handling or a never witness so the discriminated union is exhaustively checked at compile time."
     }
   },
   createOnce(context) {

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-SIHWYU24.js";
+} from "./chunk-F6SYEJAW.js";
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "19.15.0",
+  "version": "19.16.0",
   "packageManager": "npm@12.2.1",
   "description": "Custom Oxlint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",