ttsc 0.9.0 → 0.10.1

package/cmd/ttsc/api_compile.go

@@ -7,24 +7,25 @@
 package main
 
 import (
-  "encoding/json"
-  "flag"
-  "fmt"
-  "os"
-  "path/filepath"
-  "strings"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
 
-  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 
-  "github.com/samchon/ttsc/packages/ttsc/driver"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	cwdutil "github.com/samchon/ttsc/packages/ttsc/internal/cwd"
 )
 
 type apiCompileResult struct {
-  // Diagnostics is omitted only when the compiler produced no diagnostics.
-  // Output is still returned in diagnostic cases because TypeScript-Go may
-  // produce partial emit text before a build-failing error is reported.
-  Diagnostics []apiCompileDiagnostic `json:"diagnostics,omitempty"`
-  Output      map[string]string      `json:"output"`
+	// Diagnostics is omitted only when the compiler produced no diagnostics.
+	// Output is still returned in diagnostic cases because TypeScript-Go may
+	// produce partial emit text before a build-failing error is reported.
+	Diagnostics []apiCompileDiagnostic `json:"diagnostics,omitempty"`
+	Output      map[string]string      `json:"output"`
 }
 
 // apiCompileDiagnostic mirrors the public TypeScript-side diagnostic DTO.
@@ -32,124 +33,113 @@ type apiCompileResult struct {
 // `character`) instead of Go naming so callers can pass the data through
 // without remapping.
 type apiCompileDiagnostic struct {
-  File        *string `json:"file"`
-  Category    string  `json:"category"`
-  Code        int32   `json:"code"`
-  Start       *int    `json:"start,omitempty"`
-  Length      *int    `json:"length,omitempty"`
-  Line        int     `json:"line,omitempty"`
-  Character   int     `json:"character,omitempty"`
-  MessageText string  `json:"messageText"`
+	File        *string `json:"file"`
+	Category    string  `json:"category"`
+	Code        int32   `json:"code"`
+	Start       *int    `json:"start,omitempty"`
+	Length      *int    `json:"length,omitempty"`
+	Line        int     `json:"line,omitempty"`
+	Character   int     `json:"character,omitempty"`
+	MessageText string  `json:"messageText"`
 }
 
 func runAPICompile(args []string) int {
-  fs := flag.NewFlagSet("api-compile", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
-  cwdOverride := fs.String("cwd", "", "override the working directory")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
+	fs := flag.NewFlagSet("api-compile", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
 
-  cwd, ok := resolveBuildCwd(*cwdOverride)
-  if !ok {
-    return 2
-  }
+	cwd, err := cwdutil.Resolve(*cwdOverride, os.Getwd)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc: %v\n", err)
+		return 2
+	}
 
-  prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-    ForceEmit: true,
-  })
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc api-compile: %v\n", err)
-    return 2
-  }
-  if prog != nil {
-    defer prog.Close()
-    diags = append(diags, prog.Diagnostics()...)
-  }
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc api-compile: %v\n", err)
+		return 2
+	}
+	if prog != nil {
+		defer prog.Close()
+		diags = append(diags, prog.Diagnostics()...)
+	}
 
-  output := map[string]string{}
-  if prog != nil {
-    rewrites := driver.NewRewriteSet()
-    // Capture WriteFile output in a map keyed by project-relative paths. This
-    // gives the JS API a deterministic object and avoids touching outDir.
-    writeFile := shimcompiler.WriteFile(
-      func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-        output[apiOutputKey(cwd, fileName)] = text
-        return nil
-      },
-    )
-    _, emitDiags, err := prog.EmitAll(rewrites, writeFile)
-    if err != nil {
-      fmt.Fprintf(stderr, "ttsc api-compile: emit failed: %v\n", err)
-      return 3
-    }
-    diags = append(diags, emitDiags...)
-  }
+	output := map[string]string{}
+	if prog != nil {
+		rewrites := driver.NewRewriteSet()
+		// Capture WriteFile output in a map keyed by project-relative paths. This
+		// gives the JS API a deterministic object and avoids touching outDir.
+		writeFile := shimcompiler.WriteFile(
+			func(fileName, text string, _ *shimcompiler.WriteFileData) error {
+				output[apiOutputKey(cwd, fileName)] = text
+				return nil
+			},
+		)
+		_, emitDiags, err := prog.EmitAll(rewrites, writeFile)
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc api-compile: emit failed: %v\n", err)
+			return 3
+		}
+		diags = append(diags, emitDiags...)
+	}
 
