@zgeoff/oxlint-config 0.2.11 → 0.2.13

package/README.md

@@ -10,8 +10,9 @@ that loosens either comment rule. `zgeoff/function-verb` enforces the function-n
 the shared agent guidelines, `zgeoff/test-beside-module` keeps each test file beside the module it
 tests, `zgeoff/import-zones` fails an import that crosses a module boundary the repo declares,
 `zgeoff/no-restricted-words` keeps the words in its `words` option out of a path's text,
-`zgeoff/no-abbreviated-names` reports each abbreviated value name it lists with its full word, and
-`zgeoff/no-file-snapshot` bans file snapshots.
+`zgeoff/no-abbreviated-names` reports each abbreviated value name it lists with its full word,
+`zgeoff/no-file-snapshot` bans file snapshots, and `zgeoff/setup-test-only` keeps a test file's
+module level to `setupTest()` and its tests.
 
 ## Usage
 
@@ -88,6 +89,29 @@ first statement, so put the comment above it:
 A second test file for a module (`<name>.host.test.ts`) needs its own `<name>.host.<ext>`, so the
 rule reports it beside only `<name>.ts`.
 
+## `zgeoff/setup-test-only`
+
+A `<name>.test.ts` or `<name>.test.tsx` file declares one function, `setupTest()`, and nothing else,
+as the testing skill requires. At module level the rule allows imports, `type` and `interface`
+declarations, one `setupTest` function declaration, and statements that call `test`, `test.each`,
+`test.skipIf` or `test.if`, or a chain of them, with `test` under its local alias when the
+`bun:test` import renames it. It reports every other statement: a `let`, a `var`, a class, an enum,
+a second function, an export, and a call such as `beforeEach(...)`. The message holds the three ways
+out of a helper: inline it, swap it for a registered matcher, or move it to the shared test utils
+with tests of its own.
+
+A module-level `const` passes only as a skip gate: a declarator that binds at least one name, each
+binding read, and read only at collection time, inside an argument of the test runner's `skipIf` or
+inside the initializer of another gate. The runner is `test` as `bun:test` exports it, under its
+local alias if the import renames it, or a chain of its modifiers, so `matrix.skipIf(rows)` is not a
+gate read. A file that imports no `test` uses the global one, unless an import or a module-level
+declaration of its own takes the name `test`. A read inside a function never counts, so a `skipIf`
+in `setupTest()` or a test body leaves its `const` reported. A gate derived from an awaited probe
+passes beside the probe, in the same declaration or its own, but consts that only read each other
+never reach a `skipIf` and report. A `const` that nothing reads reports too, and so does a
+declarator that binds nothing, such as `const {} = registerHooks()`. The rule does not check the
+comment that the skill asks a gate to carry.
+
 ## `zgeoff/no-restricted-words`
 
 Off unless a repo configures it. The `words` option lists the words to keep out of the text of a
@@ -142,19 +166,26 @@ Each entry has a `name`, which starts its report, an optional `reason`, which en
 
 - `edges` judge an import that resolves to a file: relative, with any bundler query such as `?url`
   dropped, or the package's own name resolved through its `exports` under `conditions` plus
-  `default`. A target in a `to` zone fails unless it is also in an `allow` zone; with `allow` alone,
-  a target in none of the `allow` zones fails, a target in no zone included. `allowTypeOnly` exempts
-  type-only imports (`true`, or globs the target must match), and `allowWithin: "src/*"` exempts an
-  import inside the importer's own `src/<name>/`.
+  `default`. They also judge the name of each package whose directory a `workspaces` glob matches,
+  such as `packages/*`, with one directory level per segment. That name maps to the package folder
+  joined with the subpath, never to an export's target: `@demo/store/testing` is judged as
+  `packages/store/testing`, so a zone names the folder path, such as `packages/store{,/**}`. A
+  target in a `to` zone fails unless it is also in an `allow` zone; with `allow` alone, a target in
+  none of the `allow` zones fails, a target in no zone included. `allowTypeOnly` exempts type-only
+  imports (`true`, or globs the target must match), and `allowWithin: "src/*"` exempts an import
+  inside the importer's own `src/<name>/`.
 - `modules` restrict a package or builtin (`node:` prefix optional, subpaths included) to the
   `allow` zones; `allowTypeOnly: true` exempts type-only imports. A name that ends in `*` restricts
   every specifier that starts with the text before it, such as `@scope/*`, and `node:*` restricts
   every builtin.
 - `globals` restrict a call to a global, bare or through `globalThis`, `self` or `window`.
 - `unzoned` reports a file in a `from` zone that belongs to none of `zones`.
