@ttsc/lint 0.7.2 → 0.8.0-dev.20260505

package/plugin/config.go

@@ -1,33 +1,33 @@
 package main
 
 import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
+  "encoding/json"
+  "fmt"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
 )
 
 // Severity is the `error | warning | off` ladder.
 type Severity int
 
 const (
-	SeverityOff Severity = iota
-	SeverityWarn
-	SeverityError
+  SeverityOff Severity = iota
+  SeverityWarn
+  SeverityError
 )
 
 func (s Severity) String() string {
-	switch s {
-	case SeverityError:
-		return "error"
-	case SeverityWarn:
-		return "warning"
-	case SeverityOff:
-		return "off"
-	}
-	return "unknown"
+  switch s {
+  case SeverityError:
+    return "error"
+  case SeverityWarn:
+    return "warning"
+  case SeverityOff:
+    return "off"
+  }
+  return "unknown"
 }
 
 // PluginEntry mirrors the shape ttsc serializes into `--plugins-json`.
@@ -35,36 +35,36 @@ func (s Severity) String() string {
 // `Config` carries the original tsconfig plugin entry. `Name` and `Stage`
 // come from the JS plugin descriptor returned to the ttsc host.
 type PluginEntry struct {
-	Config map[string]any `json:"config"`
-	Name   string         `json:"name"`
-	Stage  string         `json:"stage"`
+  Config map[string]any `json:"config"`
+  Name   string         `json:"name"`
+  Stage  string         `json:"stage"`
 }
 
 // ParsePlugins decodes the `--plugins-json` payload.
 func ParsePlugins(text string) ([]PluginEntry, error) {
-	if strings.TrimSpace(text) == "" {
-		return nil, nil
-	}
-	var entries []PluginEntry
-	if err := json.Unmarshal([]byte(text), &entries); err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: invalid --plugins-json: %w", err)
-	}
-	return entries, nil
+  if strings.TrimSpace(text) == "" {
+    return nil, nil
+  }
+  var entries []PluginEntry
+  if err := json.Unmarshal([]byte(text), &entries); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: invalid --plugins-json: %w", err)
+  }
+  return entries, nil
 }
 
 // FindLintEntry returns the lint entry only when it is the first active
 // plugin. Linting after a source-transforming plugin would inspect mutated
 // source, which is not a meaningful user-code lint result.
 func FindLintEntry(entries []PluginEntry) (*PluginEntry, error) {
-	for i := range entries {
-		if entries[i].Name == "@ttsc/lint" {
-			if i != 0 {
-				return nil, fmt.Errorf("@ttsc/lint must be the first active compilerOptions.plugins entry")
-			}
-			return &entries[i], nil
-		}
-	}
-	return nil, nil
+  for i := range entries {
+    if entries[i].Name == "@ttsc/lint" {
+      if i != 0 {
+        return nil, fmt.Errorf("@ttsc/lint must be the first active compilerOptions.plugins entry")
+      }
+      return &entries[i], nil
+    }
+  }
+  return nil, nil
 }
 
 // RuleConfig captures the resolved per-rule severity. The map is keyed by
@@ -81,22 +81,22 @@ type RuleConfig map[string]Severity
 // Anything else returns an error (no silent fallback — typos in a rule
 // severity should be loud).
 func ParseRules(raw any) (RuleConfig, error) {
-	if raw == nil {
-		return RuleConfig{}, nil
-	}
-	dict, ok := raw.(map[string]any)
-	if !ok {
-		return nil, fmt.Errorf("@ttsc/lint: \"config\" must be an object, got %T", raw)
-	}
-	out := make(RuleConfig, len(dict))
-	for name, value := range dict {
-		sev, err := parseSeverity(value)
-		if err != nil {
-			return nil, fmt.Errorf("@ttsc/lint: rule %q: %w", name, err)
-		}
-		out[name] = sev
-	}
-	return out, nil
+  if raw == nil {
+    return RuleConfig{}, nil
+  }
+  dict, ok := raw.(map[string]any)
+  if !ok {
+    return nil, fmt.Errorf("@ttsc/lint: \"config\" must be an object, got %T", raw)
+  }
+  out := make(RuleConfig, len(dict))
+  for name, value := range dict {
+    sev, err := parseSeverity(value)
+    if err != nil {
+      return nil, fmt.Errorf("@ttsc/lint: rule %q: %w", name, err)
+    }
+    out[name] = sev
+  }
+  return out, nil
 }
 
 // LoadRuleConfig resolves the lint config for one plugin entry. The only
