ttsc 0.19.2 → 0.20.0

package/README.md

@@ -75,15 +75,17 @@ let total = count;
 
 ```text
 $ npx ttsc --noEmit
+src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
+
+1 var count = 3;
+  ~~~
+
 src/index.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
 
 2 let total = count;
-      ~~~~~~~~~~~~~
+    ~~~~~
 
-src/index.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
-
-1 var count = 3;
-  ~~~~~~~~~~~~~~
+Found 2 errors in the same file, starting at: src/index.ts:1
 ```
 
 Clean the project in place:

package/cmd/graphdump/main.go

@@ -28,9 +28,8 @@ func run() int {
   flag.Parse()
 
   // Resolve the project root the same way LoadProgram does (absolute, then
-  // tsgo-normalized) so it shares the node file paths' drive-letter case on
-  // Windows; otherwise the dump's prefix-based relativization would miss and
-  // leave every path absolute.
+  // tsgo-normalized) so the schema-v6 mapper receives the same canonical root
+  // grammar and drive-letter case as the compiler's source paths.
   root := *cwd
   if abs, err := filepath.Abs(root); err == nil {
     root = abs
@@ -60,7 +59,6 @@ func run() int {
   // `ttscgraph dump` is the one that proves the whole contract.
   data, err := graph.MarshalDump(g, root, *tsconfig, ignored, texts, graph.DumpOrigin{
     Provenance: graph.NewProvenance(
-      root,
       // No version: this tool is built from the tree on demand and never
       // stamped, and an invented one would be worse than an absent one.
       graph.Producer{Tool: "graphdump", Typescript: graph.TypescriptVersion()},

package/cmd/ttsc/filter.go

@@ -59,12 +59,20 @@ func filterHostArgs(args []string) []string {
   return filtered
 }
 
-// splitFlagName strips the leading `--` from a flag argument and reports
-// whether the argument carries an inline value (`--foo=value`).
+// splitFlagName strips the leading `--` from a flag argument, lower-cases the
+// result, and reports whether the argument carries an inline value
+// (`--foo=value`).
+//
+// Lower-casing is the same normalization `normalizeFlagToken` in
+// `packages/ttsc/src/flags/schema.ts` applies, and the generated
+// `HostFlagAllowList` keys are produced by it. TypeScript's option parser
+// matches option names case-insensitively, so keying this lookup on the exact
+// spelling would make the Go layer stop recognising a flag the launcher and the
+// compiler both resolve.
 func splitFlagName(arg string) (string, bool) {
   name := strings.TrimPrefix(arg, "--")
   if i := strings.IndexByte(name, '='); i != -1 {
-    return name[:i], true
+    return strings.ToLower(name[:i]), true
   }
-  return name, false
+  return strings.ToLower(name), false
 }

package/cmd/ttsc/filter_resolves_flag_names_case_insensitively_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestFilterHostArgsResolvesFlagNamesCaseInsensitively verifies the host
+// allow-list lookup applies the same flag-name normalization the schema uses
+// when it generates that allow-list.
+//
+// TypeScript's option parser matches option names case-insensitively, and
+// `normalizeFlagToken` in `packages/ttsc/src/flags/schema.ts` is the one
+// normalization every layer keys off — including `buildGoAllowList`, whose
+// output is `flags_gen.go`. Keying this lookup on the exact spelling while the
+// generated keys are normalized would recreate the split-brain one layer
+// further down: a flag the launcher and the compiler both resolve would be
+// dropped here, silently taking the following token with it.
+//
+//  1. A case-variant known flag survives with its value.
+//  2. A case-variant boolean known flag survives and does not eat the next token.
+//  3. An unknown flag is still dropped in every casing, with its value.
+func TestFilterHostArgsResolvesFlagNamesCaseInsensitively(t *testing.T) {
+  cases := []struct {
+    name string
+    in   []string
+    want []string
+  }{
+    {
+      name: "keeps a case-variant value flag with its value",
+      in:   []string{"--TSCONFIG", "tsconfig.json", "--CWD=."},
+      want: []string{"--TSCONFIG", "tsconfig.json", "--CWD=."},
+    },
+    {
+      name: "keeps a case-variant boolean flag without eating the next token",
+      in:   []string{"--NOEMIT", "--tsconfig", "tsconfig.json"},
+      want: []string{"--NOEMIT", "--tsconfig", "tsconfig.json"},
+    },
+    {
+      name: "still drops an unknown flag in any casing",
+      in:   []string{"--tsconfig=tsconfig.json", "--sTrIcT", "true"},
+      want: []string{"--tsconfig=tsconfig.json"},
+    },
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      got := filterHostArgs(tc.in)
+      if !reflect.DeepEqual(got, tc.want) {
+        t.Fatalf("filterHostArgs(%v):\n  want %v\n  got  %v", tc.in, tc.want, got)
+      }
+    })
+  }
+}

package/cmd/ttsc/flags_gen.go

@@ -17,13 +17,13 @@ var HostFlagAllowList = map[string]bool{
   "cwd":            true,
   "emit":           false,
   "manifest":       true,
-  "noEmit":         false,
-  "outDir":         true,
+  "noemit":         false,
+  "outdir":         true,
   "p":              true,
   "plugins-json":   true,
   "project":        true,
   "quiet":          false,
-  "singleThreaded": false,
+  "singlethreaded": false,
   "tsconfig":       true,
   "tsgo-args":      true,
   "verbose":        false,

package/cmd/ttscgraph/dump.go

@@ -37,9 +37,8 @@ func runDump(args []string) int {
     cwd = resolved
   }
   // Resolve the project root the same way LoadProgram does (absolute, then
-  // tsgo-normalized) so it shares the node file paths' drive-letter case on
-  // Windows; otherwise the dump's prefix-based relativization would miss and
-  // leave every path absolute.
+  // tsgo-normalized) so the schema-v6 mapper receives the same canonical root
+  // grammar and drive-letter case as the compiler's source paths.
   if abs, err := filepath.Abs(cwd); err == nil {
     cwd = abs
   }
@@ -60,7 +59,7 @@ func runDump(args []string) int {
   g := graph.Build(prog)
   ignored := graph.GitIgnoredFiles(cwd, g)
   texts := graph.SourceTexts(prog)
-  origin, err := dumpOrigin(prog, cwd, texts)
+  origin, err := dumpOrigin(prog, texts)
   if err != nil {
     fmt.Fprintf(stderr, "ttscgraph: %v\n", err)
     return 1
@@ -90,7 +89,7 @@ func runDump(args []string) int {
 // saw the project, so it carries the same provenance a served snapshot does:
 // without it the file is a pile of facts with no way to tell which program, or
 // which day, they describe.
-func dumpOrigin(prog *driver.Program, cwd string, texts map[string]string) (graph.DumpOrigin, error) {
+func dumpOrigin(prog *driver.Program, texts map[string]string) (graph.DumpOrigin, error) {
   configs, err := parsedConfigs(prog)
   if err != nil {
     return graph.DumpOrigin{}, err
@@ -105,7 +104,6 @@ func dumpOrigin(prog *driver.Program, cwd string, texts map[string]string) (grap
   }
   return graph.DumpOrigin{
     Provenance: graph.NewProvenance(
-      cwd,
       serveProducer(),
       fullSnapshotCapabilities,
       fileDigests(configHashes),
@@ -113,6 +111,6 @@ func dumpOrigin(prog *driver.Program, cwd string, texts map[string]string) (grap
       texts,
       diskDigests,
     ),
-    Diagnostics: graph.NewDiagnostics(prog, cwd),
+    Diagnostics: graph.NewDiagnostics(prog),
   }, nil
 }

package/cmd/ttscgraph/run_dump_emits_only_checker_verified_member_relations_test.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestRunDumpEmitsOnlyCheckerVerifiedMemberRelations verifies the shipped dump
+// command serializes native member facts and does not revive a rejected pair.
+//
+// The graph reader no longer synthesizes member edges from equal names, so the
+// command boundary must prove all three layers together: compiler diagnostics,
+// native pair validation, and the public implements/overrides wire vocabulary.
+//
+//  1. Dump a program with one valid and one TS2416-invalid implementation.
+//  2. Locate the container and member nodes in the serialized document.
+//  3. Require the valid member edge and its evidence, reject the invalid edge,
+//     and ensure the internal native edge kind never reaches JSON.
+func TestRunDumpEmitsOnlyCheckerVerifiedMemberRelations(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.ts"]
+}
+`)
+  writeGraphFile(t, filepath.Join(root, "src", "main.ts"), `export interface Contract {
+  execute(input: number): void;
+}
+export class Good implements Contract {
+  execute(input: number): void {}
+}
+export class Bad implements Contract {
+  execute(input: string): void {}
+}
+`)
+
+  oldStdout, oldStderr := stdout, stderr
+  defer func() { stdout, stderr = oldStdout, oldStderr }()
+  var out, errBuf bytes.Buffer
+  stdout, stderr = &out, &errBuf
+
+  if code := run([]string{"dump", "--cwd", root, "--tsconfig", "tsconfig.json"}); code != 0 {
+    t.Fatalf("run dump exit = %d, want 0; stderr:\n%s", code, errBuf.String())
+  }
+  if bytes.Contains(out.Bytes(), []byte("member-relation")) {
+    t.Fatalf("internal edge kind leaked into the public dump:\n%s", out.String())
+  }
+
+  var dump graph.Dump
+  if err := json.Unmarshal(out.Bytes(), &dump); err != nil {
+    t.Fatalf("dump output is not valid JSON: %v\n%s", err, out.String())
+  }
+  seen2416 := false
+  for _, diagnostic := range dump.Diagnostics {
+    seen2416 = seen2416 || diagnostic.Code == 2416
+  }
+  if !seen2416 {
+    t.Fatalf("fixture must retain TS2416 in the same snapshot: %v", dump.Diagnostics)
+  }
+
+  node := func(name, kind string) *graph.DumpNode {
+    t.Helper()
+    for i := range dump.Nodes {
+      candidate := &dump.Nodes[i]
+      declaredName := candidate.QualifiedName
+      if declaredName == "" {
+        declaredName = candidate.Name
+      }
+      if declaredName == name && candidate.Kind == kind {
+        return candidate
+      }
+    }
+    t.Fatalf("missing %s %s; nodes: %v", kind, name, dump.Nodes)
+    return nil
+  }
+  contract := node("Contract", "interface")
+  good := node("Good", "class")
+  contractExecute := node("Contract.execute", "method")
+  goodExecute := node("Good.execute", "method")
+  badExecute := node("Bad.execute", "method")
+
+  countEdge := func(from, to, kind string) int {
+    count := 0
+    for _, edge := range dump.Edges {
+      if edge.From == from && edge.To == to && edge.Kind == kind {
+        count++
+      }
+    }
+    return count
+  }
+  if count := countEdge(good.ID, contract.ID, "implements"); count != 1 {
+    t.Fatalf("container implementation edge count = %d, want 1; edges: %v", count, dump.Edges)
+  }
+  if count := countEdge(goodExecute.ID, contractExecute.ID, "implements"); count != 1 {
+    t.Fatalf("valid member implementation edge count = %d, want 1; edges: %v", count, dump.Edges)
+  }
+  if count := countEdge(badExecute.ID, contractExecute.ID, "implements"); count != 0 {
+    t.Fatalf("checker-invalid member implementation edge count = %d, want 0; edges: %v", count, dump.Edges)
+  }
+  for _, edge := range dump.Edges {
+    if edge.From == goodExecute.ID && edge.To == contractExecute.ID && edge.Kind == "implements" {
+      if edge.Evidence == nil || goodExecute.Evidence == nil ||
+        edge.Evidence.StartLine != goodExecute.Evidence.StartLine {
+        t.Fatalf("member edge evidence does not identify Good.execute: edge=%v node=%v", edge.Evidence, goodExecute.Evidence)
+      }
+    }
+  }
+}