-- `unresolved` reports a relative or self-referencing import that resolves to no file, and a dynamic
+- `unresolved` reports a relative or self-referencing import that resolves to no file, a workspace
+  import whose subpath no `exports` key lists, or one that a `null` key blocks, and a dynamic
   `import()`, `require()` or `import.meta.require()` whose specifier is computed. Bun's
   `import.meta.require` used as a value counts as computed too.
+- `selfImports` reports an import of the importer's own package by name, which a relative path
+  reaches without the `exports` map.
 
 ```jsonc
 {

package/import-zones-schema.js

@@ -26,6 +26,7 @@ const importZonesSchema = {
     zones: { type: 'object', additionalProperties: stringList },
     extensions: stringList,
     conditions: stringList,
+    workspaces: stringList,
     edges: buildEntrySchema(
       {
         to: stringList,
@@ -43,6 +44,7 @@ const importZonesSchema = {
     globals: buildEntrySchema({ globals: stringList, allow: stringList }, ['globals', 'allow']),
     unzoned: buildEntrySchema({ zones: stringList }, ['from', 'zones']),
     unresolved: buildEntrySchema({}, []),
+    selfImports: buildEntrySchema({}, []),
   },
   additionalProperties: false,
 };

package/import-zones.js

@@ -2,6 +2,7 @@ import { isBuiltin } from 'node:module';
 import { relative, sep } from 'node:path';
 import findRepoRoot from './find-repo-root.js';
 import importZonesSchema from './import-zones-schema.js';
+import loadWorkspaceManifests from './load-workspace-manifests.js';
 import loadZoneOptions from './load-zone-options.js';
 import resolveImportTarget from './resolve-import-target.js';
 
@@ -14,7 +15,17 @@ function buildFileState(context) {
   const root = findRepoRoot(filename) ?? context.cwd;
   const path = toRootPath(root, filename);
 
-  return { context, options, filename, root, path, zones: collectZones(options.zones, path) };
+  const workspaces = loadWorkspaceManifests(root, options.workspaces);
+
+  return {
+    context,
+    options,
+    filename,
+    root,
+    path,
+    workspaces,
+    zones: collectZones(options.zones, path),
+  };
 }
 
 function toRootPath(root, path) {
@@ -66,8 +77,13 @@ function checkImport(file, imported) {
     root: file.root,
     extensions: file.options.extensions,
     conditions: file.options.conditions,
+    workspaces: file.workspaces,
   });
 
+  if (target.self === true) {
+    emitSelfImport(file, imported.node, specifier);
+  }
+
   if (target.kind === 'module') {
     checkModule(file, imported, target.specifier);
   } else if (target.kind === 'missing') {
@@ -96,6 +112,12 @@ function emitUnresolved(file, node, report) {
   }
 }
 
+function emitSelfImport(file, node, specifier) {
+  for (const entry of collectEntries(file, file.options.selfImports)) {
+    emitReport(file, entry, { at: { node }, messageId: 'self', data: { specifier } });
+  }
+}
+
 function checkModule(file, imported, specifier) {
   for (const entry of collectEntries(file, file.options.modules)) {
     const isAllowed =
@@ -270,6 +292,7 @@ const importZones = {
       global: '{{rule}}: {{global}}() is allowed only in {{allow}}{{reason}}',
       unzoned: '{{rule}}: this file belongs to none of {{zones}}; add its path to one{{reason}}',
       unresolved: '{{rule}}: cannot resolve {{specifier}}{{reason}}',
+      self: '{{rule}}: {{specifier}} names the package this file belongs to; import it by a relative path{{reason}}',
       computed: '{{rule}}: cannot check a computed import specifier{{reason}}',
     },
     schema: [importZonesSchema],

package/load-workspace-manifests.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import makeGlobMatcher from './make-glob-matcher.js';
+
+// The manifest of every package directory the globs match, relative to the
+// root. Each glob segment matches one directory level, as a workspaces
+// field's globs do.
+export default function loadWorkspaceManifests(root, globs) {
+  return withManifestCache(JSON.stringify([root, globs]), () =>
+    globs
+      .flatMap((glob) => readGlobDirectories(root, splitGlob(glob), ''))
+      .map((directory) => loadManifest(join(root, directory)))
+      .filter((manifest) => typeof manifest?.name === 'string'),
+  );
+}
+
+const loadedManifests = new Map();
+
+// each linted file asks again, so the manifests load once per root and globs
+function withManifestCache(key, load) {
+  if (!loadedManifests.has(key)) {
+    loadedManifests.set(key, load());
+  }
+
+  return loadedManifests.get(key);
+}
+
+function splitGlob(glob) {
+  return glob.split('/').filter((segment) => segment !== '' && segment !== '.');
+}
+
+function readGlobDirectories(root, segments, prefix) {
+  const [segment, ...rest] = segments;
+
+  if (segment === undefined) {
+    return [prefix];
+  }
+
+  const isMatch = makeGlobMatcher([segment]);
+  const parent = join(root, prefix);
+  const names = existsSync(parent)
+    ? readdirSync(parent, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== 'node_modules')
+        .map((entry) => entry.name)
+        .filter((name) => isMatch(name))
+    : [];
+
+  return names.flatMap((name) => readGlobDirectories(root, rest, join(prefix, name)));
+}
+
+// `dir` is the field the resolver reads from every manifest it loads
+function loadManifest(directory) {
+  const path = join(directory, 'package.json');
+
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  const manifest = JSON.parse(readFileSync(path, 'utf8'));
+
+  manifest.dir = directory;
+
+  return manifest;
+}

package/load-zone-options.js

@@ -30,11 +30,13 @@ function buildZoneOptions(options) {
     zones,
     extensions: options.extensions ?? defaultExtensions,
     conditions: new Set([...(options.conditions ?? []), 'default']),
+    workspaces: options.workspaces ?? [],
     edges: buildEntries(options.edges),
     modules: buildEntries(options.modules),
     globals: buildEntries(options.globals),
     unzoned: buildEntries(options.unzoned),
     unresolved: buildEntries(options.unresolved),
+    selfImports: buildEntries(options.selfImports),
   };
 }
 

package/oxlintrc.json

@@ -32,6 +32,7 @@
     "zgeoff/function-verb": "error",
     "zgeoff/test-beside-module": "error",
     "zgeoff/no-file-snapshot": "error",
+    "zgeoff/setup-test-only": "error",
 
     // name a value for what it holds, in full words: one letter only for a
     // coordinate, zod's `z`, Bun's shell `$` or an unread `_` placeholder, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/oxlint-config",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Shareable oxlint config: strict categories, house-style rules, and a custom JS plugin",
   "license": "MIT",
   "repository": {
@@ -19,9 +19,11 @@
     "no-comment-rule-override.js",
     "test-beside-module.js",
     "no-file-snapshot.js",
+    "setup-test-only.js",
     "import-zones.js",
     "import-zones-schema.js",
     "find-repo-root.js",
+    "load-workspace-manifests.js",
     "load-zone-options.js",
     "make-glob-matcher.js",
     "resolve-import-target.js",

package/plugin.js

@@ -6,6 +6,7 @@ import noCommentRuleOverride from './no-comment-rule-override.js';
 import noFileSnapshot from './no-file-snapshot.js';
 import noJSDoc from './no-jsdoc.js';
 import noRestrictedWords from './no-restricted-words.js';
+import setupTestOnly from './setup-test-only.js';
 import testBesideModule from './test-beside-module.js';
 
 // custom rules loaded through oxlint's jsPlugins (ESLint v9 rule API): each
@@ -111,6 +112,7 @@ const plugin = {
     'no-abbreviated-names': noAbbreviatedNames,
     'test-beside-module': testBesideModule,
     'no-file-snapshot': noFileSnapshot,
+    'setup-test-only': setupTestOnly,
     'import-zones': importZones,
   },
 };

package/resolve-import-target.js

@@ -1,12 +1,13 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 
 // a `.js` specifier in TypeScript source names the `.ts` file beside it
 const sourceExtensions = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };
 
-// `module` with the specifier for a package or builtin, `file` with the
-// absolute path when the import resolves, `missing` otherwise. The package's
-// own name resolves through its `exports`, and `#` names through its `imports`.
+// `module` for a package or builtin, `file` with the absolute path, or
+// `missing`. The own name, which `self` marks, resolves through `exports`, `#`
+// names through `imports`, and a workspace name to a path in its folder.
 export default function resolveImportTarget(filename, specifier, settings) {
   if (isPathSpecifier(specifier)) {
     return toTarget(findImportedFile(filename, toFileSpecifier(specifier), settings.extensions));
@@ -14,30 +15,73 @@ export default function resolveImportTarget(filename, specifier, settings) {
 
   const manifest = findPackageManifest(dirname(filename), settings.root);
 
-  return resolveManifestTarget(manifest, specifier, settings.conditions);
+  return resolveManifestTarget(manifest, specifier, settings);
 }
 
-function resolveManifestTarget(manifest, specifier, conditions) {
-  const name = manifest?.name;
+function resolveManifestTarget(manifest, specifier, settings) {
+  if (!specifier.startsWith('#')) {
+    return resolveBareTarget(manifest, specifier, settings);
+  }
 
-  if (specifier.startsWith('#')) {
-    const mapped = findMappedTarget(manifest?.imports, specifier, conditions);
+  const mapped = findMappedTarget(manifest?.imports, specifier, settings.conditions);
+
+  return mapped !== null && !isPathSpecifier(mapped)
+    ? resolveBareTarget(manifest, mapped, settings)
+    : toMappedTarget(manifest, mapped);
+}
 
-    return mapped !== null && !isPathSpecifier(mapped)
-      ? { kind: 'module', specifier: mapped }
-      : toMappedTarget(manifest, mapped);
+// a builtin keeps its name even when a package shares it
+function resolveBareTarget(manifest, specifier, settings) {
+  const name = manifest?.name;
+
+  if (isBuiltin(specifier)) {
+    return { kind: 'module', specifier };
   }
 
-  if (typeof name === 'string' && (specifier === name || specifier.startsWith(`${name}/`))) {
+  if (isPackageSpecifier(name, specifier)) {
     const subpath = `.${specifier.slice(name.length)}`;
+    const mapped = findMappedTarget(toSubpathMap(manifest.exports), subpath, settings.conditions);
+
+    return { ...toMappedTarget(manifest, mapped), self: true };
+  }
+
+  return resolveWorkspaceTarget(settings.workspaces, specifier);
+}
 
-    return toMappedTarget(
-      manifest,
-      findMappedTarget(toSubpathMap(manifest.exports), subpath, conditions),
-    );
+function isPackageSpecifier(name, specifier) {
+  return typeof name === 'string' && (specifier === name || specifier.startsWith(`${name}/`));
+}
+
+// the edges judge the package folder joined with the subpath, such as
+// `packages/store/testing`, so the exports map's keys matter and not its targets
+function resolveWorkspaceTarget(workspaces, specifier) {
+  const workspace = workspaces.find((candidate) => isPackageSpecifier(candidate.name, specifier));
+
+  if (workspace === undefined) {
+    return { kind: 'module', specifier };
   }
 
-  return { kind: 'module', specifier };
+  const subpath = `.${specifier.slice(workspace.name.length)}`;
+
+  return isExportedSubpath(workspace.exports, subpath)
+    ? { kind: 'file', path: join(workspace.dir, subpath) }
+    : { kind: 'missing' };
+}
+
+// with no exports map, every subpath is public, and an empty one exports none
+function isExportedSubpath(exports, subpath) {
+  if (exports === undefined) {
+    return true;
+  }
+
+  if (typeof exports === 'object' && exports !== null && Object.keys(exports).length === 0) {
+    return false;
+  }
+
+  const map = toSubpathMap(exports);
+  const key = Object.hasOwn(map, subpath) ? subpath : findPatternKey(map, subpath);
+
+  return key !== undefined && map[key] !== null;
 }
 
 // a bundler query such as Vite's `./styles.css?url` names the file before it
@@ -105,6 +149,12 @@ function findMappedTarget(map, key, conditions) {
     return findConditionTarget(map[key], conditions);
   }
 
+  const pattern = findPatternKey(map, key);
+
+  return pattern === undefined ? null : findPatternTarget(map, pattern, { key, conditions });
+}
+
+function findPatternKey(map, key) {
   const [pattern] = Object.keys(map)
     .filter((candidate) => isPatternMatch(candidate, key))
     .toSorted((left, right) => {
@@ -113,7 +163,7 @@ function findMappedTarget(map, key, conditions) {
       return byPrefix === 0 ? right.length - left.length : byPrefix;
     });
 
-  return pattern === undefined ? null : findPatternTarget(map, pattern, { key, conditions });
+  return pattern;
 }
 
 function findPatternTarget(map, pattern, lookup) {

package/setup-test-only.js

@@ -0,0 +1,269 @@
+import { basename } from 'node:path';
+
+const testFilePattern = /\.test\.tsx?$/u;
+
+// the statements a test file holds besides its tests and `setupTest()`:
+// imports and type-only declarations, which run nothing at module level
+const allowedStatementTypes = new Set([
+  'ImportDeclaration',
+  'TSTypeAliasDeclaration',
+  'TSInterfaceDeclaration',
+]);
+
+// the members a `test` call may chain: `test.each(rows)(…)`,
+// `test.skipIf(gate)(…)`, `test.if(gate)(…)`, and chains of them
+const testModifiers = new Set(['each', 'skipIf', 'if']);
+
+const setupTestOnly = {
+  meta: {
+    type: 'problem',
+    messages: {
+      declaration:
+        'Remove the module-level `{{name}}`: a test file declares one function, `setupTest()`, and nothing else. Inline it where it is used, swap it for a registered matcher, or move it to the shared test utils with tests of its own. A module-level `const` stays only as a skip gate that `skipIf(...)` arguments alone read.',
+      statement:
+        'Move this statement into a test or `setupTest()`: at module level a test file holds only imports, types, `setupTest()` and `test` calls.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      Program(program) {
+        if (!testFilePattern.test(basename(context.physicalFilename))) {
+          return;
+        }
+
+        const testNames = collectTestNames(context, program);
+        const constants = [];
+        let hasSetupTest = false;
+
+        for (const statement of program.body) {
+          if (allowedStatementTypes.has(statement.type) || isTestCall(statement, testNames)) {
+            continue;
+          }
+
+          if (
+            statement.type === 'FunctionDeclaration' &&
+            statement.id?.name === 'setupTest' &&
+            !hasSetupTest
+          ) {
+            hasSetupTest = true;
+
+            continue;
+          }
+
+          if (statement.type === 'VariableDeclaration' && statement.kind === 'const') {
+            constants.push(...statement.declarations);
+
+            continue;
+          }
+
+          emitReport(context, statement);
+        }
+
+        const gates = collectSkipGates(context, constants, testNames);
+        const declarations = new Set(constants.map((declarator) => declarator.parent));
+
+        for (const declaration of declarations) {
+          const leaks = declaration.declarations.filter((declarator) => !gates.has(declarator));
+
+          if (leaks.length > 0) {
+            emitReport(context, declaration, leaks);
+          }
+        }
+      },
+    };
+  },
+};
+
+// the local names that `test` from `bun:test` goes by, so an aliased import
+// such as `import { test as check }` counts; a file that imports no `test`
+// reads the global one, unless a module binding of its own takes the name
+function collectTestNames(context, program) {
+  const names = program.body
+    .filter(
+      (statement) =>
+        statement.type === 'ImportDeclaration' &&
+        statement.source.value === 'bun:test' &&
+        statement.importKind !== 'type',
+    )
+    .flatMap((statement) => statement.specifiers)
+    .filter(
+      (specifier) =>
+        specifier.type === 'ImportSpecifier' &&
+        specifier.importKind !== 'type' &&
+        getImportedName(specifier) === 'test',
+    )
+    .map((specifier) => specifier.local.name);
+
+  if (names.length === 0 && !hasModuleBinding(context, program, 'test')) {
+    return new Set(['test']);
+  }
+
+  return new Set(names);
+}
+
+// every import form and every module-level declaration defines a binding in
+// the module scope, which ESM nests under the global one
+function hasModuleBinding(context, program, name) {
+  const scope = context.sourceCode.getScope(program);
+  const scopes = [scope, ...scope.childScopes.filter((child) => child.type === 'module')];
+
+  return scopes.some((candidate) => (candidate.set.get(name)?.defs.length ?? 0) > 0);
+}
+
+function getImportedName(specifier) {
+  return specifier.imported.type === 'Identifier'
+    ? specifier.imported.name
+    : specifier.imported.value;
+}
+
+function isTestCall(statement, testNames) {
+  return (
+    statement.type === 'ExpressionStatement' &&
+    statement.expression.type === 'CallExpression' &&
+    isTestRunner(statement.expression.callee, testNames)
+  );
+}
+
+// `test` itself or a chain of its modifiers, such as `test.skipIf(gate).each(rows)`
+function isTestRunner(node, testNames) {
+  let current = node;
+
+  while (current.type !== 'Identifier') {
+    if (current.type === 'CallExpression') {
+      current = current.callee;
+    } else if (
+      current.type === 'MemberExpression' &&
+      !current.computed &&
+      testModifiers.has(current.property.name)
+    ) {
+      current = current.object;
+    } else {
+      return false;
+    }
+  }
+
+  return testNames.has(current.name);
+}
+
+function emitReport(context, statement, declarators) {
+  const name = findDeclaredName(context, statement, declarators);
+
+  if (name === undefined) {
+    context.report({ node: statement, messageId: 'statement' });
+
+    return;
+  }
+
+  context.report({ node: statement, messageId: 'declaration', data: { name } });
+}
+
+function findDeclaredName(context, statement, declarators) {
+  if (statement.type === 'VariableDeclaration') {
+    return (declarators ?? statement.declarations)
+      .flatMap((declarator) => context.sourceCode.getDeclaredVariables(declarator))
+      .map((variable) => variable.name)
+      .join('`, `');
+  }
+
+  return statement.id?.name;
+}
+
+// a gate is a declarator whose every binding is read, only in a `skipIf(...)`
+// argument or another gate's initializer; the set grows out from the `skipIf`
+// reads, so consts that only read each other never join it
+function collectSkipGates(context, constants, testNames) {
+  const gates = new Set();
+  let changed = true;
+
+  while (changed) {
+    changed = false;
+
+    for (const declarator of constants) {
+      if (!gates.has(declarator) && isSkipGate(context, declarator, gates, testNames)) {
+        gates.add(declarator);
+        changed = true;
+      }
+    }
+  }
+
+  return gates;
+}
+
+function isSkipGate(context, declarator, gates, testNames) {
+  const variables = context.sourceCode.getDeclaredVariables(declarator);
+
+  // a declarator that binds nothing, such as `const {} = registerHooks()`, is
+  // a module-level call, not a gate
+  return (
+    variables.length > 0 &&
+    variables.every((variable) => {
+      const reads = variable.references.filter(
+        (reference) => !reference.init && reference.isRead(),
+      );
+
+      return (
+        reads.length > 0 &&
+        reads.every(
+          (reference) =>
+            isInSkipIfArgument(reference.identifier, testNames) ||
+            isInGateInit(reference.identifier, gates),
+        )
+      );
+    })
+  );
+}
+
+const functionTypes = new Set([
+  'FunctionDeclaration',
+  'FunctionExpression',
+  'ArrowFunctionExpression',
+]);
+
+// a read counts only at collection time, so no function may enclose it: a
+// `skipIf` inside `setupTest()` or a test runs later
+function isInSkipIfArgument(identifier, testNames) {
+  let child = identifier;
+  let isSkipIfArgument = false;
+
+  for (let node = identifier.parent; node !== null && node !== undefined; node = node.parent) {
+    if (functionTypes.has(node.type)) {
+      return false;
+    }
+
+    if (
+      node.type === 'CallExpression' &&
+      node.arguments.includes(child) &&
+      node.callee.type === 'MemberExpression' &&
+      !node.callee.computed &&
+      node.callee.property.name === 'skipIf' &&
+      isTestRunner(node.callee.object, testNames)
+    ) {
+      isSkipIfArgument = true;
+    }
+
+    child = node;
+  }
+
+  return isSkipIfArgument;
+}
+
+function isInGateInit(identifier, gates) {
+  let child = identifier;
+
+  for (let node = identifier.parent; isOutsideFunction(node); node = node.parent) {
+    if (node.type === 'VariableDeclarator') {
+      return node.init === child && gates.has(node);
+    }
+
+    child = node;
+  }
+
+  return false;
+}
+
+function isOutsideFunction(node) {
+  return node !== null && node !== undefined && !functionTypes.has(node.type);
+}
+
+export default setupTestOnly;