@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/src/findings/non-code-artifacts.ts

@@ -1,6 +1,5 @@
 import type { Config } from "../config.ts";
 import type { Finding } from "../finding.ts";
-import type { Graph } from "../graph.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 const FILE_NEVER_BUILT = "DS1501";
@@ -61,43 +60,34 @@ function fileNeverBuilt({ config, swept, files }: EmitterInput): readonly Findin
     .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
 }
 
-/**
- * The paths of every file a reference written in another file reaches, naming the
- * file or a declaration in it, a loaded consumer's file included. An import is such a
- * reference, so an import from any file reaches what it names, whatever reaches the
- * importing file.
- */
-function reachedFromOutside(union: Graph): ReadonlySet<string> {
-  const reached = new Set<string>();
-  for (const edge of union.consumed) {
-    const to = union.symbols[edge.to];
-    if (to !== undefined) {
-      reached.add(to.position.path);
-    }
-  }
-  union.out.forEach((edges, from) => {
-    const fromPath = union.symbols[from]?.position.path;
-    for (const edge of edges) {
-      const to = union.symbols[edge.to];
-      if (to !== undefined && to.position.path !== fromPath) {
-        reached.add(to.position.path);
-      }
-    }
-  });
-  return reached;
+/** The files of the run, each with whether a reference written in another file reaches it. */
+interface KeptFiles {
+  /** The files kept: reached from a live file, or named by a root, an edge or a program. */
+  readonly kept: ReadonlySet<string>;
+  /** The files a reference written in another file reaches, whatever holds that file. */
+  readonly referenced: ReadonlySet<string>;
 }
 
 /**
- * The paths of the files an import reaches, a root names, or a declared edge names a
- * declaration in. A file holding a declaration the sweep judged live is kept whatever
- * held it live, and so is a file a program holds by inclusion, which acts on every
- * file of the program without an import naming it.
+ * The paths of the files a reference from a live declaration of another file reaches, a
+ * loaded consumer's file included, a root names, or a declared edge names a declaration in,
+ * and of every file a reference written anywhere reaches. A file holding a declaration the
+ * sweep judged live is kept whatever held it live, and so is a file a program holds by
+ * inclusion, which acts on every file of the program without an import naming it. A
+ * reference from a file's top level counts once the file is kept.
  */
-function keptFiles({ swept, files, boundary }: EmitterInput): ReadonlySet<string> {
+function keptFiles({ swept, files, boundary }: EmitterInput): KeptFiles {
   const union = swept.matrix.union;
   const edgeNamed = new Set(boundary.edges.map((side) => side.symbol));
   const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
-  const kept = new Set([...reachedFromOutside(union), ...files.heldByInclusion]);
+  const kept = new Set(files.heldByInclusion);
+  const referenced = new Set<string>();
+  for (const edge of union.consumed) {
+    const to = union.symbols[edge.to];
+    if (to !== undefined) {
+      kept.add(to.position.path);
+    }
+  }
   for (const root of union.rooted) {
     const named = union.symbols[root.at];
     if (named !== undefined) {
@@ -109,21 +99,71 @@ function keptFiles({ swept, files, boundary }: EmitterInput): ReadonlySet<string
       kept.add(symbol.position.path);
     }
   }
-  return kept;
+  const fromTopLevel = new Map<string, string[]>();
+  const pending: string[] = [];
+  const keep = (path: string): void => {
+    if (!kept.has(path)) {
+      kept.add(path);
+      pending.push(path);
+    }
+  };
+  union.out.forEach((edges, from) => {
+    const source = union.symbols[from];
+    if (source === undefined) {
+      return;
+    }
+    for (const edge of edges) {
+      const to = union.symbols[edge.to]?.position.path;
+      if (to === undefined || to === source.position.path) {
+        continue;
+      }
+      referenced.add(to);
+      if (source.kind === FILE_SUBJECT) {
+        fromTopLevel.set(source.position.path, [
+          ...(fromTopLevel.get(source.position.path) ?? []),
+          to,
+        ]);
+      } else if (!dead.has(source.id)) {
+        pending.push(to);
+      }
+    }
+  });
+  pending.push(...kept);
+  for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+    kept.add(path);
+    for (const to of fromTopLevel.get(path) ?? []) {
+      keep(to);
+    }
+    fromTopLevel.delete(path);
+  }
+  return { kept, referenced };
 }
 
-/** Every file of the run that no import reaches and no root or edge names. */
+/**
+ * Every file of the run that no reference from live code reaches and no root or edge
+ * names. A file only dead code imports is found dead under reachability alone.
+ */
 function fileNeverImported(input: EmitterInput): readonly Finding[] {
-  const kept = keptFiles(input);
+  const { kept, referenced } = keptFiles(input);
   return input.swept.matrix.union.symbols
     .filter((symbol) => symbol.kind === FILE_SUBJECT && !kept.has(symbol.position.path))
-    .map((symbol) =>
-      fileFinding(
-        FILE_NEVER_IMPORTED,
-        { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine },
-        "no import reaches this file and no root names it or a declaration in it",
-      ),
-    );
+    .map((symbol) => {
+      const file = { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine };
+      return referenced.has(symbol.position.path)
+        ? {
+            ...fileFinding(
+              FILE_NEVER_IMPORTED,
+              file,
+              "only code that is itself dead imports this file, and no root names it or a declaration in it",
+            ),
+            unreachableOnly: true as const,
+          }
+        : fileFinding(
+            FILE_NEVER_IMPORTED,
+            file,
+            "no import reaches this file and no root names it or a declaration in it",
+          );
+    });
 }
 
 /** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */

package/src/findings/unused-declarations.ts

@@ -61,8 +61,9 @@ interface Judged {
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration or enum
  * member nothing names; a test-support declaration test code references as test-only
- * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
- * unused export being the unreachable kind's.
+ * use; then deprecation, a test reference, or only dead production references beside a
+ * test that stays, and the unreferenced codes, an unimportable unused export being the
+ * unreachable kind's.
  */
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
@@ -85,7 +86,11 @@ function codeOf(judged: Judged): string | undefined {
   if (candidate.productionRefs === 0 && judged.deprecated) {
     return "DS1006";
   }
-  if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
+  if (
+    candidate.testRefs > 0 &&
+    (candidate.productionRefs === 0 ||
+      (candidate.relation === "reachability" && candidate.keptByTests))
+  ) {
     return "DS1004";
   }
   if (MEMBERS.has(symbol.kind)) {
@@ -132,7 +137,9 @@ function messageOf(code: string, judged: Judged): string {
     case "DS1006":
       return `deprecated ${word} has no production reference`;
     case "DS1004":
-      return `${word} is referenced only from test files and never from production code`;
+      return candidate.productionRefs === 0
+        ? `${word} is referenced only from test files and never from production code`
+        : `${word} is referenced only from test files and from declarations that are themselves dead`;
   }
   const subject =
     code === "DS1003"
@@ -196,7 +203,31 @@ function brandMembers(input: EmitterInput): ReadonlySet<string> {
 const BRANDS: ReadonlySet<SymbolKind> = new Set(["type-member", "class-member"]);
 
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations: Emitter = (input) => familyFindings(input, false);
+export const unusedDeclarations: Emitter = (input) => [
+  ...familyFindings(input, false),
+  ...unusedImports(input),
+];
+
+/**
+ * The import bindings their file never reads, under the unexported code. A generated
+ * file's are the generator's to remove unless the run includes generated files.
+ */
+function unusedImports(input: EmitterInput): Finding[] {
+  const generated =
+    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+  return input.intraFunction.imports.flatMap((binding) =>
+    binding.used || generated?.has(binding.position.path) === true
+      ? []
+      : [
+          {
+            code: "DS1002",
+            position: binding.position,
+            symbol: { ref: binding.ref, kind: "import", name: binding.name, sizeLines: 1 },
+            message: `import binding ${binding.name} is never read in its file`,
+          },
+        ],
+  );
+}
 
 /**
  * The finding each member of a dead container would carry were its container live: what

package/src/findings/visibility-narrowing.ts

@@ -4,6 +4,7 @@ import type { InventorySymbol, SymbolKind } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
 import { declarationKey } from "../ref.ts";
 import type { RootKind } from "../roots.ts";
+import { runnerCalls } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
@@ -51,8 +52,37 @@ function publishes(kinds: ReadonlySet<RootKind> | undefined): boolean {
   return [...(kinds ?? [])].some((kind) => PUBLISHING.has(kind));
 }
 
+/**
+ * The root kinds that name a file without entering it by its exports: a configuration
+ * string or a script token runs the file, and no tool reads a name it exports.
+ */
+const RUN_ONLY: ReadonlySet<RootKind> = new Set<RootKind>(["configuration-string", "script"]);
+
+/** Whether a root makes its file an entry file, or its declaration an entry, which a tool may read by name. */
 function entersByName(kinds: ReadonlySet<RootKind> | undefined): boolean {
-  return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind));
+  return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
+}
+
+/**
+ * The root kinds whose root of a file enters no export by name: a document's import roots
+ * each export it imports, so an export it does not import is judged as in any file.
+ */
+const PER_NAME: ReadonlySet<RootKind> = new Set<RootKind>(["document-import"]);
+
+/**
+ * Whether the roots of a declaration's file enter it by name: a test runner's root
+ * enters only an export the runner calls, so another export of a test file is judged.
+ */
+function fileEntersByName(
+  kinds: ReadonlySet<RootKind> | undefined,
+  symbol: InventorySymbol,
+): boolean {
+  const entering = [...(kinds ?? [])].filter(
+    (kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind) && !PER_NAME.has(kind),
+  );
+  return (
+    entering.some((kind) => kind !== "test-runner") || (entering.length > 0 && runnerCalls(symbol))
+  );
 }
 
 /**
@@ -163,7 +193,7 @@ function narrowing(
     world.writeOnly.has(declarationKey(symbol.ref, symbol.position.path)) ||
     symbol.kind === "export-alias" ||
     entersByName(facts.rootedBy[at]) ||
-    entersByName(facts.rootedBy[file]) ||
+    fileEntersByName(facts.rootedBy[file], symbol) ||
     (facts.named[at] ?? 0) === 0
   ) {
     return undefined;
@@ -198,7 +228,7 @@ function narrowing(
  * export no code outside the target can import, because the manifest declares
  * `exports` and no root reaches it. Each arm yields to a more specific kind, so one
  * declaration is reported once: a test whose every subject is dead, an interface, a
- * declaration only a test file references, and a deprecated one.
+ * declaration only a test file references or a test that stays keeps, and a deprecated one.
  */
 function unreachable(
   facts: Facts,
@@ -213,7 +243,7 @@ function unreachable(
     (facts.rootedBy[at]?.size ?? 0) > 0 ||
     candidate.testOfDeadCode ||
     symbol.kind === "interface" ||
-    (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+    (candidate.testRefs > 0 && (candidate.productionRefs === 0 || candidate.keptByTests)) ||
     (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))
   ) {
     return undefined;
@@ -253,8 +283,13 @@ export function narrowings(input: EmitterInput): readonly Finding[] {
       return;
     }
     const candidate = candidates.get(symbol.id);
+    // A declaration of test code, a test file's or test-support code's, that only test code
+    // references is a candidate, live in the run that counts test references.
+    const live =
+      candidate === undefined ||
+      (facts.graph.test[at] === true && !candidate.unreferencedTest && !candidate.testOfDeadCode);
     const found =
-      candidate === undefined
+      candidate === undefined || live
         ? narrowing(facts, at, symbol, world)
         : unreachable(facts, at, symbol, candidate, input);
     if (found !== undefined) {

package/src/generated-file.ts

@@ -14,6 +14,15 @@ const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
 /** The documentation tag `@generated` as a word of a comment. */
 const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
 
+/** A first comment naming the tool that wrote the file. */
+const GENERATED_BY = /^\/\/ Generated by \S/u;
+
+/** The word a generator's notice holds, beside one of {@link KEEP_OUT}. */
+const GENERATED_WORD = /\bgenerated\b/iu;
+
+/** The phrases a generator's notice asks a reader not to edit the file by. */
+const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
+
 /** The comments before a text's first token, a leading hashbang line skipped. */
 function leadingComments(text: string): readonly string[] {
   const comments: string[] = [];
@@ -53,6 +62,13 @@ export function generatedByComment(text: string): string | undefined {
   if (comments.some((one) => GENERATED_TAG.test(one))) {
     return "generated by the @generated tag its leading comments hold";
   }
+  const notice = comments.join("\n");
+  if (
+    GENERATED_BY.test(comments[0] ?? "") ||
+    (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))
+  ) {
+    return "generated by the notice its leading comments hold";
+  }
   return undefined;
 }
 

package/src/git-ignore.ts

@@ -0,0 +1,98 @@
+/**
+ * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * https://git-scm.com/docs/gitignore#_pattern_format
+ */
+
+import { globExpression } from "./glob.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+
+/** One pattern line of a `.gitignore` file. */
+interface Rule {
+  readonly negated: boolean;
+  /** Whether the pattern ends with `/`, so it matches a directory alone. */
+  readonly directoryOnly: boolean;
+  /** The expression over a path below the file's own directory. */
+  readonly expression: RegExp;
+}
+
+/** The rules one `.gitignore` text writes, in order. */
+function rulesOf(text: string): readonly Rule[] {
+  const rules: Rule[] = [];
+  for (const raw of text.split(/\r?\n/u)) {
+    let line = raw.replace(/(?<!\\)\s+$/u, "");
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    const negated = line.startsWith("!");
+    line = negated || line.startsWith("\\") ? line.slice(1) : line;
+    const directoryOnly = line.endsWith("/");
+    line = line.replace(/\/+$/u, "");
+    if (line === "") {
+      continue;
+    }
+    // A separator at the start or in the middle anchors the pattern to the file's
+    // directory; with none, the pattern matches at any depth below it.
+    const anchored = line.includes("/");
+    const pattern = line.replace(/^\//u, "");
+    rules.push({
+      negated,
+      directoryOnly,
+      expression: globExpression(anchored ? pattern : `**/${pattern}`),
+    });
+  }
+  return rules;
+}
+
+/**
+ * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
+ * outside `root` is not ignored, and a file below an ignored directory stays ignored
+ * whatever a later pattern says, as git cannot re-include it.
+ */
+export function gitIgnored(host: Host, root: string): (path: string) => boolean {
+  const read = new Map<string, readonly Rule[]>();
+  const rulesAt = (dir: string): readonly Rule[] => {
+    let rules = read.get(dir);
+    if (rules === undefined) {
+      try {
+        rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
+      } catch {
+        rules = [];
+      }
+      read.set(dir, rules);
+    }
+    return rules;
+  };
+  /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
+  const decided = (path: string, directory: boolean): boolean => {
+    const dirs: string[] = [];
+    for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
+      dirs.unshift(at);
+    }
+    dirs.unshift(root);
+    let ignored = false;
+    for (const dir of dirs) {
+      const below = relativePath(dir, path);
+      for (const rule of below === undefined ? [] : rulesAt(dir)) {
+        if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+          ignored = !rule.negated;
+        }
+      }
+    }
+    return ignored;
+  };
+  return (path) => {
+    const below = relativePath(root, path);
+    if (below === undefined) {
+      return false;
+    }
+    const parts = below.split("/");
+    for (let count = 1; count <= parts.length; count += 1) {
+      const at = joinPath(root, parts.slice(0, count).join("/"));
+      if (decided(at, count < parts.length)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}

package/src/graph.ts

@@ -63,6 +63,8 @@ const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   worker: true,
   "html-entry": true,
   "workflow-step": true,
+  "computed-import": true,
+  "document-import": true,
 };
 
 /** Whether the sweep judges a declaration of one kind. */
@@ -112,6 +114,8 @@ export interface Graph {
   readonly test: readonly boolean[];
   /** Per declaration, whether a test-support file holds it. */
   readonly support: readonly boolean[];
+  /** Per declaration, whether it is ambient, describing code the target does not implement. */
+  readonly ambient: readonly boolean[];
   /** Per declaration, whether the sweep judges its liveness. */
   readonly subject: readonly boolean[];
   /**
@@ -145,6 +149,7 @@ export function graphOf(
   roots: readonly Root[],
   testFiles: readonly string[],
   supportFiles: readonly string[] = [],
+  ambient: ReadonlySet<string> = new Set(),
 ): Graph {
   const supports = new Set(supportFiles);
   const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
@@ -199,6 +204,7 @@ export function graphOf(
     parent,
     test: symbols.map((symbol) => tests.has(symbol.position.path)),
     support: symbols.map((symbol) => supports.has(symbol.position.path)),
+    ambient: symbols.map((symbol) => ambient.has(symbol.id)),
     subject: symbols.map((symbol) => swept(symbol.kind)),
     exportsOf,
     rooted,

package/src/host.ts

@@ -8,15 +8,11 @@ export interface DirectoryEntry {
 }
 
 /**
- * The platform one run reads: the filesystem, the directory relative paths
- * resolve against, and the version of the package this analyzer was installed
- * from.
- *
- * It is a parameter rather than an import because a published module that reads
- * the filesystem directly carries the whole platform's type surface into every
- * consumer's compile, and because the run's own reads are then the one thing a
- * caller can watch. The command line binds it to the platform it runs on; nothing
- * under this module does.
+ * The platform one run reads: the filesystem, the working directory and the analyzer's
+ * installed version. A run may keep what it reads for the host's life, so a caller whose
+ * tree changes passes a new host. It is a parameter, not an import, so a published module
+ * carries no platform type surface into a consumer's compile and a caller can watch the
+ * run's reads. The command line binds it to the platform; nothing under this module does.
  */
 export interface Host {
   /** The directory a relative path resolves against. */

package/src/import-bindings.ts

@@ -0,0 +1,128 @@
+/**
+ * The import bindings of one file: the names its import declarations bind, which only
+ * the file itself can read.
+ */
+
+import {
+  isExportSpecifier,
+  isExternalModuleReference,
+  isIdentifier,
+  isImportDeclaration,
+  isImportEqualsDeclaration,
+  isJsxElement,
+  isJsxFragment,
+  isJsxSelfClosingElement,
+  isNamespaceImport,
+  SyntaxKind,
+  type Identifier,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+
+/** The extensions of the files whose import bindings are judged: no markup can read them. */
+const JUDGED = /\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/u;
+
+/** The compiler's `jsx` settings whose emit calls no factory the file must hold. */
+const AUTOMATIC_RUNTIME: ReadonlySet<unknown> = new Set([4, 5, "react-jsx", "react-jsxdev"]);
+
+/** A doc comment, where a JavaScript file names the types it imports. */
+const DOC_COMMENT = /\/\*\*[\s\S]*?\*\//gu;
+
+/** The parts of a doc comment the compiler resolves names in: a `{…}` type or link, a `@see` target. */
+const DOC_REFERENCE = /\{[^{}]*\}|@see\s+[A-Za-z_$][\w$.]*/gu;
+
+/** The factory a pragma comment names: `@jsx h` or `@jsxFrag Fragment`. */
+const PRAGMA = /@jsx(?:Frag)?\s+([A-Za-z_$][\w$]*)/gu;
+
+/** The compiler options the JSX rule reads. */
+export interface JsxOptions {
+  readonly jsx?: unknown;
+  readonly jsxFactory?: unknown;
+  readonly jsxFragmentFactory?: unknown;
+}
+
+/**
+ * The names one file's import declarations bind: the default, named and namespace names of
+ * an `import` declaration, and the name of an `import x = require()` declaration that is
+ * not exported. None is judged in a declaration file or a component file.
+ */
+export function importBindings(file: SourceFile): readonly Identifier[] {
+  if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
+    return [];
+  }
+  const found: Identifier[] = [];
+  for (const statement of file.statements) {
+    if (isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      if (clause?.name !== undefined) {
+        found.push(clause.name);
+      }
+      const named = clause?.namedBindings;
+      if (named !== undefined && isNamespaceImport(named)) {
+        found.push(named.name);
+      } else if (named !== undefined) {
+        for (const element of named.elements) {
+          found.push(element.name);
+        }
+      }
+    } else if (
+      isImportEqualsDeclaration(statement) &&
+      isExternalModuleReference(statement.moduleReference) &&
+      isIdentifier(statement.name) &&
+      !(statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)
+    ) {
+      found.push(statement.name);
+    }
+  }
+  return found;
+}
+
+/** Whether one identifier names a binding in a local export, which reads it whatever it resolves to. */
+export function exportsLocally(use: Identifier): boolean {
+  return isExportSpecifier(use.parent);
+}
+
+/**
+ * The names a file reads without an identifier the program resolves: each name a type, a
+ * link or a `@see` tag of its doc comments spells, and, where it writes JSX the compiler
+ * turns into factory calls, the factories the configuration or a pragma names.
+ */
+export function implicitReads(file: SourceFile, options: JsxOptions): ReadonlySet<string> {
+  const names = new Set<string>();
+  for (const comment of file.text.match(DOC_COMMENT) ?? []) {
+    for (const reference of comment.match(DOC_REFERENCE) ?? []) {
+      for (const word of reference.match(/[A-Za-z_$][\w$]*/gu) ?? []) {
+        names.add(word);
+      }
+    }
+  }
+  if (AUTOMATIC_RUNTIME.has(options.jsx) || !writesJsx(file)) {
+    return names;
+  }
+  for (const factory of [options.jsxFactory, options.jsxFragmentFactory]) {
+    names.add(typeof factory === "string" ? (factory.split(".")[0] ?? factory) : "React");
+  }
+  for (const match of file.text.matchAll(PRAGMA)) {
+    if (match[1] !== undefined) {
+      names.add(match[1]);
+    }
+  }
+  return names;
+}
+
+/** Whether a file holds a JSX element or fragment. */
+function writesJsx(file: SourceFile): boolean {
+  let found = false;
+  const visit = (node: Node): void => {
+    if (found) {
+      return;
+    }
+    if (isJsxElement(node) || isJsxSelfClosingElement(node) || isJsxFragment(node)) {
+      found = true;
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}