-  result := apiCompileResult{
-    Diagnostics: make([]apiCompileDiagnostic, 0, len(diags)),
-    Output:      output,
-  }
-  for _, diag := range diags {
-    result.Diagnostics = append(result.Diagnostics, toAPICompileDiagnostic(diag))
-  }
+	result := apiCompileResult{
+		Diagnostics: make([]apiCompileDiagnostic, 0, len(diags)),
+		Output:      output,
+	}
+	for _, diag := range diags {
+		result.Diagnostics = append(result.Diagnostics, toAPICompileDiagnostic(diag))
+	}
 
-  data, err := json.Marshal(result)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc api-compile: result marshal failed: %v\n", err)
-    return 3
-  }
-  fmt.Fprintln(stdout, string(data))
-  if driver.CountErrors(diags) > 0 {
-    return 2
-  }
-  return 0
-}
-
-func resolveBuildCwd(cwdOverride string) (string, bool) {
-  if cwdOverride != "" {
-    return cwdOverride, true
-  }
-  cwd, err := os.Getwd()
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc: could not get working directory: %v\n", err)
-    return "", false
-  }
-  return cwd, true
+	data, err := json.Marshal(result)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc api-compile: result marshal failed: %v\n", err)
+		return 3
+	}
+	fmt.Fprintln(stdout, string(data))
+	if driver.CountErrors(diags) > 0 {
+		return 2
+	}
+	return 0
 }
 
 func toAPICompileDiagnostic(diag driver.Diagnostic) apiCompileDiagnostic {
-  var file *string
-  if diag.File != "" {
-    value := diag.File
-    file = &value
-  }
-  category := "error"
-  if diag.Severity == driver.SeverityWarning {
-    category = "warning"
-  }
-  return apiCompileDiagnostic{
-    File:        file,
-    Category:    category,
-    Code:        diag.Code,
-    Start:       diag.Start,
-    Length:      diag.Length,
-    Line:        diag.Line,
-    Character:   diag.Column,
-    MessageText: diag.Message,
-  }
+	var file *string
+	if diag.File != "" {
+		value := diag.File
+		file = &value
+	}
+	category := "error"
+	if diag.Severity == driver.SeverityWarning {
+		category = "warning"
+	}
+	return apiCompileDiagnostic{
+		File:        file,
+		Category:    category,
+		Code:        diag.Code,
+		Start:       diag.Start,
+		Length:      diag.Length,
+		Line:        diag.Line,
+		Character:   diag.Column,
+		MessageText: diag.Message,
+	}
 }
 
 func apiOutputKey(cwd, fileName string) string {
-  // Relative keys are the API contract for files inside the project. Absolute
-  // keys are preserved for uncommon compiler outputs outside cwd.
-  if rel, err := filepath.Rel(cwd, fileName); err == nil && !isOutsideRelativePath(rel) {
-    return filepath.ToSlash(rel)
-  }
-  return filepath.ToSlash(fileName)
+	// Relative keys are the API contract for files inside the project. Absolute
+	// keys are preserved for uncommon compiler outputs outside cwd.
+	if rel, err := filepath.Rel(cwd, fileName); err == nil && !isOutsideRelativePath(rel) {
+		return filepath.ToSlash(rel)
+	}
+	return filepath.ToSlash(fileName)
 }
 
 func isOutsideRelativePath(rel string) bool {
-  return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
+	return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
 }

package/cmd/ttsc/api_transform.go

@@ -7,66 +7,69 @@
 package main
 
 import (
-  "encoding/json"
-  "flag"
-  "fmt"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
 
-  "github.com/samchon/ttsc/packages/ttsc/driver"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	cwdutil "github.com/samchon/ttsc/packages/ttsc/internal/cwd"
 )
 
 type apiTransformResult struct {
-  // TypeScript contains every non-library source file visible through the
-  // Program facade, keyed the same way api-compile keys emitted files.
-  Diagnostics []apiCompileDiagnostic `json:"diagnostics,omitempty"`
-  TypeScript  map[string]string      `json:"typescript"`
+	// TypeScript contains every non-library source file visible through the
+	// Program facade, keyed the same way api-compile keys emitted files.
+	Diagnostics []apiCompileDiagnostic `json:"diagnostics,omitempty"`
+	TypeScript  map[string]string      `json:"typescript"`
 }
 
 func runAPITransform(args []string) int {
-  fs := flag.NewFlagSet("api-transform", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
-  cwdOverride := fs.String("cwd", "", "override the working directory")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
+	fs := flag.NewFlagSet("api-transform", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
 
-  cwd, ok := resolveBuildCwd(*cwdOverride)
-  if !ok {
-    return 2
-  }
+	cwd, err := cwdutil.Resolve(*cwdOverride, os.Getwd)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc: %v\n", err)
+		return 2
+	}
 
-  prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-    ForceNoEmit: true,
-  })
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc api-transform: %v\n", err)
-    return 2
-  }
-  typescript := map[string]string{}
-  if prog != nil {
-    defer prog.Close()
-    for _, file := range prog.SourceFiles() {
-      typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
-    }
-    diags = append(diags, prog.Diagnostics()...)
-  }
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceNoEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc api-transform: %v\n", err)
+		return 2
+	}
+	typescript := map[string]string{}
+	if prog != nil {
+		defer prog.Close()
+		for _, file := range prog.SourceFiles() {
+			typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
+		}
+		diags = append(diags, prog.Diagnostics()...)
+	}
 
