ttsc 0.12.2 → 0.12.4

package/cmd/ttsc/main.go

@@ -12,104 +12,108 @@
 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
-	getwd            = os.Getwd
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+  getwd            = os.Getwd
 )
 
 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
+  }
 }
 
+// isBuildAlias reports whether arg should be forwarded to runBuild without
+// requiring an explicit "build" verb. Any flag-shaped argument (leading "-")
+// or a TypeScript-project file extension is treated as a build alias, matching
+// the tsc/tsgo invocation convention.
 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
-	}
+  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:
@@ -155,37 +159,40 @@ 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
 }
 
+// demoArrow returns a JavaScript arrow-function expression that validates the
+// named atomic TypeScript type at runtime. Used by the demo sub-command to
+// produce a small synthetic emit that smoke tests can assert on.
 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/cmd/ttsc/main_alias_branches_test.go

@@ -2,28 +2,26 @@ package main
 
 import "testing"
 
-/**
- * Verifies main command aliases cover flag-shaped demo and cts project inputs.
- *
- * The top-level dispatcher treats extension-shaped arguments as build aliases
- * while demo owns its own flag parser. These small branches keep compatibility
- * with `ttsc ./tsconfig.cts`-style invocations and malformed demo flags.
- *
- * 1. Run demo with a missing flag value.
- * 2. Dispatch a `.cts` argument through the build alias path.
- * 3. Assert both routes fail through their intended parser.
- */
+// TestMainAliasBranches verifies main command aliases cover flag-shaped demo and cts project inputs.
+//
+// The top-level dispatcher treats extension-shaped arguments as build aliases
+// while demo owns its own flag parser. These small branches keep compatibility
+// with `ttsc ./tsconfig.cts`-style invocations and malformed demo flags.
+//
+// 1. Run demo with a missing flag value.
+// 2. Dispatch a `.cts` argument through the build alias path.
+// 3. Assert both routes fail through their intended parser.
 func TestMainAliasBranches(t *testing.T) {
-	code, _, _ := captureCommand(t, func() int {
-		return run([]string{"demo", "--type"})
-	})
-	if code != 2 {
-		t.Fatalf("demo flag status mismatch: %d", code)
-	}
-	code, _, _ = captureCommand(t, func() int {
-		return run([]string{"project.cts"})
-	})
-	if code != 2 {
-		t.Fatalf("cts build alias status mismatch: %d", code)
-	}
+  code, _, _ := captureCommand(t, func() int {
+    return run([]string{"demo", "--type"})
+  })
+  if code != 2 {
+    t.Fatalf("demo flag status mismatch: %d", code)
+  }
+  code, _, _ = captureCommand(t, func() int {
+    return run([]string{"project.cts"})
+  })
+  if code != 2 {
+    t.Fatalf("cts build alias status mismatch: %d", code)
+  }
 }

package/cmd/ttscserver/main.go

@@ -12,34 +12,34 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"os/signal"
-	"runtime"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+  "context"
+  "errors"
+  "flag"
+  "fmt"
+  "io"
+  "os"
+  "os/signal"
+  "runtime"
+  "strings"
+  "syscall"
+  "time"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // Build metadata; overwritten via -ldflags in release builds.
 var (
-	version = "0.0.0-dev"
-	commit  = "dev"
-	date    = "unknown"
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
 )
 
 // Package-level writers so command tests can capture output without
 // patching os.Stdout / os.Stderr globally.
 var (
-	stdout io.Writer = os.Stdout
-	stderr io.Writer = os.Stderr
-	stdin  io.Reader = os.Stdin
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+  stdin  io.Reader = os.Stdin
 )
 
 // runLSPServer is the seam command tests use to substitute a fake LSP
