ttsc 0.16.2 → 0.16.5

package/cmd/utility-host/main.go

@@ -28,6 +28,8 @@ func run(args []string) int {
     return utility.RunCheck(args[1:])
   case "transform":
     return utility.RunTransform(args[1:])
+  case "serve":
+    return utility.RunServe(os.Stdin, os.Stdout, args[1:])
   case "-h", "--help", "help":
     printHelp()
     return 0
@@ -45,5 +47,6 @@ func printHelp() {
 Usage:
   utility-host build --tsconfig=tsconfig.json --plugins-json='[...]'
   utility-host check --tsconfig=tsconfig.json --plugins-json='[...]'
-  utility-host transform --tsconfig=tsconfig.json --plugins-json='[...]'`)
+  utility-host transform --tsconfig=tsconfig.json --plugins-json='[...]'
+  utility-host serve --tsconfig=tsconfig.json --plugins-json='[...]'`)
 }

package/driver/overlay.go

@@ -0,0 +1,64 @@
+package driver
+
+import (
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  "github.com/microsoft/typescript-go/shim/vfs"
+)
+
+// OverlayFS layers in-memory file contents over an inner filesystem. Overridden
+// paths return the in-memory text from ReadFile and report present from
+// FileExists; every other operation delegates to the inner FS. A resident
+// Session or serve host uses this to feed a caller's unsaved buffer (for example
+// Metro's per-file src, or an editor's edited file) to the compiler without
+// writing to disk.
+type OverlayFS struct {
+  vfs.FS
+  caseSensitive bool
+  overrides     map[string]string
+}
+
+// NewOverlayFS returns an overlay over inner with no overrides set.
+func NewOverlayFS(inner vfs.FS) *OverlayFS {
+  return &OverlayFS{
+    FS:            inner,
+    caseSensitive: inner.UseCaseSensitiveFileNames(),
+    overrides:     map[string]string{},
+  }
+}
+
+// key normalizes a path the same way the compiler keys its files, so an
+// override registered for one spelling is found however the host asks for it.
+func (o *OverlayFS) key(path string) string {
+  return shimtspath.GetCanonicalFileName(shimtspath.NormalizePath(path), o.caseSensitive)
+}
+
+// Set records an in-memory override for path.
+func (o *OverlayFS) Set(path, content string) {
+  o.overrides[o.key(path)] = content
+}
+
+// Get returns the in-memory override for path, if one is set.
+func (o *OverlayFS) Get(path string) (string, bool) {
+  content, ok := o.overrides[o.key(path)]
+  return content, ok
+}
+
+// Unset removes the in-memory override for path, so reads fall back to the
+// inner filesystem.
+func (o *OverlayFS) Unset(path string) {
+  delete(o.overrides, o.key(path))
+}
+
+func (o *OverlayFS) ReadFile(path string) (string, bool) {
+  if content, ok := o.overrides[o.key(path)]; ok {
+    return content, true
+  }
+  return o.FS.ReadFile(path)
+}
+
+func (o *OverlayFS) FileExists(path string) bool {
+  if _, ok := o.overrides[o.key(path)]; ok {
+    return true
+  }
+  return o.FS.FileExists(path)
+}

package/driver/program.go

@@ -215,6 +215,10 @@ type LoadProgramOptions struct {
   // TypeScript-Go's own command-line parser into a CompilerOptions overlay
   // that wins over the tsconfig, exactly as `tsgo`'s CLI merges them.
   TsgoArgs []string
+  // FS overrides the filesystem the program is built on. When nil, DefaultFS
+  // is used. A resident Session passes an overlay FS so in-memory edits stay
+  // visible to the program and to incremental UpdateProgram calls.
+  FS vfs.FS
 }
 
 // Close releases the checker pool lease acquired by LoadProgram.
@@ -342,7 +346,10 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
   if preamble != "" {
     options.SourcePreamble += preamble
   }
