@sshkeda/task 0.0.0-stage → 1.0.1

package/src/lib/main-thread/lib/scan-module-source/internal/find-task-declarations.ts

@@ -0,0 +1,205 @@
+import { Visitor } from "oxc-parser";
+import type { parseSync, CallExpression, Expression, Program } from "oxc-parser";
+
+import { TASK_PACKAGE } from "../../../../../shared/task-package.ts";
+import {
+  TaskCalledBelowTopLevel,
+  TaskNameEmpty,
+  TaskNameComputed,
+  TaskNameMissing,
+  TaskNameNotString,
+  TaskPackageImportedWithoutTask,
+} from "../../../shared/main-thread-errors.ts";
+import type { ModuleScanRefusal } from "../../../shared/main-thread-errors.ts";
+import { readBarePackageName } from "../../../shared/read-bare-package-name.ts";
+import { findLexicalBindings } from "./find-lexical-bindings.ts";
+import { readLiteralString } from "./read-literal-string.ts";
+import { listValueImports, readRequireFunctionName } from "./read-module-loads.ts";
+import { unwrapTypeAssertions } from "./unwrap-type-assertions.ts";
+
+const unwrapPipeCalls = (
+  expression: Expression | null | undefined,
+): Expression | null | undefined => {
+  const isMissing = expression === null || expression === undefined;
+  if (isMissing) {
+    return expression;
+  }
+  const unwrapped = unwrapTypeAssertions(expression);
+  if (unwrapped.type !== "CallExpression") {
+    return unwrapped;
+  }
+  const callee = unwrapped.callee;
+  const callsPipeMethod =
+    callee.type === "MemberExpression" && !callee.computed && callee.property.name === "pipe";
+  return callsPipeMethod ? unwrapPipeCalls(callee.object) : unwrapped;
+};
+
+const listInitializers = (
+  statement: Program["body"][number],
+): readonly (Expression | null | undefined)[] => {
+  const declared = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+  if (declared?.type === "VariableDeclaration") {
+    return declared.declarations.map((declarator) => declarator.init);
+  }
+  if (declared?.type === "ExpressionStatement") {
+    return [declared.expression];
+  }
+  if (declared?.type !== "ExportDefaultDeclaration") {
+    return [];
+  }
+  const declaration = declared.declaration;
+  const isDeclaration =
+    declaration.type === "FunctionDeclaration" ||
+    declaration.type === "ClassDeclaration" ||
+    declaration.type === "TSInterfaceDeclaration";
+  return isDeclaration ? [] : [declaration];
+};
+
+const readRequiredModule = (initializer: Expression | null) => {
+  if (initializer === null) {
+    return null;
+  }
+  const required = unwrapTypeAssertions(initializer);
+  const isRequireCall =
+    required.type === "CallExpression" && readRequireFunctionName(required) !== null;
+  return isRequireCall ? readLiteralString(required.arguments[0]) : null;
+};
+
+const listTaskPackageRequires = (program: Program) =>
+  program.body.flatMap((statement) =>
+    statement.type === "VariableDeclaration"
+      ? statement.declarations.flatMap(({ id, init: initializer }) => {
+          const requiredModule = readRequiredModule(initializer);
+          const requiresTaskPackage =
+            requiredModule !== null && readBarePackageName(requiredModule) === TASK_PACKAGE.name;
+          return requiresTaskPackage ? [id] : [];
+        })
+      : [],
+  );
+
+export const findTaskDeclarations = (
+  parsed: ReturnType<typeof parseSync>,
+  text: string,
+  lineAt: (offset: number) => number,
+) => {
+  const importViolations: (typeof ModuleScanRefusal.Type)[] = [];
+  const nameViolations: (typeof ModuleScanRefusal.Type)[] = [];
+  const bindingFor = findLexicalBindings(parsed.program);
+  const taskNamespaceBindings = new Set<number>();
+  const moduleNamespaceBindings = new Set<number>();
+  for (const { declaration, valueEntries } of listValueImports(parsed)) {
+    const importedModule = declaration.moduleRequest.value;
+    if (readBarePackageName(importedModule) !== TASK_PACKAGE.name) {
+      continue;
+    }
+
+    for (const importEntry of valueEntries) {
+      if (importEntry.importName.name === "Task") {
+        taskNamespaceBindings.add(importEntry.localName.start);
+      } else if (importEntry.importName.kind === "NamespaceObject") {
+        moduleNamespaceBindings.add(importEntry.localName.start);
+      } else if (importEntry.importName.name === null) {
+        importViolations.push(
+          new TaskPackageImportedWithoutTask({ line: lineAt(declaration.start) }),
+        );
+      }
+    }
+  }
+
+  for (const binding of listTaskPackageRequires(parsed.program)) {
+    if (binding.type === "Identifier") {
+      moduleNamespaceBindings.add(binding.start);
+      continue;
+    }
+    if (binding.type !== "ObjectPattern") {
+      continue;
+    }
+    for (const property of binding.properties) {
+      const bindsTaskNamespace =
+        property.type === "Property" &&
+        !property.computed &&
+        property.key.type === "Identifier" &&
+        property.key.name === "Task" &&
+        property.value.type === "Identifier";
+      if (bindsTaskNamespace) {
+        taskNamespaceBindings.add(property.value.start);
+      }
+    }
+  }
+
+  const isTaskNamespace = (expression: Expression): boolean =>
+    expression.type === "Identifier"
+      ? taskNamespaceBindings.has(bindingFor(expression) ?? -1)
+      : expression.type === "MemberExpression" &&
+        !expression.computed &&
+        expression.object.type === "Identifier" &&
+        moduleNamespaceBindings.has(bindingFor(expression.object) ?? -1) &&
+        expression.property.name === "Task";
+
+  const callsTask = (call: CallExpression) => {
+    const callee = call.callee;
+    const isNamedMemberCall = callee.type === "MemberExpression" && !callee.computed;
+    return isNamedMemberCall && callee.property.name === "make" && isTaskNamespace(callee.object);
+  };
+
+  const madeTasks: { readonly name: string; readonly line: number }[] = [];
+  const topLevelTaskCalls = new Set<number>();
+  for (const statement of parsed.program.body) {
+    for (const pipedInitializer of listInitializers(statement)) {
+      const initializer = unwrapPipeCalls(pipedInitializer);
+      const isTaskCall = initializer?.type === "CallExpression" && callsTask(initializer);
+      if (!isTaskCall) {
+        continue;
+      }
+
+      topLevelTaskCalls.add(initializer.start);
+      const [nameArgument] = initializer.arguments;
+      const taskName = readLiteralString(nameArgument);
+      const isNonStringLiteralName = taskName === null && nameArgument?.type === "Literal";
+      if (nameArgument === undefined) {
+        nameViolations.push(new TaskNameMissing({ line: lineAt(initializer.start) }));
+      } else if (isNonStringLiteralName) {
+        nameViolations.push(
+          new TaskNameNotString({
+            line: lineAt(initializer.start),
+            nameText: text.slice(nameArgument.start, nameArgument.end),
+          }),
+        );
+      } else if (taskName === null) {
+        nameViolations.push(
+          new TaskNameComputed({
+            line: lineAt(initializer.start),
+            nameText: text.slice(nameArgument.start, nameArgument.end),
+          }),
+        );
+      } else if (taskName === "") {
+        nameViolations.push(new TaskNameEmpty({ line: lineAt(initializer.start) }));
+      } else {
+        madeTasks.push({ name: taskName, line: lineAt(initializer.start) });
+      }
+    }
+  }
+
+  return { madeTasks, importViolations, nameViolations, callsTask, topLevelTaskCalls };
+};
+
+export const findTaskCallsBelowTopLevel = (
+  program: Program,
+  taskDeclarations: Pick<
+    ReturnType<typeof findTaskDeclarations>,
+    "callsTask" | "topLevelTaskCalls"
+  >,
+  lineAt: (offset: number) => number,
+) => {
+  const violations: (typeof ModuleScanRefusal.Type)[] = [];
+  new Visitor({
+    CallExpression: (call) => {
+      const isTaskCallBelowTopLevel =
+        taskDeclarations.callsTask(call) && !taskDeclarations.topLevelTaskCalls.has(call.start);
+      if (isTaskCallBelowTopLevel) {
+        violations.push(new TaskCalledBelowTopLevel({ line: lineAt(call.start) }));
+      }
+    },
+  }).visit(program);
+  return violations;
+};

