@eagleoutice/eslint-config-flowr 2.1.7 → 2.1.9

package/README.md

@@ -19,7 +19,9 @@ configuration from your `tsdoc.json`:
 ## The `flowr` plugin
 
 flowR groups its functions in helper objects (`DfEdge`, `Resolve`, `NodeId`, and friends) so that there is one obvious
-entry point per topic. Two rules keep the code on those entry points, both on by default.
+entry point per topic. Two rules keep the code on those entry points, both on by default. A third,
+`flowr/file-naming`, checks file names (`dataflow-graph.ts`, `1-setup.ts`, `Vertex.ts`) and keeps `*.spec.ts` files
+below `test/`.
 
 | rule | driven by | finds |
 | :-- | :-- | :-- |
@@ -70,6 +72,7 @@ To add one, append to [`patterns.ts`](patterns.ts):
 | `replace` | the replacement, required. `{{name}}` is a capture's source text, `{{name\|last}}` keeps the part behind its last dot, turning `VertexType.Use` into `Use` |
 | `capture` | name to a path relative to the match |
 | `declaredIn` | path to a file the node's symbol must come from, so an unrelated `types` or `tag` does not match. The declaring file itself is exempt |
+| `helperIn` | path to the file the replacement's helper lives in, for a shape without a flowR symbol to pin; in a program without that file the pattern stays silent |
 | `sameText` | pairs of paths that must spell the same code, esquery has no back-references |
 | `message` | what to tell the reader, filled from the captures like `replace` |
 | `fix` | `true` always fixes, `false` always suggests, which is right when the replacement can change type narrowing. Omitted, it fixes when the replacement is in scope |
@@ -82,10 +85,16 @@ The shipped set groups into families:
 | `edge-*` | `e.types === T`, `(e.types & T) !== 0`, and the bitmask spellings around them | `DfEdge` |
 | `vertex-is*`, `vertex-has-origin` | `v.tag === VertexType.X`, `DfgVertex.isFunctionCall(v) && v.origin.includes(o)` | `DfgVertex` |
 | `node-is*` | `n.type === RType.X`, negated and through `?.` | `RSymbol`, `RFunctionCall`, and the rest of the `R*` node objects |
