@ttsc/lint 0.7.2 → 0.7.3

package/plugin/host.go

@@ -10,35 +10,35 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"fmt"
-	"path/filepath"
+  "context"
+  "errors"
+  "fmt"
+  "path/filepath"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	"github.com/microsoft/typescript-go/shim/bundled"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	"github.com/microsoft/typescript-go/shim/tsoptions"
-	"github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
-	"github.com/microsoft/typescript-go/shim/vfs/osvfs"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/microsoft/typescript-go/shim/bundled"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+  "github.com/microsoft/typescript-go/shim/tsoptions"
+  "github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
+  "github.com/microsoft/typescript-go/shim/vfs/osvfs"
 )
 
 // program bundles the tsgo Program with the parsed config and a checker
 // release callback so the orchestration code can clean up after itself.
 type program struct {
-	cwd            string
-	tsProgram      *shimcompiler.Program
-	parsed         *tsoptions.ParsedCommandLine
-	checker        *shimchecker.Checker
-	releaseChecker func()
+  cwd            string
+  tsProgram      *shimcompiler.Program
+  parsed         *tsoptions.ParsedCommandLine
+  checker        *shimchecker.Checker
+  releaseChecker func()
 }
 
 type loadProgramOptions struct {
-	forceEmit   bool
-	forceNoEmit bool
-	outDir      string
+  forceEmit   bool
+  forceNoEmit bool
+  outDir      string
 }
 
 // loadProgram parses the given tsconfig, builds a Program, and acquires a