package/src/lib/main-thread/lib/scan-module-source/internal/parse-module-text.ts

@@ -0,0 +1,34 @@
+import { parseSync } from "oxc-parser";
+
+import type { SCRIPT_LOADERS } from "../../../../../shared/find-bun-loader-for-script.ts";
+
+const PARSER_LANGUAGE_OF_LOADER = {
+  js: "jsx",
+  jsx: "jsx",
+  ts: "ts",
+  tsx: "tsx",
+} as const satisfies Record<(typeof SCRIPT_LOADERS)[number], string>;
+
+const findParserLanguage = (
+  moduleFilePath: string,
+  configuredLoader: (typeof SCRIPT_LOADERS)[number] | null,
+) => {
+  if (configuredLoader !== null) {
+    return { lang: PARSER_LANGUAGE_OF_LOADER[configuredLoader] };
+  }
+  return moduleFilePath.endsWith(".js") ? { lang: "jsx" as const } : {};
+};
+
+export const parseModuleText = (
+  moduleFilePath: string,
+  text: string,
+  options: {
+    readonly configuredLoader: (typeof SCRIPT_LOADERS)[number] | null;
+    readonly sourceType?: "commonjs";
+  },
+) =>
+  parseSync(moduleFilePath, text, {
+    preserveParens: false,
+    ...findParserLanguage(moduleFilePath, options.configuredLoader),
+    ...(options.sourceType === undefined ? {} : { sourceType: options.sourceType }),
+  });

