@konvert7/klint 0.38.0 → 1.0.1

package/plugins/index.ts

@@ -1,6 +0,0 @@
-import type { KlintPlugin } from "../core/types";
-import { sonarPlugin } from "./sonar";
-
-export const BUILT_IN_PLUGINS: Record<string, KlintPlugin> = {
-  sonar: sonarPlugin,
-};

package/plugins/sonar.ts

@@ -1,27 +0,0 @@
-import type { KlintPlugin } from "../core/types";
-import { noSingleCharClass } from "../rules/no-single-char-class";
-import { preferAt } from "../rules/prefer-at";
-import { preferNullishCoalescingAssign } from "../rules/prefer-nullish-coalescing-assign";
-import { preferStringRaw } from "../rules/prefer-string-raw";
-import { preferStringRawRegexp } from "../rules/prefer-string-raw-regexp";
-import { preferStringReplaceall } from "../rules/prefer-string-replaceall";
-
-export const sonarPlugin: KlintPlugin = {
-  name: "sonar",
-  rules: {
-    "sonar/prefer-string-replaceall": "error",
-    "sonar/prefer-string-raw-regexp": "error",
-    "sonar/prefer-string-raw": "error",
-    "sonar/prefer-nullish-coalescing-assign": "error",
-    "sonar/no-single-char-class": "error",
-    "sonar/prefer-at": "error",
-  },
-  implementations: {
-    "sonar/prefer-string-replaceall": preferStringReplaceall,
-    "sonar/prefer-string-raw-regexp": preferStringRawRegexp,
-    "sonar/prefer-string-raw": preferStringRaw,
-    "sonar/prefer-nullish-coalescing-assign": preferNullishCoalescingAssign,
-    "sonar/no-single-char-class": noSingleCharClass,
-    "sonar/prefer-at": preferAt,
-  },
-};

package/rules/index.ts

@@ -1,26 +0,0 @@
-import type { KlintRule } from "../core/types";
-import { noAsyncPredicate } from "./no-async-predicate";
-import { noConsecutiveArrayPush } from "./no-consecutive-array-push";
-import { noDateEquality } from "./no-date-equality";
-import { noFloatingPromise } from "./no-floating-promise";
-import { noMisusedPromises } from "./no-misused-promises";
-import { noNestedTemplateLiterals } from "./no-nested-template-literals";
-import { noObjectInTemplate } from "./no-object-in-template";
-import { noOptionalChainOnNonNullable } from "./no-optional-chain-on-non-nullable";
-import { noStringMatch } from "./no-string-match";
-import { noSyncInAsync } from "./no-sync-in-async";
-import { noUnguardedJsonParse } from "./no-unguarded-json-parse";
-
-export const BUILT_IN_RULES: Record<string, KlintRule> = {
-  "no-unguarded-json-parse": noUnguardedJsonParse,
-  "no-sync-in-async": noSyncInAsync,
-  "no-floating-promise": noFloatingPromise,
-  "no-misused-promises": noMisusedPromises,
-  "no-async-predicate": noAsyncPredicate,
-  "no-date-equality": noDateEquality,
-  "no-optional-chain-on-non-nullable": noOptionalChainOnNonNullable,
-  "no-object-in-template": noObjectInTemplate,
-  "no-nested-template-literals": noNestedTemplateLiterals,
-  "no-consecutive-array-push": noConsecutiveArrayPush,
-  "no-string-match": noStringMatch,
-};

package/rules/no-async-predicate.ts