@@ -48,143 +48,143 @@ type loadProgramOptions struct {
 // before the program is created so `--noEmit` and friends behave like
 // they do in `ttsc check`.
 func loadProgram(cwd, tsconfigPath string, options loadProgramOptions) (*program, []*shimast.Diagnostic, error) {
-	if !filepath.IsAbs(cwd) {
-		abs, err := filepath.Abs(cwd)
-		if err != nil {
-			return nil, nil, fmt.Errorf("loadProgram: cwd: %w", err)
-		}
-		cwd = abs
-	}
-	resolved := tsconfigPath
-	if !filepath.IsAbs(resolved) {
-		resolved = filepath.Join(cwd, resolved)
-	}
+  if !filepath.IsAbs(cwd) {
+    abs, err := filepath.Abs(cwd)
+    if err != nil {
+      return nil, nil, fmt.Errorf("loadProgram: cwd: %w", err)
+    }
+    cwd = abs
+  }
+  resolved := tsconfigPath
+  if !filepath.IsAbs(resolved) {
+    resolved = filepath.Join(cwd, resolved)
+  }
 
-	fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
-	host := shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
+  fs := bundled.WrapFS(cachedvfs.From(osvfs.FS()))
+  host := shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
 
-	parsed, parseDiags := tsoptions.GetParsedCommandLineOfConfigFile(
-		resolved,
-		&shimcore.CompilerOptions{},
-		nil,
-		host,
-		nil,
-	)
-	if parsed == nil {
-		return nil, nil, fmt.Errorf("tsoptions: parsed command line was nil for %s", resolved)
-	}
-	if len(parseDiags) > 0 {
-		return nil, parseDiags, nil
-	}
-	if len(parsed.Errors) > 0 {
-		return nil, parsed.Errors, nil
-	}
-	if options.forceNoEmit {
-		forceNoEmit(parsed)
-	}
-	if options.forceEmit {
-		forceEmit(parsed)
-	}
-	if options.outDir != "" {
-		overrideOutDir(cwd, parsed, options.outDir)
-	}
+  parsed, parseDiags := tsoptions.GetParsedCommandLineOfConfigFile(
+    resolved,
+    &shimcore.CompilerOptions{},
+    nil,
+    host,
+    nil,
+  )
+  if parsed == nil {
+    return nil, nil, fmt.Errorf("tsoptions: parsed command line was nil for %s", resolved)
+  }
+  if len(parseDiags) > 0 {
+    return nil, parseDiags, nil
+  }
+  if len(parsed.Errors) > 0 {
+    return nil, parsed.Errors, nil
+  }
+  if options.forceNoEmit {
+    forceNoEmit(parsed)
+  }
+  if options.forceEmit {
+    forceEmit(parsed)
+  }
+  if options.outDir != "" {
+    overrideOutDir(cwd, parsed, options.outDir)
+  }
 
-	tsProgram := shimcompiler.NewProgram(shimcompiler.ProgramOptions{
-		Config:                      parsed,
-		SingleThreaded:              shimcore.TSTrue,
-		Host:                        host,
-		UseSourceOfProjectReference: true,
-	})
-	if tsProgram == nil {
-		return nil, nil, errors.New("compiler.NewProgram returned nil")
-	}
-	checker, release := tsProgram.GetTypeChecker(context.Background())
-	return &program{
-		cwd:            cwd,
-		tsProgram:      tsProgram,
-		parsed:         parsed,
-		checker:        checker,
-		releaseChecker: release,
-	}, nil, nil
+  tsProgram := shimcompiler.NewProgram(shimcompiler.ProgramOptions{
+    Config:                      parsed,
+    SingleThreaded:              shimcore.TSTrue,
+    Host:                        host,
+    UseSourceOfProjectReference: true,
+  })
+  if tsProgram == nil {
+    return nil, nil, errors.New("compiler.NewProgram returned nil")
+  }
+  checker, release := tsProgram.GetTypeChecker(context.Background())
+  return &program{
+    cwd:            cwd,
+    tsProgram:      tsProgram,
+    parsed:         parsed,
+    checker:        checker,
+    releaseChecker: release,
+  }, nil, nil
 }
 
 func (p *program) close() {
-	if p == nil {
-		return
-	}
-	if p.releaseChecker != nil {
-		p.releaseChecker()
-		p.releaseChecker = nil
-	}
+  if p == nil {
+    return
+  }
+  if p.releaseChecker != nil {
+    p.releaseChecker()
+    p.releaseChecker = nil
+  }
 }
 
 // userSourceFiles returns the program's user-authored source files
 // (declaration files filtered out — those belong to library typings).
 func (p *program) userSourceFiles() []*shimast.SourceFile {
-	out := make([]*shimast.SourceFile, 0)
-	for _, f := range p.tsProgram.SourceFiles() {
-		if f == nil || f.IsDeclarationFile {
-			continue
-		}
-		out = append(out, f)
-	}
-	return out
+  out := make([]*shimast.SourceFile, 0)
+  for _, f := range p.tsProgram.SourceFiles() {
+    if f == nil || f.IsDeclarationFile {
+      continue
+    }
+    out = append(out, f)
+  }
+  return out
 }
 
 // programDiagnostics returns the bind + semantic diagnostics for the
 // loaded program. Same surface tsgo's CLI prints when you run a regular
 // `tsgo --noEmit`.
 func (p *program) programDiagnostics() []*shimast.Diagnostic {
-	if p == nil || p.tsProgram == nil {
-		return nil
-	}
-	ctx := context.Background()
-	raw := shimcompiler.GetDiagnosticsOfAnyProgram(
-		ctx,
-		p.tsProgram,
-		nil,
-		false,
-		p.tsProgram.GetBindDiagnostics,
-		p.tsProgram.GetSemanticDiagnostics,
-	)
-	return shimcompiler.SortAndDeduplicateDiagnostics(raw)
+  if p == nil || p.tsProgram == nil {
+    return nil
+  }
+  ctx := context.Background()
+  raw := shimcompiler.GetDiagnosticsOfAnyProgram(
+    ctx,
+    p.tsProgram,
+    nil,
+    false,
+    p.tsProgram.GetBindDiagnostics,
+    p.tsProgram.GetSemanticDiagnostics,
+  )
+  return shimcompiler.SortAndDeduplicateDiagnostics(raw)
 }
 
 // findSourceFile locates a source file in the program by absolute path.
 // tsgo normalizes paths to forward slashes; we do the same on our side.
 func (p *program) findSourceFile(target string) *shimast.SourceFile {
-	want := filepath.ToSlash(target)
-	for _, file := range p.tsProgram.SourceFiles() {
-		if filepath.ToSlash(file.FileName()) == want {
-			return file
-		}
-	}
-	return nil
+  want := filepath.ToSlash(target)
+  for _, file := range p.tsProgram.SourceFiles() {
+    if filepath.ToSlash(file.FileName()) == want {
+      return file
+    }
+  }
+  return nil
 }
 
 func forceEmit(parsed *tsoptions.ParsedCommandLine) {
-	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-		return
-	}
-	options := parsed.ParsedConfig.CompilerOptions
-	options.NoEmit = shimcore.TSFalse
-	options.EmitDeclarationOnly = shimcore.TSFalse
+  if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+    return
+  }
+  options := parsed.ParsedConfig.CompilerOptions
+  options.NoEmit = shimcore.TSFalse
+  options.EmitDeclarationOnly = shimcore.TSFalse
 }
 
 func forceNoEmit(parsed *tsoptions.ParsedCommandLine) {
-	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-		return
-	}
-	parsed.ParsedConfig.CompilerOptions.NoEmit = shimcore.TSTrue
+  if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+    return
+  }
+  parsed.ParsedConfig.CompilerOptions.NoEmit = shimcore.TSTrue
 }
 
 func overrideOutDir(cwd string, parsed *tsoptions.ParsedCommandLine, outDir string) {
-	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-		return
-	}
-	if filepath.IsAbs(outDir) {
-		parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(outDir)
-		return
-	}
-	parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(filepath.Join(cwd, outDir))
+  if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+    return
+  }
+  if filepath.IsAbs(outDir) {
+    parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(outDir)
+    return
+  }
+  parsed.ParsedConfig.CompilerOptions.OutDir = filepath.ToSlash(filepath.Join(cwd, outDir))
 }