package/src/lib/main-thread/lib/scan-module-source/internal/read-literal-string.ts

@@ -0,0 +1,15 @@
+import type { Argument } from "oxc-parser";
+
+export const readLiteralString = (argument: Argument | undefined) => {
+  const isStringLiteral = argument?.type === "Literal" && typeof argument.value === "string";
+  if (isStringLiteral) {
+    return argument.value;
+  }
+  const isPlainTemplateLiteral =
+    argument?.type === "TemplateLiteral" && argument.expressions.length === 0;
+  if (isPlainTemplateLiteral) {
+    const [onlyQuasi] = argument.quasis;
+    return onlyQuasi === undefined ? null : onlyQuasi.value.cooked;
+  }
+  return null;
+};

package/src/lib/main-thread/lib/scan-module-source/internal/read-module-loads.ts

@@ -0,0 +1,316 @@
+import { Visitor } from "oxc-parser";
+import type {
+  Argument,
+  CallExpression,
+  Expression,
+  ImportAttribute,
+  parseSync,
+  Program,
+  TSImportEqualsDeclaration,
+} from "oxc-parser";
+
+import { readLiteralString } from "./read-literal-string.ts";
+import { visitNonReferenceIdentifiers } from "./visit-non-reference-identifiers.ts";
+
+const REQUIRE_FUNCTION_NAMES = new Set(["require", "__require"]);
+
+const MODULE_LOADER_NAMES = new Set([...REQUIRE_FUNCTION_NAMES, "createRequire"]);
+
+const readAttributeLoader = (attributes: readonly ImportAttribute[]) =>
+  attributes.find((attribute) =>
+    attribute.key.type === "Identifier"
+      ? attribute.key.name === "type"
+      : attribute.key.value === "type",
+  )?.value.value ?? null;
+
+const readObjectProperty = (expression: Expression | null, name: string) => {
+  if (expression?.type !== "ObjectExpression") {
+    return;
+  }
+  const properties = expression.properties;
+  const hasComputedOrSpreadProperties = properties.some(
+    (property) => property.type === "SpreadElement" || property.computed,
+  );
+  if (hasComputedOrSpreadProperties) {
+    return;
+  }
+  for (const property of properties.toReversed()) {
+    const isNamedProperty =
+      property.type === "Property" &&
+      (property.key.type === "Identifier"
+        ? property.key.name === name
+        : property.key.type === "Literal" && property.key.value === name);
+    if (isNamedProperty) {
+      return property.value;
+    }
+  }
+  return null;
+};
+
+const readDynamicImportLoader = (options: Expression | null) => {
+  if (options === null) {
+    return null;
+  }
+  const attributes = readObjectProperty(options, "with");
+  const hasNoAttributes = attributes === undefined || attributes === null;
+  if (hasNoAttributes) {
+    return attributes;
+  }
+  const loader = readObjectProperty(attributes, "type");
+  const hasNoLoader = loader === undefined || loader === null;
+  if (hasNoLoader) {
+    return loader;
+  }
+  return readLiteralString(loader) ?? undefined;
+};
+
+const LITERAL_PATH_PREFIX = /^\.{0,2}\//u;
+
+const readLiteralPrefix = (argument: Argument | undefined): string | null => {
+  if (argument?.type === "TemplateLiteral") {
+    return argument.quasis[0]?.value.cooked ?? null;
+  }
+  const isConcatenation = argument?.type === "BinaryExpression" && argument.operator === "+";
+  if (isConcatenation) {
+    return readLiteralPrefix(argument.left);
+  }
+  return readLiteralString(argument);
+};
+
+const readLiteralDirectory = (argument: Argument | undefined) => {
+  const prefix = readLiteralPrefix(argument);
+  const namesPathDirectory = prefix !== null && LITERAL_PATH_PREFIX.test(prefix);
+  return namesPathDirectory ? prefix.slice(0, prefix.lastIndexOf("/") + 1) : null;
+};
+
+const readRequireResolveName = (callee: CallExpression["callee"]) => {
+  const isResolveMember =
+    callee.type === "MemberExpression" && !callee.computed && callee.property.name === "resolve";
+  if (!isResolveMember) {
+    return null;
+  }
+  const owner = callee.object;
+  const isRequire = owner.type === "Identifier" && owner.name === "require";
+  if (isRequire) {
+    return "require.resolve";
+  }
+  const isGlobalRequire =
+    owner.type === "MemberExpression" &&
+    !owner.computed &&
+    owner.object.type === "Identifier" &&
+    owner.object.name === "globalThis" &&
+    owner.property.name === "require";
+  return isGlobalRequire ? "globalThis.require.resolve" : null;
+};
+
+export const readRequireFunctionName = (call: CallExpression) => {
+  const { callee } = call;
+  const isRequireFunction = callee.type === "Identifier" && REQUIRE_FUNCTION_NAMES.has(callee.name);
+  return isRequireFunction ? callee.name : null;
+};
+
+const readValueImportEqualsPath = (declaration: TSImportEqualsDeclaration) => {
+  const { moduleReference } = declaration;
+  const isValueExternalModuleImport =
+    declaration.importKind !== "type" && moduleReference.type === "TSExternalModuleReference";
+  return isValueExternalModuleImport ? moduleReference.expression : null;
+};
+
+export const listValueImports = (parsed: ReturnType<typeof parseSync>) => {
+  const typeOnlyImportDeclarationStarts = new Set(
+    parsed.program.body.flatMap((statement) => {
+      const isTypeOnlyImport =
+        statement.type === "ImportDeclaration" && statement.importKind === "type";
+      return isTypeOnlyImport ? [statement.start] : [];
+    }),
+  );
+  return parsed.module.staticImports.flatMap((declaration) => {
+    const valueEntries = declaration.entries.filter((importEntry) => !importEntry.isType);
+    const importsOnlyTypes =
+      typeOnlyImportDeclarationStarts.has(declaration.start) ||
+      (declaration.entries.length > 0 && valueEntries.length === 0);
+    return importsOnlyTypes ? [] : [{ declaration, valueEntries }];
+  });
+};
+
+export const listStaticImportSpecifiers = (parsed: ReturnType<typeof parseSync>) => {
+  const loaders = new Map(
+    parsed.program.body.flatMap((statement) => {
+      const hasImportAttributes =
+        statement.type === "ImportDeclaration" ||
+        statement.type === "ExportNamedDeclaration" ||
+        statement.type === "ExportAllDeclaration";
+      if (!hasImportAttributes) {
+        return [];
+      }
+      const { source, attributes } = statement;
+      return source === null ? [] : [[source.start, readAttributeLoader(attributes)] as const];
+    }),
+  );
+  return [
+    ...listValueImports(parsed).map(({ declaration }) => declaration.moduleRequest),
+    ...parsed.module.staticExports.flatMap((declaration) =>
+      declaration.entries.flatMap(({ moduleRequest, isType }) => {
+        const reexportsValues = moduleRequest !== null && !isType;
+        return reexportsValues ? [moduleRequest] : [];
+      }),
+    ),
+  ].map((moduleRequest) => ({
+    value: moduleRequest.value,
+    start: moduleRequest.start,
+    end: moduleRequest.end,
+    kind: "import" as const,
+    loader: loaders.get(moduleRequest.start) ?? null,
+  }));
+};
+
+export const findModuleLoads = (program: Program, text: string) => {
+  const literalLoads: {
+    readonly value: string;
+    readonly start: number;
+    readonly end: number;
+    readonly kind: "import" | "require.resolve" | "require";
+    readonly loader: string | null;
+  }[] = [];
+  const unfollowedLoads: {
+    readonly start: number;
+    readonly loader: string;
+    readonly argumentText: string | null;
+    readonly literalDirectory: string | null;
+  }[] = [];
+  const nonReferenceStarts = new Set<number>();
+  const followedLoaderStarts = new Set<number>();
+  new Visitor({
+    ...visitNonReferenceIdentifiers(nonReferenceStarts),
+    MemberExpression: (member) => {
+      if (member.computed) {
+        return;
+      }
+      nonReferenceStarts.add(member.property.start);
+      const resolveName = readRequireResolveName(member);
+      const isUnfollowedResolver = resolveName !== null && !followedLoaderStarts.has(member.start);
+      if (isUnfollowedResolver) {
+        unfollowedLoads.push({
+          start: member.start,
+          loader: resolveName,
+          argumentText: null,
+          literalDirectory: null,
+        });
+      }
+      const isModuleOrImportMetaRequire =
+        member.property.name === "require" &&
+        ((member.object.type === "Identifier" && member.object.name === "module") ||
+          member.object.type === "MetaProperty");
+      if (isModuleOrImportMetaRequire) {
+        unfollowedLoads.push({
+          start: member.start,
+          loader: member.object.type === "MetaProperty" ? "import.meta.require" : "module.require",
+          argumentText: null,
+          literalDirectory: null,
+        });
+      }
+    },
+    ImportExpression: (dynamicImport) => {
+      const importedPath = readLiteralString(dynamicImport.source);
+      const loader = readDynamicImportLoader(dynamicImport.options);
+      if (loader === undefined) {
+        unfollowedLoads.push({
+          start: dynamicImport.start,
+          loader: "import attributes",
+          argumentText: null,
+          literalDirectory: null,
+        });
+      } else if (importedPath === null) {
+        unfollowedLoads.push({
+          start: dynamicImport.start,
+          loader: "import",
+          argumentText: text.slice(dynamicImport.source.start, dynamicImport.source.end),
+          literalDirectory: readLiteralDirectory(dynamicImport.source),
+        });
+      } else {
+        literalLoads.push({
+          value: importedPath,
+          start: dynamicImport.source.start,
+          end: dynamicImport.source.end,
+          kind: "import",
+          loader,
+        });
+      }
+    },
+    CallExpression: (call) => {
+      const { callee } = call;
+      const resolveName = readRequireResolveName(callee);
+      const requireFunctionName = resolveName ?? readRequireFunctionName(call);
+      if (requireFunctionName === null) {
+        return;
+      }
+      followedLoaderStarts.add(callee.start);
+      const isResolveCall = resolveName !== null && callee.type === "MemberExpression";
+      if (isResolveCall) {
+        followedLoaderStarts.add(callee.object.start);
+        if (call.arguments.length !== 1) {
+          unfollowedLoads.push({
+            start: call.start,
+            loader: resolveName,
+            argumentText: null,
+            literalDirectory: null,
+          });
+          return;
+        }
+      }
+      const [requiredPathArgument] = call.arguments;
+      const requiredPath = readLiteralString(requiredPathArgument);
+      const isUnfollowedRequire = requiredPathArgument === undefined || requiredPath === null;
+      if (isUnfollowedRequire) {
+        unfollowedLoads.push({
+          start: call.start,
+          loader: requireFunctionName,
+          argumentText:
+            requiredPathArgument === undefined
+              ? ""
+              : text.slice(requiredPathArgument.start, requiredPathArgument.end),
+          literalDirectory: readLiteralDirectory(requiredPathArgument),
+        });
+      } else {
+        literalLoads.push({
+          value: requiredPath,
+          start: requiredPathArgument.start,
+          end: requiredPathArgument.end,
+          kind: resolveName === null ? "require" : "require.resolve",
+          loader: null,
+        });
+      }
+    },
+    Identifier: (identifier) => {
+      const isUnfollowedLoaderReference =
+        MODULE_LOADER_NAMES.has(identifier.name) &&
+        !nonReferenceStarts.has(identifier.start) &&
+        !followedLoaderStarts.has(identifier.start);
+      if (isUnfollowedLoaderReference) {
+        unfollowedLoads.push({
+          start: identifier.start,
+          loader: identifier.name,
+          argumentText: null,
+          literalDirectory: null,
+        });
+      }
+    },
+    TSImportEqualsDeclaration: (declaration) => {
+      const requiredPath = readValueImportEqualsPath(declaration);
+      if (requiredPath !== null) {
+        literalLoads.push({
+          value: requiredPath.value,
+          start: requiredPath.start,
+          end: requiredPath.end,
+          kind: "require",
+          loader: null,
+        });
+      }
+    },
+  }).visit(program);
+  return { literalLoads, unfollowedLoads };
+};
+
+export const listSpecifiersOnce = <Specifier extends { readonly start: number }>(
+  specifiers: readonly Specifier[],
+) => [...new Map(specifiers.map((specifier) => [specifier.start, specifier])).values()];

