ttsc 0.33.0 → 0.34.0

package/targets/7.1/facade/vfs/osvfs/facade_gen.go

@@ -0,0 +1,20 @@
+// Code generated by packages/ttsc/tools/gen_facade. DO NOT EDIT.
+
+// Package osvfs is the documented github.com/microsoft/typescript-go/shim/vfs/osvfs plugin import path.
+// It aliases every exported identity of github.com/microsoft/TypeScript/tsc/shim/vfs/osvfs, the
+// bridge that reaches the compiler's internal packages.
+package osvfs
+
+import (
+  tsctspath "github.com/microsoft/TypeScript/tsc/shim/tspath"
+  tscvfs "github.com/microsoft/TypeScript/tsc/shim/vfs"
+  tscosvfs "github.com/microsoft/TypeScript/tsc/shim/vfs/osvfs"
+)
+
+func FS() tscvfs.FS {
+  return tscosvfs.FS()
+}
+
+func GetGlobalTypingsCacheLocation() tsctspath.RootedDirectoryPath {
+  return tscosvfs.GetGlobalTypingsCacheLocation()
+}

package/targets/7.1/facade/vfs/osvfs/go.mod

@@ -0,0 +1,21 @@
+module github.com/microsoft/typescript-go/shim/vfs/osvfs
+
+go 1.27
+
+require (
+	github.com/microsoft/TypeScript/tsc/shim/tspath v0.0.0
+	github.com/microsoft/TypeScript/tsc/shim/vfs v0.0.0
+	github.com/microsoft/TypeScript/tsc/shim/vfs/osvfs v0.0.0
+)
+
+require (
+	github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906 // indirect
+	golang.org/x/sync v0.23.0 // indirect
+	golang.org/x/sys v0.48.0 // indirect
+)
+
+replace github.com/microsoft/TypeScript/tsc/shim/vfs => ../../../bridge/vfs
+
+replace github.com/microsoft/TypeScript/tsc/shim/vfs/osvfs => ../../../bridge/vfs/osvfs
+
+replace github.com/microsoft/TypeScript/tsc/shim/tspath => ../../../bridge/tspath

package/targets/7.1/facade/vfs/osvfs/go.sum

@@ -0,0 +1,10 @@
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906 h1:Wn+Kp4ORyay6jJwvOng7G8pTD6HOP+Fwx8si66Wq7Bk=
+github.com/microsoft/TypeScript/tsc v0.0.0-20261019224239-28534d760906/go.mod h1:28hWKaTYwRARPm0T9Y0XvdvYpU2HtjONzsMqAdYLucY=
+golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
+golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
+golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
+golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=

package/tools/gen_facade/committed_facades_match_their_bridges_test.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+  "bytes"
+  "os"
+  "path/filepath"
+  "testing"
+)
+
+// Verifies every committed TypeScript 7.1 facade is the generator's output for
+// the current bridges, and no facade outlives its bridge.
+//
+// A bridge edit that adds, renames or removes an export changes the documented
+// plugin surface; this gate makes that drift fail instead of shipping silently.
+//
+//  1. Load every real bridge module below packages/ttsc/targets/7.1/bridge.
+//  2. Render each facade and its go.mod in memory.
+//  3. Compare with the committed files, in both directions.
+//
+// Adapted from Danny Wilson's TypeScript 7.1 port (#1727).
+//
+// @evidence contracts/testing.md#behavioral-verification Runs the production generate over the real bridge modules and compares exact bytes with each committed facade_gen.go and go.mod.
+// @evidence contracts/testing.md#independent-expectations The committed files are the reviewed public surface; the generator must reproduce them rather than the test deriving its expectation from the same run.
+// @evidence contracts/testing.md#distinguishing-cases A stale facade, a missing facade and an orphaned facade without a bridge each fail with their own message.
+// @evidence contracts/testing.md#execution-ownership This tools/gen_facade unit loads the repository's bridge modules through go/packages in its own process and writes no file.
+func TestCommittedFacadesMatchTheirBridges(t *testing.T) {
+  target := filepath.Join("..", "..", "targets", "7.1")
+  facadeRoot := filepath.Join(target, "facade")
+  outputs, err := generate(filepath.Join(target, "bridge"), facadeRoot)
+  if err != nil {
+    t.Fatal(err)
+  }
+  generated := map[string]bool{}
+  for _, output := range outputs {
+    generated[output.path] = true
+    current, err := os.ReadFile(output.path)
+    if err != nil {
+      t.Errorf("missing facade file %s: %v", output.path, err)
+      continue
+    }
+    if !bytes.Equal(current, output.source) {
+      t.Errorf("stale facade file %s; run go -C tools/gen_facade run .", output.path)
+    }
+  }
+  err = filepath.WalkDir(facadeRoot, func(path string, entry os.DirEntry, err error) error {
+    if err != nil {
+      return err
+    }
+    if name := entry.Name(); !entry.IsDir() && (name == outputName || name == "go.mod") && !generated[path] {
+      t.Errorf("facade file %s has no bridge", path)
+    }
+    return nil
+  })
+  if err != nil {
+    t.Fatal(err)
+  }
+}

