@eagleoutice/eslint-config-flowr 2.1.9 → 2.1.11

package/README.md

@@ -27,6 +27,7 @@ below `test/`.
 | :-- | :-- | :-- |
 | `flowr/use-instead` | the `@useInstead` tag | a reference to what a helper object replaced |
 | `flowr/replacement-pattern` | [`patterns.ts`](patterns.ts) | a shape of code with a helper equivalent |
+| `flowr/no-semantic-widening` | the types | a value of a `__brand`ed type (`NodeId`, `BrandedIdentifier`, ...) that silently becomes a plain `string` or `number`, also within `string[]`, `Set<string>`, or `Map<string, ...>` |
 
 Both fix in place when every name the replacement needs is already in scope, and offer an editor suggestion otherwise,
 since a fixer cannot add the missing import. A type-only binding of the right name does not count.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/eslint-config-flowr",
-  "version": "2.1.9",
+  "version": "2.1.11",
   "description": "Linting rules for flowr and friends",
   "license": "ISC",
   "repository": {

package/plugin.d.ts

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

package/plugin.js

@@ -6,12 +6,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 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 no_semantic_widening_1 = __importDefault(require("./rules/no-semantic-widening"));
 const plugin = {
     meta: { name: '@eagleoutice/eslint-config-flowr' },
     rules: {
         'use-instead': use_instead_1.default,
         'replacement-pattern': replacement_pattern_1.default,
-        'file-naming': file_naming_1.default
+        'file-naming': file_naming_1.default,
+        'no-semantic-widening': no_semantic_widening_1.default
     }
 };
 module.exports = plugin;

package/rules/no-semantic-widening.d.ts

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

package/rules/no-semantic-widening.js

@@ -0,0 +1,108 @@
+"use strict";
+const util_1 = require("./util");
+/* ts.TypeFlags and ts.SymbolFlags, spelled out to keep typescript out of the dependencies */
+const StringFlag = 1 << 2;
+const NumberFlag = 1 << 3;
+const UndefinedFlag = 1 << 15;
+const NullFlag = 1 << 16;
+const TypeParameterFlag = 1 << 18;
+const BrandProperty = '__brand';
+const Collections = new Set(['Array', 'ReadonlyArray', 'Set', 'ReadonlySet', 'Map', 'ReadonlyMap', 'DefaultMap']);
+function membersOf(type) {
+    return (type.isUnion() ? type.types : [type]).filter(t => (t.flags & (UndefinedFlag | NullFlag)) === 0);
+}
+/** A semantic type carries a brand: `string & { __brand?: 'node-id' }`. */
+function isSemantic(type, checker) {
+    const members = membersOf(type);
+    return members.length > 0 && members.every(t => checker.getPropertyOfType(t, BrandProperty) !== undefined);
+}
+function isPlainPrimitive(type, checker) {
+    const members = membersOf(type);
+    return members.length > 0 && members.every(t => (t.flags & (StringFlag | NumberFlag)) !== 0 && checker.getPropertyOfType(t, BrandProperty) === undefined);
+}
+function collectionArguments(type, checker) {
+    const [member] = membersOf(type);
+    const name = member?.getSymbol()?.getName();
+    return name !== undefined && Collections.has(name) ? checker.getTypeArguments(member) : undefined;
+}
+/** Whether a value of type `source` loses its meaning in a place of type `target`, on its own or inside a collection. */
+function widens(source, target, checker) {
+    if (isSemantic(source, checker)) {
+        return isPlainPrimitive(target, checker);
+    }
+    const from = collectionArguments(source, checker);
+    const to = collectionArguments(target, checker);
+    return from !== undefined && to !== undefined && from.some((f, i) => to[i] !== undefined && widens(f, to[i], checker));
+}
+/** A parameter a library declares as a plain string takes any string, while one of a collection (`Set<string>`) states what the code chose. */
+function acceptedByLibrary(call, argument, tsCall, checker) {
+    if (call.type !== 'CallExpression' && call.type !== 'NewExpression') {
+        return false;
+    }
+    const declaration = checker.getResolvedSignature(tsCall)?.declaration;
+    if (declaration?.getSourceFile()?.fileName.includes('/node_modules/') !== true) {
+        return false;
+    }
+    const parameters = declaration.parameters;
+    const parameter = parameters?.[Math.min(call.arguments.indexOf(argument), parameters.length - 1)];
+    return parameter !== undefined && (checker.getTypeAtLocation(parameter).flags & TypeParameterFlag) === 0;
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'a value of a semantic type (NodeId, BrandedIdentifier, ...) must not silently become a plain string or number' },
+        messages: {
+            widens: 'This turns a {{source}} into a plain {{target}}. Use a semantic type for what receives it, or cast explicitly if the meaning really ends here.'
+        },
+        schema: []
+    },
+    create(context) {
+        const services = (0, util_1.typeServices)(context);
+        if (!services) {
+            return {};
+        }
+        const checker = services.program.getTypeChecker();
+        const check = (node) => {
+            if (!node || node.type === 'SpreadElement') {
+                return;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            const target = checker.getContextualType(tsNode);
+            if (target === undefined) {
+                return;
+            }
+            const source = checker.getTypeAtLocation(tsNode);
+            if (!widens(source, target, checker) || (0, util_1.suppressed)(context, node, ['no-semantic-widening'])) {
+                return;
+            }
+            const parent = node.parent;
+            if (acceptedByLibrary(parent, node, services.esTreeNodeToTSNodeMap.get(parent), checker)) {
+                return;
+            }
+            context.report({ node, messageId: 'widens', data: { source: checker.typeToString(source), target: checker.typeToString(target) } });
+        };
+        const checkArguments = (call) => call.arguments.forEach(check);
+        return {
+            CallExpression: checkArguments,
+            NewExpression: checkArguments,
+            ReturnStatement: node => check(node.argument),
+            VariableDeclarator(node) {
+                check(node.init);
+            },
+            AssignmentExpression(node) {
+                if (node.operator === '=') {
+                    check(node.right);
+                }
+            },
+            Property(node) {
+                check(node.value);
+            },
+            ArrowFunctionExpression(node) {
+                if (node.body.type !== 'BlockStatement') {
+                    check(node.body);
+                }
+            }
+        };
+    }
+};
+module.exports = rule;