@@ -104,86 +104,86 @@ func ParseRules(raw any) (RuleConfig, error) {
 // rules object or a string path to a standalone config file. Relative config
 // paths are resolved from the tsconfig directory.
 func LoadRuleConfig(entry *PluginEntry, cwd, tsconfigPath string) (RuleConfig, error) {
-	if entry == nil {
-		return RuleConfig{}, nil
-	}
-	inline := entry.Config
-	if inline == nil {
-		inline = map[string]any{}
-	}
-	for _, key := range []string{"rules", "configFile", "configPath"} {
-		if _, ok := inline[key]; ok {
-			return nil, fmt.Errorf("@ttsc/lint: %q is not supported; use \"config\"", key)
-		}
-	}
-
-	value, ok := inline["config"]
-	if !ok {
-		return RuleConfig{}, nil
-	}
-	switch typed := value.(type) {
-	case string:
-		if strings.TrimSpace(typed) == "" {
-			return nil, fmt.Errorf("@ttsc/lint: \"config\" must not be empty")
-		}
-		rules, err := loadConfigFile(resolveConfigFilePath(typed, cwd, tsconfigPath))
-		if err != nil {
-			return nil, err
-		}
-		return ParseRules(rules)
-	case map[string]any:
-		return ParseRules(typed)
-	default:
-		return nil, fmt.Errorf("@ttsc/lint: \"config\" must be a string path or object, got %T", value)
-	}
+  if entry == nil {
+    return RuleConfig{}, nil
+  }
+  inline := entry.Config
+  if inline == nil {
+    inline = map[string]any{}
+  }
+  for _, key := range []string{"rules", "configFile", "configPath"} {
+    if _, ok := inline[key]; ok {
+      return nil, fmt.Errorf("@ttsc/lint: %q is not supported; use \"config\"", key)
+    }
+  }
+
+  value, ok := inline["config"]
+  if !ok {
+    return RuleConfig{}, nil
+  }
+  switch typed := value.(type) {
+  case string:
+    if strings.TrimSpace(typed) == "" {
+      return nil, fmt.Errorf("@ttsc/lint: \"config\" must not be empty")
+    }
+    rules, err := loadConfigFile(resolveConfigFilePath(typed, cwd, tsconfigPath))
+    if err != nil {
+      return nil, err
+    }
+    return ParseRules(rules)
+  case map[string]any:
+    return ParseRules(typed)
+  default:
+    return nil, fmt.Errorf("@ttsc/lint: \"config\" must be a string path or object, got %T", value)
+  }
 }
 
 func resolveConfigFilePath(configPath, cwd, tsconfigPath string) string {
-	if filepath.IsAbs(configPath) {
-		return configPath
-	}
-	base := cwd
-	if tsconfigPath != "" {
-		resolvedTsconfig := tsconfigPath
-		if !filepath.IsAbs(resolvedTsconfig) {
-			resolvedTsconfig = filepath.Join(cwd, resolvedTsconfig)
-		}
-		base = filepath.Dir(resolvedTsconfig)
-	}
-	return filepath.Join(base, configPath)
+  if filepath.IsAbs(configPath) {
+    return configPath
+  }
+  base := cwd
+  if tsconfigPath != "" {
+    resolvedTsconfig := tsconfigPath
+    if !filepath.IsAbs(resolvedTsconfig) {
+      resolvedTsconfig = filepath.Join(cwd, resolvedTsconfig)
+    }
+    base = filepath.Dir(resolvedTsconfig)
+  }
+  return filepath.Join(base, configPath)
 }
 
 func loadConfigFile(location string) (map[string]any, error) {
-	ext := strings.ToLower(filepath.Ext(location))
-	switch ext {
-	case ".json":
-		return loadJSONConfigFile(location)
-	case ".js", ".cjs", ".mjs":
-		return loadScriptConfigFile(location)
-	case ".ts", ".cts", ".mts":
-		return loadTypeScriptConfigFile(location)
-	default:
-		return nil, fmt.Errorf("@ttsc/lint: unsupported config file extension %q for %s", ext, location)
-	}
+  ext := strings.ToLower(filepath.Ext(location))
+  switch ext {
+  case ".json":
+    return loadJSONConfigFile(location)
+  case ".js", ".cjs", ".mjs":
+    return loadScriptConfigFile(location)
+  case ".ts", ".cts", ".mts":
+    return loadTypeScriptConfigFile(location)
+  default:
+    return nil, fmt.Errorf("@ttsc/lint: unsupported config file extension %q for %s", ext, location)
+  }
 }
 
 func loadJSONConfigFile(location string) (map[string]any, error) {
-	body, err := os.ReadFile(location)
-	if err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: read config file %s: %w", location, err)
-	}
-	var out map[string]any
-	if err := json.Unmarshal(body, &out); err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: parse config file %s: %w", location, err)
-	}
-	if out == nil {
-		return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
-	}
-	return out, nil
+  body, err := os.ReadFile(location)
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: read config file %s: %w", location, err)
+  }
+  var out map[string]any
+  if err := json.Unmarshal(body, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: parse config file %s: %w", location, err)
+  }
+  if out == nil {
+    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
+  }
+  return out, nil
 }
 
 func loadScriptConfigFile(location string) (map[string]any, error) {
-	const script = `
+  const script = `
 const { pathToFileURL } = require("node:url");
 
 (async () => {
@@ -199,107 +199,107 @@ const { pathToFileURL } = require("node:url");
   process.exit(1);
 });
 `
-	node := os.Getenv("TTSC_NODE_BINARY")
-	if node == "" {
-		node = "node"
-	}
-	cmd := exec.Command(node, "-e", script, location)
-	output, err := cmd.Output()
-	if err != nil {
-		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 map[string]any
-	if err := json.Unmarshal(output, &out); err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: parse config file %s output: %w", location, err)
-	}
-	if out == nil {
-		return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
-	}
-	return out, nil
+  node := os.Getenv("TTSC_NODE_BINARY")
+  if node == "" {
+    node = "node"
+  }
+  cmd := exec.Command(node, "-e", script, location)
+  output, err := cmd.Output()
+  if err != nil {
+    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 map[string]any
+  if err := json.Unmarshal(output, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: parse config file %s output: %w", location, err)
+  }
+  if out == nil {
+    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
+  }
+  return out, nil
 }
 
 func loadTypeScriptConfigFile(location string) (map[string]any, error) {
-	tempDir, err := os.MkdirTemp("", "ttsc-lint-config-")
-	if err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: create config loader tempdir: %w", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	if err := linkNearestNodeModules(tempDir, filepath.Dir(location)); err != nil {
-		return nil, err
-	}
-
-	loader := filepath.Join(tempDir, "loader.mts")
-	tsconfig := filepath.Join(tempDir, "tsconfig.json")
-	importSpecifier, err := relativeImportSpecifier(tempDir, location)
-	if err != nil {
-		return nil, err
-	}
-	importLiteral, err := json.Marshal(importSpecifier)
-	if err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: encode config import %s: %w", location, err)
-	}
-	if err := os.WriteFile(loader, []byte(typeScriptConfigLoaderSource(string(importLiteral))), 0o644); err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: write config loader: %w", err)
-	}
-	if err := os.WriteFile(tsconfig, []byte(typeScriptConfigLoaderTsconfig(loader, location, tempDir)), 0o644); err != nil {
-		return nil, fmt.Errorf("@ttsc/lint: write config loader tsconfig: %w", err)
-	}
-
-	args := []string{
-		"--project", tsconfig,
-		"--cwd", tempDir,
-		"--cache-dir", filepath.Join(tempDir, "cache"),
-	}
-	if tsgo := os.Getenv("TTSC_TSGO_BINARY"); tsgo != "" {
-		args = append(args, "--binary", tsgo)
-	}
-	args = append(args, loader)
-
-	cmd := ttsxCommand(args...)
-	cmd.Env = nodeConfigLoaderEnv(location)
-	output, err := cmd.Output()
-	if err != nil {
-		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 map[string]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 out == nil {
-		return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
-	}
-	return out, nil
+  tempDir, err := os.MkdirTemp("", "ttsc-lint-config-")
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: create config loader tempdir: %w", err)
+  }
+  defer os.RemoveAll(tempDir)
+
+  if err := linkNearestNodeModules(tempDir, filepath.Dir(location)); err != nil {
+    return nil, err
+  }
+
+  loader := filepath.Join(tempDir, "loader.mts")
+  tsconfig := filepath.Join(tempDir, "tsconfig.json")
+  importSpecifier, err := relativeImportSpecifier(tempDir, location)
+  if err != nil {
+    return nil, err
+  }
+  importLiteral, err := json.Marshal(importSpecifier)
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: encode config import %s: %w", location, err)
+  }
+  if err := os.WriteFile(loader, []byte(typeScriptConfigLoaderSource(string(importLiteral))), 0o644); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: write config loader: %w", err)
+  }
+  if err := os.WriteFile(tsconfig, []byte(typeScriptConfigLoaderTsconfig(loader, location, tempDir)), 0o644); err != nil {
+    return nil, fmt.Errorf("@ttsc/lint: write config loader tsconfig: %w", err)
+  }
+
+  args := []string{
+    "--project", tsconfig,
+    "--cwd", tempDir,
+    "--cache-dir", filepath.Join(tempDir, "cache"),
+  }
+  if tsgo := os.Getenv("TTSC_TSGO_BINARY"); tsgo != "" {
+    args = append(args, "--binary", tsgo)
+  }
+  args = append(args, loader)
+
+  cmd := ttsxCommand(args...)
+  cmd.Env = nodeConfigLoaderEnv(location)
+  output, err := cmd.Output()
+  if err != nil {
+    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 map[string]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 out == nil {
+    return nil, fmt.Errorf("@ttsc/lint: config file %s must export an object", location)
+  }
+  return out, nil
 }
 
 func relativeImportSpecifier(fromDir, location string) (string, error) {
-	relative, err := filepath.Rel(fromDir, location)
-	if err != nil {
-		return "", fmt.Errorf("@ttsc/lint: resolve relative config import %s: %w", location, err)
-	}
-	relative = filepath.ToSlash(relative)
-	if strings.HasPrefix(relative, "../") || strings.HasPrefix(relative, "./") {
-		return relative, nil
-	}
-	return "./" + relative, nil
+  relative, err := filepath.Rel(fromDir, location)
+  if err != nil {
+    return "", fmt.Errorf("@ttsc/lint: resolve relative config import %s: %w", location, err)
+  }
+  relative = filepath.ToSlash(relative)
+  if strings.HasPrefix(relative, "../") || strings.HasPrefix(relative, "./") {
+    return relative, nil
+  }
+  return "./" + relative, nil
 }
 
 func typeScriptConfigLoaderSource(importLiteral string) string {
-	return fmt.Sprintf(`import * as importedConfig from %s;
+  return fmt.Sprintf(`import * as importedConfig from %s;
 
 declare const process: {
   stdout: { write(value: string): void };
@@ -350,138 +350,138 @@ function hasOwn(value: Record<string, unknown>, key: string): boolean {
 }
 
 func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
-	content := map[string]any{
-		"compilerOptions": map[string]any{
-			"allowImportingTsExtensions":      true,
-			"module":                          "ESNext",
-			"moduleResolution":                "bundler",
-			"outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
-			"rewriteRelativeImportExtensions": true,
-			"rootDir":                         "/",
-			"skipLibCheck":                    true,
-			"strict":                          true,
-			"target":                          "ES2022",
-		},
-		"files": []string{
-			filepath.ToSlash(loader),
-			filepath.ToSlash(location),
-		},
-	}
-	body, err := json.MarshalIndent(content, "", "  ")
-	if err != nil {
-		panic(err)
-	}
-	return string(body)
+  content := map[string]any{
+    "compilerOptions": map[string]any{
+      "allowImportingTsExtensions":      true,
+      "module":                          "ESNext",
+      "moduleResolution":                "bundler",
+      "outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
+      "rewriteRelativeImportExtensions": true,
+      "rootDir":                         "/",
+      "skipLibCheck":                    true,
+      "strict":                          true,
+      "target":                          "ES2022",
+    },
+    "files": []string{
+      filepath.ToSlash(loader),
+      filepath.ToSlash(location),
+    },
+  }
+  body, err := json.MarshalIndent(content, "", "  ")
+  if err != nil {
+    panic(err)
+  }
+  return string(body)
 }
 
 func ttsxCommand(args ...string) *exec.Cmd {
-	ttsx := os.Getenv("TTSC_TTSX_BINARY")
-	if ttsx == "" {
-		ttsx = "ttsx"
-	}
-	if shouldRunTtsxThroughNode(ttsx) {
-		node := os.Getenv("TTSC_NODE_BINARY")
-		if node == "" {
-			node = "node"
-		}
-		return exec.Command(node, append([]string{ttsx}, args...)...)
-	}
-	return exec.Command(ttsx, args...)
+  ttsx := os.Getenv("TTSC_TTSX_BINARY")
+  if ttsx == "" {
+    ttsx = "ttsx"
+  }
+  if shouldRunTtsxThroughNode(ttsx) {
+    node := os.Getenv("TTSC_NODE_BINARY")
+    if node == "" {
+      node = "node"
+    }
+    return exec.Command(node, append([]string{ttsx}, args...)...)
+  }
+  return exec.Command(ttsx, args...)
 }
 
 func shouldRunTtsxThroughNode(binary string) bool {
-	switch strings.ToLower(filepath.Ext(binary)) {
-	case ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts":
-		return true
-	default:
-		return false
-	}
+  switch strings.ToLower(filepath.Ext(binary)) {
+  case ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts":
+    return true
+  default:
+    return false
+  }
 }
 
 func nodeConfigLoaderEnv(location string) []string {
-	env := os.Environ()
-	parts := make([]string, 0, 2)
-	if nodeModules := findNearestNodeModules(filepath.Dir(location)); nodeModules != "" {
-		parts = append(parts, nodeModules)
-	}
-	if existing := os.Getenv("NODE_PATH"); existing != "" {
-		parts = append(parts, existing)
-	}
-	if len(parts) == 0 {
-		return env
-	}
-	return setEnv(env, "NODE_PATH", strings.Join(parts, string(os.PathListSeparator)))
+  env := os.Environ()
+  parts := make([]string, 0, 2)
+  if nodeModules := findNearestNodeModules(filepath.Dir(location)); nodeModules != "" {
+    parts = append(parts, nodeModules)
+  }
+  if existing := os.Getenv("NODE_PATH"); existing != "" {
+    parts = append(parts, existing)
+  }
+  if len(parts) == 0 {
+    return env
+  }
+  return setEnv(env, "NODE_PATH", strings.Join(parts, string(os.PathListSeparator)))
 }
 
 func linkNearestNodeModules(tempDir, sourceDir string) error {
-	nodeModules := findNearestNodeModules(sourceDir)
-	if nodeModules == "" {
-		return nil
-	}
-	link := filepath.Join(tempDir, "node_modules")
-	if err := os.Symlink(nodeModules, link); err != nil {
-		return fmt.Errorf("@ttsc/lint: link config node_modules %s: %w", nodeModules, err)
-	}
-	return nil
+  nodeModules := findNearestNodeModules(sourceDir)
+  if nodeModules == "" {
+    return nil
+  }
+  link := filepath.Join(tempDir, "node_modules")
+  if err := os.Symlink(nodeModules, link); err != nil {
+    return fmt.Errorf("@ttsc/lint: link config node_modules %s: %w", nodeModules, err)
+  }
+  return nil
 }
 
 func findNearestNodeModules(start string) string {
-	dir := filepath.Clean(start)
-	for {
-		candidate := filepath.Join(dir, "node_modules")
-		if stat, err := os.Stat(candidate); err == nil && stat.IsDir() {
-			return candidate
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			return ""
-		}
-		dir = parent
-	}
+  dir := filepath.Clean(start)
+  for {
+    candidate := filepath.Join(dir, "node_modules")
+    if stat, err := os.Stat(candidate); err == nil && stat.IsDir() {
+      return candidate
+    }
+    parent := filepath.Dir(dir)
+    if parent == dir {
+      return ""
+    }
+    dir = parent
+  }
 }
 
 func setEnv(env []string, key, value string) []string {
-	prefix := key + "="
-	for i, entry := range env {
-		if strings.HasPrefix(entry, prefix) {
-			env[i] = prefix + value
-			return env
-		}
-	}
-	return append(env, prefix+value)
+  prefix := key + "="
+  for i, entry := range env {
+    if strings.HasPrefix(entry, prefix) {
+      env[i] = prefix + value
+      return env
+    }
+  }
+  return append(env, prefix+value)
 }
 
 func parseSeverity(v any) (Severity, error) {
-	switch x := v.(type) {
-	case string:
-		switch x {
-		case "off":
-			return SeverityOff, nil
-		case "warning", "warn":
-			return SeverityWarn, nil
-		case "error":
-			return SeverityError, nil
-		}
-		return SeverityOff, fmt.Errorf("unknown severity %q (want off | warning | error)", x)
-	case float64:
-		switch x {
-		case 0:
-			return SeverityOff, nil
-		case 1:
-			return SeverityWarn, nil
-		case 2:
-			return SeverityError, nil
-		}
-		return SeverityOff, fmt.Errorf("unknown severity %v (want off | warning | error)", x)
-	}
-	return SeverityOff, fmt.Errorf("severity must be one of: off | warning | error, got %T", v)
+  switch x := v.(type) {
+  case string:
+    switch x {
+    case "off":
+      return SeverityOff, nil
+    case "warning", "warn":
+      return SeverityWarn, nil
+    case "error":
+      return SeverityError, nil
+    }
+    return SeverityOff, fmt.Errorf("unknown severity %q (want off | warning | error)", x)
+  case float64:
+    switch x {
+    case 0:
+      return SeverityOff, nil
+    case 1:
+      return SeverityWarn, nil
+    case 2:
+      return SeverityError, nil
+    }
+    return SeverityOff, fmt.Errorf("unknown severity %v (want off | warning | error)", x)
+  }
+  return SeverityOff, fmt.Errorf("severity must be one of: off | warning | error, got %T", v)
 }
 
 // Severity returns the configured level for a rule, defaulting to
 // `SeverityOff`. Rules opt in explicitly — silent on missing entries.
 func (c RuleConfig) Severity(name string) Severity {
-	if c == nil {
-		return SeverityOff
-	}
-	return c[name]
+  if c == nil {
+    return SeverityOff
+  }
+  return c[name]
 }