package/tools/gen_facade/facade_manifest_points_into_the_bridge_root_test.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "golang.org/x/mod/modfile"
+)
+
+// Verifies a facade manifest requires and replaces exactly the bridges its
+// facade imports, each replacement relative from the facade into the bridge root.
+//
+// Facades and bridges live in sibling roots of one compiler target. A replace
+// path computed from the facade's own depth alone would point outside the
+// bridge root for a nested facade such as vfs/cachedvfs.
+//
+//  1. Write a nested facade go.mod that still requires and replaces a bridge it
+//     no longer imports, beside an unrelated requirement.
+//  2. Build its manifest for the two bridges it now imports.
+//  3. Parse the result and compare its requirements and replacements.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls the production facadeManifest over a real go.mod file and parses its output with x/mod, asserting module, requirements and replacement targets.
+// @evidence contracts/testing.md#independent-expectations The expected replacement paths follow from the authored sibling layout, three levels up from targets/7.1/facade/vfs/cachedvfs and into bridge/, not from the generator's output.
+// @evidence contracts/testing.md#distinguishing-cases A stale bridge requirement and replacement must be dropped, two imported bridges at different depths must be added, and an unrelated requirement must survive.
+// @evidence contracts/testing.md#execution-ownership This tools/gen_facade unit writes one temporary go.mod and reads it in process; it loads no package and starts no process.
+func TestFacadeManifestPointsIntoTheBridgeRoot(t *testing.T) {
+  target := t.TempDir()
+  bridgeRoot := filepath.Join(target, "bridge")
+  facadeDir := filepath.Join(target, "facade", "vfs", "cachedvfs")
+  if err := os.MkdirAll(facadeDir, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  manifestPath := filepath.Join(facadeDir, "go.mod")
+  stale := bridgePrefix + "tspath"
+  if err := os.WriteFile(manifestPath, []byte("module "+facadePrefix+"vfs/cachedvfs\n\ngo 1.27\n\nrequire (\n\t"+stale+" v0.0.0\n\texample.com/kept v1.2.3\n)\n\nreplace "+stale+" => ../../../bridge/tspath\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+
+  source, err := facadeManifest(manifestPath, "vfs/cachedvfs", bridgeRoot, []string{bridgePrefix + "vfs/cachedvfs", bridgePrefix + "vfs"})
+  if err != nil {
+    t.Fatal(err)
+  }
+  file, err := modfile.Parse(manifestPath, source, nil)
+  if err != nil {
+    t.Fatal(err)
+  }
+  requires := map[string]string{}
+  for _, require := range file.Require {
+    requires[require.Mod.Path] = require.Mod.Version
+  }
+  replaces := map[string]string{}
+  for _, replace := range file.Replace {
+    replaces[replace.Old.Path] = replace.New.Path
+  }
+  want := map[string]string{
+    bridgePrefix + "vfs/cachedvfs": "../../../bridge/vfs/cachedvfs",
+    bridgePrefix + "vfs":           "../../../bridge/vfs",
+  }
+  for bridge, path := range want {
+    if requires[bridge] != "v0.0.0" || replaces[bridge] != path {
+      t.Errorf("%s: require %q, replace %q; want v0.0.0 and %q", bridge, requires[bridge], replaces[bridge], path)
+    }
+  }
+  if _, ok := requires[stale]; ok {
+    t.Errorf("stale bridge requirement survived:\n%s", source)
+  }
+  if _, ok := replaces[stale]; ok || len(replaces) != len(want) {
+    t.Errorf("replacements = %v, want only %v", replaces, want)
+  }
+  if requires["example.com/kept"] != "v1.2.3" || !strings.HasPrefix(string(source), "module "+facadePrefix+"vfs/cachedvfs") {
+    t.Errorf("unrelated lines changed:\n%s", source)
+  }
+}

package/tools/gen_facade/facade_spells_internal_types_through_bridge_aliases_test.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+  "go/token"
+  "go/types"
+  "strings"
+  "testing"
+)
+
+// Verifies the facade names a compiler-internal type only through a bridge
+// alias and degrades exactly where Go cannot spell a signature.
+//
+// Authored go/types packages stand in for one internal package and one bridge,
+// so the cases isolate the printer's naming policy from module loading.
+//
+//  1. Declare internal Node and Hidden types, and a bridge aliasing only Node.
+//  2. Give the bridge functions over Node, over Hidden, and a generic over Hidden.
+//  3. Render the facade and assert each spelling or the generation failure.
+//
+// @evidence contracts/testing.md#behavioral-verification Calls the production renderFacade and newAliasIndex and asserts the exact forwarded function, alias, held-variable and failure outputs.
+// @evidence contracts/testing.md#independent-expectations Literal facade lines and the unexposed type's name are written from the facade contract, not derived from generator output.
+// @evidence contracts/testing.md#distinguishing-cases Covers an aliased internal parameter, an unaliased internal parameter in a non-generic function, and the same type in a generic function, each with a different required result.
+// @evidence contracts/testing.md#execution-ownership This tools/gen_facade source unit builds packages in memory in one Go process; it loads no module, writes no file and starts no process.
+func TestFacadeSpellsInternalTypesThroughBridgeAliases(t *testing.T) {
+  internal := types.NewPackage(internalPrefix+"ast", "ast")
+  node := types.NewNamed(types.NewTypeName(token.NoPos, internal, "Node", nil), types.NewStruct(nil, nil), nil)
+  internal.Scope().Insert(node.Obj())
+  hidden := types.NewNamed(types.NewTypeName(token.NoPos, internal, "Hidden", nil), types.NewStruct(nil, nil), nil)
+  internal.Scope().Insert(hidden.Obj())
+
+  newBridge := func(withGeneric bool) bridge {
+    pkg := types.NewPackage(bridgePrefix+"ast", "ast")
+    alias := types.NewTypeName(token.NoPos, pkg, "Node", nil)
+    types.NewAlias(alias, node)
+    pkg.Scope().Insert(alias)
+    param := func(typ types.Type) *types.Tuple {
+      return types.NewTuple(types.NewVar(token.NoPos, pkg, "n", typ))
+    }
+    insertFunc := func(name string, sig *types.Signature) {
+      pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, name, sig))
+    }
+    insertFunc("Visit", types.NewSignatureType(nil, nil, nil, param(types.NewPointer(node)), types.NewTuple(types.NewVar(token.NoPos, pkg, "", types.Typ[types.Bool])), false))
+    insertFunc("Peek", types.NewSignatureType(nil, nil, nil, param(types.NewPointer(hidden)), nil, false))
+    if withGeneric {
+      typeParam := types.NewTypeParam(types.NewTypeName(token.NoPos, pkg, "T", nil), types.Universe.Lookup("any").Type())
+      insertFunc("Map", types.NewSignatureType(nil, nil, []*types.TypeParam{typeParam}, param(types.NewPointer(hidden)), types.NewTuple(types.NewVar(token.NoPos, pkg, "", typeParam)), false))
+    }
+    return bridge{rel: "ast", pkg: pkg}
+  }
+
+  plain := newBridge(false)
+  source, _, err := renderFacade(plain, newAliasIndex([]bridge{plain}))
+  if err != nil {
+    t.Fatal(err)
+  }
+  for _, want := range []string{
+    `tscast "github.com/microsoft/TypeScript/tsc/shim/ast"`,
+    "type Node = tscast.Node",
+    "func Visit(p0 *tscast.Node) bool {\n  return tscast.Visit(p0)\n}",
+    "// exposes (" + internalPrefix + "ast.Hidden).\nvar Peek = tscast.Peek",
+  } {
+    if !strings.Contains(string(source), want) {
+      t.Errorf("facade lacks %q:\n%s", want, source)
+    }
+  }
+  if strings.Contains(string(source), `"`+internalPrefix) {
+    t.Errorf("facade imports the internal package:\n%s", source)
+  }
+
+  generic := newBridge(true)
+  _, _, err = renderFacade(generic, newAliasIndex([]bridge{generic}))
+  if err == nil || !strings.Contains(err.Error(), bridgePrefix+"ast.Map: cannot name "+internalPrefix+"ast.Hidden") {
+    t.Fatalf("generic function over an unexposed type: got %v", err)
+  }
+}