@@ -1,51 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-const PREDICATE_METHODS = new Set(["filter", "some", "every", "find", "findIndex"]);
-
-export const noAsyncPredicate = defineAstRule({
-  meta: {
-    description:
-      "Flags `async` functions passed to `.filter`/`.some`/`.every`/`.find`/`.findIndex`. Array methods coerce the returned promise to truthy, so every element appears to match.",
-    examples: ["no-async-predicate: error"],
-  },
-  visit(node, ctx) {
-    if (
-      !ts.isCallExpression(node) ||
-      !ts.isPropertyAccessExpression(node.expression) ||
-      !PREDICATE_METHODS.has(node.expression.name.text) ||
-      node.arguments.length === 0
-    )
-      return;
-
-    const receiverType = ctx.checker.getTypeAtLocation(node.expression.expression);
-    if (isArrayLike(receiverType) && isAsyncFunction(node.arguments[0])) {
-      const method = node.expression.name.text;
-      ctx.report(
-        node.arguments[0],
-        `Async callback passed to .${method}() — the returned Promise is always truthy, so the predicate never filters correctly. The array method cannot await it.`
-      );
-    }
-  },
-});
-
-function isArrayLike(type: ts.Type): boolean {
-  if (type.isUnion()) return type.types.some((t) => isArrayLike(t));
-  const sym = type.getSymbol();
-  if (sym?.name === "Array" || sym?.name === "ReadonlyArray") return true;
-  const ref = type as ts.TypeReference;
-  if (ref.target) {
-    const targetSym = ref.target.getSymbol();
-    if (targetSym?.name === "Array" || targetSym?.name === "ReadonlyArray") return true;
-  }
-  return false;
-}
-
-function isAsyncFunction(
-  node: ts.Node
-): node is ts.ArrowFunction | ts.FunctionExpression {
-  return (
-    (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
-    (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false)
-  );
-}

package/rules/no-consecutive-array-push.ts

@@ -1,61 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const noConsecutiveArrayPush: KlintRule = {
-  meta: {
-    description:
-      "Flags consecutive `arr.push(x); arr.push(y);` calls — combine into `arr.push(x, y)` or `arr.push(...items)`.",
-    examples: ["no-consecutive-array-push: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        const statements =
-          ts.isBlock(node) || ts.isSourceFile(node) ? node.statements : null;
-        if (!statements) return;
-
-        let runStart = -1;
-        let runReceiver = "";
-
-        const flush = (upTo: number) => {
-          if (runStart !== -1 && upTo - runStart >= 2) {
-            const { line } = src.getLineAndCharacterOfPosition(
-              statements[runStart].getStart()
-            );
-            violations.push({
-              file: relativeSlashPath(root, file),
-              line: line + 1,
-              message: `${upTo - runStart} consecutive .push() calls on \`${runReceiver}\` — combine into a single .push(a, b, …) call.`,
-            });
-          }
-          runStart = -1;
-          runReceiver = "";
-        };
-
-        for (let i = 0; i < statements.length; i++) {
-          const receiver = getPushReceiver(statements[i], src);
-          if (receiver && receiver === runReceiver) {
-            // continue the run
-          } else {
-            flush(i);
-            runStart = receiver ? i : -1;
-            runReceiver = receiver ?? "";
-          }
-        }
-        flush(statements.length);
-      });
-    }
-  },
-};
-
-function getPushReceiver(node: ts.Statement, src: ts.SourceFile): string | null {
-  if (!ts.isExpressionStatement(node)) return null;
-  const expr = node.expression;
-  if (!ts.isCallExpression(expr)) return null;
-  if (!ts.isPropertyAccessExpression(expr.expression)) return null;
-  if (expr.expression.name.text !== "push") return null;
-  return expr.expression.expression.getText(src);
-}

package/rules/no-date-equality.ts

@@ -1,35 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-export const noDateEquality = defineAstRule({
-  meta: {
-    description:
-      "Flags `Date` comparisons with `==`/`===`/`!=`/`!==` — these compare object identity, not the time value. Use `.getTime()` instead.",
-    examples: ["no-date-equality: error"],
-  },
-  visit(node, ctx) {
-    if (!ts.isBinaryExpression(node)) return;
-    const { kind } = node.operatorToken;
-    if (
-      kind !== ts.SyntaxKind.EqualsEqualsEqualsToken &&
-      kind !== ts.SyntaxKind.ExclamationEqualsEqualsToken
-    )
-      return;
-
-    const leftType = ctx.checker.getTypeAtLocation(node.left);
-    const rightType = ctx.checker.getTypeAtLocation(node.right);
-    if (isDateType(leftType) && isDateType(rightType)) {
-      const op = node.operatorToken.getText(ctx.sourceFile);
-      ctx.report(
-        node,
-        `Date values compared with ${op} — this compares object references, not time values. Use .getTime() or .valueOf() instead.`
-      );
-    }
-  },
-});
-
-function isDateType(type: ts.Type): boolean {
-  if (type.getSymbol()?.name === "Date") return true;
-  if (type.isUnion()) return type.types.some(isDateType);
-  return false;
-}

