perf: make ExportMap util and no-cycle rule faster

src/rules/no-cycle.ts

@@ -12,11 +12,11 @@ import {
   resolve,
 } from '../utils'
 
-type Options = ModuleOptions & {
+type Options = {
   allowUnsafeDynamicCyclicDependency?: boolean
   ignoreExternal?: boolean
   maxDepth?: number
-}
+} & ModuleOptions
 
 type MessageId = 'cycle'
 
@@ -83,9 +83,10 @@ export = createRule<[Options?], MessageId>({
         ? options.maxDepth
         : Number.POSITIVE_INFINITY
 
-    const ignoreModule = (name: string) =>
-      options.ignoreExternal &&
-      isExternalModule(name, resolve(name, context)!, context)
+    const ignoreModule = options.ignoreExternal
+      ? (name: string) =>
+          isExternalModule(name, resolve(name, context)!, context)
+      : () => false
 
     return {
       ...moduleVisitor(function checkSourceValue(sourceNode, importer) {

src/utils/export-map.ts

@@ -21,8 +21,8 @@
 } from '../types'
 
 import { getValue } from './get-value'
-import { hashObject } from './hash'
 import { hasValidExtension, ignore } from './ignore'
+import { lazy, defineLazyProperty } from './lazy-value'
 import { parse } from './parse'
 import { relative, resolve } from './resolve'
 import { isMaybeUnambiguousModule, isUnambiguousModule } from './unambiguous'
@@ -58,24 +58,30 @@
 
 export class ExportMap {
   static for(context: ChildContext) {
-    const { path: filepath } = context
-
-    const cacheKey = context.cacheKey || hashObject(context).digest('hex')
+    const filepath = context.path
+    const cacheKey = context.cacheKey
     let exportMap = exportCache.get(cacheKey)
 
-    // return cached ignore
-    if (exportMap === null) {
-      return null
-    }
+    const stats = lazy(() => fs.statSync(filepath))
 
-    const stats = fs.statSync(context.path)
-    if (
-      exportMap != null && // date equality check
-      exportMap.mtime.valueOf() - stats.mtime.valueOf() === 0
-    ) {
-      return exportMap
+    if (exportCache.has(cacheKey)) {
+      const exportMap = exportCache.get(cacheKey)
+
+      // return cached ignore
+      if (exportMap === null) {
+        return null
+      }
+
+      // check if the file has been modified since cached exportmap generation
+      if (
+        exportMap != null &&
+        exportMap.mtime.valueOf() - stats().mtime.valueOf() === 0
+      ) {
+        return exportMap
+      }
+
+      // future: check content equality?
     }
-    // future: check content equality?
 
     // check valid extensions first
     if (!hasValidExtension(filepath, context)) {
@@ -84,7 +90,7 @@
     }
 
     // check for and cache ignore
-    if (ignore(filepath, context)) {
+    if (ignore(filepath, context, true)) {
       log('ignored path due to ignore settings:', filepath)
       exportCache.set(cacheKey, null)
       return null
@@ -103,13 +109,13 @@
     exportMap = ExportMap.parse(filepath, content, context)
 
     // ambiguous modules return null
-    if (exportMap == null) {
+    if (exportMap === null) {
       log('ignored path due to ambiguous parse:', filepath)
       exportCache.set(cacheKey, null)
       return null
     }
 
-    exportMap.mtime = stats.mtime
+    exportMap.mtime = stats().mtime
 
     exportCache.set(cacheKey, exportMap)
 
@@ -127,12 +133,12 @@
 
   static parse(filepath: string, content: string, context: ChildContext) {
     const m = new ExportMap(filepath)
-    const isEsModuleInteropTrue = isEsModuleInterop()
+    const isEsModuleInteropTrue = lazy(isEsModuleInterop)
 
     let ast: TSESTree.Program
     let visitorKeys: TSESLint.SourceCode.VisitorKeys | null
     try {
-      ;({ ast, visitorKeys } = parse(filepath, content, context))
+      ; ({ ast, visitorKeys } = parse(filepath, content, context))
     } catch (error) {
       m.errors.push(error as ParseError)
       return m // can't continue
@@ -181,9 +187,10 @@
       },
     })
 
-    const unambiguouslyESM = isUnambiguousModule(ast)
-    if (!unambiguouslyESM && !hasDynamicImports) {
-      return null
+    const unambiguouslyESM = lazy(() => isUnambiguousModule(ast))
+
+    if (!hasDynamicImports && !unambiguouslyESM()) {
+      return null;
     }
 
     const docStyles = (context.settings &&
@@ -195,25 +202,6 @@
       docStyleParsers[style] = availableDocStyleParsers[style]
     }
 
-    // attempt to collect module doc
-    if (ast.comments) {
-      ast.comments.some(c => {
-        if (c.type !== 'Block') {
-          return false
-        }
-        try {
-          const doc = doctrine.parse(c.value, { unwrap: true })
-          if (doc.tags.some(t => t.title === 'module')) {
-            m.doc = doc
-            return true
-          }
-        } catch {
-          /* ignore */
-        }
-        return false
-      })
-    }
-
     const namespaces = new Map</* identifier */ string, /* source */ string>()
 
     function remotePath(value: string) {
@@ -400,12 +388,12 @@
       const parserOptions = context.parserOptions || {}
       let tsconfigRootDir = parserOptions.tsconfigRootDir
       const project = parserOptions.project
-      const cacheKey = hashObject({
-        tsconfigRootDir,
-        project,
-      }).digest('hex')
-      let tsConfig = tsconfigCache.get(cacheKey)
-      if (tsConfig === undefined) {
+      const cacheKey = stableHash({ tsconfigRootDir, project })
+      let tsConfig: TsConfigJsonResolved | null
+
+      if (tsconfigCache.has(cacheKey)) {
+        tsConfig = tsconfigCache.get(cacheKey)!
+      } else {
         tsconfigRootDir = tsconfigRootDir || process.cwd()
         let tsconfigResult
         if (project) {
@@ -427,9 +415,7 @@
         tsconfigCache.set(cacheKey, tsConfig)
       }
 
-      return tsConfig && tsConfig.compilerOptions
-        ? tsConfig.compilerOptions.esModuleInterop
-        : false
+      return tsConfig?.compilerOptions?.esModuleInterop ?? false
     }
 
     for (const n of ast.body) {
@@ -516,7 +502,7 @@
       }
 
       const exports = ['TSExportAssignment']
-      if (isEsModuleInteropTrue) {
+      if (isEsModuleInteropTrue()) {
         exports.push('TSNamespaceExportDeclaration')
       }
 
@@ -525,17 +511,17 @@
         const exportedName =
           n.type === 'TSNamespaceExportDeclaration'
             ? (
-                n.id ||
-                // @ts-expect-error - legacy parser type
-                n.name
-              ).name
+              n.id ||
+              // @ts-expect-error - legacy parser type
+              n.name
+            ).name
             : ('expression' in n &&
-                n.expression &&
-                (('name' in n.expression && n.expression.name) ||
-                  ('id' in n.expression &&
-                    n.expression.id &&
-                    n.expression.id.name))) ||
-              null
+              n.expression &&
+              (('name' in n.expression && n.expression.name) ||
+                ('id' in n.expression &&
+                  n.expression.id &&
+                  n.expression.id.name))) ||
+            null
 
         const declTypes = new Set([
           'VariableDeclaration',
@@ -565,7 +551,7 @@
               ('name' in node.id
                 ? node.id.name === exportedName
                 : 'left' in node.id &&
-                  getRoot(node.id).name === exportedName)) ||
+                getRoot(node.id).name === exportedName)) ||
               ('declarations' in node &&
                 node.declarations.find(
                   d => 'name' in d.id && d.id.name === exportedName,
@@ -580,7 +566,7 @@
         }
 
         if (
-          isEsModuleInteropTrue && // esModuleInterop is on in tsconfig
+          isEsModuleInteropTrue() && // esModuleInterop is on in tsconfig
           !m.namespace.has('default') // and default isn't added already
         ) {
           m.namespace.set('default', {}) // add default export
@@ -652,15 +638,36 @@
       }
     }
 
+    // attempt to collect module doc
+    defineLazyProperty(m, 'doc', () => {
+      if (ast.comments) {
+        for (let i = 0, len = ast.comments.length; i < len; i++) {
+          const c = ast.comments[i]
+          if (c.type !== 'Block') {
+            continue
+          }
+          try {
+            const doc = doctrine.parse(c.value, { unwrap: true })
+            if (doc.tags.some(t => t.title === 'module')) {
+              return doc
+              break
+            }
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+    })
+
     if (
-      isEsModuleInteropTrue && // esModuleInterop is on in tsconfig
+      isEsModuleInteropTrue() && // esModuleInterop is on in tsconfig
       m.namespace.size > 0 && // anything is exported
       !m.namespace.has('default') // and default isn't added already
     ) {
       m.namespace.set('default', {}) // add default export
     }
 
-    if (unambiguouslyESM) {
+    if (unambiguouslyESM()) {
       m.parseGoal = 'Module'
     }
     return m
@@ -695,9 +702,9 @@
 
   private declare mtime: Date
 
-  declare doc: Annotation
+  declare doc: Annotation | undefined
 
-  constructor(public path: string) {}
+  constructor(public path: string) { }
 
   get hasDefault() {
     return this.get('default') != null
@@ -1090,7 +1097,7 @@
   const { settings, parserOptions, parserPath, languageOptions } = context
 
   return {
-    cacheKey: makeContextCacheKey(context) + String(path),
+    cacheKey: makeContextCacheKey(context) + path,
     settings,
     parserOptions,
     parserPath,

src/utils/ignore.ts

@@ -45,9 +45,15 @@ export function getFileExtensions(settings: PluginSettings) {
   return exts
 }
 
-export function ignore(filepath: string, context: ChildContext | RuleContext) {
+// In ExportMap.for, ignore() is called after hasValidExtension() check.
+// Add an argument to skip the check
+export function ignore(
+  filepath: string,
+  context: ChildContext | RuleContext,
+  skipExtensionCheck = false,
+) {
   // check extension whitelist first (cheap)
-  if (!hasValidExtension(filepath, context)) {
+  if (!skipExtensionCheck && !hasValidExtension(filepath, context)) {
     return true
   }
 
@@ -57,7 +63,8 @@ export function ignore(filepath: string, context: ChildContext | RuleContext) {
     return false
   }
 
-  for (const ignoreString of ignoreStrings) {
+  for (let i = 0, len = ignoreStrings.length; i < len; i++) {
+    const ignoreString = ignoreStrings[i]
     const regex = new RegExp(ignoreString)
     if (regex.test(filepath)) {
       log(`ignoring ${filepath}, matched pattern /${ignoreString}/`)

src/utils/import-type.ts

@@ -43,11 +43,6 @@ export function isExternalModule(
   modulePath: string,
   context: RuleContext,
 ) {
-  if (arguments.length < 3) {
-    throw new TypeError(
-      'isExternalModule: name, path, and context are all required',
-    )
-  }
   return (
     (isModule(name) || isScoped(name)) &&
     typeTest(name, context, modulePath) === 'external'

src/utils/lazy-value.ts

@@ -16,3 +16,30 @@ export const lazy = <T>(cb: () => T): LazyValue<T> => {
 }
 
 export type LazyValue<T> = () => Readonly<T>
+
+export function defineLazyProperty<
+	ObjectType extends Record<string, any>,
+	PropertyNameType extends string,
+	PropertyValueType
+>(
+  object: ObjectType,
+	propertyName: PropertyNameType,
+	valueGetter: () => PropertyValueType
+) {
+	const define = (value: PropertyValueType) => Object.defineProperty(object, propertyName, {value, enumerable: true, writable: true});
+
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = valueGetter();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+
+	return object;
+}

src/utils/module-cache.ts

@@ -45,10 +45,8 @@ export class ModuleCache {
 
     // parse infinity
     if (
-      (['∞', 'Infinity'] as const).includes(
-        // @ts-expect-error - TS can't narrow properly from `includes`
-        cacheSettings.lifetime,
-      )
+      typeof cacheSettings.lifetime === 'string' &&
+      (['∞', 'Infinity'] as const).includes(cacheSettings.lifetime)
     ) {
       cacheSettings.lifetime = Number.POSITIVE_INFINITY
     }