package/plugin/main.go

@@ -16,33 +16,33 @@
 package main
 
 import (
-	"fmt"
-	"os"
+  "fmt"
+  "os"
 )
 
 const version = "0.0.1"
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-	if len(args) == 0 {
-		fmt.Fprintln(os.Stderr, "@ttsc/lint: command required (expected check|build|transform|version)")
-		return 2
-	}
-	switch args[0] {
-	case "-v", "--version", "version":
-		fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", version)
-		return 0
-	case "check":
-		return RunCheck(args[1:])
-	case "build":
-		return RunBuild(args[1:])
-	case "transform":
-		return RunTransform(args[1:])
-	default:
-		fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
-		return 2
-	}
+  if len(args) == 0 {
+    fmt.Fprintln(os.Stderr, "@ttsc/lint: command required (expected check|build|transform|version)")
+    return 2
+  }
+  switch args[0] {
+  case "-v", "--version", "version":
+    fmt.Fprintf(os.Stdout, "@ttsc/lint %s\n", version)
+    return 0
+  case "check":
+    return RunCheck(args[1:])
+  case "build":
+    return RunBuild(args[1:])
+  case "transform":
+    return RunTransform(args[1:])
+  default:
+    fmt.Fprintf(os.Stderr, "@ttsc/lint: unknown command %q\n", args[0])
+    return 2
+  }
 }

package/plugin/rules_arrays.go

@@ -9,19 +9,19 @@ type noSparseArrays struct{}
 
 func (noSparseArrays) Name() string { return "no-sparse-arrays" }
 func (noSparseArrays) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+  return []shimast.Kind{shimast.KindArrayLiteralExpression}
 }
 func (noSparseArrays) Check(ctx *Context, node *shimast.Node) {
-	arr := node.AsArrayLiteralExpression()
-	if arr == nil || arr.Elements == nil {
-		return
-	}
-	for _, el := range arr.Elements.Nodes {
-		if el != nil && el.Kind == shimast.KindOmittedExpression {
-			ctx.Report(node, "Unexpected comma in middle of array.")
-			return
-		}
-	}
+  arr := node.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return
+  }
+  for _, el := range arr.Elements.Nodes {
+    if el != nil && el.Kind == shimast.KindOmittedExpression {
+      ctx.Report(node, "Unexpected comma in middle of array.")
+      return
+    }
+  }
 }
 
 // no-array-constructor: forbid `new Array(0)` / `Array(1, 2, 3)` (use