@@ -56,89 +56,95 @@ var notifyContext = signal.NotifyContext
 var getwd = os.Getwd
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
+// run dispatches top-level subcommands/flags and returns an exit code.
+// Called by main with os.Args[1:] and overridden in tests with a synthetic
+// argument slice to avoid spawning a real tsgo process.
 func run(args []string) int {
-	if len(args) == 0 {
-		printHelp(stdout)
-		return 0
-	}
-	switch args[0] {
-	case "-h", "--help", "help":
-		printHelp(stdout)
-		return 0
-	case "-v", "--version", "version":
-		printVersion(stdout)
-		return 0
-	}
-	return runLSP(args)
+  if len(args) == 0 {
+    printHelp(stdout)
+    return 0
+  }
+  switch args[0] {
+  case "-h", "--help", "help":
+    printHelp(stdout)
+    return 0
+  case "-v", "--version", "version":
+    printVersion(stdout)
+    return 0
+  }
+  return runLSP(args)
 }
 
+// runLSP parses LSP-mode flags and starts the proxy. It returns 0 on clean
+// shutdown, 1 on a runtime error from the LSP host, and 2 on invalid
+// invocation (missing --stdio, unresolvable cwd, unknown flags).
 func runLSP(args []string) int {
-	fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
-	cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
-	tsgoFlag := fs.String("tsgo", "", "absolute tsgo binary path (defaults to TTSC_TSGO_BINARY)")
-	progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if !*stdioFlag {
-		fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
-		return 2
-	}
-
-	cwd := strings.TrimSpace(*cwdFlag)
-	if cwd == "" {
-		resolved, err := getwd()
-		if err != nil {
-			fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
-			return 2
-		}
-		cwd = resolved
-	}
-
-	ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-	defer stop()
-
-	tsgoBinary := strings.TrimSpace(*tsgoFlag)
-	if tsgoBinary == "" {
-		tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
-	}
-
-	err := runLSPServer(ctx, lspserver.LSPServerOptions{
-		In:            stdin,
-		Out:           stdout,
-		Err:           stderr,
-		Cwd:           cwd,
-		TsgoBinary:    tsgoBinary,
-		Source:        lspserver.NullPluginSource{},
-		ProgressDelay: *progressDelayFlag,
-	})
-	if err != nil && !errors.Is(err, context.Canceled) {
-		fmt.Fprintf(stderr, "ttscserver: %v\n", err)
-		return 1
-	}
-	return 0
+  fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
+  cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
+  tsgoFlag := fs.String("tsgo", "", "absolute tsgo binary path (defaults to TTSC_TSGO_BINARY)")
+  progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+  if !*stdioFlag {
+    fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
+    return 2
+  }
+
+  cwd := strings.TrimSpace(*cwdFlag)
+  if cwd == "" {
+    resolved, err := getwd()
+    if err != nil {
+      fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
+      return 2
+    }
+    cwd = resolved
+  }
+
+  ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+  defer stop()
+
+  tsgoBinary := strings.TrimSpace(*tsgoFlag)
+  if tsgoBinary == "" {
+    tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
+  }
+
+  err := runLSPServer(ctx, lspserver.LSPServerOptions{
+    In:            stdin,
+    Out:           stdout,
+    Err:           stderr,
+    Cwd:           cwd,
+    TsgoBinary:    tsgoBinary,
+    Source:        lspserver.NullPluginSource{},
+    ProgressDelay: *progressDelayFlag,
+  })
+  if err != nil && !errors.Is(err, context.Canceled) {
+    fmt.Fprintf(stderr, "ttscserver: %v\n", err)
+    return 1
+  }
+  return 0
 }
 
 func printVersion(w io.Writer) {
-	fmt.Fprintf(
-		w,
-		"ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
-		version,
-		commit,
-		date,
-		runtime.GOOS,
-		runtime.GOARCH,
-		runtime.Version(),
-	)
+  fmt.Fprintf(
+    w,
+    "ttscserver %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(`
 ttscserver — Language Server Protocol host for ttsc.
 
 Usage:

package/cmd/ttscserver/run_lsp_prefers_tsgo_flag_test.go

@@ -1,11 +1,11 @@
 package main
 
 import (
-	"bytes"
-	"context"
-	"testing"
+  "bytes"
+  "context"
+  "testing"
 
-	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // TestRunLSPPrefersTsgoFlag verifies the native command forwards an explicit
@@ -19,24 +19,24 @@ import (
 // 2. Run runLSP with --stdio, --cwd, and --tsgo.
 // 3. Assert the captured TsgoBinary is the flag value.
 func TestRunLSPPrefersTsgoFlag(t *testing.T) {
-	const expected = "/tmp/tsgo-test-binary"
-	prev := runLSPServer
-	var captured lspserver.LSPServerOptions
-	runLSPServer = func(_ context.Context, opts lspserver.LSPServerOptions) error {
-		captured = opts
-		return nil
-	}
-	defer func() { runLSPServer = prev }()
+  const expected = "/tmp/tsgo-test-binary"
+  prev := runLSPServer
+  var captured lspserver.LSPServerOptions
+  runLSPServer = func(_ context.Context, opts lspserver.LSPServerOptions) error {
+    captured = opts
+    return nil
+  }
+  defer func() { runLSPServer = prev }()
 
-	outBuf := &bytes.Buffer{}
-	errBuf := &bytes.Buffer{}
-	withIO(t, outBuf, errBuf, nil, func() {
-		if code := runLSP([]string{"--stdio", "--cwd", t.TempDir(), "--tsgo", expected}); code != 0 {
-			t.Fatalf("expected exit 0, got %d (stderr=%q)", code, errBuf.String())
-		}
-	})
+  outBuf := &bytes.Buffer{}
+  errBuf := &bytes.Buffer{}
+  withIO(t, outBuf, errBuf, nil, func() {
+    if code := runLSP([]string{"--stdio", "--cwd", t.TempDir(), "--tsgo", expected}); code != 0 {
+      t.Fatalf("expected exit 0, got %d (stderr=%q)", code, errBuf.String())
+    }
+  })
 
-	if captured.TsgoBinary != expected {
-		t.Fatalf("expected TsgoBinary %q, got %q", expected, captured.TsgoBinary)
-	}
+  if captured.TsgoBinary != expected {
+    t.Fatalf("expected TsgoBinary %q, got %q", expected, captured.TsgoBinary)
+  }
 }

package/cmd/ttscserver/run_lsp_reports_server_error_test.go

@@ -1,13 +1,13 @@
 package main
 
 import (
-	"bytes"
-	"context"
-	"errors"
-	"strings"
-	"testing"
+  "bytes"
+  "context"
+  "errors"
+  "strings"
+  "testing"
 
-	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // TestRunLSPReportsServerError pins the non-cancellation error path in
@@ -19,22 +19,22 @@ import (
 // 2. Run runLSP with --stdio --cwd <tempdir>.
 // 3. Assert exit 1 and the sentinel text on stderr.
 func TestRunLSPReportsServerError(t *testing.T) {
-	sentinel := errors.New("lsp host blew up")
-	prev := runLSPServer
-	runLSPServer = func(_ context.Context, _ lspserver.LSPServerOptions) error {
-		return sentinel
-	}
-	defer func() { runLSPServer = prev }()
+  sentinel := errors.New("lsp host blew up")
+  prev := runLSPServer
+  runLSPServer = func(_ context.Context, _ lspserver.LSPServerOptions) error {
+    return sentinel
+  }
+  defer func() { runLSPServer = prev }()
 
-	outBuf := &bytes.Buffer{}
-	errBuf := &bytes.Buffer{}
-	withIO(t, outBuf, errBuf, nil, func() {
-		if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 1 {
-			t.Fatalf("expected exit 1, got %d", code)
-		}
-	})
+  outBuf := &bytes.Buffer{}
+  errBuf := &bytes.Buffer{}
+  withIO(t, outBuf, errBuf, nil, func() {
+    if code := runLSP([]string{"--stdio", "--cwd", t.TempDir()}); code != 1 {
+      t.Fatalf("expected exit 1, got %d", code)
+    }
+  })
 
-	if !strings.Contains(errBuf.String(), sentinel.Error()) {
-		t.Fatalf("expected sentinel on stderr, got: %q", errBuf.String())
-	}
+  if !strings.Contains(errBuf.String(), sentinel.Error()) {
+    t.Fatalf("expected sentinel on stderr, got: %q", errBuf.String())
+  }
 }