package/rules/no-floating-promise.ts

@@ -1,37 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-export const noFloatingPromise = defineAstRule({
-  meta: {
-    description:
-      "Flags Promise-returning expressions that aren't awaited or `.catch()`-handled — silent failures and unpredictable execution order.",
-    examples: ["no-floating-promise: error"],
-  },
-  visit(node, ctx) {
-    if (
-      ts.isExpressionStatement(node) &&
-      ts.isCallExpression(node.expression) &&
-      !isHandled(node.expression)
-    ) {
-      const type = ctx.checker.getTypeAtLocation(node.expression);
-      if (isPromiseLike(type)) {
-        ctx.report(
-          node,
-          "Promise-returning call is not awaited — errors will be silently discarded and execution order is unpredictable. Use await, void, or .catch()."
-        );
-      }
-    }
-  },
-});
-
-function isHandled(node: ts.CallExpression): boolean {
-  if (!ts.isPropertyAccessExpression(node.expression)) return false;
-  const name = node.expression.name.text;
-  return name === "catch" || name === "finally";
-}
-
-function isPromiseLike(type: ts.Type): boolean {
-  if (type.getSymbol()?.name === "Promise") return true;
-  if (type.isUnion()) return type.types.some(isPromiseLike);
-  return false;
-}

package/rules/no-misused-promises.ts