-  result := apiTransformResult{
-    Diagnostics: make([]apiCompileDiagnostic, 0, len(diags)),
-    TypeScript:  typescript,
-  }
-  for _, diag := range diags {
-    result.Diagnostics = append(result.Diagnostics, toAPICompileDiagnostic(diag))
-  }
+	result := apiTransformResult{
+		Diagnostics: make([]apiCompileDiagnostic, 0, len(diags)),
+		TypeScript:  typescript,
+	}
+	for _, diag := range diags {
+		result.Diagnostics = append(result.Diagnostics, toAPICompileDiagnostic(diag))
+	}
 
-  data, err := json.Marshal(result)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc api-transform: result marshal failed: %v\n", err)
-    return 3
-  }
-  fmt.Fprintln(stdout, string(data))
-  if driver.CountErrors(diags) > 0 {
-    return 2
-  }
-  return 0
+	data, err := json.Marshal(result)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc api-transform: result marshal failed: %v\n", err)
+		return 3
+	}
+	fmt.Fprintln(stdout, string(data))
+	if driver.CountErrors(diags) > 0 {
+		return 2
+	}
+	return 0
 }

package/cmd/ttsc/main.go

@@ -12,121 +12,103 @@
 package main
 
 import (
-  "flag"
-  "fmt"
-  "io"
-  "os"
-  "runtime"
-  "strings"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
 )
 
 // These are overridden via `-ldflags "-X main.version=... -X main.commit=..."`
 // in CI. Sensible defaults keep local `go run ./cmd/ttsc` usable.
 var (
-  version = "0.0.0-dev"
-  commit  = "dev"
-  date    = "unknown"
+	version = "0.0.0-dev"
+	commit  = "dev"
+	date    = "unknown"
 )
 
 // stdout / stderr are package-level to keep the CLI testable.
 var (
-  stdout io.Writer = os.Stdout
-  stderr io.Writer = os.Stderr
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
 )
 
 func main() {
-  os.Exit(run(os.Args[1:]))
+	os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-  if len(args) == 0 {
-    return runBuild(nil)
-  }
-
-  switch args[0] {
-  case "-h", "--help", "help":
-    printHelp(stdout)
-    return 0
-  case "-v", "--version", "version":
-    printVersion(stdout)
-    return 0
-  case "demo":
-    return runDemo(args[1:])
-  case "build":
-    return runBuild(args[1:])
-  case "api-compile":
-    return runAPICompile(args[1:])
-  case "api-transform":
-    return runAPITransform(args[1:])
-  case "check":
-    // `ttsc check` runs the analyze pipeline without emitting JS — useful
-    // in CI and pre-commit checks that only need schema validation.
-    return runBuild(append([]string{"--noEmit"}, args[1:]...))
-  case "-p", "--project":
-    if len(args) < 2 {
-      fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
-      return 2
-    }
-    return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
-  default:
-    if isBuildAlias(args[0]) {
-      return runBuild(args)
-    }
-    fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
-    fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
-    return 2
-  }
+	if len(args) == 0 {
+		return runBuild(nil)
+	}
+
+	switch args[0] {
+	case "-h", "--help", "help":
+		printHelp(stdout)
+		return 0
+	case "-v", "--version", "version":
+		printVersion(stdout)
+		return 0
+	case "demo":
+		return runDemo(args[1:])
+	case "build":
+		return runBuild(args[1:])
+	case "api-compile":
+		return runAPICompile(args[1:])
+	case "api-transform":
+		return runAPITransform(args[1:])
+	case "check":
+		// `ttsc check` runs the analyze pipeline without emitting JS — useful
+		// in CI and pre-commit checks that only need schema validation.
+		return runBuild(append([]string{"--noEmit"}, args[1:]...))
+	case "-p", "--project":
+		if len(args) < 2 {
+			fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
+			return 2
+		}
+		return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
+	default:
+		if isBuildAlias(args[0]) {
+			return runBuild(args)
+		}
+		fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
+		fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
+		return 2
+	}
 }
 
 func isBuildAlias(arg string) bool {
-  if strings.HasPrefix(arg, "-") {
-    return true
-  }
-  switch {
-  case strings.HasSuffix(arg, ".json"),
-    strings.HasSuffix(arg, ".ts"),
-    strings.HasSuffix(arg, ".tsx"),
-    strings.HasSuffix(arg, ".mts"),
-    strings.HasSuffix(arg, ".cts"):
-    return true
-  default:
-    return false
-  }
-}
-
-// appendUnique appends `extra` to `args` only when it's not already present.
-func appendUnique(args []string, extra ...string) []string {
-  out := append([]string{}, args...)
-  for _, e := range extra {
-    seen := false
-    for _, a := range out {
-      if a == e {
-        seen = true
-        break
-      }
-    }
-    if !seen {
-      out = append(out, e)
-    }
-  }
-  return out
+	if strings.HasPrefix(arg, "-") {
+		return true
+	}
+	switch {
+	case strings.HasSuffix(arg, ".json"),
+		strings.HasSuffix(arg, ".ts"),
+		strings.HasSuffix(arg, ".tsx"),
+		strings.HasSuffix(arg, ".mts"),
+		strings.HasSuffix(arg, ".cts"):
+		return true
+	default:
+		return false
+	}
 }
 
 func printVersion(w io.Writer) {
-  fmt.Fprintf(
-    w,
-    "ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
-    version,
-    commit,
-    date,
-    runtime.GOOS,
-    runtime.GOARCH,
-    runtime.Version(),
-  )
+	fmt.Fprintf(
+		w,
+		"ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
+		version,
+		commit,
+		date,
+		runtime.GOOS,
+		runtime.GOARCH,
+		runtime.Version(),
+	)
 }
 
 func printHelp(w io.Writer) {
-  fmt.Fprintln(w, strings.TrimSpace(`
+	fmt.Fprintln(w, strings.TrimSpace(`
 ttsc — standalone typescript-go host.
 
 Usage:
@@ -172,37 +154,37 @@ Integration guide (bundlers):
 }
 
 func runDemo(args []string) int {
-  fs := flag.NewFlagSet("demo", flag.ContinueOnError)
-  fs.SetOutput(stderr)
-  typ := fs.String("type", "string", "atomic type to simulate")
-  if err := fs.Parse(args); err != nil {
-    return 2
-  }
-
-  arrow, err := demoArrow(*typ)
-  if err != nil {
-    fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
-    return 2
-  }
-
-  fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
-  fmt.Fprintln(stdout, arrow)
-  return 0
+	fs := flag.NewFlagSet("demo", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	typ := fs.String("type", "string", "atomic type to simulate")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+
+	arrow, err := demoArrow(*typ)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
+		return 2
+	}
+
+	fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
+	fmt.Fprintln(stdout, arrow)
+	return 0
 }
 
 func demoArrow(name string) (string, error) {
-  switch strings.ToLower(name) {
-  case "any":
-    return "(input) => true", nil
-  case "boolean":
-    return `(input) => "boolean" === typeof input`, nil
-  case "number":
-    return `(input) => "number" === typeof input`, nil
-  case "bigint":
-    return `(input) => "bigint" === typeof input`, nil
-  case "string", "":
-    return `(input) => "string" === typeof input`, nil
-  default:
-    return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
-  }
+	switch strings.ToLower(name) {
+	case "any":
+		return "(input) => true", nil
+	case "boolean":
+		return `(input) => "boolean" === typeof input`, nil
+	case "number":
+		return `(input) => "number" === typeof input`, nil
+	case "bigint":
+		return `(input) => "bigint" === typeof input`, nil
+	case "string", "":
+		return `(input) => "string" === typeof input`, nil
+	default:
+		return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
+	}
 }

package/driver/program.go

@@ -85,7 +85,7 @@ func NewLintDiagnostic(
   if file != nil {
     d.File = file.FileName()
     if pos >= 0 {
-      length := end - pos
+      length := lint.Len()
       d.Start = &pos
       d.Length = &length
       line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
@@ -240,6 +240,9 @@ func ParseTSConfig(fs vfs.FS, cwd, tsconfigPath string, host shimcompiler.Compil
 
 // CreateProgramFromConfig builds a tsgo Program from the parsed config.
 func CreateProgramFromConfig(parsed *tsoptions.ParsedCommandLine, host shimcompiler.CompilerHost) (*shimcompiler.Program, []Diagnostic, error) {
+  if parsed == nil {
+    return nil, nil, errors.New("driver: nil parsed command line")
+  }
   opts := shimcompiler.ProgramOptions{
     Config:                      parsed,
     SingleThreaded:              core.TSTrue,
@@ -403,6 +406,9 @@ func ApplySourcePreamble(text string, preamble string) string {
 // files filtered out).
 func (p *Program) SourceFiles() []*ast.SourceFile {
   out := make([]*ast.SourceFile, 0)
+  if p == nil || p.TSProgram == nil {
+    return out
+  }
   for _, f := range p.TSProgram.SourceFiles() {
     if f.IsDeclarationFile {
       continue