@pyreon/lint 0.12.12 → 0.12.14

package/src/rules/styling/no-theme-outside-provider.ts

@@ -2,6 +2,8 @@ import type { Rule, VisitorCallbacks } from '../../types'
 import { getSpan, isCallTo } from '../../utils/ast'
 import { extractImportInfo } from '../../utils/imports'
 
+const HOOK_NAME = /^use[A-Z]/
+
 export const noThemeOutsideProvider: Rule = {
   meta: {
     id: 'pyreon/no-theme-outside-provider',
@@ -12,9 +14,36 @@ export const noThemeOutsideProvider: Rule = {
   },
   create(context) {
     let hasProviderImport = false
-    const themeCalls: Array<{ span: { start: number; end: number } }> = []
+    let hookDepth = 0
+    // Each useTheme call records whether it was inside a hook implementation.
+    // Hook files (e.g. `useThemeValue.ts`) legitimately call `useTheme()` to
+    // re-export theme access — they delegate provider responsibility to the
+    // consuming component, which is the place the rule actually targets.
+    const themeCalls: Array<{ span: { start: number; end: number }; insideHook: boolean }> = []
+
+    function declaratorIsHook(node: any): boolean {
+      if (node?.id?.type !== 'Identifier') return false
+      const init = node.init
+      if (init?.type !== 'ArrowFunctionExpression' && init?.type !== 'FunctionExpression') return false
+      return HOOK_NAME.test(node.id.name)
+    }
 
     const callbacks: VisitorCallbacks = {
+      // `function useFoo() { … }`
+      FunctionDeclaration(node: any) {
+        if (node.id?.name && HOOK_NAME.test(node.id.name)) hookDepth++
+      },
+      'FunctionDeclaration:exit'(node: any) {
+        if (node.id?.name && HOOK_NAME.test(node.id.name)) hookDepth--
+      },
+      // `const useFoo = () => { … }` (oxc visitor doesn't pass parent, so
+      // hook into the declarator — it brackets the inner function body).
+      VariableDeclarator(node: any) {
+        if (declaratorIsHook(node)) hookDepth++
+      },
+      'VariableDeclarator:exit'(node: any) {
+        if (declaratorIsHook(node)) hookDepth--
+      },
       ImportDeclaration(node: any) {
         const info = extractImportInfo(node)
         if (!info) return
@@ -26,12 +55,15 @@ export const noThemeOutsideProvider: Rule = {
       },
       CallExpression(node: any) {
         if (isCallTo(node, 'useTheme')) {
-          themeCalls.push({ span: getSpan(node) })
+          themeCalls.push({ span: getSpan(node), insideHook: hookDepth > 0 })
         }
       },
       'Program:exit'() {
         if (hasProviderImport) return
         for (const call of themeCalls) {
+          // Inside a hook implementation? The hook delegates provider
+          // responsibility to its caller — silence here.
+          if (call.insideHook) continue
           context.report({
             message:
               '`useTheme()` without a `PyreonUI` or `ThemeProvider` import — the theme context may not be available.',

package/src/runner.ts

@@ -1,16 +1,28 @@
 import { parseSync, Visitor } from 'oxc-parser'
 import type { AstCache } from './cache'
 import type {
+  ConfigDiagnostic,
   Diagnostic,
   LintConfig,
   LintFileResult,
   Rule,
   RuleContext,
+  RuleOptions,
   Severity,
   VisitorCallbacks,
 } from './types'
 import { JS_EXTENSIONS } from './utils/index'
 import { LineIndex } from './utils/source'
+import { validateRuleOptions } from './utils/validate-options'
+
+// Per-process cache so we only validate a given (rule, options) pair once
+// and only print-once even across a multi-file lint run.
+const VALIDATION_CACHE = new Map<string, { ok: boolean; diagnostics: ConfigDiagnostic[] }>()
+
+/** Reset caches — exposed for tests; not part of the public surface. */
+export function _resetConfigDiagnosticsCache(): void {
+  VALIDATION_CACHE.clear()
+}
 
 function getExtension(filePath: string): string {
   const lastDot = filePath.lastIndexOf('.')
@@ -28,6 +40,7 @@ function getLang(ext: string): OxcLang {
 function createRuleContext(
   rule: Rule,
   severity: Severity,
+  options: RuleOptions,
   diagnostics: Diagnostic[],
   lineIndex: LineIndex,
   sourceText: string,
@@ -50,6 +63,9 @@ function createRuleContext(
     getFilePath() {
       return filePath
     },
+    getOptions() {
+      return options
+    },
   }
 }
 
@@ -96,6 +112,12 @@ export function lintFile(
   rules: Rule[],
   config: LintConfig,
   cache?: AstCache | undefined,
+  /**
+   * Optional sink for config-level diagnostics (malformed rule options).
+   * When provided, diagnostics are appended to it instead of printed to
+   * stderr — `lint()` uses this to surface them on `LintResult`.
+   */
+  configDiagnosticsSink?: ConfigDiagnostic[],
 ): LintFileResult {
   const ext = getExtension(filePath)
   if (!JS_EXTENSIONS.has(ext)) {
@@ -128,9 +150,66 @@ export function lintFile(
   // Filter to enabled rules and create visitor callbacks
   const allCallbacks: VisitorCallbacks[] = []
   for (const rule of rules) {
-    const severity = config.rules[rule.meta.id]
-    if (severity === undefined || severity === 'off') continue
-    const ctx = createRuleContext(rule, severity, diagnostics, lineIndex, sourceText, filePath)
+    const entry = config.rules[rule.meta.id]
+    if (entry === undefined) continue
+    // Normalize bare severity vs `[severity, options]` tuple.
+    const [severity, options]: [Severity, RuleOptions] = Array.isArray(entry)
+      ? [entry[0] as Severity, (entry[1] ?? {}) as RuleOptions]
+      : [entry as Severity, {}]
+    if (severity === 'off') continue
+
+    // Validate options against the rule's declared schema. Cached per
+    // (rule, options) pair — config doesn't change within a run.
+    const cacheKey = `${rule.meta.id}::${JSON.stringify(options)}`
+    let cached = VALIDATION_CACHE.get(cacheKey)
+    if (!cached) {
+      const { errors, warnings } = validateRuleOptions(rule, options)
+      const configDiags: ConfigDiagnostic[] = []
+      for (const message of warnings) {
+        configDiags.push({ ruleId: rule.meta.id, severity: 'warn', message })
+      }
+      for (const message of errors) {
+        configDiags.push({ ruleId: rule.meta.id, severity: 'error', message })
+      }
+      cached = { ok: errors.length === 0, diagnostics: configDiags }
+      VALIDATION_CACHE.set(cacheKey, cached)
+    }
+    // Surface config diagnostics once per (rule, options) pair: prefer
+    // the caller-supplied sink (so `lint()` can put them on LintResult);
+    // fall back to stderr for standalone `lintFile` usage.
+    if (cached.diagnostics.length > 0) {
+      if (configDiagnosticsSink) {
+        // Dedupe within the sink by (ruleId, message) so two different rules
+        // that happen to produce an identical message don't collapse.
+        for (const d of cached.diagnostics) {
+          if (
+            !configDiagnosticsSink.some(
+              (x) => x.ruleId === d.ruleId && x.message === d.message,
+            )
+          ) {
+            configDiagnosticsSink.push(d)
+          }
+        }
+      } else {
+        for (const d of cached.diagnostics) {
+          // oxlint-disable-next-line no-console
+          const emit = d.severity === 'error' ? console.error : console.warn
+          emit(`[pyreon-lint] ${d.message}`)
+        }
+      }
+    }
+    // Hard error in options → skip this rule entirely for the run.
+    if (!cached.ok) continue
+
+    const ctx = createRuleContext(
+      rule,
+      severity,
+      options,
+      diagnostics,
+      lineIndex,
+      sourceText,
+      filePath,
+    )
     allCallbacks.push(rule.create(ctx))
   }
 
@@ -138,17 +217,28 @@ export function lintFile(
   const visitor = new Visitor(mergeCallbacks(allCallbacks))
   visitor.visit(program)
 
-  // Filter suppressed diagnostics:
-  // // pyreon-lint-ignore             — suppress all on next line
-  // // pyreon-lint-ignore rule-name   — suppress specific rule on next line
+  // Filter suppressed diagnostics. Two equivalent comment syntaxes:
+  //   // pyreon-lint-ignore                            — suppress all on next line
+  //   // pyreon-lint-ignore <rule-id>                  — suppress one rule
+  //   // pyreon-lint-disable-next-line                 — alias of `ignore`
+  //   // pyreon-lint-disable-next-line <rule-id>       — alias of `ignore <rule-id>`
+  // The `disable-next-line` form is the convention several rule docstrings
+  // already document — we accept both so the docs and runtime match.
+  // Word-boundary matching prevents typos like `// pyreon-lint-ignored` from
+  // accidentally being treated as suppressions.
   const lines = sourceText.split('\n')
+  const SUPPRESS_RE = /^\/\/\s*pyreon-lint-(?:ignore|disable-next-line)(?:\s+(\S+))?\s*$/
   const filtered = diagnostics.filter((d) => {
     const prevLineIdx = d.loc.line - 2
     if (prevLineIdx < 0) return true
-    const prevLine = lines[prevLineIdx]?.trim()
-    if (!prevLine?.startsWith('// pyreon-lint-ignore')) return true
-    const rest = prevLine.slice('// pyreon-lint-ignore'.length).trim()
-    return rest.length > 0 && rest !== d.ruleId
+    const prevLine = lines[prevLineIdx]?.trim() ?? ''
+    const match = SUPPRESS_RE.exec(prevLine)
+    if (!match) return true
+    const ruleId = match[1]
+    // Bare suppression (no rule id) → suppress every diagnostic on next line.
+    if (!ruleId) return false
+    // Rule-specific suppression → drop only the matching rule.
+    return ruleId !== d.ruleId
   })
 
   filtered.sort((a, b) => a.span.start - b.span.start)