@@ -1,59 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-export const noMisusedPromises = defineAstRule({
-  meta: {
-    description:
-      "Flags Promises passed where the type expects a non-thenable (e.g. an `if` condition, a `void` callback). The Promise's truthiness — not its resolved value — drives the branch.",
-    examples: ["no-misused-promises: error"],
-  },
-  visit(node, ctx) {
-    if (!ts.isCallExpression(node)) return;
-    const sig = ctx.checker.getResolvedSignature(node);
-    if (!sig) return;
-    const params = sig.getParameters();
-    for (let i = 0; i < node.arguments.length; i++) {
-      const arg = node.arguments[i];
-      if (!isAsyncFunction(arg)) continue;
-
-      const param = params[Math.min(i, params.length - 1)];
-      if (!param) continue;
-
-      const paramType = ctx.checker.getTypeOfSymbolAtLocation(param, node);
-      if (expectsSyncCallback(paramType, ctx.checker)) {
-        ctx.report(
-          arg,
-          "Async function passed where a sync callback is expected — the caller cannot await it and errors will be silently lost."
-        );
-      }
-    }
-  },
-});
-
-function isAsyncFunction(
-  node: ts.Node
-): node is ts.ArrowFunction | ts.FunctionExpression {
-  return (
-    (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
-    (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false)
-  );
-}
-
-function expectsSyncCallback(type: ts.Type, checker: ts.TypeChecker): boolean {
-  if (type.isUnion()) {
-    const callable = type.types.filter(
-      (t) => !(t.flags & ts.TypeFlags.Undefined) && !(t.flags & ts.TypeFlags.Null)
-    );
-    return callable.length > 0 && callable.every((t) => expectsSyncCallback(t, checker));
-  }
-  const sigs = type.getCallSignatures();
-  if (sigs.length === 0) return false;
-  return sigs.every((sig) => !returnsPromise(checker.getReturnTypeOfSignature(sig)));
-}
-
-function returnsPromise(type: ts.Type): boolean {
-  const name = type.getSymbol()?.name;
-  if (name === "Promise" || name === "PromiseLike") return true;
-  if (type.isUnion()) return type.types.some(returnsPromise);
-  return false;
-}

package/rules/no-nested-template-literals.ts

@@ -1,47 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const noNestedTemplateLiterals: KlintRule = {
-  meta: {
-    description:
-      "Flags template literals nested inside template literals — almost always unreadable; extract to a variable.",
-    examples: ["no-nested-template-literals: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (!ts.isTemplateExpression(node)) return;
-        for (const span of node.templateSpans) {
-          findNestedTemplate(span.expression, src, file, root, violations);
-        }
-      });
-    }
-  },
-};
-
-function findNestedTemplate(
-  node: ts.Node,
-  src: ts.SourceFile,
-  file: string,
-  root: string,
-  violations: ReturnType<typeof Array.prototype.slice>
-): void {
-  if (ts.isTemplateExpression(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-    const { line } = src.getLineAndCharacterOfPosition(node.getStart());
-    violations.push({
-      file: relativeSlashPath(root, file),
-      line: line + 1,
-      message:
-        "Nested template literal — extract the inner template to a variable to improve readability.",
-    });
-    return;
-  }
-  // Don't descend into tagged templates — they are a single semantic unit
-  if (ts.isTaggedTemplateExpression(node)) return;
-  ts.forEachChild(node, (child) =>
-    findNestedTemplate(child, src, file, root, violations)
-  );
-}

package/rules/no-object-in-template.ts

@@ -1,95 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-// Builtins with a meaningful toString() that isn't [object Object]
-const SAFE_SYMBOL_NAMES = new Set([
-  "Date",
-  "RegExp",
-  "Error",
-  "TypeError",
-  "RangeError",
-  "SyntaxError",
-  "ReferenceError",
-  "Array",
-  "Map",
-  "Set",
-  "URL",
-  "URLSearchParams",
-  "Symbol",
-]);
-
-export const noObjectInTemplate = defineAstRule({
-  meta: {
-    description:
-      "Flags non-primitive objects interpolated into template literals — produces `[object Object]` unless `toString()` is overridden.",
-    examples: ["no-object-in-template: error"],
-  },
-  visit(node, ctx) {
-    if (!ts.isTemplateExpression(node)) return;
-    for (const span of node.templateSpans) {
-      const type = ctx.checker.getTypeAtLocation(span.expression);
-      if (wouldRenderAsObjectObject(type, ctx.checker)) {
-        ctx.report(
-          span.expression,
-          "Object interpolated in template literal has no custom toString() — it will render as [object Object]. Access a specific property or implement toString()."
-        );
-      }
-    }
-  },
-});
-
-function wouldRenderAsObjectObject(type: ts.Type, checker: ts.TypeChecker): boolean {
-  const primitiveFlags =
-    ts.TypeFlags.String |
-    ts.TypeFlags.Number |
-    ts.TypeFlags.Boolean |
-    ts.TypeFlags.BigInt |
-    ts.TypeFlags.Null |
-    ts.TypeFlags.Undefined |
-    ts.TypeFlags.StringLiteral |
-    ts.TypeFlags.NumberLiteral |
-    ts.TypeFlags.BooleanLiteral |
-    ts.TypeFlags.BigIntLiteral |
-    ts.TypeFlags.Any |
-    ts.TypeFlags.Unknown |
-    ts.TypeFlags.Never |
-    ts.TypeFlags.Void |
-    ts.TypeFlags.ESSymbol |
-    ts.TypeFlags.UniqueESSymbol |
-    ts.TypeFlags.Enum |
-    ts.TypeFlags.EnumLiteral;
-
-  if (type.flags & primitiveFlags) return false;
-
-  if (type.isUnion()) {
-    const meaningful = type.types.filter(
-      (t) => !(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
-    );
-    return (
-      meaningful.length > 0 &&
-      meaningful.every((t) => wouldRenderAsObjectObject(t, checker))
-    );
-  }
-
-  // Functions coerce to their source string — unusual but not [object Object]
-  if (type.getCallSignatures().length > 0) return false;
-
-  // Known builtins with meaningful toString
-  const sym = type.getSymbol();
-  if (sym && SAFE_SYMBOL_NAMES.has(sym.name)) return false;
-
-  // Check for a custom toString not originating from TypeScript's built-in lib
-  const toStringProp = checker.getPropertyOfType(type, "toString");
-  if (!toStringProp) return true;
-
-  const decls = toStringProp.getDeclarations() ?? [];
-  const hasCustomToString = decls.some((d) => {
-    const fileName = d.getSourceFile().fileName;
-    return (
-      !fileName.includes("/typescript/lib/lib") &&
-      !fileName.includes(String.raw`\typescript\lib\lib`)
-    );
-  });
-
-  return !hasCustomToString;
-}

package/rules/no-optional-chain-on-non-nullable.ts

@@ -1,47 +0,0 @@
-import ts from "typescript";
-import { defineAstRule } from "../core/rule-helpers";
-
-export const noOptionalChainOnNonNullable = defineAstRule({
-  meta: {
-    description:
-      "Flags `?.` on receivers whose static type cannot be `null` or `undefined`. The optional chain is dead code and obscures the real shape.",
-    examples: ["no-optional-chain-on-non-nullable: warn"],
-  },
-  shouldRun(program) {
-    return program.getCompilerOptions().strictNullChecks === true;
-  },
-  visit(node, ctx) {
-    const receiver = getOptionalChainReceiver(node);
-    if (!receiver) return;
-    const type = ctx.checker.getTypeAtLocation(receiver);
-    if (!isNullable(type)) {
-      ctx.report(
-        node,
-        "Optional chain (?.) on a non-nullable type — the receiver can never be null or undefined here. Use . to remove misleading dead code."
-      );
-    }
-  },
-});
-
-function getOptionalChainReceiver(node: ts.Node): ts.Expression | undefined {
-  if (
-    (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
-    node.questionDotToken
-  ) {
-    return node.expression;
-  }
-  if (ts.isCallExpression(node) && node.questionDotToken) {
-    return node.expression;
-  }
-  return undefined;
-}
-
-function isNullable(type: ts.Type): boolean {
-  if (
-    type.flags &
-    (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Any | ts.TypeFlags.Unknown)
-  )
-    return true;
-  if (type.isUnion()) return type.types.some(isNullable);
-  return false;
-}

package/rules/no-single-char-class.ts

@@ -1,113 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import { buildNodeReplacementFix } from "../core/rule-helpers";
-import type { KlintRule } from "../core/types";
-
-/**
- * Metacharacters that lose their special meaning inside a character class, so `[.]`
- * is a valid shorthand for a literal dot and must not be unwrapped to a bare `.`.
- */
-const METACHAR_EXCEPTIONS = new Set([".", "*", "+", "?", "{", "}", "(", ")", "|", "$"]);
-
-interface CharClass {
-  bracketStart: number;
-  bracketEnd: number;
-  innerToken: string;
-}
-
-function parseCharClasses(pattern: string): CharClass[] {
-  const results: CharClass[] = [];
-  let i = 0;
-  while (i < pattern.length) {
-    if (pattern[i] === "\\") {
-      i += 2;
-      continue;
-    }
-    if (pattern[i] !== "[") {
-      i++;
-      continue;
-    }
-    const start = i++;
-    // Negated classes have different semantics — skip
-    if (i < pattern.length && pattern[i] === "^") {
-      while (i < pattern.length && pattern[i] !== "]") {
-        if (pattern[i] === "\\") i++;
-        i++;
-      }
-      i++;
-      continue;
-    }
-    const tokens: string[] = [];
-    while (i < pattern.length && pattern[i] !== "]") {
-      if (pattern[i] === "\\") {
-        const s = i++;
-        if (i >= pattern.length) break;
-        const c = pattern[i];
-        if (c === "u" && i + 5 <= pattern.length) {
-          i += 5; // \uXXXX
-        } else if (c === "x" && i + 3 <= pattern.length) {
-          i += 3; // \xXX
-        } else if (c === "c" && i + 1 < pattern.length) {
-          i += 2; // \cX
-        } else {
-          i++;
-        }
-        tokens.push(pattern.slice(s, i));
-      } else {
-        tokens.push(pattern[i++]);
-      }
-    }
-    if (i >= pattern.length) break;
-    const end = i++;
-    if (tokens.length === 1) {
-      results.push({ bracketStart: start, bracketEnd: end, innerToken: tokens[0] });
-    }
-  }
-  return results;
-}
-
-export const noSingleCharClass: KlintRule = {
-  meta: {
-    description:
-      "Flags single-character character classes in regex (e.g. `/[a]/`) — drop the brackets; the regex matches the same.",
-    examples: ["sonar/no-single-char-class: warn"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (!ts.isRegularExpressionLiteral(node)) return;
-
-        const regexSrc = node.getText(src);
-        const lastSlash = regexSrc.lastIndexOf("/");
-        const pattern = regexSrc.slice(1, lastSlash);
-        const flags = regexSrc.slice(lastSlash + 1);
-
-        const allClasses = parseCharClasses(pattern);
-        const toFix = allClasses.filter((c) => !METACHAR_EXCEPTIONS.has(c.innerToken));
-        if (toFix.length === 0) return;
-
-        let fixedPattern = "";
-        let prev = 0;
-        for (const cls of allClasses) {
-          if (METACHAR_EXCEPTIONS.has(cls.innerToken)) continue;
-          fixedPattern += pattern.slice(prev, cls.bracketStart);
-          fixedPattern += cls.innerToken;
-          prev = cls.bracketEnd + 1;
-        }
-        fixedPattern += pattern.slice(prev);
-
-        const fixedRegex = `/${fixedPattern}/${flags}`;
-        const fix = buildNodeReplacementFix(src, node, fixedRegex);
-
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: fix.startLine,
-          message: `Character class [${toFix[0].innerToken}] contains a single element — remove the brackets.`,
-          fix,
-        });
-      });
-    }
-  },
-};