package/src/lib/main-thread/lib/scan-module-source/internal/scan-module-text.ts

@@ -0,0 +1,70 @@
+import type { SCRIPT_LOADERS } from "../../../../../shared/find-bun-loader-for-script.ts";
+import {
+  ModuleLoadedByComputedPath,
+  ModuleLoaderRefused,
+  ModuleSyntaxInvalid,
+} from "../../../shared/main-thread-errors.ts";
+import type { ModuleScanRefusal } from "../../../shared/main-thread-errors.ts";
+import { findTaskCallsBelowTopLevel, findTaskDeclarations } from "./find-task-declarations.ts";
+import { parseModuleText } from "./parse-module-text.ts";
+import {
+  findModuleLoads,
+  listSpecifiersOnce,
+  listStaticImportSpecifiers,
+} from "./read-module-loads.ts";
+
+export const scanProjectModule = (
+  moduleFilePath: string,
+  text: string,
+  configuredLoader: (typeof SCRIPT_LOADERS)[number] | null = null,
+) => {
+  const parsed = parseModuleText(moduleFilePath, text, { configuredLoader });
+  const refusals: (typeof ModuleScanRefusal.Type)[] = [];
+  const lineAt = (offset: number) => text.slice(0, offset).split("\n").length;
+
+  for (const error of parsed.errors) {
+    const [firstLabel] = error.labels;
+    refusals.push(
+      new ModuleSyntaxInvalid({
+        line: firstLabel === undefined ? null : lineAt(firstLabel.start),
+        parserMessage: error.message,
+      }),
+    );
+  }
+
+  const taskDeclarations = findTaskDeclarations(parsed, text, lineAt);
+  refusals.push(...taskDeclarations.importViolations);
+  const moduleLoads = findModuleLoads(parsed.program, text);
+  for (const unfollowedLoad of moduleLoads.unfollowedLoads) {
+    if (unfollowedLoad.argumentText === null) {
+      refusals.push(
+        new ModuleLoaderRefused({
+          line: lineAt(unfollowedLoad.start),
+          loader: unfollowedLoad.loader,
+        }),
+      );
+    } else {
+      refusals.push(
+        new ModuleLoadedByComputedPath({
+          line: lineAt(unfollowedLoad.start),
+          loader: unfollowedLoad.loader,
+          argumentText: unfollowedLoad.argumentText,
+        }),
+      );
+    }
+  }
+
+  refusals.push(
+    ...taskDeclarations.nameViolations,
+    ...findTaskCallsBelowTopLevel(parsed.program, taskDeclarations, lineAt),
+  );
+
+  return {
+    specifiers: listSpecifiersOnce([
+      ...listStaticImportSpecifiers(parsed),
+      ...moduleLoads.literalLoads,
+    ]),
+    madeTasks: taskDeclarations.madeTasks,
+    refusals,
+  };
+};

