@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/linthost/config.go

@@ -125,13 +125,13 @@ type RuleResolver interface {
 // ResolveRules implements RuleResolver. A flat RuleConfig has no glob scoping,
 // so every file receives the full map unchanged.
 func (c RuleConfig) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: c}
+  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(c)}
 }
 
 // ActiveRuleNames implements RuleResolver. Returns rule names whose severity
 // is not SeverityOff, sorted for deterministic engine dispatch-table construction.
 func (c RuleConfig) ActiveRuleNames() []string {
-  return sortedRuleNames(c, func(sev Severity) bool { return sev != SeverityOff })
+  return sortedRuleNames(normalizeRuleConfigKeys(c), func(sev Severity) bool { return sev != SeverityOff })
 }
 
 // EnabledRuleConfig implements RuleResolver. Returns a copy containing only the
@@ -140,7 +140,7 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
   out := RuleConfig{}
   for name, sev := range c {
     if sev != SeverityOff {
-      out[name] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return out
@@ -151,6 +151,17 @@ func (c RuleConfig) EnabledRuleConfig() RuleConfig {
 // predate option support.
 func (RuleConfig) RuleOptions(string) json.RawMessage { return nil }
 
+func normalizeRuleConfigKeys(c RuleConfig) RuleConfig {
+  if len(c) == 0 {
+    return c
+  }
+  out := RuleConfig{}
+  for name, sev := range c {
+    out[normalizeBuiltinRuleName(name)] = sev
+  }
+  return out
+}
+
 // InlineRuleResolver pairs a severity map with an options map. The fields
 // are public so tests can construct one without going through
 // ParseRulesWithOptions.
@@ -162,7 +173,7 @@ type InlineRuleResolver struct {
 // ResolveRules implements RuleResolver. Inline rules have no glob scoping;
 // the full map applies to every file.
 func (r InlineRuleResolver) ResolveRules(string) ResolvedRuleConfig {
-  return ResolvedRuleConfig{Rules: r.Rules}
+  return ResolvedRuleConfig{Rules: normalizeRuleConfigKeys(r.Rules)}
 }
 
 // ActiveRuleNames implements RuleResolver by delegating to the inner RuleConfig.
@@ -182,7 +193,14 @@ func (r InlineRuleResolver) RuleOptions(name string) json.RawMessage {
   if r.Options == nil {
     return nil
   }
-  return r.Options[name]
+  if raw := r.Options[name]; len(raw) > 0 {
+    return raw
+  }
+  canonical := normalizeBuiltinRuleName(name)
+  if raw := r.Options[canonical]; len(raw) > 0 {
+    return raw
+  }
+  return nil
 }
 
 // ConfigStore holds the parsed representation of a lint config file. It
@@ -210,7 +228,14 @@ func (s *ConfigStore) RuleOptions(name string) json.RawMessage {
   if s == nil {
     return nil
   }
-  return s.options[name]
+  if raw := s.options[name]; len(raw) > 0 {
+    return raw
+  }
+  canonical := normalizeBuiltinRuleName(name)
+  if raw := s.options[canonical]; len(raw) > 0 {
+    return raw
+  }
+  return nil
 }
 
 // ConfigEntry is the parsed form of one config file in the extends chain.
@@ -245,7 +270,7 @@ func (s *ConfigStore) ResolveRules(fileName string) ResolvedRuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[name] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return ResolvedRuleConfig{Rules: out}
@@ -266,7 +291,7 @@ func (s *ConfigStore) ActiveRuleNames() []string {
     }
     for name, sev := range entry.Rules {
       if sev != SeverityOff {
-        active[name] = sev
+        active[normalizeBuiltinRuleName(name)] = sev
       }
     }
   }
@@ -289,8 +314,9 @@ func (s *ConfigStore) EnabledRuleConfig() RuleConfig {
       if sev == SeverityOff {
         continue
       }
-      if out[name] != SeverityError {
-        out[name] = sev
+      canonical := normalizeBuiltinRuleName(name)
+      if out[canonical] != SeverityError {
+        out[canonical] = sev
       }
     }
   }
@@ -310,7 +336,7 @@ func (s *ConfigStore) Flatten() RuleConfig {
       continue
     }
     for name, sev := range entry.Rules {
-      out[name] = sev
+      out[normalizeBuiltinRuleName(name)] = sev
     }
   }
   return out
@@ -565,7 +591,18 @@ func collectConfigObject(store *ConfigStore, raw any, baseDir, path string, chai
       if !ok {
         return fmt.Errorf("@ttsc/lint: %s.rules must be a rule severity map, got %T", path, rulesValue)
       }
+      // `format/*` rules are configured exclusively through the `format`
+      // block; they are never valid keys in `rules`. Silently drop any that
+      // appear, the same way an unknown rule name is ignored (see
+      // parseExternalRuleMapInto): a config must not carry a formatter
+      // setting in two places, and a stray `format/*` here is simply not the
+      // formatting surface, so it has no effect rather than erroring.
       rulesMap = typedMap
+      for key := range rulesMap {
+        if isFormatRuleName(key) {
+          delete(rulesMap, key)
+        }
+      }
     }
     merged := mergeRuleMaps(formatRulesRaw, rulesMap)
     if len(merged) > 0 {
@@ -620,7 +657,7 @@ func collectExternalRuleMapWithOptions(out RuleConfig, opts RuleOptionsMap, raw
     if err != nil {
       return fmt.Errorf("@ttsc/lint: rule %q: %w", name, err)
     }
-    canonical := normalizeExternalRuleName(name)
+    canonical := normalizeBuiltinRuleName(name)
     out[canonical] = sev
     if opts != nil && len(ruleOpts) > 0 {
       opts[canonical] = ruleOpts
@@ -649,14 +686,6 @@ func rejectUnknownConfigKeys(value map[string]any, path string) error {
   return nil
 }
 
-// normalizeExternalRuleName strips the standard typescript-eslint namespace
-// prefixes so that rules like "@typescript-eslint/no-explicit-any" and the
-// bare "no-explicit-any" key both resolve to the same engine-internal name.
-func normalizeExternalRuleName(name string) string {
-  name = strings.TrimPrefix(name, "@typescript-eslint/")
-  return strings.TrimPrefix(name, "typescript-eslint/")
-}
-
 // parsePatternList coerces a raw config value to a string slice for use as a
 // `files` or `ignores` pattern list. Accepts a bare string (single-pattern
 // shorthand) or a string array. Empty patterns are rejected eagerly.
@@ -743,7 +772,7 @@ func LoadConfigResolver(entry *PluginEntry, cwd, tsconfigPath string) (RuleResol
     return nil, err
   }
   if discovered == "" {
-    return nil, fmt.Errorf("@ttsc/lint: no lint.config.* or ttsc-lint.config.* file found (searched upward from %s); create one or set \"configFile\" on the tsconfig plugin entry", cwd)
+    return nil, fmt.Errorf("%w (searched upward from %s); create one or set \"configFile\" on the tsconfig plugin entry", errNoLintConfigFile, cwd)
   }
   return loadConfigResolver(discovered)
 }
@@ -1029,13 +1058,66 @@ func loadJSONConfigFile(location string) (any, error) {
   return out, nil
 }
 
+// serializableConfigKeys is the single source of truth for the ITtscLintConfig
+// keys that survive the JSON round trip from a config-loader subprocess back to
+// the Go sidecar. Both the .js/.cjs/.mjs loader (loadScriptConfigFile) and the
+// .ts/.cts/.mts loader (typeScriptConfigLoaderSource) splice this list into the
+// `toSerializableConfig` key whitelist of their generated scripts, so the set
+// of copied keys is defined here once rather than duplicated per loader.
+var serializableConfigKeys = []string{"files", "ignores", "extends", "plugins", "rules", "format"}
+
+// serializableConfigKeysLiteral renders serializableConfigKeys as a
+// JS/TS array literal (e.g. `"files", "ignores", ...`) for splicing into the
+// generated loader scripts' `toSerializableConfig` whitelist.
+func serializableConfigKeysLiteral() string {
+  quoted := make([]string, len(serializableConfigKeys))
+  for i, key := range serializableConfigKeys {
+    quoted[i] = fmt.Sprintf("%q", key)
+  }
+  return strings.Join(quoted, ", ")
+}
+
+// runConfigLoaderCommand runs a prepared config-loader subprocess (`cmd`),
+// then turns its result into a parsed config object. It owns the shared tail
+// of both subprocess-backed loaders: capturing stdout, distinguishing a
+// timeout from a process error (extracting the subprocess stderr when present),
+// JSON-parsing the output, and rejecting a non-object result. `ctx` is the
+// timeout context the caller bound `cmd` to; `location` is the config file path
+// for error messages; `label` is the human-readable subject (e.g. "config
+// file" or "TypeScript config file") spliced into the load/parse error
+// prefixes so each loader keeps its own wording.
+func runConfigLoaderCommand(ctx context.Context, cmd *exec.Cmd, location, label string) (any, error) {
+  output, err := cmd.Output()
+  if err != nil {
+    if ctx.Err() == context.DeadlineExceeded {
+      return nil, fmt.Errorf("@ttsc/lint: load %s %s: timed out after %s", label, location, configLoaderTimeout)
+    }
+    stderr := ""
+    if exit, ok := err.(*exec.ExitError); ok {
+      stderr = strings.TrimSpace(string(exit.Stderr))
+    }
+    if stderr != "" {
+      return nil, fmt.Errorf("@ttsc/lint: load %s %s: %s", label, location, stderr)
+    }
+    return nil, fmt.Errorf("@ttsc/lint: load %s %s: %w", label, location, err)
+  }
+  var out any
+  if err := json.Unmarshal(output, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: parse %s %s output: %w", label, location, err)
+  }
+  if !isConfigObject(out) {
+    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
+  }
+  return out, nil
+}
+
 // loadScriptConfigFile evaluates a .js/.cjs/.mjs config file by running a
 // Node subprocess that dynamic-imports the file, resolves the exported config
 // through the same 8-hop default/config unwrap used by the TS loader, and
 // serializes the result as JSON to stdout. The subprocess has a
 // configLoaderTimeout deadline to prevent user code from hanging indefinitely.
 func loadScriptConfigFile(location string) (any, error) {
-  const script = `
+  script := fmt.Sprintf(`
 const { pathToFileURL } = require("node:url");
 
 (async () => {
@@ -1075,14 +1157,14 @@ const { pathToFileURL } = require("node:url");
 // whose only key is ` + "`" + `format` + "`" + ` is not silently dropped.
 function toSerializableConfig(value) {
   const out = {};
-  for (const key of ["files", "ignores", "extends", "plugins", "rules", "format"]) {
+  for (const key of [%s]) {
     if (Object.prototype.hasOwnProperty.call(value, key)) {
       out[key] = value[key];
     }
   }
   return out;
 }
-`
+`, serializableConfigKeysLiteral())
   node := os.Getenv("TTSC_NODE_BINARY")
   if node == "" {
     node = "node"
@@ -1090,28 +1172,7 @@ function toSerializableConfig(value) {
   ctx, cancel := context.WithTimeout(context.Background(), configLoaderTimeout)
   defer cancel()
   cmd := exec.CommandContext(ctx, node, "-e", script, location)
-  output, err := cmd.Output()
-  if err != nil {
-    if ctx.Err() == context.DeadlineExceeded {
-      return nil, fmt.Errorf("@ttsc/lint: load config file %s: timed out after %s", location, configLoaderTimeout)
-    }
-    stderr := ""
-    if exit, ok := err.(*exec.ExitError); ok {
-      stderr = strings.TrimSpace(string(exit.Stderr))
-    }
-    if stderr != "" {
-      return nil, fmt.Errorf("@ttsc/lint: load config file %s: %s", location, stderr)
-    }
-    return nil, fmt.Errorf("@ttsc/lint: load config file %s: %w", location, err)
-  }
-  var out any
-  if err := json.Unmarshal(output, &out); err != nil {
-    return nil, fmt.Errorf("@ttsc/lint: parse config file %s output: %w", location, err)
-  }
-  if !isConfigObject(out) {
-    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
-  }
-  return out, nil
+  return runConfigLoaderCommand(ctx, cmd, location, "config file")
 }
 
 // loadTypeScriptConfigFile evaluates a .ts/.cts/.mts config file by writing
@@ -1170,28 +1231,7 @@ func loadTypeScriptConfigFile(location string) (any, error) {
   defer cancel()
   cmd := ttsxCommandContext(ctx, args...)
   cmd.Env = nodeConfigLoaderEnv(location)
-  output, err := cmd.Output()
-  if err != nil {
-    if ctx.Err() == context.DeadlineExceeded {
-      return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: timed out after %s", location, configLoaderTimeout)
-    }
-    stderr := ""
-    if exit, ok := err.(*exec.ExitError); ok {
-      stderr = strings.TrimSpace(string(exit.Stderr))
-    }
-    if stderr != "" {
-      return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: %s", location, stderr)
-    }
-    return nil, fmt.Errorf("@ttsc/lint: load TypeScript config file %s: %w", location, err)
-  }
-  var out any
-  if err := json.Unmarshal(output, &out); err != nil {
-    return nil, fmt.Errorf("@ttsc/lint: parse TypeScript config file %s output: %w", location, err)
-  }
-  if !isConfigObject(out) {
-    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an ITtscLintConfig object", location)
-  }
-  return out, nil
+  return runConfigLoaderCommand(ctx, cmd, location, "TypeScript config file")
 }
 
 // isConfigObject reports whether `value` is a top-level config object. A lint
@@ -1279,14 +1319,14 @@ function hasOwn(value: Record<string, unknown>, key: string): boolean {
 // whose only key is "format" is not silently dropped.
 function toSerializableConfig(value: Record<string, unknown>): Record<string, unknown> {
   const out: Record<string, unknown> = {};
-  for (const key of ["files", "ignores", "extends", "plugins", "rules", "format"]) {
+  for (const key of [%s]) {
     if (hasOwn(value, key)) {
       out[key] = value[key];
     }
   }
   return out;
 }
-`, importLiteral)
+`, importLiteral, serializableConfigKeysLiteral())
 }
 
 // typeScriptConfigLoaderTsconfig generates the JSON content of the ephemeral
@@ -1704,5 +1744,12 @@ func (c RuleConfig) Severity(name string) Severity {
   if c == nil {
     return SeverityOff
   }
-  return c[name]
+  if sev, ok := c[name]; ok {
+    return sev
+  }
+  canonical := normalizeBuiltinRuleName(name)
+  if sev, ok := c[canonical]; ok {
+    return sev
+  }
+  return SeverityOff
 }