-| `argument-is-*`, `call-is-*`, `list-is-implicit` | a guard written out, `RFunctionCall.is(n) && n.named` | the narrower guard of the same object |
+| `argument-is-*`, `call-is-*`, `list-is-implicit` | a guard written out, `RFunctionCall.is(n) && n.named`, `RFunctionCall.isNamed(c) && Identifier.getName(c.functionName.content) === 'f'` (also with a set's `has`, and negated) | the narrower guard of the same object, `RFunctionCall.isNamed(c, 'f')` |
 | `symbol-name-comparison*` | `symbol.content === 'name'`, which misses `pkg::name` because an identifier with a namespace is an array | `Identifier.getName` / `Identifier.matches` |
 | `graph-edges-from`, `graph-edges-to` | `g.outgoingEdges(id) ?? []` / `?? NoEdges`, a fallback the total accessors already are | `edgesFrom` / `edgesTo` |
 | `location-range-hop`, `location-at-node`, `accessor-undefined-guard`, `identifier-tostring-fallback` | an unwrap, a positional destructure, or an absent-value guard in front of a reader that passes `undefined` through by itself | `SourceLocation`, `Identifier` |
+| `node-lexeme*`, `node-own-lexeme*`, `node-range*`, `node-own-range*`, `range-*`, `node-id-recover-name` | `x.info.fullLexeme ?? x.lexeme`, `x.info.fullRange ?? x.location` (and the reverse orders), `range?.[0]`, `idMap.get(id)?.lexeme` | `RNode.lexeme`, `RNode.ownLexeme`, `SourceRange.fromNode`, `SourceRange.ownFromNode` and the range readers, `NodeId.recoverName` |
+| `unpack-arg*`, `find-named-arg*`, `call-sole-argument`, `call-called-name*`, `callee-lexeme-comparison*` | argument and callee reads written out, `lexeme` compared against a name | `RArgument.valueOf`, `RArgument.findNamed`, `RFunctionCall.soleArgument`, `calledName`, `isNamed` |
+| `vertex-origin-includes`, `vertex-lacks-origin`, `vertex-has-origin-array`, `vertex-name-comparison*` | origin lists read by hand, a call compared by its spelling | `DfgVertex.hasOrigin`, `Dataflow.qualify` |
+| `edge-targets`, `edge-sources`, `edge-has-type-between`, `graph-vertices-of-type`, `environment-frames` | walks over edges, vertices and environment frames spelled out | `Dataflow.targetsOf`, `Dataflow.sourcesOf`, `Dataflow.hasEdge`, `verticesOfType`, `REnvironment.frames` |
+| `built-in-id-*`, `to-built-in-*` | the `built-in:` prefix handled by hand | `NodeId.isBuiltIn`, `NodeId.toBuiltIn` |
+| `remove-r-quotes`, `escape-regex`, `identifier-split`, `unique-array*`, `array-equal`, `sort-code-unit` | text, set and array chores with a helper | `RString.unquote`, `escapeRegex`, `Identifier.parse`, `uniqueArray`, `arrayEqual`, `compareByCodeUnit` |
 | `some-instead-of-filter-length`, `array-sum` | a full walk where a helper does it once | `some`, `arraySum` |
 
 A pattern is exempt in the file `declaredIn` resolves to, which is why a shape only earns a place here when the
@@ -93,6 +102,9 @@ match names a flowR symbol: without one the rule cannot tell the helper's own bo
 `@lintIgnore` on the declaration would be papering over that. A guard that *is* the raw comparison
 (`RSymbol.is` compares `type` against `RType.Symbol`) is the case the tag is actually for.
 
+A match inside a function named like the one the replacement calls is never reported either: that is the helper's
+own body (`escapeRegex` spelling out the class it escapes), where the fix would make the helper call itself.
+
 An own `patterns` array replaces the defaults rather than merging with them. To propose one, open an issue with the
 [replacement pattern template](.github/ISSUE_TEMPLATE/replacement-pattern.yaml).
 

package/index.js

@@ -10,7 +10,6 @@ const eslint_plugin_2 = __importDefault(require("@stylistic/eslint-plugin"));
 const eslint_plugin_jsdoc_1 = __importDefault(require("eslint-plugin-jsdoc"));
 const eslint_plugin_tsdoc_1 = __importDefault(require("eslint-plugin-tsdoc"));
 const eslint_plugin_unused_imports_1 = __importDefault(require("eslint-plugin-unused-imports"));
-const eslint_plugin_check_file_1 = __importDefault(require("eslint-plugin-check-file"));
 const eslint_plugin_import_x_1 = __importDefault(require("eslint-plugin-import-x"));
 const eslint_plugin_unicorn_1 = __importDefault(require("eslint-plugin-unicorn"));
 const plugin_1 = __importDefault(require("./plugin"));
@@ -41,7 +40,6 @@ const config = [
             '@stylistic': eslint_plugin_2.default,
             'import-x': eslint_plugin_import_x_1.default,
             'unused-imports': eslint_plugin_unused_imports_1.default,
-            'check-file': eslint_plugin_check_file_1.default,
             tsdoc: eslint_plugin_tsdoc_1.default,
             jsdoc: eslint_plugin_jsdoc_1.default,
             flowr: plugin_1.default,
@@ -57,7 +55,8 @@ const config = [
              * so it would force every consumer to strip it again before bundling. */
             'no-restricted-imports': ['error', {
                     patterns: [{
-                            group: ['node:*', 'node:*/*'],
+                            /* `node:test` has no bare name */
+                            group: ['node:*', 'node:*/*', '!node:test'],
                             message: 'Import the bare module (`path`, not `node:path`) so a bundler can swap it for a browser polyfill.'
                         }]
                 }],
@@ -185,12 +184,7 @@ const config = [
                         throw: { after: false }
                     }
                 }],
-            'check-file/filename-naming-convention': ['error', {
-                    '**/*.ts': '?(\\d+-)?([A-Z])+([a-z])*((-|.)?([A-Z])+([a-z]))'
-                }],
-            'check-file/folder-match-with-fex': ['error', {
-                    '*.spec.{js,jsx,ts,tsx}': 'test/**'
-                }],
+            'flowr/file-naming': 'error',
             '@stylistic/no-trailing-spaces': 'error',
             '@stylistic/space-infix-ops': ['error', { int32Hint: false }],
             '@typescript-eslint/no-unused-vars': 'off',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/eslint-config-flowr",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "Linting rules for flowr and friends",
   "license": "ISC",
   "repository": {
@@ -37,7 +37,6 @@
     "@stylistic/eslint-plugin": "^5.7.1",
     "@typescript-eslint/eslint-plugin": "^8.54.0",
     "@typescript-eslint/parser": "^8.54.0",
-    "eslint-plugin-check-file": "^3.3.1",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-jsdoc": "^62.5.0",
     "eslint-plugin-tsdoc": "^0.5.0",

package/pattern-type.d.ts

@@ -11,6 +11,8 @@ export interface ReplacementPattern {
     readonly replace: string;
     /** path to a substring of the file its symbol must be declared in */
     readonly declaredIn?: Readonly<Record<string, string>>;
+    /** path to a substring of the file the replacement's helper lives in; without that file in the program the pattern stays silent */
+    readonly helperIn?: string;
     /** pairs of paths that have to spell the same code */
     readonly sameText?: readonly (readonly string[])[];
     /** `true` forces the autofix, `false` forces a suggestion */

package/patterns.d.ts

@@ -1,8 +1,6 @@
 /**
  * Default patterns of `flowr/replacement-pattern`, see the README for the format.
- * The helpers they point at live in flowR: `DfEdge` in `dataflow/graph/edge`, the vertex helpers in
- * `dataflow/graph/vertex`, `NoEdges` in `dataflow/graph/graph`, the `RNode` helpers in
- * `r-bridge/lang-4.x/ast/model`, and the collection helpers in `util/collections`.
+ * The helpers they point at live in flowR, the paths below are the files declaring them.
  */
 import type { ReplacementPattern } from './pattern-type';
 declare const patterns: readonly ReplacementPattern[];

package/patterns.js

@@ -1,60 +1,75 @@
 "use strict";
 /**
  * Default patterns of `flowr/replacement-pattern`, see the README for the format.
- * The helpers they point at live in flowR: `DfEdge` in `dataflow/graph/edge`, the vertex helpers in
- * `dataflow/graph/vertex`, `NoEdges` in `dataflow/graph/graph`, the `RNode` helpers in
- * `r-bridge/lang-4.x/ast/model`, and the collection helpers in `util/collections`.
+ * The helpers they point at live in flowR, the paths below are the files declaring them.
  */
-const EDGE = 'dataflow/graph/edge';
-const VERTEX = 'dataflow/graph/vertex';
-const GRAPH = 'dataflow/graph/graph';
-const RTYPE = 'r-bridge/lang-4.x/ast/model/type';
-const CALL_NODE = 'r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-const ARGUMENT_NODE = 'r-bridge/lang-4.x/ast/model/nodes/r-argument';
-const SYMBOL_NODE = 'r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-const LIST_NODE = 'r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-const RANGE = 'util/range';
-const IDENTIFIER = 'dataflow/environments/identifier';
-/** `x.types` under the given path */
-const types = (prefix) => `[${prefix}.type="MemberExpression"][${prefix}.computed=false][${prefix}.property.name="types"]`;
-/** `x.<name>` under the given path, without asserting the node kind, which the caller pins down */
-const member = (prefix, name) => `[${prefix}.computed=false][${prefix}.property.name="${name}"]`;
-/** `EdgeType.<Member>` / `VertexType.<Member>` / `RType.<Member>` on the right */
-const rightIs = (name) => `[right.type="MemberExpression"][right.computed=false][right.object.name="${name}"]`;
-/** compared against the literal `0`, either for "some bit is set" or for "none is" */
+const Files = {
+    edge: 'dataflow/graph/edge',
+    vertex: 'dataflow/graph/vertex',
+    graph: 'dataflow/graph/graph',
+    rType: 'r-bridge/lang-4.x/ast/model/type',
+    call: 'r-bridge/lang-4.x/ast/model/nodes/r-function-call',
+    argument: 'r-bridge/lang-4.x/ast/model/nodes/r-argument',
+    symbol: 'r-bridge/lang-4.x/ast/model/nodes/r-symbol',
+    string: 'r-bridge/lang-4.x/ast/model/nodes/r-string',
+    list: 'r-bridge/lang-4.x/ast/model/nodes/r-expression-list',
+    model: 'r-bridge/lang-4.x/ast/model/model',
+    nodeId: 'r-bridge/lang-4.x/ast/model/processing/node-id',
+    range: 'util/range',
+    identifier: 'dataflow/environments/identifier',
+    environment: 'dataflow/environments/environment',
+    arrays: 'util/collections/arrays',
+    strings: 'util/text/strings'
+};
+/* selector parts, each about the node at the given path, `''` being the match itself */
+const at = (path, key) => path === '' ? key : `${path}.${key}`;
+/** `x.<name>`, without asserting the node kind */
+const member = (path, name) => `[${at(path, 'computed')}=false][${at(path, 'property.name')}="${name}"]`;
+/** `x.<name>` */
+const prop = (path, name) => `[${at(path, 'type')}="MemberExpression"]${member(path, name)}`;
+/** a call of `x.<method>(...)` */
+const call = (path, method) => `[${at(path, 'type')}="CallExpression"]${prop(at(path, 'callee'), method)}`;
+/** a call of `<Helper>.<method>(...)` with `n` arguments */
+const helperCall = (path, helper, method, n = 1) => `${call(path, method)}[${at(path, 'callee.object.name')}="${helper}"][${at(path, 'arguments.length')}=${n}]`;
+/** the identifier `<name>` */
+const identifier = (path, name) => `[${at(path, 'type')}="Identifier"][${at(path, 'name')}="${name}"]`;
+/** the string literal `<value>`, or any string literal */
+const text = (path, value) => `[${at(path, 'type')}="Literal"][${at(path, 'value')}=${value === undefined ? 'type(string)' : `"${value}"`}]`;
+/** `!x` */
+const not = (path) => `[${at(path, 'type')}="UnaryExpression"][${at(path, 'operator')}="!"]`;
+/** `x === undefined` or, `set`, `x !== undefined` */
+const versusUndefined = (at, set) => `[${at}.type="BinaryExpression"][${at}.operator="${set ? '!==' : '==='}"]${identifier(`${at}.right`, 'undefined')}`;
+/** `<Enum>.<Member>` */
+const enumMember = (at, name) => `[${at}.type="MemberExpression"][${at}.computed=false][${at}.object.name="${name}"]`;
+/** `x.types` */
+const types = (at) => prop(at, 'types');
+/** compared against `0`, for "some bit is set" or, `nonZero` false, for "none is" */
 const versusZero = (nonZero) => `BinaryExpression[operator=${nonZero ? '/^(!==|>)$/' : '"==="'}][right.type="Literal"][right.value=0]`;
-/** the `x.types & T` on the left of such a comparison */
-const mask = '[left.type="BinaryExpression"][left.operator="&"]';
-/** a call of `<prefix>.<property>(...)` */
-const call = (prefix, property) => `[${prefix}.type="CallExpression"][${prefix}.callee.type="MemberExpression"][${prefix}.callee.property.name="${property}"]`;
-/** a call of `<Helper>.<property>(<one argument>)` under the given path */
-const helperCall = (prefix, helper, property) => `${call(prefix, property)}[${prefix}.callee.object.name="${helper}"][${prefix}.arguments.length=1]`;
-/** the same call as the match itself rather than below it */
-const rootHelperCall = (helper, property) => `CallExpression[callee.type="MemberExpression"][callee.computed=false][callee.property.name="${property}"]`
-    + `[callee.object.name="${helper}"][arguments.length=1]`;
-/** `x === undefined` / `x !== undefined` under the given path */
-const versusUndefined = (prefix, set) => `[${prefix}.type="BinaryExpression"][${prefix}.operator="${set ? '!==' : '==='}"][${prefix}.right.type="Identifier"][${prefix}.right.name="undefined"]`;
-const destructuringHint = ' Prefer keeping the edge over destructuring `types`, the helpers take it directly and the wrapper object goes away.';
-/** `x.types === T`, on the edge itself or on a destructured `types` */
-const edgeIsOnly = (id, { negated = false, destructured = false } = {}) => ({
-    id,
-    selector: `BinaryExpression[operator="${negated ? '!==' : '==='}"]`
-        + (destructured ? `[left.type="Identifier"][left.name="types"]${rightIs('EdgeType')}` : `${types('left')}:not([right.type="Literal"])`),
+/** the root as `===` or, `negated`, `!==` */
+const equality = (negated) => `BinaryExpression[operator="${negated ? '!==' : '==='}"]`;
+const bang = (negated) => negated ? '!' : '';
+/** A pattern and its negated twin, under the two ids given. */
+const negatable = (ids, make) => [{ id: ids[0], ...make(false) }, { id: ids[1], ...make(true) }];
+/** A pattern and its twin spelled with `?.`, which wraps the member expression in a chain. */
+const optionalToo = (ids, make) => [{ id: ids[0], ...make(false) }, { id: ids[1], ...make(true) }];
+/** `x.types === T`, on the edge or on a destructured `types` */
+const edgeIsOnly = (negated, destructured) => ({
+    selector: equality(negated) + (destructured ? `${identifier('left', 'types')}${enumMember('right', 'EdgeType')}` : `${types('left')}:not([right.type="Literal"])`),
     capture: destructured ? { type: 'right' } : { edge: 'left.object', type: 'right' },
-    replace: `${negated ? '!' : ''}DfEdge.isOnlyType(${destructured ? '{ types }' : '{{edge}}'}, {{type}})`,
-    declaredIn: destructured ? { 'right.object': EDGE } : { 'left.property': EDGE },
+    replace: `${bang(negated)}DfEdge.isOnlyType(${destructured ? '{ types }' : '{{edge}}'}, {{type}})`,
+    declaredIn: destructured ? { 'right.object': Files.edge } : { 'left.property': Files.edge },
     message: `\`${destructured ? '' : 'x.'}types ${negated ? '!==' : '==='} T\` `
         + (negated ? 'holds as soon as any other type is set' : 'holds only if T is the *only* type')
-        + `; say so with \`${negated ? '!' : ''}DfEdge.isOnlyType\`, or use \`DfEdge.${negated ? 'doesNotIncludeType' : 'includesType'}\` for "${negated ? 'has not' : 'has'} this type".`
-        + (destructured ? destructuringHint : '')
+        + `; say so with \`${bang(negated)}DfEdge.isOnlyType\`, or use \`DfEdge.${negated ? 'doesNotIncludeType' : 'includesType'}\` for "${negated ? 'has not' : 'has'} this type".`
+        + (destructured ? ' Prefer keeping the edge over destructuring `types`, the helpers take it directly.' : '')
 });
 /** `(x.types & T) !== 0` and its inverse */
 const edgeMask = (id, helper, nonZero) => ({
     id,
-    selector: `${versusZero(nonZero)}${mask}${types('left.left')}`,
+    selector: `${versusZero(nonZero)}[left.type="BinaryExpression"][left.operator="&"]${types('left.left')}`,
     capture: { edge: 'left.left.object', type: 'left.right' },
     replace: `DfEdge.${helper}({{edge}}, {{type}})`,
-    declaredIn: { 'left.left.property': EDGE },
+    declaredIn: { 'left.left.property': Files.edge },
     message: `Use \`DfEdge.${helper}\` instead of testing the bitmask by hand.`
 });
 /** `x.types !== 0`, the literal-0 comparisons {@link edgeIsOnly} leaves out */
@@ -63,149 +78,286 @@ const edgeStates = (id, helper, what, nonZero) => ({
     selector: `${versusZero(nonZero)}${types('left')}`,
     capture: { edge: 'left.object' },
     replace: `DfEdge.${helper}({{edge}})`,
-    declaredIn: { 'left.property': EDGE },
+    declaredIn: { 'left.property': Files.edge },
     message: `Use \`DfEdge.${helper}\` to ask whether the edge states ${what}.`
 });
 /**
- * A discriminator compared against its enum, `v.tag === VertexType.X` and `n.type === RType.X`.
- * `optional` covers the `?.` spelling, which parses as a chain around the same member expression.
- * `declaring` maps a path of the match to the file its symbol has to come from; the enum on the right is
- * always pinned, the property on the left only where one file declares it for every case.
+ * `v.tag === VertexType.X` and `n.type === RType.X`, in all four spellings.
+ * The helpers are named after the enum members, so `{{type|last}}` spells the check: `VertexType.Use` to `DfgVertex.isUse`,
+ * `RType.Symbol` to `RSymbol.is`. The property is only pinned for vertices, on the `RNode` union `type` has no declaring file.
  */
-const discriminatorIs = (id, { property, enumName, enumFile, propertyFile, helper, member: name = 'is', hint }, { negated = false, optional = false } = {}) => {
+const discriminatorIs = (ids, { property, enumName, enumFile, propertyFile, helper, hint }) => [false, true].flatMap(optional => {
     const left = optional ? 'left.expression' : 'left';
-    return {
-        id,
-        selector: `BinaryExpression[operator="${negated ? '!==' : '==='}"][left.type="${optional ? 'ChainExpression' : 'MemberExpression'}"]${member(left, property)}${rightIs(enumName)}`,
+    return negatable([ids[optional ? 2 : 0], ids[optional ? 3 : 1]], negated => ({
+        selector: `${equality(negated)}[left.type="${optional ? 'ChainExpression' : 'MemberExpression'}"]${member(left, property)}${enumMember('right', enumName)}`,
         capture: { subject: `${left}.object`, type: 'right' },
-        replace: `${negated ? '!' : ''}${helper}.${name}({{subject}})`,
+        replace: `${bang(negated)}${helper}({{subject}})`,
         declaredIn: { 'right.object': enumFile, ...propertyFile ? { [`${left}.property`]: propertyFile } : {} },
-        message: `${hint} (\`${helper}.${name}\`), it narrows the type as well.`
-    };
-};
-/**
- * `v.tag === VertexType.X`. One `DfgVertex` helper answers for every kind, and its members are named after
- * the enum, so `{{type|last}}` spells the check without a table: `VertexType.Use` to `DfgVertex.isUse`.
- */
-const vertexIs = (id, options) => discriminatorIs(id, {
-    property: 'tag', enumName: 'VertexType', enumFile: VERTEX, propertyFile: VERTEX,
-    helper: 'DfgVertex', member: 'is{{type|last}}', hint: 'Compare through the vertex helper'
-}, options);
-/**
- * `n.type === RType.X`. Every `RType` member has a helper object of the same name prefixed with `R`
- * (`RType.Symbol` to `RSymbol`), so `{{type|last}}` names it without a table.
- * Only the enum is pinned to its file: `type` is declared once per node interface, and on the `RNode`
- * union it resolves to a synthesized symbol, so demanding a declaring file for it would match nothing.
- */
-const nodeIs = (id, options) => discriminatorIs(id, {
-    property: 'type', enumName: 'RType', enumFile: RTYPE,
-    helper: 'R{{type|last}}', hint: 'Ask the AST node helper'
-}, options);
-/**
- * `<Helper>.is(x) && <extra check on x>`, the body of a more specific guard written out.
- * `guard` pins down the right-hand side, `subject` is the path of the operand it repeats.
- */
-const guardWrittenOut = ({ id, helper, member: narrower, file, guard, subject, message, fix }) => ({
+        message: `${hint} (\`${helper}\`), it narrows the type as well.`
+    }));
+});
+/** `<Helper>.is(x) && <extra check on x>`, a more specific guard written out; `subject` is where the check repeats `x` */
+const guardWrittenOut = (id, helper, narrower, file, guard, subject, message) => ({
     id,
     selector: `LogicalExpression[operator="&&"]${helperCall('left', helper, 'is')}${guard}`,
     capture: { node: 'left.arguments.0' },
     replace: `${helper}.${narrower}({{node}})`,
     declaredIn: { 'left.callee.object': file },
     sameText: [['left.arguments.0', subject]],
-    ...fix === undefined ? {} : { fix },
     message
 });
+/** `Identifier.getName(<call>.functionName.content)` */
+const calledName = (at) => `${helperCall(at, 'Identifier', 'getName')}${prop(`${at}.arguments.0`, 'content')}${prop(`${at}.arguments.0.object`, 'functionName')}`;
+/**
+ * `RFunctionCall.isNamed(x) && Identifier.getName(x.functionName.content) === 'f'`, and the negation
+ * `!RFunctionCall.isNamed(x) || ... !== 'f'`. `inSet` covers `Names.has(...)` in place of the comparison.
+ */
+const namedCallOf = (inSet) => (negated) => {
+    const guard = negated ? 'left.argument' : 'left';
+    const test = inSet ? (negated ? 'right.argument' : 'right') : 'right';
+    const nameCall = inSet ? `${test}.arguments.0` : 'right.left';
+    return {
+        selector: `LogicalExpression[operator="${negated ? '||' : '&&'}"]${negated ? not('left') : ''}${helperCall(guard, 'RFunctionCall', 'isNamed')}`
+            + (inSet
+                ? `${negated ? not('right') : ''}${call(test, 'has')}[${test}.arguments.length=1]`
+                : `[right.type="BinaryExpression"][right.operator="${negated ? '!==' : '==='}"]:matches(${text('right.right')}, [right.right.type="Identifier"])`)
+            + calledName(nameCall),
+        capture: { node: `${guard}.arguments.0`, names: inSet ? `${test}.callee.object` : 'right.right' },
+        replace: `${bang(negated)}RFunctionCall.isNamed({{node}}, {{names}})`,
+        declaredIn: { [`${guard}.callee.object`]: Files.call },
+        sameText: [[`${guard}.arguments.0`, `${nameCall}.arguments.0.object.object`]],
+        message: `Use \`${bang(negated)}RFunctionCall.isNamed({{node}}, {{names}})\`, it checks the call and its name in one go and still narrows.`
+    };
+};
+/** `g.outgoingEdges(id) ?? []` or `?? NoEdges`, which `edgesFrom`/`edgesTo` already are */
+const edgesFallback = (id, raw, total) => ({
+    id,
+    selector: 'LogicalExpression[operator="??"]:matches([right.type="ArrayExpression"][right.elements.length=0], [right.type="Identifier"][right.name="NoEdges"])'
+        + `${call('left', raw)}[left.callee.computed=false][left.arguments.length=1]`,
+    capture: { graph: 'left.callee.object', id: 'left.arguments.0' },
+    replace: `{{graph}}.${total}({{id}})`,
+    declaredIn: { 'left.callee.property': Files.graph },
+    message: `\`${total}\` is \`${raw}\` without the fallback: it answers with the shared empty map itself.`
+});
 /**
- * `symbol.content === 'name'`. `content` of an {@link RSymbol} is an `Identifier`, which carries a namespace
- * and turns into an array once it has one, so `===` against a bare name silently misses `pkg::name`.
+ * `x.info.fullLexeme ?? x.lexeme` and its mirrors, reading the text or the range of a node by hand.
+ * `infoFirst` says which side of the `??` goes through `info`.
  */
-const symbolName = (id, negated) => ({
+const nodeFallback = (ids, infoProp, plainProp, infoFirst, helper, message) => optionalToo(ids, optional => {
+    const [infoSide, plainSide] = infoFirst ? ['left', 'right'] : ['right', 'left'];
+    const info = optional ? `${infoSide}.expression` : infoSide, plain = optional ? `${plainSide}.expression` : plainSide;
+    const kind = optional ? 'ChainExpression' : 'MemberExpression';
+    return {
+        selector: `LogicalExpression[operator="??"][${infoSide}.type="${kind}"][${plainSide}.type="${kind}"]${member(info, infoProp)}${prop(`${info}.object`, 'info')}${member(plain, plainProp)}`,
+        capture: { node: `${plain}.object` },
+        replace: `${helper}({{node}})`,
+        declaredIn: { [`${info}.property`]: Files.model, [`${plain}.property`]: Files.model },
+        sameText: [[`${info}.object.object`, `${plain}.object`]],
+        message
+    };
+});
+/** `range?.[0]` and friends, the accessors say which index is which */
+const rangeIndex = (id, index, reader) => ({
     id,
-    selector: `BinaryExpression[operator="${negated ? '!==' : '==='}"][left.type="MemberExpression"]${member('left', 'content')}[right.type="Literal"][right.value=type(string)]`,
+    selector: 'ChainExpression[expression.type="MemberExpression"][expression.computed=true][expression.optional=true]'
+        + `[expression.property.type="Literal"][expression.property.value=${index}][expression.object.type="MemberExpression"]`
+        + ':matches([expression.object.property.name="location"], [expression.object.property.name="fullRange"])',
+    capture: { range: 'expression.object' },
+    replace: `SourceRange.${reader}({{range}})`,
+    declaredIn: { 'expression.object.property': Files.model },
+    message: `\`range?.[${index}]\` hides what the index means; \`SourceRange.${reader}\` says it and answers \`undefined\` for an absent range just the same.`
+});
+/** `arg === EmptyArgument ? undefined : arg.value`, and the inverted spelling */
+const unpacked = (id, empty) => {
+    const [value, absent] = empty ? ['alternate', 'consequent'] : ['consequent', 'alternate'];
+    return {
+        id,
+        selector: `ConditionalExpression[test.type="BinaryExpression"][test.operator="${empty ? '===' : '!=='}"]${identifier('test.right', 'EmptyArgument')}`
+            + `${identifier(absent, 'undefined')}${prop(value, 'value')}`,
+        capture: { arg: 'test.left' },
+        replace: 'RArgument.valueOf({{arg}})',
+        declaredIn: { 'test.right': Files.call, [`${value}.property`]: Files.argument },
+        sameText: [['test.left', `${value}.object`]],
+        message: '`RArgument.valueOf` is this: the value of an argument, `undefined` for an empty one.'
+    };
+};
+/**
+ * `args.find(a => <a is not empty> && a.name?.content === 'x')`.
+ * `guard` is how the emptiness is tested: `a !== EmptyArgument`, `!RArgument.isEmpty(a)` or `RArgument.isNotEmpty(a)`.
+ */
+const findNamed = (id, guard) => {
+    const body = 'arguments.0.body', test = `${body}.left`, rhs = `${body}.right`, content = `${rhs}.left.expression`;
+    const [reference, pin, shape] = {
+        neq: [`${test}.left`, `${test}.right`, `[${test}.type="BinaryExpression"][${test}.operator="!=="]${identifier(`${test}.right`, 'EmptyArgument')}`],
+        isEmpty: [`${test}.argument.arguments.0`, `${test}.argument.callee.object`, `${not(test)}${helperCall(`${test}.argument`, 'RArgument', 'isEmpty')}`],
+        isNotEmpty: [`${test}.arguments.0`, `${test}.callee.object`, helperCall(test, 'RArgument', 'isNotEmpty')]
+    }[guard];
+    return {
+        id,
+        selector: `CallExpression${prop('callee', 'find')}[arguments.length=1]`
+            + `[arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=1][${body}.type="LogicalExpression"][${body}.operator="&&"]`
+            + `${shape}[${rhs}.type="BinaryExpression"][${rhs}.operator="==="][${rhs}.left.type="ChainExpression"]`
+            + `${member(content, 'content')}${prop(`${content}.object`, 'name')}:matches([${rhs}.right.type="Literal"], [${rhs}.right.type="Identifier"])`,
+        capture: { args: 'callee.object', name: `${rhs}.right` },
+        replace: 'RArgument.findNamed({{args}}, {{name}})',
+        declaredIn: { [pin]: guard === 'neq' ? Files.call : Files.argument, [`${content}.property`]: Files.symbol },
+        sameText: [['arguments.0.params.0', reference], ['arguments.0.params.0', `${content}.object.object`]],
+        message: '`RArgument.findNamed` finds the argument given by this exact name and skips the empty ones itself.'
+    };
+};
+/** `[...new Set(<x>)]` */
+const spreadSet = (extra) => 'ArrayExpression[elements.length=1][elements.0.type="SpreadElement"][elements.0.argument.type="NewExpression"]'
+    + `[elements.0.argument.callee.name="Set"][elements.0.argument.arguments.length=1]${extra}`;
+/** `[...g.edgesFrom(id)].filter(([, e]) => DfEdge.includesType(e, T)).map(([t]) => t)` and its `edgesTo` twin */
+const edgeNeighbors = (id, raw, helper) => {
+    const filter = 'callee.object', spread = `${filter}.callee.object.elements.0`, test = `${filter}.arguments.0`;
+    return {
+        id,
+        selector: `CallExpression${call('', 'map')}[arguments.length=1]`
+            + '[arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=1][arguments.0.params.0.type="ArrayPattern"]'
+            + '[arguments.0.params.0.elements.length=1][arguments.0.body.type="Identifier"]'
+            + `${call(filter, 'filter')}[${filter}.arguments.length=1][${filter}.callee.object.type="ArrayExpression"]`
+            + `[${filter}.callee.object.elements.length=1][${spread}.type="SpreadElement"]${call(`${spread}.argument`, raw)}[${spread}.argument.arguments.length=1]`
+            + `[${test}.type="ArrowFunctionExpression"][${test}.params.0.type="ArrayPattern"][${test}.params.0.elements.length=2]`
+            + `[${test}.params.0.elements.1.type="Identifier"]${helperCall(`${test}.body`, 'DfEdge', 'includesType', 2)}`,
+        capture: { graph: `${spread}.argument.callee.object`, node: `${spread}.argument.arguments.0`, types: `${test}.body.arguments.1` },
+        replace: `${helper}({{graph}}, {{node}}, {{types}})`,
+        declaredIn: { [`${spread}.argument.callee.property`]: Files.graph, [`${test}.body.callee.property`]: Files.edge },
+        sameText: [['arguments.0.params.0.elements.0', 'arguments.0.body'], [`${test}.params.0.elements.1`, `${test}.body.arguments.0`]],
+        message: `\`${helper}\` is this walk, name it instead of spelling out the filter.`
+    };
+};
+/** `x.name === 'lit'` on a vertex */
+const vertexName = (negated) => ({
+    selector: `${equality(negated)}${prop('left', 'name')}${text('right')}`,
+    capture: { vertex: 'left.object', name: 'right' },
+    replace: `Identifier.getName({{vertex}}.name) ${negated ? '!==' : '==='} {{name}}`,
+    declaredIn: { 'left.property': Files.vertex },
+    /* what the call is, rather than how it is spelled, may be what is meant */
+    fix: false,
+    message: 'The name of a call is how it is spelled: `pkg::name` is an array here, and an alias or a shadowing definition is not seen at all. Ask what it is with `DfgVertex.hasOrigin`, or `Dataflow.qualify` for the package.'
+});
+/** `symbol.content === 'name'`, which misses `pkg::name` as an identifier with a namespace is an array */
+const symbolName = (negated) => ({
+    selector: `${equality(negated)}${prop('left', 'content')}${text('right')}`,
     capture: { symbol: 'left.object', name: 'right' },
     replace: `Identifier.getName({{symbol}}.content) ${negated ? '!==' : '==='} {{name}}`,
-    declaredIn: { 'left.property': SYMBOL_NODE },
-    /* which of the two is meant is the author's call, so this is offered rather than applied */
+    declaredIn: { 'left.property': Files.symbol },
+    /* whether the namespace should count is the author's call */
     fix: false,
     message: 'An `Identifier` is not its name: `pkg::{{name}}` is an array and never `===` a string. Compare `Identifier.getName({{symbol}}.content)`, or `Identifier.matches` when the namespace should count.'
 });
-/** an empty-array or `NoEdges` fallback, the two ways the absent case used to be written out */
-const emptyEdges = ':matches([right.type="ArrayExpression"][right.elements.length=0], [right.type="Identifier"][right.name="NoEdges"])';
-/**
- * `graph.outgoingEdges(id) ?? <nothing>`, which `edgesFrom()`/`edgesTo()` already are: they answer with the
- * shared empty map for a vertex without edges, so the fallback is dead weight and an `[]` one allocates on
- * every miss besides. One pattern per direction, as the replacement names the method.
- */
-const edgesFallback = (id, raw, total) => ({
+/** `c.functionName.lexeme === 'lit'` on a call */
+const calleeLexeme = (negated) => ({
+    selector: `${equality(negated)}${prop('left', 'lexeme')}${prop('left.object', 'functionName')}${text('right')}`,
+    capture: { call: 'left.object.object', name: 'right' },
+    replace: `${bang(negated)}RFunctionCall.isNamed({{call}}, {{name}})`,
+    declaredIn: { 'left.property': Files.model },
+    /* the lexeme keeps quotes and the namespace, the helper compares the name */
+    fix: false,
+    message: 'The lexeme is how the callee is spelled, `RFunctionCall.isNamed` compares its name and keeps `pkg::{{name}}` and backticks out of the way.'
+});
+/** `isNamed(n) ? n.functionName.content : undefined`, guarded by the call or by a read of `named` */
+const calledNameOf = (id, guard) => ({
     id,
-    selector: `LogicalExpression[operator="??"]${emptyEdges}[left.type="CallExpression"]`
-        + `[left.callee.type="MemberExpression"][left.callee.computed=false][left.callee.property.name="${raw}"][left.arguments.length=1]`,
-    capture: { graph: 'left.callee.object', id: 'left.arguments.0' },
-    replace: `{{graph}}.${total}({{id}})`,
-    declaredIn: { 'left.callee.property': GRAPH },
-    message: `\`${total}\` is \`${raw}\` without the fallback: it answers with the shared empty map itself.`
+    selector: `ConditionalExpression${identifier('alternate', 'undefined')}${prop('consequent', 'content')}${prop('consequent.object', 'functionName')}`
+        + (guard === 'call' ? helperCall('test', 'RFunctionCall', 'isNamed') : prop('test', 'named')),
+    capture: { node: 'consequent.object.object' },
+    replace: 'RFunctionCall.calledName({{node}})',
+    declaredIn: { 'consequent.object.property': Files.call, [guard === 'call' ? 'test.callee.object' : 'test.property']: Files.call },
+    sameText: [[guard === 'call' ? 'test.arguments.0' : 'test.object', 'consequent.object.object']],
+    message: '`RFunctionCall.calledName` is this: the name of a named call, `undefined` otherwise.'
+});
+/** `v.origin.includes(o)` behind a call guard, as `isFunctionCall(v) && ...` or `!isFunctionCall(v) || !...` */
+const originGuarded = (negated) => {
+    const guard = negated ? 'left.argument' : 'left', includes = negated ? 'right.argument' : 'right';
+    return {
+        selector: `LogicalExpression[operator="${negated ? '||' : '&&'}"]${negated ? `${not('left')}${not('right')}` : ''}${helperCall(guard, 'DfgVertex', 'isFunctionCall')}`
+            + `${call(includes, 'includes')}[${includes}.arguments.length=1]${prop(`${includes}.callee.object`, 'origin')}`,
+        capture: { vertex: `${guard}.arguments.0`, origin: `${includes}.arguments.0` },
+        replace: `${bang(negated)}DfgVertex.hasOrigin({{vertex}}, {{origin}})`,
+        declaredIn: { [`${guard}.callee.object`]: Files.vertex, [`${includes}.callee.object.property`]: Files.vertex },
+        sameText: [[`${guard}.arguments.0`, `${includes}.callee.object.object`]],
+        /* `hasOrigin` does not narrow, code below may rely on the guard */
+        fix: false,
+        message: `Use \`${bang(negated)}DfgVertex.hasOrigin\`, it is exactly this check. Check the narrowing first, \`hasOrigin\` returns a plain boolean.`
+    };
+};
+/** `String(id).startsWith('built-in:')` and the plain `id.startsWith('built-in:')` */
+const builtInPrefix = (id, wrapped) => ({
+    id,
+    selector: `CallExpression${prop('callee', 'startsWith')}[arguments.length=1]${text('arguments.0', 'built-in:')}`
+        + (wrapped ? '[callee.object.type="CallExpression"][callee.object.callee.name="String"][callee.object.arguments.length=1]' : ':not([callee.object.type="CallExpression"])'),
+    capture: { id: wrapped ? 'callee.object.arguments.0' : 'callee.object' },
+    replace: 'NodeId.isBuiltIn({{id}})',
+    helperIn: Files.nodeId,
+    /* a lexeme or a path is not a node id */
+    ...wrapped ? {} : { fix: false },
+    message: 'Ask `NodeId.isBuiltIn`, the `built-in:` prefix is the helper\'s business.'
+});
+const builtInId = (id, selector, name) => ({
+    id,
+    selector,
+    capture: { name },
+    replace: 'NodeId.toBuiltIn({{name}})',
+    helperIn: Files.nodeId,
+    message: 'Build a built-in id with `NodeId.toBuiltIn`, the prefix is the helper\'s business.'
+});
+/** `filter(...).length > 0` or `=== 0`, `some` stops at the first hit */
+const someInsteadOfFilter = (id, nonZero) => ({
+    id,
+    selector: `${versusZero(nonZero)}${prop('left', 'length')}${call('left.object', 'filter')}[left.object.arguments.length=1]`,
+    capture: { array: 'left.object.callee.object', predicate: 'left.object.arguments.0' },
+    replace: `${bang(!nonZero)}{{array}}.some({{predicate}})`,
+    message: `\`filter(...).length ${nonZero ? '> 0' : '=== 0'}\` walks the whole list and allocates the matches, \`${bang(!nonZero)}some\` stops at the first hit.`
 });
 const patterns = [
-    edgeIsOnly('edge-is-only-type'),
-    edgeIsOnly('edge-is-not-only-type', { negated: true }),
-    edgeIsOnly('edge-is-only-type-destructured', { destructured: true }),
-    edgeIsOnly('edge-is-not-only-type-destructured', { negated: true, destructured: true }),
+    ...negatable(['edge-is-only-type', 'edge-is-not-only-type'], negated => edgeIsOnly(negated, false)),
+    ...negatable(['edge-is-only-type-destructured', 'edge-is-not-only-type-destructured'], negated => edgeIsOnly(negated, true)),
     edgeStates('edge-has-any-type', 'hasAnyType', 'anything', true),
     edgeStates('edge-has-no-type', 'hasNoType', 'nothing', false),
     edgeMask('edge-includes-type', 'includesType', true),
     edgeMask('edge-does-not-include-type', 'doesNotIncludeType', false),
     {
-        /*
-         * `SourceLocation.fromNode(n) ?? []` only exists so the positional destructure below it survives an
-         * absent location; the view reads the same places by name and combines with `?.`
-         */
+        /* the `?? []` only exists so a positional destructure survives an absent location */
         id: 'location-at-node',
         selector: `LogicalExpression[operator="??"][right.type="ArrayExpression"][right.elements.length=0]${helperCall('left', 'SourceLocation', 'fromNode')}`,
         capture: { node: 'left.arguments.0' },
         replace: 'SourceLocation.at({{node}})',
-        declaredIn: { 'left.callee.object': RANGE },
-        /* the destructure around it has to become property reads, which is the author's call */
+        declaredIn: { 'left.callee.object': Files.range },
+        /* the destructure has to become property reads */
         fix: false,
         message: '`SourceLocation.at({{node}})` answers with a view: `.startLine`, `.file`, and `?.` for the absent case, so the `?? []` and the positional destructure both go away.'
     },
     {
-        /*
-         * every source range is a source location without a file, so the range readers take a location as it
-         * is and `SourceLocation` re-exports them under its own name
-         */
+        /* a source range is a source location without a file, so the readers take a location as it is */
         id: 'location-range-hop',
-        selector: 'CallExpression[callee.type="MemberExpression"][callee.computed=false]'
-            + '[callee.object.name=/^Source(Range|Location)$/][arguments.length=1]'
-            + `${helperCall('arguments.0', 'SourceLocation', 'getRange')}`,
+        selector: 'CallExpression[callee.type="MemberExpression"][callee.computed=false][callee.object.name=/^Source(Range|Location)$/][arguments.length=1]'
+            + helperCall('arguments.0', 'SourceLocation', 'getRange'),
         capture: { reader: 'callee.property', location: 'arguments.0.arguments.0' },
         replace: 'SourceLocation.{{reader}}({{location}})',
-        declaredIn: { 'callee.object': RANGE, 'arguments.0.callee.object': RANGE },
+        declaredIn: { 'callee.object': Files.range, 'arguments.0.callee.object': Files.range },
         message: 'Drop the `getRange` hop, `SourceLocation.{{reader}}` reads the location directly.'
     },
     {
-        /* the readers answer `undefined` for an absent input, so the guard repeats what the type already says */
+        /* the readers answer `undefined` for an absent input */
         id: 'accessor-undefined-guard',
-        selector: `ConditionalExpression${versusUndefined('test', false)}`
-            + '[consequent.type="Identifier"][consequent.name="undefined"]'
+        selector: `ConditionalExpression${versusUndefined('test', false)}${identifier('consequent', 'undefined')}`
             + '[alternate.type="CallExpression"][alternate.callee.type="MemberExpression"][alternate.callee.computed=false]'
-            + '[alternate.callee.property.name=/^(get|format|view|at)/]'
-            + '[alternate.callee.object.name=/^Source(Range|Location)$/][alternate.arguments.length=1]',
+            + '[alternate.callee.property.name=/^(get|format|view|at)/][alternate.callee.object.name=/^Source(Range|Location)$/][alternate.arguments.length=1]',
         capture: { call: 'alternate' },
         replace: '{{call}}',
         sameText: [['test.left', 'alternate.arguments.0']],
-        declaredIn: { 'alternate.callee.object': RANGE },
+        declaredIn: { 'alternate.callee.object': Files.range },
         message: 'The reader passes an absent input through, the `=== undefined` guard says nothing on top of it.'
     },
     {
-        /* `Identifier.toString` answers `undefined` for an absent identifier, an empty name is a different thing */
         id: 'identifier-tostring-fallback',
-        selector: `${rootHelperCall('Identifier', 'toString')}`
-            + '[arguments.0.type="LogicalExpression"][arguments.0.operator="??"]'
-            + '[arguments.0.right.type="Literal"][arguments.0.right.value=""]',
+        selector: `CallExpression${helperCall('', 'Identifier', 'toString')}[arguments.0.type="LogicalExpression"][arguments.0.operator="??"]${text('arguments.0.right', '')}`,
         capture: { id: 'arguments.0.left' },
         replace: 'Identifier.toString({{id}})',
-        declaredIn: { 'callee.object': IDENTIFIER },
-        /* an empty string and `undefined` read differently downstream, so this is offered rather than applied */
+        declaredIn: { 'callee.object': Files.identifier },
+        /* an empty string and `undefined` read differently downstream */
         fix: false,
         message: '`Identifier.toString` passes an absent identifier through; the `?? \'\'` turns "no name" into the name `""`.'
     },
@@ -214,97 +366,224 @@ const patterns = [
         selector: `:matches(IfStatement, ConditionalExpression, WhileStatement, DoWhileStatement, LogicalExpression, UnaryExpression[operator="!"], ArrowFunctionExpression) > BinaryExpression[operator="&"]${types('left')}`,
         capture: { edge: 'left.object', type: 'right' },
         replace: 'DfEdge.includesType({{edge}}, {{type}})',
-        declaredIn: { 'left.property': EDGE },
+        declaredIn: { 'left.property': Files.edge },
         message: 'Do not rely on the bitmask being truthy, `DfEdge.includesType` says what is meant.'
     },
-    {
-        id: 'vertex-has-origin',
-        selector: 'LogicalExpression[operator="&&"]'
-            + `${helperCall('left', 'DfgVertex', 'isFunctionCall')}`
-            + `${call('right', 'includes')}[right.callee.object.type="MemberExpression"][right.callee.object.property.name="origin"]`,
-        capture: { vertex: 'left.arguments.0', origin: 'right.arguments.0' },
-        replace: 'DfgVertex.hasOrigin({{vertex}}, {{origin}})',
-        declaredIn: { 'left.callee.object': VERTEX, 'right.callee.object.property': VERTEX },
-        sameText: [['left.arguments.0', 'right.callee.object.object']],
-        /* `hasOrigin` is no type predicate, so the replacement can drop a narrowing the code below relies on */
-        fix: false,
-        message: 'Use `DfgVertex.hasOrigin`, it is exactly this check. Check the narrowing first, `hasOrigin` returns a plain boolean.'
-    },
+    ...negatable(['vertex-has-origin', 'vertex-lacks-origin'], originGuarded),
     edgesFallback('graph-edges-from', 'outgoingEdges', 'edgesFrom'),
     edgesFallback('graph-edges-to', 'ingoingEdges', 'edgesTo'),
-    vertexIs('vertex-is'),
-    vertexIs('vertex-is-not', { negated: true }),
-    vertexIs('vertex-is-optional', { optional: true }),
-    vertexIs('vertex-is-not-optional', { negated: true, optional: true }),
-    nodeIs('node-is'),
-    nodeIs('node-is-not', { negated: true }),
-    nodeIs('node-is-optional', { optional: true }),
-    nodeIs('node-is-not-optional', { negated: true, optional: true }),
-    guardWrittenOut({
-        id: 'call-is-named', helper: 'RFunctionCall', member: 'isNamed', file: CALL_NODE,
-        guard: `[right.type="MemberExpression"]${member('right', 'named')}`,
-        subject: 'right.object',
-        message: 'Use `RFunctionCall.isNamed`, it is this check and narrows to `RNamedFunctionCall`.'
-    }),
-    guardWrittenOut({
-        id: 'call-is-named-strict', helper: 'RFunctionCall', member: 'isNamed', file: CALL_NODE,
-        guard: `[right.type="BinaryExpression"][right.operator="==="][right.right.type="Literal"][right.right.value=true]${member('right.left', 'named')}`,
-        subject: 'right.left.object',
-        message: 'Use `RFunctionCall.isNamed`, it is this check and narrows to `RNamedFunctionCall`.'
-    }),
-    guardWrittenOut({
-        id: 'call-is-unnamed', helper: 'RFunctionCall', member: 'isUnnamed', file: CALL_NODE,
-        guard: `[right.type="UnaryExpression"][right.operator="!"][right.argument.type="MemberExpression"]${member('right.argument', 'named')}`,
-        subject: 'right.argument.object',
-        message: 'Use `RFunctionCall.isUnnamed`, it is this check and narrows to `RUnnamedFunctionCall`.'
-    }),
-    guardWrittenOut({
-        id: 'argument-is-named', helper: 'RArgument', member: 'isNamed', file: ARGUMENT_NODE,
-        guard: `${versusUndefined('right', true)}${member('right.left', 'name')}`,
-        subject: 'right.left.object',
-        message: 'Use `RArgument.isNamed`, it is this check and keeps the `name` non-optional afterwards.'
-    }),
-    guardWrittenOut({
-        id: 'argument-is-with-value', helper: 'RArgument', member: 'isWithValue', file: ARGUMENT_NODE,
-        guard: `${versusUndefined('right', true)}${member('right.left', 'value')}`,
-        subject: 'right.left.object',
-        message: 'Use `RArgument.isWithValue`, it is this check and keeps the `value` non-optional afterwards.'
+    ...discriminatorIs(['vertex-is', 'vertex-is-not', 'vertex-is-optional', 'vertex-is-not-optional'], {
+        property: 'tag', enumName: 'VertexType', enumFile: Files.vertex, propertyFile: Files.vertex,
+        helper: 'DfgVertex.is{{type|last}}', hint: 'Compare through the vertex helper'
     }),
-    guardWrittenOut({
-        id: 'list-is-implicit', helper: 'RExpressionList', member: 'isImplicit', file: LIST_NODE,
-        guard: `${versusUndefined('right', false)}${member('right.left', 'grouping')}`,
-        subject: 'right.left.object',
-        message: 'Use `RExpressionList.isImplicit`, an expression list without `grouping` is exactly the implicit one.'
+    ...discriminatorIs(['node-is', 'node-is-not', 'node-is-optional', 'node-is-not-optional'], {
+        property: 'type', enumName: 'RType', enumFile: Files.rType,
+        helper: 'R{{type|last}}.is', hint: 'Ask the AST node helper'
     }),
-    symbolName('symbol-name-comparison', false),
-    symbolName('symbol-name-comparison-not', true),
+    guardWrittenOut('call-is-named', 'RFunctionCall', 'isNamed', Files.call, prop('right', 'named'), 'right.object', 'Use `RFunctionCall.isNamed`, it is this check and narrows to `RNamedFunctionCall`.'),
+    guardWrittenOut('call-is-named-strict', 'RFunctionCall', 'isNamed', Files.call, `[right.type="BinaryExpression"][right.operator="==="][right.right.type="Literal"][right.right.value=true]${member('right.left', 'named')}`, 'right.left.object', 'Use `RFunctionCall.isNamed`, it is this check and narrows to `RNamedFunctionCall`.'),
+    guardWrittenOut('call-is-unnamed', 'RFunctionCall', 'isUnnamed', Files.call, `${not('right')}${prop('right.argument', 'named')}`, 'right.argument.object', 'Use `RFunctionCall.isUnnamed`, it is this check and narrows to `RUnnamedFunctionCall`.'),
+    guardWrittenOut('argument-is-named', 'RArgument', 'isNamed', Files.argument, `${versusUndefined('right', true)}${member('right.left', 'name')}`, 'right.left.object', 'Use `RArgument.isNamed`, it is this check and keeps the `name` non-optional afterwards.'),
+    guardWrittenOut('argument-is-with-value', 'RArgument', 'isWithValue', Files.argument, `${versusUndefined('right', true)}${member('right.left', 'value')}`, 'right.left.object', 'Use `RArgument.isWithValue`, it is this check and keeps the `value` non-optional afterwards.'),
+    guardWrittenOut('list-is-implicit', 'RExpressionList', 'isImplicit', Files.list, `${versusUndefined('right', false)}${member('right.left', 'grouping')}`, 'right.left.object', 'Use `RExpressionList.isImplicit`, an expression list without `grouping` is exactly the implicit one.'),
+    ...negatable(['call-is-named-literal', 'call-is-not-named-literal'], namedCallOf(false)),
+    ...negatable(['call-is-named-in-set', 'call-is-not-named-in-set'], namedCallOf(true)),
+    ...nodeFallback(['node-lexeme', 'node-lexeme-optional'], 'fullLexeme', 'lexeme', true, 'RNode.lexeme', 'Use `RNode.lexeme`, it reads the code the node spans, the full lexeme first.'),
+    ...nodeFallback(['node-own-lexeme', 'node-own-lexeme-optional'], 'fullLexeme', 'lexeme', false, 'RNode.ownLexeme', 'Use `RNode.ownLexeme`, it reads the token the node is made of, its own lexeme first.'),
+    ...nodeFallback(['node-range', 'node-range-optional'], 'fullRange', 'location', true, 'SourceRange.fromNode', 'Use `SourceRange.fromNode`, it reads the full range and falls back to the location.'),
+    ...nodeFallback(['node-own-range', 'node-own-range-optional'], 'fullRange', 'location', false, 'SourceRange.ownFromNode', 'Use `SourceRange.ownFromNode`, it reads the location of the node\'s own token and falls back to the full range.'),
+    rangeIndex('range-start-line', 0, 'getStartLine'),
+    rangeIndex('range-start-column', 1, 'getStartColumn'),
+    rangeIndex('range-end-line', 2, 'getEndLine'),
+    rangeIndex('range-end-column', 3, 'getEndColumn'),
+    {
+        id: 'node-id-recover-name',
+        selector: `ChainExpression[expression.type="MemberExpression"][expression.optional=true]${member('expression', 'lexeme')}`
+            + `${call('expression.object', 'get')}[expression.object.callee.computed=false][expression.object.arguments.length=1]`
+            + ':matches([expression.object.callee.object.name=/idMap/i], [expression.object.callee.object.property.name=/idMap/i])',
+        capture: { id: 'expression.object.arguments.0', map: 'expression.object.callee.object' },
+        replace: 'NodeId.recoverName({{id}}, {{map}})',
+        declaredIn: { 'expression.property': Files.model },
+        message: '`NodeId.recoverName` is this lookup, the lexeme of the node an id belongs to.'
+    },
+    unpacked('unpack-arg', true),
+    unpacked('unpack-arg-inverted', false),
+    findNamed('find-named-arg', 'neq'),
+    findNamed('find-named-arg-not-empty', 'isNotEmpty'),
+    findNamed('find-named-arg-negated-empty', 'isEmpty'),
+    {
+        id: 'call-sole-argument',
+        selector: 'ConditionalExpression[test.type="LogicalExpression"][test.operator="&&"][test.left.type="BinaryExpression"][test.left.operator="==="]'
+            + `${prop('test.left.left', 'length')}[test.left.right.type="Literal"][test.left.right.value=1]`
+            + '[test.right.type="BinaryExpression"][test.right.operator="!=="][test.right.left.type="MemberExpression"][test.right.left.computed=true]'
+            + `[test.right.left.property.value=0]${identifier('test.right.right', 'EmptyArgument')}`
+            + `[consequent.type="MemberExpression"][consequent.computed=true][consequent.property.value=0]${identifier('alternate', 'undefined')}`,
+        capture: { args: 'test.left.left.object' },
+        replace: 'RFunctionCall.soleArgument({{args}})',
+        declaredIn: { 'test.right.right': Files.call },
+        sameText: [['test.left.left.object', 'test.right.left.object'], ['test.left.left.object', 'consequent.object']],
+        message: '`RFunctionCall.soleArgument` is this: the one argument, `undefined` unless there is exactly one and it is not empty.'
+    },
+    calledNameOf('call-called-name', 'call'),
+    calledNameOf('call-called-name-named', 'property'),
+    ...negatable(['callee-lexeme-comparison', 'callee-lexeme-comparison-not'], calleeLexeme),
+    ...negatable(['vertex-name-comparison', 'vertex-name-comparison-not'], vertexName),
+    ...negatable(['symbol-name-comparison', 'symbol-name-comparison-not'], symbolName),
+    {
+        id: 'vertex-has-origin-array',
+        selector: `LogicalExpression[operator="&&"][left.type="LogicalExpression"][left.operator="&&"]${helperCall('left.left', 'DfgVertex', 'isFunctionCall')}`
+            + `${helperCall('left.right', 'Array', 'isArray')}${prop('left.right.arguments.0', 'origin')}`
+            + `${call('right', 'includes')}[right.arguments.length=1]${prop('right.callee.object', 'origin')}`,
+        capture: { vertex: 'left.left.arguments.0', origin: 'right.arguments.0' },
+        replace: 'DfgVertex.hasOrigin({{vertex}}, {{origin}})',
+        declaredIn: { 'left.left.callee.object': Files.vertex, 'right.callee.object.property': Files.vertex },
+        sameText: [['left.left.arguments.0', 'left.right.arguments.0.object'], ['left.left.arguments.0', 'right.callee.object.object']],
+        fix: false,
+        message: '`DfgVertex.hasOrigin` is this check including the `Array.isArray`. Check the narrowing first, `hasOrigin` returns a plain boolean.'
+    },
+    {
+        id: 'vertex-origin-includes',
+        /* the guarded spellings have patterns of their own, and the origin of a `link` is no vertex origin */
+        selector: `CallExpression${prop('callee', 'includes')}`
+            + ':not(LogicalExpression[operator="&&"] > CallExpression):not(LogicalExpression[operator="||"] > UnaryExpression > CallExpression)'
+            + `[arguments.length=1]${prop('callee.object', 'origin')}:not([callee.object.object.property.name="link"])`,
+        capture: { vertex: 'callee.object.object', origin: 'arguments.0' },
+        replace: 'DfgVertex.hasOrigin({{vertex}}, {{origin}})',
+        declaredIn: { 'callee.object.property': Files.vertex },
+        /* the vertex may need the narrowing `hasOrigin` adds */
+        fix: false,
+        message: 'Ask `DfgVertex.hasOrigin` instead of reading the origin list by hand.'
+    },
+    {
+        id: 'graph-vertices-of-type',
+        selector: `CallExpression${prop('callee', 'filter')}[arguments.length=1]${call('callee.object', 'vertices')}[callee.object.arguments.length=1]`
+            + '[arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=1][arguments.0.params.0.type="ArrayPattern"][arguments.0.params.0.elements.length=2]'
+            + '[arguments.0.params.0.elements.1.type="Identifier"][arguments.0.body.type="BinaryExpression"][arguments.0.body.operator="==="]'
+            + `${prop('arguments.0.body.left', 'tag')}${enumMember('arguments.0.body.right', 'VertexType')}`,
+        capture: { graph: 'callee.object.callee.object', type: 'arguments.0.body.right' },
+        replace: '{{graph}}.verticesOfType({{type}})',
+        declaredIn: { 'callee.object.callee.property': Files.graph, 'arguments.0.body.right.object': Files.vertex },
+        sameText: [['arguments.0.params.0.elements.1', 'arguments.0.body.left.object']],
+        /* the order follows the types, not the insertion */
+        fix: false,
+        message: '`verticesOfType` goes straight to the vertices of that type instead of walking all of them.'
+    },
+    edgeNeighbors('edge-targets', 'edgesFrom', 'Dataflow.targetsOf'),
+    edgeNeighbors('edge-sources', 'edgesTo', 'Dataflow.sourcesOf'),
+    {
+        id: 'edge-has-type-between',
+        selector: `CallExpression${helperCall('', 'DfEdge', 'includesType', 2)}`
+            + `[arguments.0.type="LogicalExpression"][arguments.0.operator="??"]${call('arguments.0.left', 'get')}[arguments.0.left.arguments.length=1]`
+            + `${call('arguments.0.left.callee.object', 'edgesFrom')}[arguments.0.left.callee.object.arguments.length=1]`
+            + '[arguments.0.right.type="ObjectExpression"][arguments.0.right.properties.length=1][arguments.0.right.properties.0.key.name="types"][arguments.0.right.properties.0.value.value=0]',
+        capture: { graph: 'arguments.0.left.callee.object.callee.object', from: 'arguments.0.left.callee.object.arguments.0', to: 'arguments.0.left.arguments.0', types: 'arguments.1' },
+        replace: 'Dataflow.hasEdge({{graph}}, {{from}}, {{to}}, {{types}})',
+        declaredIn: { 'callee.property': Files.edge, 'arguments.0.left.callee.object.callee.property': Files.graph },
+        message: '`Dataflow.hasEdge` asks whether an edge between two vertices carries a type, absent edge included.'
+    },
+    {
+        id: 'environment-frames',
+        selector: `ForStatement[init.type="VariableDeclaration"][init.declarations.length=1]${not('test')}${prop('test.argument', 'builtInEnv')}`
+            + `[update.type="AssignmentExpression"][update.operator="="]${prop('update.right', 'parent')}`,
+        capture: { frame: 'init.declarations.0.id', start: 'init.declarations.0.init', body: 'body' },
+        replace: 'for(const {{frame}} of REnvironment.frames({{start}})) {{body}}',
+        declaredIn: { 'test.argument.property': Files.environment },
+        sameText: [['init.declarations.0.id', 'test.argument.object'], ['init.declarations.0.id', 'update.left'], ['init.declarations.0.id', 'update.right.object']],
+        /* the walk may stop early or reassign the variable */
+        fix: false,
+        message: '`REnvironment.frames` yields these frames, innermost first and without the built-in one.'
+    },
+    builtInPrefix('built-in-id-string', true),
+    builtInPrefix('built-in-id-prefix', false),
+    builtInId('to-built-in-template', 'TemplateLiteral[quasis.length=2][expressions.length=1][quasis.0.value.raw="built-in:"][quasis.1.value.raw=""]', 'expressions.0'),
+    builtInId('to-built-in-concat', `BinaryExpression[operator="+"]${text('left', 'built-in:')}`, 'right'),
+    {
+        id: 'remove-r-quotes',
+        selector: `CallExpression${prop('callee', 'replace')}[arguments.length=2][arguments.0.type="Literal"][arguments.0.regex.flags="g"]`
+            + String.raw `[arguments.0.regex.pattern=/^\^\[[^\]]*[\x22\x27\x60][^\]]*\]\|\[[^\]]*[\x22\x27\x60][^\]]*\]\$$/]`
+            + text('arguments.1', ''),
+        capture: { str: 'callee.object' },
+        replace: 'RString.unquote({{str}})',
+        helperIn: Files.string,
+        /* the regex strips each end on its own, the helper only a matching pair */
+        fix: false,
+        message: '`RString.unquote` strips the R quotes of a name, `RString.splitQuotes` also tells which one it was.'
+    },
+    {
+        id: 'escape-regex',
+        selector: 'CallExpression[callee.type="MemberExpression"][callee.property.name=/^replace(All)?$/][arguments.length=2][arguments.0.type="Literal"]'
+            + String.raw `[arguments.0.regex.flags="g"][arguments.0.regex.pattern=/^\[\.\*\+\?\^\$\{\}\(\)\|\[\\\]\\\\\]$/]`
+            + String.raw `[arguments.1.type="Literal"][arguments.1.value=/^\\\$&$/]`,
+        capture: { str: 'callee.object' },
+        replace: 'escapeRegex({{str}})',
+        helperIn: Files.strings,
+        message: 'Use `escapeRegex` to match text literally, do not spell out the character class.'
+    },
+    {
+        id: 'identifier-split',
+        selector: `CallExpression${prop('callee', 'split')}[arguments.length=1]${text('arguments.0', '::')}`
+            + ':matches([callee.object.name=/name|ident|symbol|qualified|fn/i], [callee.object.property.name=/name|ident|symbol|qualified|fn/i], [callee.object.expression.property.name=/name|ident|symbol|qualified|fn/i])',
+        capture: { str: 'callee.object' },
+        replace: 'Identifier.parse({{str}})',
+        helperIn: Files.identifier,
+        /* the parts come back as a tuple, and the text may not be an identifier at all */
+        fix: false,
+        message: 'Do not take `pkg::name` apart by hand: `Identifier.parse`, then `Identifier.getName` and `Identifier.getNamespace` (`:::` is part of the syntax).'
+    },
+    {
+        id: 'unique-array',
+        selector: spreadSet(':not([elements.0.argument.arguments.0.type="ArrayExpression"])'),
+        capture: { items: 'elements.0.argument.arguments.0' },
+        replace: 'uniqueArray({{items}})',
+        helperIn: Files.arrays,
+        message: 'Use `uniqueArray`, a duplicate-free copy is not a place for a `Set` detour.'
+    },
+    {
+        id: 'unique-array-merge',
+        selector: spreadSet('[elements.0.argument.arguments.0.type="ArrayExpression"][elements.0.argument.arguments.0.elements.length=2]'
+            + '[elements.0.argument.arguments.0.elements.0.type="SpreadElement"][elements.0.argument.arguments.0.elements.1.type="SpreadElement"]'),
+        capture: { left: 'elements.0.argument.arguments.0.elements.0.argument', right: 'elements.0.argument.arguments.0.elements.1.argument' },
+        replace: 'uniqueArrayMerge({{left}}, {{right}})',
+        helperIn: Files.arrays,
+        /* the helper wants arrays, a spread also takes iterables */
+        fix: false,
+        message: 'Use `uniqueArrayMerge`, it merges two arrays without duplicates.'
+    },
+    {
+        id: 'array-equal',
+        selector: `LogicalExpression[operator="&&"][left.type="BinaryExpression"][left.operator="==="]${prop('left.left', 'length')}${prop('left.right', 'length')}`
+            + `${call('right', 'every')}[right.arguments.length=1][right.arguments.0.type="ArrowFunctionExpression"][right.arguments.0.params.length=2]`
+            + '[right.arguments.0.body.type="BinaryExpression"][right.arguments.0.body.operator="==="][right.arguments.0.body.right.type="MemberExpression"][right.arguments.0.body.right.computed=true]',
+        capture: { left: 'left.left.object', right: 'left.right.object' },
+        replace: 'arrayEqual({{left}}, {{right}})',
+        helperIn: Files.arrays,
+        sameText: [['left.left.object', 'right.callee.object'], ['left.right.object', 'right.arguments.0.body.right.object'],
+            ['right.arguments.0.params.0', 'right.arguments.0.body.left'], ['right.arguments.0.params.1', 'right.arguments.0.body.right.property']],
+        message: 'Use `arrayEqual`, comparing two arrays element by element is its job.'
+    },
+    {
+        id: 'sort-code-unit',
+        selector: `CallExpression${prop('callee', 'sort')}[arguments.length=1][arguments.0.type="ArrowFunctionExpression"]`
+            + `[arguments.0.params.length=2]${call('arguments.0.body', 'localeCompare')}[arguments.0.body.arguments.length=1]`,
+        capture: { list: 'callee.object' },
+        replace: '{{list}}.sort(compareByCodeUnit)',
+        helperIn: Files.strings,
+        sameText: [['arguments.0.params.0', 'arguments.0.body.callee.object'], ['arguments.0.params.1', 'arguments.0.body.arguments.0']],
+        /* `localeCompare` is fine for an order only a reader sees */
+        fix: false,
+        message: '`localeCompare` depends on the locale and the ICU build, so an order that feeds an analysis result should use `compareByCodeUnit`.'
+    },
     {
         id: 'array-sum',
-        selector: 'CallExpression[callee.type="MemberExpression"][callee.property.name="reduce"][arguments.length=2]'
-            + '[arguments.1.type="Literal"][arguments.1.value=0]'
-            + '[arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=2]'
-            + '[arguments.0.body.type="BinaryExpression"][arguments.0.body.operator="+"]',
+        selector: `CallExpression${prop('callee', 'reduce')}[arguments.length=2][arguments.1.type="Literal"][arguments.1.value=0]`
+            + '[arguments.0.type="ArrowFunctionExpression"][arguments.0.params.length=2][arguments.0.body.type="BinaryExpression"][arguments.0.body.operator="+"]',
         capture: { array: 'callee.object' },
         replace: 'arraySum({{array}})',
+        helperIn: Files.arrays,
         sameText: [['arguments.0.params.0', 'arguments.0.body.left'], ['arguments.0.params.1', 'arguments.0.body.right']],
         message: 'Use `arraySum`, summing a list is not a place to spell out a fold.'
     },
-    {
-        /* `filter` walks the whole list and allocates the matches only to ask whether there is one */
-        id: 'some-instead-of-filter-length',
-        selector: `${versusZero(true)}[left.type="MemberExpression"]${member('left', 'length')}`
-            + `${call('left.object', 'filter')}[left.object.arguments.length=1]`,
-        capture: { array: 'left.object.callee.object', predicate: 'left.object.arguments.0' },
-        replace: '{{array}}.some({{predicate}})',
-        message: '`filter(...).length > 0` walks the whole list and allocates the matches, `some` stops at the first hit.'
-    },
-    {
-        id: 'none-instead-of-filter-length',
-        selector: `${versusZero(false)}[left.type="MemberExpression"]${member('left', 'length')}`
-            + `${call('left.object', 'filter')}[left.object.arguments.length=1]`,
-        capture: { array: 'left.object.callee.object', predicate: 'left.object.arguments.0' },
-        replace: '!{{array}}.some({{predicate}})',
-        message: '`filter(...).length === 0` walks the whole list and allocates the matches, `!some` stops at the first hit.'
-    }
+    someInsteadOfFilter('some-instead-of-filter-length', true),
+    someInsteadOfFilter('none-instead-of-filter-length', false)
 ];
 module.exports = patterns;

package/plugin.d.ts

@@ -5,6 +5,7 @@ declare const plugin: {
     rules: {
         'use-instead': import("eslint").Rule.RuleModule;
         'replacement-pattern': import("eslint").Rule.RuleModule;
+        'file-naming': import("eslint").Rule.RuleModule;
     };
 };
 export = plugin;

package/plugin.js

@@ -5,11 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 /** The flowR-specific rules, see the README for the tags they read. */
 const replacement_pattern_1 = __importDefault(require("./rules/replacement-pattern"));
 const use_instead_1 = __importDefault(require("./rules/use-instead"));
+const file_naming_1 = __importDefault(require("./rules/file-naming"));
 const plugin = {
     meta: { name: '@eagleoutice/eslint-config-flowr' },
     rules: {
         'use-instead': use_instead_1.default,
-        'replacement-pattern': replacement_pattern_1.default
+        'replacement-pattern': replacement_pattern_1.default,
+        'file-naming': file_naming_1.default
     }
 };
 module.exports = plugin;

package/rules/file-naming.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export = rule;

package/rules/file-naming.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = __importDefault(require("path"));
+/** `dataflow-graph`, `Vertex`, `1-setup`, `r-bridge.test`: lower-case words, each optionally capitalized */
+const fileName = /^(\d+-)?[A-Z]?[a-z]+([-.][A-Z]?[a-z]+)*$/;
+const specFile = /\.spec\.[jt]sx?$/;
+const rule = {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'enforce the flowR file naming convention and keep spec files in the test folder',
+            url: 'https://github.com/flowr-analysis/flowr-lint#flowrfile-naming'
+        },
+        schema: [],
+        messages: {
+            name: 'The filename "{{ name }}" does not match {{ pattern }}',
+            spec: 'The spec file "{{ name }}" belongs below test/'
+        }
+    },
+    create(context) {
+        return {
+            Program(node) {
+                const file = path_1.default.relative(context.cwd, context.physicalFilename).split(path_1.default.sep).join('/');
+                const name = path_1.default.posix.basename(file);
+                if (name.endsWith('.ts') && !fileName.test(name.slice(0, name.lastIndexOf('.')))) {
+                    context.report({ node, messageId: 'name', data: { name, pattern: String(fileName) } });
+                }
+                if (specFile.test(name) && !file.startsWith('test/')) {
+                    context.report({ node, messageId: 'spec', data: { name } });
+                }
+            }
+        };
+    }
+};
+module.exports = rule;

package/rules/replacement-pattern.js

@@ -28,6 +28,46 @@ function render(template, captures, node, sourceCode) {
     });
     return failed ? undefined : filled;
 }
+/** the name a replacement calls, `escapeRegex` for `escapeRegex(s)` and `toBuiltIn` for `!NodeId.toBuiltIn(x)` */
+function calledBy(replacement) {
+    return /^!?(?:[A-Za-z_$][\w$]*\.)*([A-Za-z_$][\w$]*)\(/.exec(replacement)?.[1];
+}
+/** the name a function is declared or bound under, as a declaration, an object member, or a variable */
+function nameOf(fn, parent) {
+    if (fn.type === 'FunctionDeclaration' || fn.type === 'FunctionExpression') {
+        if (fn.id) {
+            return fn.id.name;
+        }
+    }
+    if (parent?.type === 'Property' || parent?.type === 'MethodDefinition') {
+        return parent.key.type === 'Identifier' ? parent.key.name : undefined;
+    }
+    return parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier' ? parent.id.name : undefined;
+}
+/** Whether `node` sits in the function the replacement would call, where the fix would make the helper call itself. */
+function withinReplacement(node, replacement, sourceCode) {
+    const called = calledBy(replacement);
+    if (called === undefined) {
+        return false;
+    }
+    const ancestors = sourceCode.getAncestors(node);
+    return ancestors.some((fn, i) => (fn.type === 'FunctionDeclaration' || fn.type === 'FunctionExpression' || fn.type === 'ArrowFunctionExpression')
+        && nameOf(fn, ancestors[i - 1]) === called);
+}
+/** per program, whether one of its files matches a `helperIn` path; every file of a run shares the program */
+const helperFiles = new WeakMap();
+function programHas(program, path) {
+    let known = helperFiles.get(program);
+    if (known === undefined) {
+        helperFiles.set(program, known = new Map());
+    }
+    let has = known.get(path);
+    if (has === undefined) {
+        has = program.getSourceFiles().some(file => file.fileName.replaceAll('\\', '/').includes(path));
+        known.set(path, has);
+    }
+    return has;
+}
 const rule = {
     meta: {
         type: 'suggestion',
@@ -56,6 +96,8 @@ const rule = {
                                 replace: { type: 'string' },
                                 /** path to a substring of the file its symbol must be declared in, this is what keeps the pattern flowR-specific */
                                 declaredIn: { type: 'object', additionalProperties: { type: 'string' } },
+                                /** path to a substring of the file the replacement's helper lives in, the pattern is silent in a program without it */
+                                helperIn: { type: 'string' },
                                 /** pairs of paths that have to spell the same code, esquery has no back-references */
                                 sameText: { type: 'array', items: { type: 'array', items: { type: 'string' }, minItems: 2, maxItems: 2 } },
                                 /** `true` forces the autofix, `false` forces a suggestion; by default it is fixed when the replacement is already in scope */
@@ -94,7 +136,10 @@ const rule = {
          * The declaring file itself is exempt, it is where the helper is built.
          */
         function isFlowr(node, pattern) {
-            if (!pattern.declaredIn) {
+            if (pattern.helperIn !== undefined && (!services || !programHas(services.program, pattern.helperIn))) {
+                return false;
+            }
+            else if (!pattern.declaredIn) {
                 return true;
             }
             else if (!services || !checker) {
@@ -121,7 +166,10 @@ const rule = {
             const replacement = render(pattern.replace, captures, node, sourceCode);
             const message = (pattern.message === undefined ? undefined : render(pattern.message, captures, node, sourceCode))
                 ?? (replacement ? `Use \`${replacement}\` here.` : `\`${pattern.id ?? pattern.selector}\` has a helper replacement.`);
-            if (replacement === undefined) {
+            if (replacement !== undefined && withinReplacement(node, replacement, sourceCode)) {
+                return;
+            }
+            else if (replacement === undefined) {
                 context.report({ node, messageId: 'replacement', data: { message } });
                 return;
             }

package/rules/ts-types.d.ts

@@ -32,6 +32,9 @@ export interface TsTypeChecker {
 export interface TypeServices {
     program: {
         getTypeChecker(): TsTypeChecker;
+        getSourceFiles(): readonly {
+            fileName: string;
+        }[];
     };
     esTreeNodeToTSNodeMap: {
         get(node: unknown): unknown;

package/rules/util.js

@@ -6,10 +6,10 @@ exports.symbolOf = symbolOf;
 exports.declarationFile = declarationFile;
 exports.useInsteadOf = useInsteadOf;
 exports.isApplicable = isApplicable;
-const USE_INSTEAD_TAG = 'useInstead';
-const SUPPRESS_TAG = '@lintIgnore';
+const UseInsteadTag = 'useInstead';
+const SuppressTag = '@lintIgnore';
 /* ts.SymbolFlags.Alias, spelled out to keep typescript out of the dependencies */
-const ALIAS_FLAG = 1 << 21;
+const AliasFlag = 1 << 21;
 /** The type-aware services, or `undefined` if the file is parsed without a program. */
 function typeServices(context) {
     const services = context.sourceCode.parserServices;
@@ -36,7 +36,7 @@ function silences(comment, ids) {
  */
 function suppressed(context, node, ids) {
     const sourceCode = context.sourceCode;
-    if (!sourceCode.text.includes(SUPPRESS_TAG)) {
+    if (!sourceCode.text.includes(SuppressTag)) {
         return false;
     }
     /* a header comment marks the whole file: above the imports, or separated by a blank line */
@@ -59,7 +59,7 @@ function suppressed(context, node, ids) {
 }
 /** Resolves import aliases so the documentation of the original declaration is read. */
 function resolveAlias(symbol, checker) {
-    return (symbol.flags & ALIAS_FLAG) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
+    return (symbol.flags & AliasFlag) !== 0 ? checker.getAliasedSymbol(symbol) : symbol;
 }
 /** The symbol an ESTree node resolves to, with import aliases followed. */
 function symbolOf(node, services, checker) {
@@ -74,7 +74,7 @@ function declarationFile(symbol) {
 /** The text of the `@useInstead` tag of a symbol, `undefined` if it carries none. */
 function useInsteadOf(symbol, checker) {
     for (const tag of symbol.getJsDocTags(checker)) {
-        if (tag.name === USE_INSTEAD_TAG) {
+        if (tag.name === UseInsteadTag) {
             return (tag.text ?? []).map(p => p.text).join('').trim();
         }
     }