-  fs := DefaultFS()
+  fs := options.FS
+  if fs == nil {
+    fs = DefaultFS()
+  }
   if options.SourcePreamble != "" {
     fs = sourcePreambleFS{
       FS:       fs,

package/driver/session.go

@@ -0,0 +1,85 @@
+package driver
+
+import (
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// Session is a resident compiler host for incremental type-checking: it keeps a
+// loaded program alive and re-parses only the changed file on each edit (reusing
+// the unchanged ASTs and the pinned checker through UpdateProgram), instead of
+// recompiling the whole project per request.
+//
+// It is the driver-level incremental type-check primitive. The resident
+// transform path (utility-host `serve`) deliberately does not use it: the
+// linked-plugin pass mutates source ASTs in place, so a transform cannot reuse a
+// warm clean program and must rebuild a fresh one per edit. Session therefore
+// provides type-check reuse, not transform reuse (samchon/ttsc#255).
+//
+// Construct one per project (cwd absolute), feed file edits through Apply, and
+// read the resident program's source through SourceText. Apply reuses the
+// existing program when the edited file's import/reference graph is unchanged.
+type Session struct {
+  cwd     string
+  overlay *OverlayFS
+  prog    *Program
+}
+
+// NewSession loads the project over an overlay filesystem and keeps the
+// resulting program resident. cwd must be absolute; tsconfig may be relative.
+func NewSession(cwd, tsconfig string, options LoadProgramOptions) (*Session, []Diagnostic, error) {
+  overlay := NewOverlayFS(DefaultFS())
+  options.FS = overlay
+  prog, diags, err := LoadProgram(cwd, tsconfig, options)
+  if err != nil {
+    return nil, diags, err
+  }
+  if prog == nil {
+    return nil, diags, nil
+  }
+  return &Session{cwd: cwd, overlay: overlay, prog: prog}, nil, nil
+}
+
+// Apply sets the in-memory content of one file and incrementally updates the
+// resident program. It returns whether the update reused the existing program
+// (true) or had to rebuild it because the file's import/reference graph changed
+// (false).
+func (s *Session) Apply(absPath, content string) bool {
+  s.overlay.Set(absPath, content)
+  name := absPath
+  if file := s.prog.SourceFile(absPath); file != nil {
+    name = file.FileName()
+  }
+  changed := shimtspath.ToPath(name, s.cwd, s.overlay.caseSensitive)
+  newHost := DefaultHost(s.cwd, s.overlay)
+  newProg, reused := s.prog.TSProgram.UpdateProgram(changed, newHost, nil)
+  if newProg != nil {
+    s.prog.TSProgram = newProg
+    s.prog.Host = newHost
+  }
+  return reused
+}
+
+// Program returns the resident program, reflecting every Apply so far. The
+// handle changes when an edit reshapes the import graph, so callers should read
+// it after Apply rather than caching it across edits.
+func (s *Session) Program() *Program {
+  return s.prog
+}
+
+// SourceText returns the source text the resident program currently holds for
+// absPath, or ("", false) when the program has no such file.
+func (s *Session) SourceText(absPath string) (string, bool) {
+  file := s.prog.SourceFile(absPath)
+  if file == nil {
+    return "", false
+  }
+  return file.Text(), true
+}
+
+// Close releases the resident program's resources.
+func (s *Session) Close() error {
+  if s.prog != nil {
+    return s.prog.Close()
+  }
+  return nil
+}

package/internal/graph/build.go

@@ -0,0 +1,330 @@
+package graph
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// Build walks the program's user-authored source files and records a node for
+// each top-level declaration. driver.SourceFiles already drops declaration files
+// and the program never compiles a dependency's `.ts`, so every node Build emits
+// is workspace source: External is false. External boundary leaves enter the
+// graph only as the resolved target of an edge (see Resolve).
+func Build(prog *driver.Program) *Graph {
+  g := &Graph{
+    Nodes:     map[string]*Node{},
+    bodyNodes: map[string]bool{},
+    seen:      map[string]struct{}{},
+  }
+  for _, file := range prog.SourceFiles() {
+    collectDeclarations(g, file)
+  }
+  g.addEdges(prog)
+  return g
+}
+
+// SourceTexts maps each program source file to its text — the evidence input
+// NewDump needs to turn a node or edge byte span into a line/column.
+func SourceTexts(prog *driver.Program) map[string]string {
+  files := prog.SourceFiles()
+  out := make(map[string]string, len(files))
+  for _, file := range files {
+    out[file.FileName()] = file.Text()
+  }
+  return out
+}
+
+// collectDeclarations records a node for each declaration statement in file,
+// plus a method node for each callable member of a class or interface, so
+// method-to-method calls have both endpoints. It descends into namespace bodies
+// so a `namespace X { … }` member is a node too, keyed by its namespace-qualified
+// name. This pass establishes the symbol nodes that cross-file edges connect.
+func collectDeclarations(g *Graph, file *shimast.SourceFile) {
+  if file.Statements == nil {
+    return
+  }
+  collectStatements(g, file.FileName(), file.Statements.Nodes)
+}
+
+// collectStatements records the nodes for a statement list — the file's top
+// level, or the body of a namespace it recurses into. A member's id is built
+// from its symbol, which already carries the enclosing namespace in its parent
+// chain, so a node recorded here and an edge target resolved later agree without
+// the walk having to thread the namespace name through.
+func collectStatements(g *Graph, path string, statements []*shimast.Node) {
+  for _, statement := range statements {
+    switch statement.Kind {
+    case shimast.KindFunctionDeclaration:
+      addNode(g, path, statement, NodeFunction)
+    case shimast.KindClassDeclaration:
+      addNode(g, path, statement, NodeClass)
+      collectMembers(g, path, statement)
+    case shimast.KindInterfaceDeclaration:
+      addNode(g, path, statement, NodeInterface)
+      collectMembers(g, path, statement)
+    case shimast.KindTypeAliasDeclaration:
+      addNode(g, path, statement, NodeTypeAlias)
+    case shimast.KindEnumDeclaration:
+      addNode(g, path, statement, NodeEnum)
+    case shimast.KindVariableStatement:
+      collectVariables(g, path, statement)
+    case shimast.KindModuleDeclaration:
+      // `namespace X { … }` — its members are declarations in their own right,
+      // so recurse into the body. The namespace itself is a grouping container,
+      // not a referenceable symbol the graph models as a node.
+      collectStatements(g, path, moduleStatements(statement))
+    }
+  }
+}
+
+// collectVariables records a variable node for each binding in a top-level
+// variable statement (both bindings of `const a = 1, b = 2`).
+func collectVariables(g *Graph, path string, statement *shimast.Node) {
+  variables := statement.AsVariableStatement()
+  if variables == nil || variables.DeclarationList == nil {
+    return
+  }
+  list := variables.DeclarationList.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil {
+    return
+  }
+  for _, binding := range list.Declarations.Nodes {
+    addNode(g, path, binding, NodeVariable)
+  }
+}
+
+// addNode records a node for the symbol declared by node under its
+// position-invariant id. A declaration the checker did not bind to a single
+// named symbol (a destructuring pattern) is skipped. Redeclarations keep the
+// first node except callable overload sets, where the implementation body
+// replaces earlier signature-only declarations so graph answers show executable
+// code instead of just the overload header.
+func addNode(g *Graph, path string, node *shimast.Node, kind NodeKind) {
+  symbol := node.Symbol()
+  if symbol == nil || symbol.Name == "" {
+    return
+  }
+  putDeclaredNode(g, path, qualifiedName(symbol), kind, node)
+}
+
+// collectMembers records callable members (method, constructor, accessor) and
+// property members of a class or interface declaration, keyed by their
+// class-qualified names so resolved member references land on the same node.
+func collectMembers(g *Graph, path string, statement *shimast.Node) {
+  for _, member := range classMembers(statement) {
+    name := methodName(member.Symbol())
+    if name == "" {
+      continue
+    }
+    switch {
+    case isMethodMember(member.Kind):
+      putDeclaredNode(g, path, name, NodeMethod, member)
+    case isPropertyMember(member.Kind):
+      putDeclaredNode(g, path, name, NodeVariable, member)
+    }
+  }
+}
+
+func putDeclaredNode(g *Graph, path, name string, kind NodeKind, declaration *shimast.Node) {
+  id := nodeID(path, name, kind)
+  hasBody := declarationHasImplementation(declaration, kind)
+  if _, exists := g.Nodes[id]; exists {
+    if !hasBody || g.bodyNodes[id] {
+      return
+    }
+  }
+  g.Nodes[id] = &Node{
+    ID:        id,
+    Name:      name,
+    Simple:    simpleName(declaration.Symbol()),
+    Kind:      kind,
+    File:      path,
+    Pos:       declaration.Pos(),
+    End:       declaration.End(),
+    Modifiers: declarationModifiers(declaration),
+  }
+  g.bodyNodes[id] = hasBody
+}
+
+// declarationModifiers maps a declaration's combined modifier flags onto the
+// wire-string subset of the TtscGraphNodeModifier union. Only flags with an
+// exact union member are emitted, in a stable order; an unknown string would
+// break the TypeScript-side typia.assert on the dump. It returns nil when the
+// declaration carries no recorded modifier.
+func declarationModifiers(declaration *shimast.Node) []string {
+  flags := shimast.GetCombinedModifierFlags(declaration)
+  if flags == shimast.ModifierFlagsNone {
+    return nil
+  }
+  var modifiers []string
+  for _, m := range modifierFlagStrings {
+    if flags&m.flag != 0 {
+      modifiers = append(modifiers, m.text)
+    }
+  }
+  return modifiers
+}
+
+// modifierFlagStrings is the ordered flag-to-wire-string table
+// declarationModifiers walks. The order fixes the emitted sequence so a dump is
+// deterministic; ModifierFlagsAmbient is the `declare` keyword.
+var modifierFlagStrings = []struct {
+  flag shimast.ModifierFlags
+  text string
+}{
+  {shimast.ModifierFlagsExport, "export"},
+  {shimast.ModifierFlagsDefault, "default"},
+  {shimast.ModifierFlagsAmbient, "declare"},
+  {shimast.ModifierFlagsAbstract, "abstract"},
+  {shimast.ModifierFlagsStatic, "static"},
+  {shimast.ModifierFlagsReadonly, "readonly"},
+  {shimast.ModifierFlagsAsync, "async"},
+  {shimast.ModifierFlagsConst, "const"},
+  {shimast.ModifierFlagsPublic, "public"},
+  {shimast.ModifierFlagsPrivate, "private"},
+  {shimast.ModifierFlagsProtected, "protected"},
+}
+
+func declarationHasImplementation(declaration *shimast.Node, kind NodeKind) bool {
+  switch kind {
+  case NodeFunction, NodeMethod:
+    return declaration.Body() != nil
+  default:
+    return false
+  }
+}
+
+// classMembers returns the member nodes of a class or interface declaration, or
+// nil for anything else.
+func classMembers(statement *shimast.Node) []*shimast.Node {
+  switch statement.Kind {
+  case shimast.KindClassDeclaration:
+    if decl := statement.AsClassDeclaration(); decl != nil && decl.Members != nil {
+      return decl.Members.Nodes
+    }
+  case shimast.KindInterfaceDeclaration:
+    if decl := statement.AsInterfaceDeclaration(); decl != nil && decl.Members != nil {
+      return decl.Members.Nodes
+    }
+  }
+  return nil
+}
+
+// isMethodMember reports whether a class/interface member kind is a callable the
+// graph models as a method node.
+func isMethodMember(kind shimast.Kind) bool {
+  switch kind {
+  case shimast.KindMethodDeclaration, shimast.KindMethodSignature,
+    shimast.KindConstructor, shimast.KindGetAccessor, shimast.KindSetAccessor:
+    return true
+  default:
+    return false
+  }
+}
+
+func isPropertyMember(kind shimast.Kind) bool {
+  switch kind {
+  case shimast.KindPropertyDeclaration, shimast.KindPropertySignature:
+    return true
+  default:
+    return false
+  }
+}
+
+// methodName returns the qualified, printable name of a method symbol
+// ("Class.method", or "Namespace.Class.method" for a method of a namespaced
+// class), or "" when it has no named parent (a synthesized member).
+// symbol.Parent is the class/interface symbol, set by the binder for every
+// member.
+func methodName(symbol *shimast.Symbol) string {
+  if symbol == nil || symbol.Name == "" || symbol.Parent == nil || symbol.Parent.Name == "" {
+    return ""
+  }
+  return qualifiedName(symbol)
+}
+
+// simpleName is the unqualified declared name of a symbol with no owner prefix,
+// the same form qualifiedName uses for the trailing member. A constructor's
+// internal-name prefix (\xFE) is escaped to "__" so the two agree.
+func simpleName(symbol *shimast.Symbol) string {
+  if symbol == nil || symbol.Name == "" {
+    return ""
+  }
+  return strings.ReplaceAll(symbol.Name, "\xFE", "__")
+}
+
+// qualifiedName is the identity name of a symbol: its own name, prefixed by the
+// dotted chain of every enclosing namespace and declaring class or interface. A
+// declaration at a module's top level has no such container, so its name is
+// returned unchanged, which keeps every existing top-level node id stable. A
+// constructor's internal-name prefix (\xFE) is escaped to "__".
+func qualifiedName(symbol *shimast.Symbol) string {
+  name := simpleName(symbol)
+  if name == "" {
+    return ""
+  }
+  if prefix := containerPrefix(symbol); prefix != "" {
+    return prefix + "." + name
+  }
+  return name
+}
+
+// containerPrefix returns the qualified name of symbol's enclosing namespace or
+// declaring class/interface, or "" at a module's top level. The source-file
+// module symbol is not a namespace — its declaration is the file, not a
+// `namespace` block — so a top-level declaration gets no prefix.
+func containerPrefix(symbol *shimast.Symbol) string {
+  parent := symbol.Parent
+  if parent == nil || parent.Name == "" {
+    return ""
+  }
+  if isNamespaceSymbol(parent) || isTypeContainerSymbol(parent) {
+    return qualifiedName(parent)
+  }
+  return ""
+}
+
+// isNamespaceSymbol reports whether symbol is declared by a `namespace` / `module`
+// block, the container whose members the graph qualifies by name. A string-named
+// ambient module (`declare module "x"`) and the `global` augmentation scope are
+// also module declarations, but qualifying members by their quoted or internal
+// names would produce malformed ids, so they are excluded.
+func isNamespaceSymbol(symbol *shimast.Symbol) bool {
+  if strings.HasPrefix(symbol.Name, "\"") || strings.Contains(symbol.Name, "\xFE") {
+    return false
+  }
+  for _, declaration := range symbol.Declarations {
+    if declaration.Kind == shimast.KindModuleDeclaration {
+      return true
+    }
+  }
+  return false
+}
+
+// isTypeContainerSymbol reports whether symbol is a class or interface, whose
+// members the graph qualifies ("Class.method").
+func isTypeContainerSymbol(symbol *shimast.Symbol) bool {
+  return symbol.Flags&(shimast.SymbolFlagsClass|shimast.SymbolFlagsInterface) != 0
+}
+
+// moduleStatements returns the member statements inside a namespace/module body,
+// or nil. `namespace A.B { … }` nests B's module declaration as A's body rather
+// than a block, so descend through any chained module declarations to reach the
+// block.
+func moduleStatements(statement *shimast.Node) []*shimast.Node {
+  body := statement.Body()
+  for body != nil && body.Kind == shimast.KindModuleDeclaration {
+    body = body.Body()
+  }
+  if body == nil || body.Kind != shimast.KindModuleBlock {
+    return nil
+  }
+  block := body.AsModuleBlock()
+  if block == nil || block.Statements == nil {
+    return nil
+  }
+  return block.Statements.Nodes
+}

package/internal/graph/build_records_a_node_per_top_level_declaration_test.go

@@ -0,0 +1,96 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// fixtureTSConfig is the minimal tsconfig the graph probes compile their
+// single-file fixtures with. ES2022 + commonjs keeps lib resolution light and
+// extensionless relative imports working.
+const fixtureTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.ts"]
+}
+`
+
+// TestBuildRecordsANodePerTopLevelDeclaration verifies that Build records one
+// graph node for each kind of top-level declaration, keyed by its
+// position-invariant id, and classifies workspace source as non-external.
+//
+// It pins the declaration-to-node mapping the rest of the graph is laid over: a
+// missing kind here is an edge with no endpoint later. driver.SourceFiles drops
+// declaration files, so every node must report External=false.
+//
+//  1. Compile a fixture with a function, class, interface, type alias, enum, and
+//     const declaration.
+//  2. Build the graph.
+//  3. Assert exactly those six nodes exist with the right kind and name, none
+//     marked external.
+func TestBuildRecordsANodePerTopLevelDeclaration(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function fn(): void {}
+export class Cls {}
+export interface Iface {}
+export type Alias = number;
+export enum En {
+  A,
+}
+export const value = 1;
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  want := map[string]NodeKind{
+    "fn":    NodeFunction,
+    "Cls":   NodeClass,
+    "Iface": NodeInterface,
+    "Alias": NodeTypeAlias,
+    "En":    NodeEnum,
+    "value": NodeVariable,
+  }
+  if len(graph.Nodes) != len(want) {
+    t.Fatalf("expected %d nodes, got %d: %v", len(want), len(graph.Nodes), nodeIDSet(graph))
+  }
+  for name, kind := range want {
+    id := nodeID(path, name, kind)
+    node, ok := graph.Nodes[id]
+    if !ok {
+      t.Fatalf("missing node for %s (%s); have %v", name, kind, nodeIDSet(graph))
+    }
+    if node.Name != name || node.Kind != kind {
+      t.Fatalf("node %s: got name=%q kind=%q", id, node.Name, node.Kind)
+    }
+    if node.External {
+      t.Fatalf("workspace declaration %s misclassified as external", id)
+    }
+  }
+}
+
+// nodeIDSet returns the graph's node ids as a slice for failure messages.
+func nodeIDSet(graph *Graph) []string {
+  ids := make([]string, 0, len(graph.Nodes))
+  for id := range graph.Nodes {
+    ids = append(ids, id)
+  }
+  return ids
+}