package/src/lib/main-thread/lib/scan-module-source/internal/unwrap-type-assertions.ts

@@ -0,0 +1,10 @@
+import type { Expression } from "oxc-parser";
+
+export const unwrapTypeAssertions = (expression: Expression): Expression => {
+  const isTypeAssertion =
+    expression.type === "TSAsExpression" ||
+    expression.type === "TSSatisfiesExpression" ||
+    expression.type === "TSNonNullExpression" ||
+    expression.type === "TSTypeAssertion";
+  return isTypeAssertion ? unwrapTypeAssertions(expression.expression) : expression;
+};

package/src/lib/main-thread/lib/scan-module-source/internal/visit-non-reference-identifiers.ts

@@ -0,0 +1,21 @@
+import type { VisitorObject } from "oxc-parser";
+
+export const visitNonReferenceIdentifiers = (nonReferenceStarts: Set<number>) =>
+  ({
+    Property: (property) => {
+      const hasNonReferenceKey = !property.computed && !property.shorthand;
+      if (hasNonReferenceKey) {
+        nonReferenceStarts.add(property.key.start);
+      }
+    },
+    PropertyDefinition: (definition) => {
+      if (!definition.computed) {
+        nonReferenceStarts.add(definition.key.start);
+      }
+    },
+    MethodDefinition: (definition) => {
+      if (!definition.computed) {
+        nonReferenceStarts.add(definition.key.start);
+      }
+    },
+  }) satisfies VisitorObject;