Rust製の高速JavaScriptリンター「oxlint」を試してみた

mkdir oxlint-trial && cd oxlint-trial
npm init -y
npm install -D oxlint typescript
mkdir src

{
  "compilerOptions": {
    "strict": true,
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "noEmit": true
  },
  "include": ["src"]
}

{
  "scripts": {
    "lint": "oxlint",
    "lint:fix": "oxlint --fix"
  }
}

const greeting = "hello"
console.log(greeting)

npx oxlint src/

Found 0 warnings and 0 errors.
Finished in 16ms on 1 file with 93 rules using 12 threads.

import { greet } from './moduleB'

export function hello() {
  return greet("world")
}

import { hello } from './moduleA'

export function greet(name: string) {
  return `${hello()} ${name}`
}

{
  "plugins": ["import"],
  "rules": {
    "import/no-cycle": "error"
  }
}

npx oxlint src/moduleA.ts src/moduleB.ts

x eslint-plugin-import(no-cycle): Dependency cycle detected
   ,-[src/moduleA.ts:1:23]
 1 | import { greet } from './moduleB'
   :                       ^^^^^^^^^^^
   `----
  help: Refactor to remove the cycle. Consider extracting shared code into
        a separate module that both files can import.
  note: These paths form a cycle:
           ╭──▶ ./moduleB (src/moduleB.ts)
           │         ⬇ imports
           │    ./moduleA (src/moduleA.ts)
           ╰─────────╯ imports the current file

rm src/index.ts src/moduleA.ts src/moduleB.ts .oxlintrc.json

npm install -D oxlint-tsgolint

npx oxlint --type-aware src/

{
  "options": {
    "typeAware": true
  }
}

async function fetchData(): Promise<string> {
  return "data"
}

function main() {
  // awaitもcatchもしていない
  fetchData()
}

main()

npx oxlint --type-aware -D typescript/no-floating-promises src/floating-promise.ts

 × typescript-eslint(no-floating-promises): Promises must be awaited, add void operator to ignore.
   ╭─[src/floating-promise.ts:7:3]
 6 │   // awaitもcatchもしていない
 7 │   fetchData()
   ·   ───────────
 8 │ }
   ╰────
  help: The promise must end with a call to .catch, or end with a call to .then with a rejection handler, or be explicitly marked as ignored with the `void` operator.

async function fetchData(): Promise<string> {
  return "data"
}

async function main() {
  await fetchData()
}

main().catch(console.error)

npx oxlint --type-aware -D typescript/no-floating-promises src/floating-promise.ts

Found 0 warnings and 0 errors.
Finished in 223ms on 1 file with 107 rules using 12 threads.

rm src/floating-promise.ts

export const SoraModelKeys = {
  feature1: 'feature1',
  feature2: 'feature2',
} as const

// Case 1: typeof on a const object in type position
import { SoraModelKeys } from './keys'

type FeatureName =
  (typeof SoraModelKeys)[keyof typeof SoraModelKeys]

export type { FeatureName }

export enum ModelType {
  SD1 = 'SD1',
  SD2 = 'SD2',
  SD3 = 'SD3',
}

export interface Prices {
  price: number
}

// Case 2: enum used as computed property key in type literal
import { ModelType, Prices } from './types'

type Config = {
  pricing?: {
    byModelType?: {
      [ModelType.SD1]?: Prices
      [ModelType.SD2]?: Prices
      [ModelType.SD3]?: Prices
    }
  }
}

export type { Config }

npx oxlint -D typescript/consistent-type-imports src/case1-typeof.ts src/case2-enum.ts

  × typescript-eslint(consistent-type-imports): All imports in the declaration are only used as types. Use `import type`.
   ╭─[src/case1-typeof.ts:2:1]
 1 │ // Case 1: typeof on a const object in type position
 2 │ import { SoraModelKeys } from './keys'
   · ──────────────────────────────────────
 3 │ 
   ╰────
  help: Replace the `import` declaration with `import type`. For example, change `import { Type } from 'module'` would become `import type { Type } from 'module'`.
  note: Using `import type` for type-only imports helps with tree-shaking, makes it clear that these imports don't affect runtime code, and can improve build performance by allowing bundlers to eliminate unused type imports.

  × typescript-eslint(consistent-type-imports): All imports in the declaration are only used as types. Use `import type`.
   ╭─[src/case2-enum.ts:2:1]
 1 │ // Case 2: enum used as computed property key in type literal
 2 │ import { ModelType, Prices } from './types'
   · ───────────────────────────────────────────
 3 │ 
   ╰────
  help: Replace the `import` declaration with `import type`. For example, change `import { Type } from 'module'` would become `import type { Type } from 'module'`.
  note: Using `import type` for type-only imports helps with tree-shaking, makes it clear that these imports don't affect runtime code, and can improve build performance by allowing bundlers to eliminate unused type imports.

Found 0 warnings and 2 errors.
Finished in 29ms on 2 files with 94 rules using 12 threads.

import type { SoraModelKeys } from './keys'

type FeatureName =
  (typeof SoraModelKeys)[keyof typeof SoraModelKeys]

export type { FeatureName }

npx tsc --noEmit src/case1-typeof.ts