package/rules/no-string-match.ts

@@ -1,63 +0,0 @@
-import ts from "typescript";
-import { walkAst } from "../core/ast";
-import { relativeSlashPath } from "../core/paths";
-import type { KlintRule } from "../core/types";
-
-export const noStringMatch: KlintRule = {
-  meta: {
-    description:
-      "Flags `String#match` — prefer `.matchAll()` for iteration or `.test()` for boolean checks. `.match()` returns different shapes depending on the `/g` flag.",
-    examples: ["no-string-match: error"],
-  },
-  check({ files, root, fileContents }, violations) {
-    for (const file of files) {
-      const content = fileContents.get(file) ?? "";
-      walkAst(file, content, (node, src) => {
-        if (
-          ts.isCallExpression(node) &&
-          ts.isPropertyAccessExpression(node.expression) &&
-          node.expression.name.text === "match" &&
-          node.arguments.length === 1 &&
-          ts.isRegularExpressionLiteral(node.arguments[0])
-        ) {
-          const flags = regexFlags(node.arguments[0].text);
-          if (!flags.includes("g")) {
-            const strText = (
-              node.expression as ts.PropertyAccessExpression
-            ).expression.getText(src);
-            const regexText = node.arguments[0].getText(src);
-            const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
-            const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
-            const fix =
-              s === e
-                ? (() => {
-                    const lineStart = src.getPositionOfLineAndCharacter(s, 0);
-                    const nlPos = src.text.indexOf("\n", lineStart);
-                    const lineText = src.text.slice(
-                      lineStart,
-                      nlPos === -1 ? undefined : nlPos
-                    );
-                    const fixed = lineText.replace(
-                      node.getText(src),
-                      `new RegExp(${regexText}).exec(${strText})`
-                    );
-                    return { startLine: s + 1, endLine: e + 1, replacement: fixed };
-                  })()
-                : undefined;
-            violations.push({
-              file: relativeSlashPath(root, file),
-              line: s + 1,
-              message: `Use RegExp.exec() instead of String.match() for non-global regexes — use new RegExp(${regexText}).exec(${strText}) instead.`,
-              fix,
-            });
-          }
-        }
-      });
-    }
-  },
-};
-
-function regexFlags(literal: string): string {
-  const last = literal.lastIndexOf("/");
-  return last > 0 ? literal.slice(last + 1) : "";
-}