@@ -32,49 +32,49 @@ type noArrayConstructor struct{}
 
 func (noArrayConstructor) Name() string { return "no-array-constructor" }
 func (noArrayConstructor) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
 }
 func (noArrayConstructor) Check(ctx *Context, node *shimast.Node) {
-	var callee *shimast.Node
-	var argCount int
-	switch node.Kind {
-	case shimast.KindNewExpression:
-		ne := node.AsNewExpression()
-		if ne == nil {
-			return
-		}
-		if ne.TypeArguments != nil && len(ne.TypeArguments.Nodes) > 0 {
-			return // `new Array<string>()` is a typed empty array
-		}
-		callee = ne.Expression
-		if ne.Arguments != nil {
-			argCount = len(ne.Arguments.Nodes)
-		}
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil {
-			return
-		}
-		if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
-			return
-		}
-		callee = call.Expression
-		if call.Arguments != nil {
-			argCount = len(call.Arguments.Nodes)
-		}
-	}
-	if identifierText(callee) != "Array" {
-		return
-	}
-	// Single-arg numeric — ambiguous (length vs single element). Skip
-	// so existing patterns aren't flagged when the intent is preallocate.
-	if argCount == 1 {
-		return
-	}
-	ctx.Report(node, "The array literal notation [] is preferable.")
+  var callee *shimast.Node
+  var argCount int
+  switch node.Kind {
+  case shimast.KindNewExpression:
+    ne := node.AsNewExpression()
+    if ne == nil {
+      return
+    }
+    if ne.TypeArguments != nil && len(ne.TypeArguments.Nodes) > 0 {
+      return // `new Array<string>()` is a typed empty array
+    }
+    callee = ne.Expression
+    if ne.Arguments != nil {
+      argCount = len(ne.Arguments.Nodes)
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return
+    }
+    if call.TypeArguments != nil && len(call.TypeArguments.Nodes) > 0 {
+      return
+    }
+    callee = call.Expression
+    if call.Arguments != nil {
+      argCount = len(call.Arguments.Nodes)
+    }
+  }
+  if identifierText(callee) != "Array" {
+    return
+  }
+  // Single-arg numeric — ambiguous (length vs single element). Skip
+  // so existing patterns aren't flagged when the intent is preallocate.
+  if argCount == 1 {
+    return
+  }
+  ctx.Report(node, "The array literal notation [] is preferable.")
 }
 
 func init() {
-	Register(noSparseArrays{})
-	Register(noArrayConstructor{})
+  Register(noSparseArrays{})
+  Register(noArrayConstructor{})
 }

package/plugin/rules_console.go

@@ -2,36 +2,35 @@ package main
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// no-console: forbid `console.*` calls. Default mode flags every method;
-// users who want to allow specific methods can configure ESLint-style
-// allowlists in a future iteration.
+// no-console: forbid `console.*` calls. This implementation models the
+// default rule shape and flags every console method.
 // https://eslint.org/docs/latest/rules/no-console
 type noConsole struct{}
 
 func (noConsole) Name() string           { return "no-console" }
 func (noConsole) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noConsole) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Expression) != "console" {
-		return
-	}
-	method := identifierText(access.Name())
-	if method == "" {
-		return
-	}
-	ctx.Report(node, "Unexpected console statement.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "console" {
+    return
+  }
+  method := identifierText(access.Name())
+  if method == "" {
+    return
+  }
+  ctx.Report(node, "Unexpected console statement.")
 }
 
 func init() {
-	Register(noConsole{})
+  Register(noConsole{})
 }

package/plugin/rules_debugger.go

@@ -9,7 +9,7 @@ type noDebugger struct{}
 func (noDebugger) Name() string           { return "no-debugger" }
 func (noDebugger) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindDebuggerStatement} }
 func (noDebugger) Check(ctx *Context, node *shimast.Node) {
-	ctx.Report(node, "Unexpected `debugger` statement.")
+  ctx.Report(node, "Unexpected `debugger` statement.")
 }
 
 // no-with: forbid `with` statements (already disallowed in strict mode,
@@ -20,10 +20,10 @@ type noWith struct{}
 func (noWith) Name() string           { return "no-with" }
 func (noWith) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindWithStatement} }
 func (noWith) Check(ctx *Context, node *shimast.Node) {
-	ctx.Report(node, "Unexpected `with` statement.")
+  ctx.Report(node, "Unexpected `with` statement.")
 }
 
 func init() {
-	Register(noDebugger{})
-	Register(noWith{})
+  Register(noDebugger{})
+  Register(noWith{})
 }