package/rules/replacement-pattern.js

@@ -28,32 +28,6 @@ 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) {
@@ -131,10 +105,7 @@ const rule = {
                 bySelector.set(pattern.selector, [pattern]);
             }
         }
-        /**
-         * The match only counts if every named node resolves to a declaration of the expected flowR file.
-         * The declaring file itself is exempt, it is where the helper is built.
-         */
+        /** The match only counts if every named node resolves to a declaration of the expected flowR file. */
         function isFlowr(node, pattern) {
             if (pattern.helperIn !== undefined && (!services || !programHas(services.program, pattern.helperIn))) {
                 return false;
@@ -147,7 +118,7 @@ const rule = {
             }
             return Object.entries(pattern.declaredIn).every(([path, expected]) => {
                 const file = (0, util_1.declarationFile)((0, util_1.symbolOf)(resolvePath(node, path), services, checker));
-                return file !== undefined && file !== context.filename && file.replaceAll('\\', '/').includes(expected);
+                return file !== undefined && file.replaceAll('\\', '/').includes(expected);
             });
         }
         /** esquery cannot demand that two sub-nodes are the same, so the pattern names the pairs itself */
@@ -166,7 +137,7 @@ 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 && withinReplacement(node, replacement, sourceCode)) {
+            if (replacement !== undefined && (0, util_1.insideReplacement)(node, replacement, sourceCode, services)) {
                 return;
             }
             else if (replacement === undefined) {

package/rules/ts-types.d.ts

@@ -7,6 +7,8 @@ export interface TsSourceFile {
 }
 export interface TsDeclaration {
     getSourceFile(): TsSourceFile | undefined;
+    /** what a property or variable is set to, `frames: framesOf` binds `framesOf` */
+    initializer?: unknown;
 }
 export interface TsJsDocTag {
     name: string;
@@ -21,20 +23,40 @@ export interface TsSymbol {
     getJsDocTags(checker: TsTypeChecker): readonly TsJsDocTag[];
 }
 export interface TsType {
+    flags: number;
+    types?: readonly TsType[];
     getProperties(): readonly TsSymbol[];
+    getSymbol(): TsSymbol | undefined;
+    isUnion(): this is TsType & {
+        types: readonly TsType[];
+    };
+}
+/** What a call resolves to, its parameters only for a declaration in code. */
+export interface TsSignature {
+    declaration?: TsDeclaration & {
+        parameters?: readonly unknown[];
+    };
 }
 export interface TsTypeChecker {
     getSymbolAtLocation(node: unknown): TsSymbol | undefined;
     getAliasedSymbol(symbol: TsSymbol): TsSymbol;
     getTypeOfSymbolAtLocation(symbol: TsSymbol, location: TsDeclaration): TsType;
+    getTypeAtLocation(node: unknown): TsType;
+    getContextualType(node: unknown): TsType | undefined;
+    getPropertyOfType(type: TsType, name: string): TsSymbol | undefined;
+    getTypeArguments(type: TsType): readonly TsType[];
+    getResolvedSignature(node: unknown): TsSignature | undefined;
+    typeToString(type: TsType): string;
+    /** what a module exports, its symbol taken from the source file */
+    getExportsOfModule(module: TsSymbol): readonly TsSymbol[];
+    /** the variable a shorthand property `{ framesOf }` stands for */
+    getShorthandAssignmentValueSymbol(declaration: TsDeclaration): TsSymbol | undefined;
 }
 /** What typescript-eslint hands to a type-aware rule. */
 export interface TypeServices {
     program: {
         getTypeChecker(): TsTypeChecker;
-        getSourceFiles(): readonly {
-            fileName: string;
-        }[];
+        getSourceFiles(): readonly TsSourceFile[];
     };
     esTreeNodeToTSNodeMap: {
         get(node: unknown): unknown;

package/rules/use-instead.js

@@ -35,10 +35,16 @@ function cachedMemberTags(symbol, checker) {
     memberCache.set(symbol, tags);
     return tags;
 }
-/** `{@link Resolve.toValue}` becomes `Resolve.toValue`, owned by `Resolve`. */
+/** `X.member` around a reference to `X`, with the member it reads */
+function memberRead(node) {
+    const parent = node.parent;
+    return parent?.type === 'MemberExpression' && parent.object === node && !parent.computed && parent.property.type === 'Identifier'
+        ? { node: parent, member: parent.property.name } : undefined;
+}
+/** `{@link Resolve.toValue}` becomes `Resolve.toValue`. */
 function parseTarget(tag) {
     const display = tag.replace(/^\{\s*@link\s*/, '').replace(/\s*\|.*$/, '').replace(/\s*\}\s*$/, '').trim();
-    return { display, owner: display.split('.')[0] };
+    return { display };
 }
 /** The references that build the replacement in the first place: helper-object wiring and re-exports. */
 function isWiring(identifier) {
@@ -74,6 +80,7 @@ const rule = {
         messages: {
             useInstead: 'Do not use `{{name}}` directly, use `{{replacement}}` instead.',
             useInsteadPlain: 'Do not use `{{name}}` directly, see its documentation for the replacement.',
+            useInsteadMissing: 'Do not use `{{name}}` directly, use `{{replacement}}` instead, which has no counterpart of `{{member}}` yet.',
             suggest: 'Replace with `{{replacement}}`.'
         }
     },
@@ -87,21 +94,28 @@ const rule = {
         /* helper objects are PascalCase, so member checks stay cheap */
         const helperObjectPattern = new RegExp(context.options[0]?.helperObjectPattern ?? '^[A-Z]');
         const candidates = new Map();
-        /** the helper objects declared here, a file may use what it wraps */
-        const owned = new Set();
         function report(node, name, tag) {
-            const { display, owner } = parseTarget(tag);
-            if (owned.has(owner) || (0, util_1.suppressed)(context, node, ['use-instead'])) {
+            const { display } = parseTarget(tag);
+            /* only the wrapper itself may use what it wraps, anywhere else the replacement holds */
+            if ((0, util_1.insideReplacement)(node, display, sourceCode, services) || (0, util_1.suppressed)(context, node, ['use-instead'])) {
+                return;
+            }
+            /* `Old.member` moves to the member of the replacement that takes its place, which may be named differently */
+            const access = memberRead(node);
+            const counterpart = display === '' || access === undefined || !services ? null : (0, util_1.counterpartOf)(node, access.member, display, sourceCode, services);
+            if (counterpart === undefined) {
+                context.report({ node, messageId: 'useInsteadMissing', data: { name, replacement: display, member: access?.member ?? '' } });
                 return;
             }
-            const fix = (fixer) => fixer.replaceText(node, display);
+            const [target, text] = counterpart === null || access === undefined ? [node, display] : [access.node, `${display}.${counterpart}`];
+            const fix = (fixer) => fixer.replaceText(target, text);
             /* fixed on the spot where the helper is already in scope, offered as a suggestion otherwise */
             const applicable = display !== '' && (0, util_1.isApplicable)(context, node, display);
             context.report({
                 node,
                 messageId: display ? 'useInstead' : 'useInsteadPlain',
-                data: { name, replacement: display },
-                ...display === '' ? {} : applicable ? { fix } : { suggest: [{ messageId: 'suggest', data: { replacement: display }, fix }] }
+                data: { name, replacement: text },
+                ...display === '' ? {} : applicable ? { fix } : { suggest: [{ messageId: 'suggest', data: { replacement: text }, fix }] }
             });
         }
         return {
@@ -111,18 +125,15 @@ const rule = {
                 const foreign = [];
                 for (const variable of module?.variables ?? []) {
                     const declaration = variable.defs[0]?.name;
-                    if (declaration?.type !== 'Identifier') {
+                    /* only what is imported is someone else's to replace, the file's own declarations may use themselves;
+                       asked of the code rather than of file paths, which differ between systems */
+                    if (declaration?.type !== 'Identifier' || variable.defs[0]?.type !== 'ImportBinding') {
                         continue;
                     }
                     const symbol = (0, util_1.symbolOf)(declaration, services, checker);
                     if (!symbol) {
                         continue;
                     }
-                    else if ((0, util_1.declarationFile)(symbol) === context.filename) {
-                        /* a declaration may always use itself */
-                        owned.add(variable.name);
-                        continue;
-                    }
                     if (helperObjectPattern.test(variable.name)) {
                         candidates.set(variable.name, symbol);
                     }

package/rules/util.d.ts

@@ -2,7 +2,7 @@
  * Shared helpers of the flowR rules.
  * Tags: `@useInstead <target>` names a replacement, `@lintIgnore [ids]` silences the rules.
  */
-import type { Rule } from 'eslint';
+import type { Rule, SourceCode } from 'eslint';
 import type { Node } from 'estree';
 import type { TsSymbol, TsTypeChecker, TypeServices } from './ts-types';
 /** The type-aware services, or `undefined` if the file is parsed without a program. */
@@ -14,6 +14,18 @@ export declare function typeServices(context: Rule.RuleContext): TypeServices |
 export declare function suppressed(context: Rule.RuleContext, node: Rule.Node, ids: readonly string[]): boolean;
 /** The symbol an ESTree node resolves to, with import aliases followed. */
 export declare function symbolOf(node: Node | undefined, services: TypeServices, checker: TsTypeChecker): TsSymbol | undefined;
+/**
+ * The member of `replacement` that takes the place of `member` of `original`: the one of the same name, else the one
+ * bound to the same function under another name. `undefined` if the replacement has none, `null` if it cannot be told.
+ */
+export declare function counterpartOf(original: Node, member: string, replacement: string, sourceCode: SourceCode, services: TypeServices): string | undefined | null;
+/**
+ * Whether `node` sits in a function the replacement would call, where putting the replacement in would make that
+ * function call itself. A replacement can only call what it names: a function is excluded if it is declared or bound
+ * under one of those names, or, with types, if one of them resolves to it, wired up under another name or in another
+ * file. Both ask the code alone, never file paths, which differ between systems and how a file was opened.
+ */
+export declare function insideReplacement(node: Node, replacement: string, sourceCode: SourceCode, services?: TypeServices): boolean;
 /** The file a symbol is declared in. */
 export declare function declarationFile(symbol: TsSymbol | undefined): string | undefined;
 /** The text of the `@useInstead` tag of a symbol, `undefined` if it carries none. */

package/rules/util.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.typeServices = typeServices;
 exports.suppressed = suppressed;
 exports.symbolOf = symbolOf;
+exports.counterpartOf = counterpartOf;
+exports.insideReplacement = insideReplacement;
 exports.declarationFile = declarationFile;
 exports.useInsteadOf = useInsteadOf;
 exports.isApplicable = isApplicable;
@@ -67,6 +69,109 @@ function symbolOf(node, services, checker) {
     const symbol = tsNode ? checker.getSymbolAtLocation(tsNode) : undefined;
     return symbol ? resolveAlias(symbol, checker) : undefined;
 }
+/** the name node a function is declared or bound under: a declaration, a member of an object or class, a variable, or an assignment */
+function nameOf(fn, parent) {
+    if ((fn.type === 'FunctionDeclaration' || fn.type === 'FunctionExpression') && fn.id) {
+        return fn.id;
+    }
+    switch (parent?.type) {
+        case 'Property':
+        case 'MethodDefinition':
+        case 'PropertyDefinition':
+            return parent.key;
+        case 'VariableDeclarator':
+            return parent.id;
+        case 'AssignmentExpression':
+            return parent.left.type === 'MemberExpression' ? parent.left.property : parent.left;
+        default:
+            return undefined;
+    }
+}
+/** a symbol together with what it is bound to, so `frames` of `{ frames: framesOf }` also stands for `framesOf` */
+function boundTo(symbol, checker) {
+    if (symbol === undefined) {
+        return [];
+    }
+    const declaration = symbol.declarations?.[0];
+    const value = declaration?.initializer === undefined ? declaration && checker.getShorthandAssignmentValueSymbol(declaration) : checker.getSymbolAtLocation(declaration.initializer);
+    return value === undefined ? [symbol] : [symbol, resolveAlias(value, checker)];
+}
+/* per program, what its modules export under a name, for a replacement the file does not import yet */
+const exportedNames = new WeakMap();
+/** what `name` stands for at `node`: what is in scope there, else what a module of the program exports under it */
+function rootSymbol(name, node, sourceCode, services) {
+    const checker = services.program.getTypeChecker();
+    let scope = sourceCode.getScope(node);
+    while (scope && !scope.set.has(name)) {
+        scope = scope.upper;
+    }
+    if (scope) {
+        return symbolOf(scope.set.get(name)?.defs[0]?.name, services, checker);
+    }
+    let known = exportedNames.get(services.program);
+    if (known === undefined) {
+        exportedNames.set(services.program, known = new Map());
+    }
+    if (!known.has(name)) {
+        const modules = services.program.getSourceFiles().map(file => checker.getSymbolAtLocation(file)).filter(m => m !== undefined);
+        known.set(name, modules.flatMap(m => checker.getExportsOfModule(m)).find(e => e.getName() === name));
+    }
+    return known.get(name);
+}
+/** the properties of what a symbol holds */
+function propertiesOf(symbol, checker) {
+    const declaration = symbol?.declarations?.[0];
+    return symbol === undefined || declaration === undefined ? [] : checker.getTypeOfSymbolAtLocation(symbol, declaration).getProperties();
+}
+/** each link of a dotted name, `Dataflow.origin`, as the symbols it resolves to: the name and what it is bound to */
+function resolveChain(chain, node, sourceCode, services) {
+    const checker = services.program.getTypeChecker();
+    const [root, ...members] = chain.split('.');
+    const links = [boundTo(rootSymbol(root, node, sourceCode, services), checker)];
+    for (const member of members) {
+        links.push(boundTo(propertiesOf(links[links.length - 1][0], checker).find(p => p.getName() === member), checker));
+    }
+    return links;
+}
+/** Every symbol the dotted names of a replacement resolve to, `REnvironment.frames` to `REnvironment`, its `frames`, and the function that member is bound to. */
+function symbolsNamedBy(replacement, node, sourceCode, services) {
+    return new Set((replacement.match(/[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/g) ?? []).flatMap(chain => resolveChain(chain, node, sourceCode, services).flat()));
+}
+/**
+ * The member of `replacement` that takes the place of `member` of `original`: the one of the same name, else the one
+ * bound to the same function under another name. `undefined` if the replacement has none, `null` if it cannot be told.
+ */
+function counterpartOf(original, member, replacement, sourceCode, services) {
+    const checker = services.program.getTypeChecker();
+    const target = resolveChain(replacement, original, sourceCode, services).at(-1)?.[0];
+    if (target === undefined) {
+        return null;
+    }
+    const offered = propertiesOf(target, checker);
+    const was = boundTo(propertiesOf(symbolOf(original, services, checker), checker).find(p => p.getName() === member), checker);
+    return (offered.find(p => p.getName() === member) ?? offered.find(p => boundTo(p, checker).some(s => was.includes(s))))?.getName();
+}
+/**
+ * Whether `node` sits in a function the replacement would call, where putting the replacement in would make that
+ * function call itself. A replacement can only call what it names: a function is excluded if it is declared or bound
+ * under one of those names, or, with types, if one of them resolves to it, wired up under another name or in another
+ * file. Both ask the code alone, never file paths, which differ between systems and how a file was opened.
+ */
+function insideReplacement(node, replacement, sourceCode, services) {
+    const names = new Set(replacement.match(/[A-Za-z_$][\w$]*/g) ?? []);
+    const ancestors = sourceCode.getAncestors(node);
+    const functions = ancestors.flatMap((fn, i) => fn.type === 'FunctionDeclaration' || fn.type === 'FunctionExpression' || fn.type === 'ArrowFunctionExpression' ? [nameOf(fn, ancestors[i - 1])] : [])
+        .filter((name) => name !== undefined);
+    if (functions.some(name => name.type === 'Identifier' && names.has(name.name))) {
+        return true;
+    }
+    if (services === undefined || functions.length === 0) {
+        return false;
+    }
+    const called = symbolsNamedBy(replacement, node, sourceCode, services);
+    const checker = services.program.getTypeChecker();
+    return functions.some(name => boundTo(symbolOf(name, services, checker), checker).some(symbol => called.has(symbol)));
+}
 /** The file a symbol is declared in. */
 function declarationFile(symbol) {
     return symbol?.declarations?.[0]?.getSourceFile()?.fileName;