package/tools/gen_facade/facade_types_are_their_bridge_types_test.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+  "go/types"
+  "os"
+  "path/filepath"
+  "testing"
+
+  "golang.org/x/tools/go/packages"
+)
+
+// Verifies each documented TypeScript 7.1 import path names the bridge's own
+// types rather than copies of them.
+//
+// A plugin can import github.com/microsoft/typescript-go/shim/ast while ttsc's
+// driver imports the bridge or another facade. A facade type that were a new
+// defined type would make a value from one path unusable through the other.
+//
+//  1. Load every committed facade module with its dependencies.
+//  2. For every exported facade type that its bridge also exports, require an
+//     alias whose type is identical to the bridge's.
+//  3. Spot-check the AST node, checker and Program identities by name.
+//
+// @evidence contracts/testing.md#behavioral-verification Type-checks the real facade and bridge modules through go/packages and asserts types.Identical for every exported pair, so a defined type, a wrong alias target or a missing alias fails.
+// @evidence contracts/testing.md#independent-expectations The expected relation, one identical type per documented name, is the facade contract itself; the spot-checked names are written literally rather than read from generator output.
+// @evidence contracts/testing.md#distinguishing-cases Covers every facade package, nested paths such as vfs/cachedvfs, generic and non-generic aliases, and the three named identities plugins and the driver exchange most.
+// @evidence contracts/testing.md#execution-ownership This tools/gen_facade unit loads the committed modules through the go command in its own process and writes no file.
+func TestFacadeTypesAreTheirBridgeTypes(t *testing.T) {
+  facadeRoot := filepath.Join("..", "..", "targets", "7.1", "facade")
+  var dirs []string
+  err := filepath.WalkDir(facadeRoot, func(path string, entry os.DirEntry, err error) error {
+    if err == nil && !entry.IsDir() && entry.Name() == "go.mod" {
+      dirs = append(dirs, filepath.Dir(path))
+    }
+    return err
+  })
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(dirs) == 0 {
+    t.Fatal("no facade modules found")
+  }
+  checked := map[string]bool{}
+  for _, dir := range dirs {
+    loaded, err := packages.Load(&packages.Config{
+      Dir:  dir,
+      Env:  standaloneModuleEnv(),
+      Mode: packages.NeedName | packages.NeedTypes | packages.NeedImports | packages.NeedDeps,
+    }, ".")
+    if err != nil || len(loaded) != 1 || len(loaded[0].Errors) > 0 {
+      t.Fatalf("load %s: %v %v", dir, err, loaded)
+    }
+    facade := loaded[0]
+    bridgePath := bridgePrefix + facade.PkgPath[len(facadePrefix):]
+    bridge := facade.Imports[bridgePath]
+    if bridge == nil {
+      t.Fatalf("%s does not import its bridge %s", facade.PkgPath, bridgePath)
+    }
+    for _, name := range facade.Types.Scope().Names() {
+      object, ok := facade.Types.Scope().Lookup(name).(*types.TypeName)
+      if !ok || !object.Exported() {
+        continue
+      }
+      original, ok := bridge.Types.Scope().Lookup(name).(*types.TypeName)
+      if !ok {
+        continue
+      }
+      if !aliasesBridgeType(object, original) {
+        t.Errorf("%s.%s is not the bridge's %s", facade.PkgPath, name, original.Type())
+      }
+      checked[facade.PkgPath[len(facadePrefix):]+"."+name] = true
+    }
+  }
+  for _, name := range []string{"ast.Node", "ast.SourceFile", "ast.Symbol", "checker.Checker", "compiler.Program", "vfs/cachedvfs.FS"} {
+    if !checked[name] {
+      t.Errorf("identity of %s was not checked", name)
+    }
+  }
+}
+
+// aliasesBridgeType reports whether the facade type is an alias of original.
+// A generic alias declares its own type parameters, so original is
+// instantiated with them before the comparison.
+func aliasesBridgeType(object *types.TypeName, original *types.TypeName) bool {
+  alias, ok := object.Type().(*types.Alias)
+  if !ok || !object.IsAlias() {
+    return false
+  }
+  params := alias.TypeParams()
+  if params.Len() == 0 {
+    return types.Identical(alias, original.Type())
+  }
+  args := make([]types.Type, params.Len())
+  for i := range params.Len() {
+    args[i] = params.At(i)
+  }
+  instance, err := types.Instantiate(nil, original.Type(), args, true)
+  return err == nil && types.Identical(alias.Rhs(), instance)
+}

package/tools/gen_facade/go.mod

@@ -0,0 +1,10 @@
+module github.com/samchon/ttsc/packages/ttsc/tools/gen_facade
+
+go 1.27
+
+require (
+	golang.org/x/mod v0.42.0
+	golang.org/x/tools v0.52.0
+)
+
+require golang.org/x/sync v0.24.0 // indirect

package/tools/gen_facade/go.sum

@@ -0,0 +1,8 @@
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg=
+golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs=
+golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
+golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
+golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs=
+golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=