@zyno-io/ts-server-foundation 26.712.36

package/dist/src/type-compiler/go/emit_ast_test.go

@@ -0,0 +1,248 @@
+package main
+
+import (
+	"path/filepath"
+	"testing"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	shimparser "github.com/microsoft/typescript-go/shim/parser"
+	shimprinter "github.com/microsoft/typescript-go/shim/printer"
+)
+
+func TestExpressionTemplateParsesStructuredMetadata(t *testing.T) {
+	template, err := parseExpressionTemplate(`{
+		kind: 16,
+		classType: () => Date,
+		value: (() => ({nested: [true, 1, "two"]}))()
+	}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if template.parsed == nil || template.parsed.Kind != shimast.KindParenthesizedExpression {
+		t.Fatalf("parsed expression kind = %v", template.parsed)
+	}
+}
+
+func TestExpressionTemplateRejectsMalformedSourceAndPlaceholders(t *testing.T) {
+	for _, source := range []string{
+		`{kind:`,
+		`__tsf_runtime_import__("pkg", "Value")`,
+		`__tsf_runtime_namespace__("pkg", 1)`,
+	} {
+		if _, err := parseExpressionTemplate(source); err == nil {
+			t.Fatalf("parseExpressionTemplate(%q) unexpectedly succeeded", source)
+		}
+	}
+}
+
+func TestRuntimePlaceholderMaterializationPreservesModuleSemantics(t *testing.T) {
+	template, err := parseExpressionTemplate(`{
+		member: __tsf_runtime_import__("./dependency", "Value", "/project/dependency.ts"),
+		namespace: __tsf_runtime_namespace__("@scope/shared", "")
+	}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, test := range []struct {
+		name        string
+		commonJS    bool
+		wantImports int
+		wantRequire bool
+	}{
+		{name: "esm", wantImports: 2},
+		{name: "commonjs", commonJS: true, wantRequire: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ec := shimprinter.NewEmitContext()
+			file := parseTestSourceFile(t, "/project/consumer.ts", `export const value = 1;`)
+			imports := newAstImportRegistry(ec, file, test.commonJS)
+			materialized := template.materialize(ec, imports)
+			if containsRuntimePlaceholder(materialized) {
+				t.Fatal("compiler placeholder survived materialization")
+			}
+			if got := len(imports.statements()); got != test.wantImports {
+				t.Fatalf("generated imports = %d, want %d", got, test.wantImports)
+			}
+			if got := astContainsIdentifier(materialized, "require"); got != test.wantRequire {
+				t.Fatalf("contains require = %v, want %v", got, test.wantRequire)
+			}
+		})
+	}
+}
+
+func TestUpdateMetadataCallUsesAbsoluteArgumentSlot(t *testing.T) {
+	ec := shimprinter.NewEmitContext()
+	imports := newAstImportRegistry(ec, nil, true)
+	template, err := parseExpressionTemplate(`{kind: 7}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	call := ec.Factory.NewCallExpression(
+		ec.Factory.NewIdentifier("cast"),
+		nil,
+		nil,
+		ec.Factory.NewNodeList([]*shimast.Node{ec.Factory.NewIdentifier("input")}),
+		shimast.NodeFlagsNone,
+	).AsCallExpression()
+	updated := updateMetadataCall(ec, call, callEmissionPlan{metadataArgIndex: 4, metadata: template}, imports).AsCallExpression()
+	if got := len(updated.Arguments.Nodes); got != 5 {
+		t.Fatalf("arguments = %d, want 5", got)
+	}
+	for index := 1; index < 4; index++ {
+		if updated.Arguments.Nodes[index].Kind != shimast.KindIdentifier || updated.Arguments.Nodes[index].Text() != "undefined" {
+			t.Fatalf("argument %d was not an undefined filler", index)
+		}
+	}
+}
+
+func TestMetadataTransformMatchesExactCallPosition(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/calls.ts", `
+		function same<T>(): void {}
+		same<number>();
+		same<string>();
+	`)
+	calls := collectAstNodes(file.AsNode(), shimast.KindCallExpression)
+	if len(calls) != 2 {
+		t.Fatalf("call expressions = %d, want 2", len(calls))
+	}
+	template, err := parseExpressionTemplate(`{kind: 7}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plans := emissionPlans{file.FileName(): {
+		calls: map[int]callEmissionPlan{
+			calls[1].Pos(): {metadataArgIndex: 0, metadata: template},
+		},
+		classes:  map[int]classEmissionPlan{},
+		commonJS: true,
+	}}
+	transformed := metadataTransform(plans)(shimprinter.NewEmitContext(), file)
+	transformedCalls := collectAstNodes(transformed.AsNode(), shimast.KindCallExpression)
+	if len(transformedCalls) != 2 {
+		t.Fatalf("transformed calls = %d, want 2", len(transformedCalls))
+	}
+	if len(transformedCalls[0].AsCallExpression().Arguments.Nodes) != 0 {
+		t.Fatal("unplanned same-named call was transformed")
+	}
+	if len(transformedCalls[1].AsCallExpression().Arguments.Nodes) != 1 {
+		t.Fatal("planned call was not transformed")
+	}
+}
+
+func TestClassMetadataTransformMaterializesOneSharedObject(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/model.ts", `class Model { value: string }`)
+	classes := collectAstNodes(file.AsNode(), shimast.KindClassDeclaration)
+	if len(classes) != 1 {
+		t.Fatalf("class declarations = %d, want 1", len(classes))
+	}
+	template, err := parseExpressionTemplate(`{kind: 16, properties: []}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plans := emissionPlans{file.FileName(): {
+		calls: map[int]callEmissionPlan{},
+		classes: map[int]classEmissionPlan{
+			classes[0].Pos(): {name: "Model", metadata: template},
+		},
+		commonJS: true,
+	}}
+	transformed := metadataTransform(plans)(shimprinter.NewEmitContext(), file)
+	if got := len(collectAstNodes(transformed.AsNode(), shimast.KindObjectLiteralExpression)); got != 1 {
+		t.Fatalf("metadata object literals = %d, want 1", got)
+	}
+}
+
+func TestClassFromNodeRecognizesAmbientContext(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/ambient.ts", `
+		declare namespace AmbientScope {
+			class Nested { value: string }
+		}
+	`)
+	classes := collectAstNodes(file.AsNode(), shimast.KindClassDeclaration)
+	if len(classes) != 1 {
+		t.Fatalf("class declarations = %d, want 1", len(classes))
+	}
+	info := &fileInfo{file: file}
+	class := classFromNode(info, classes[0])
+	if class == nil || !class.ambient {
+		t.Fatal("class nested in an ambient namespace was not marked ambient")
+	}
+}
+
+func TestPrecomputeSkipsAmbientClasses(t *testing.T) {
+	file := parseTestSourceFile(t, "/project/precompute.ts", ``)
+	ambient := &classInfo{ambient: true, properties: []propertyInfo{{typeText: "string"}}}
+	runtimeClass := &classInfo{properties: []propertyInfo{{typeText: "string"}}}
+	info := &fileInfo{
+		file:       file,
+		moduleKey:  moduleKey(file.FileName()),
+		precompute: true,
+		aliases:    map[string]aliasInfo{},
+		interfaces: map[string][]interfaceInfo{},
+		enums:      map[string]enumInfo{},
+		classes:    []*classInfo{ambient, runtimeClass},
+		imports:    map[string]importRef{},
+		reexports:  map[string]importRef{},
+	}
+	reg := &registry{
+		files:         map[string]*fileInfo{file.FileName(): info},
+		byPath:        map[string]*fileInfo{info.moduleKey: info},
+		typiaCache:    map[typiaCacheKey]string{},
+		typiaFailures: map[*shimchecker.Type]bool{},
+		classes:       map[string]*classInfo{},
+		external:      map[string]map[string][]functionInfo{},
+	}
+
+	precomputeMetadataExpressions(reg)
+
+	if ambient.properties[0].metadataText != "" {
+		t.Fatal("ambient class metadata was precomputed")
+	}
+	if runtimeClass.properties[0].metadataText == "" {
+		t.Fatal("runtime class metadata was not precomputed")
+	}
+}
+
+func parseTestSourceFile(t *testing.T, fileName string, source string) *shimast.SourceFile {
+	t.Helper()
+	file := shimparser.ParseSourceFile(
+		shimast.SourceFileParseOptions{FileName: filepath.ToSlash(fileName)},
+		source,
+		shimcore.ScriptKindTS,
+	)
+	if file == nil || len(file.Diagnostics()) != 0 {
+		t.Fatalf("failed to parse test source %s", fileName)
+	}
+	return file
+}
+
+func collectAstNodes(root *shimast.Node, kind shimast.Kind) []*shimast.Node {
+	out := []*shimast.Node{}
+	var walk func(*shimast.Node)
+	walk = func(node *shimast.Node) {
+		if node == nil {
+			return
+		}
+		if node.Kind == kind {
+			out = append(out, node)
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			walk(child)
+			return false
+		})
+	}
+	walk(root)
+	return out
+}
+
+func astContainsIdentifier(root *shimast.Node, name string) bool {
+	for _, node := range collectAstNodes(root, shimast.KindIdentifier) {
+		if node.Text() == name {
+			return true
+		}
+	}
+	return false
+}

package/dist/src/type-compiler/go/go.mod

@@ -0,0 +1,10 @@
+module tsf-type-replacement-plugin
+
+go 1.26
+
+require (
+	// ttsc replaces this placeholder with the installed npm package's Go sources
+	// while building source plugins. The nested Go module has no semver tags.
+	github.com/samchon/ttsc/packages/ttsc v0.0.0
+	github.com/samchon/typia/packages/typia/native v0.0.0-20260709031533-27f105ae8e56
+)

package/dist/src/type-compiler/go/plugin.go

@@ -0,0 +1,308 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+const foundationPackageSpec = "@zyno-io/ts-server-foundation"
+
+type registry struct {
+	files         map[string]*fileInfo
+	byPath        map[string]*fileInfo
+	checker       *shimchecker.Checker
+	typiaCache    map[typiaCacheKey]string
+	typiaFailures map[*shimchecker.Type]bool
+	classes       map[string]*classInfo
+	external      map[string]map[string][]functionInfo
+}
+
+type typiaCacheKey struct {
+	typ       *shimchecker.Type
+	moduleKey string
+	raw       string
+	pos       int
+}
+
+type fileInfo struct {
+	file       *shimast.SourceFile
+	moduleKey  string
+	precompute bool
+	aliases    map[string]aliasInfo
+	interfaces map[string][]interfaceInfo
+	enums      map[string]enumInfo
+	classes    []*classInfo
+	functions  map[string][]functionInfo
+	imports    map[string]importRef
+	reexports  map[string]importRef
+	exportStar []importRef
+	calls      []callInfo
+}
+
+type aliasInfo struct {
+	body             string
+	params           []string
+	defaults         []string
+	typeNode         *shimast.Node
+	metadataText     string
+	metadataTooLarge bool
+	pos              int
+}
+
+type interfaceInfo struct {
+	body       string
+	extends    []string
+	properties []utilityProperty
+	pos        int
+	source     string
+}
+
+type enumInfo struct {
+	name   string
+	values []string
+	pos    int
+}
+
+type importRef struct {
+	source     string
+	exportName string
+	spec       string
+}
+
+type classInfo struct {
+	name          string
+	pos           int
+	end           int
+	ambient       bool
+	properties    []propertyInfo
+	methods       []methodInfo
+	staticMethods []methodInfo
+	ctor          []paramInfo
+	hasCtor       bool
+}
+
+type propertyInfo struct {
+	name         string
+	typeText     string
+	typeNode     *shimast.Node
+	metadataText string
+	optional     bool
+}
+
+type utilityProperty struct {
+	name     string
+	typeText string
+	typeNode *shimast.Node
+	optional bool
+	owner    *fileInfo
+}
+
+type methodInfo struct {
+	name               string
+	description        string
+	typeParams         []string
+	returnType         string
+	returnTypeNode     *shimast.Node
+	returnMetadataText string
+	preferTypia        bool
+	params             []paramInfo
+}
+
+type functionInfo struct {
+	name       string
+	owner      string
+	typeParams []string
+	params     []paramInfo
+	pos        int
+}
+
+type paramInfo struct {
+	name         string
+	typeText     string
+	typeNode     *shimast.Node
+	metadataText string
+	optional     bool
+	hasDefault   bool
+}
+
+type callInfo struct {
+	name             string
+	nodePos          int
+	metadataArgIndex int
+	typeText         string
+	typeNode         *shimast.Node
+	metadataText     string
+	preferTypia      bool
+	pos              int
+}
+
+type typeContext struct {
+	seen  map[string]bool
+	depth int
+	pos   int
+}
+
+type hostOptions struct {
+	checkers       int
+	cwd            string
+	emit           bool
+	noEmit         bool
+	outDir         string
+	pluginsJSON    string
+	quiet          bool
+	singleThreaded bool
+	tsconfig       string
+	tsgoArgs       []string
+	verbose        bool
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "tssf metadata host: expected command: build, check, or transform")
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "build", "check":
+		os.Exit(runBuild(os.Args[1], os.Args[2:]))
+	case "transform":
+		fmt.Fprintln(os.Stderr, "tssf metadata host: transform text output is not implemented in this POC")
+		os.Exit(2)
+	default:
+		fmt.Fprintf(os.Stderr, "tssf metadata host: unsupported command %q\n", os.Args[1])
+		os.Exit(2)
+	}
+}
+
+func runBuild(command string, args []string) int {
+	opts, ok := parseHostOptions(command, args)
+	if !ok {
+		return 2
+	}
+	if command == "check" {
+		opts.noEmit = true
+	}
+	if opts.verbose {
+		opts.quiet = false
+	}
+	prog, diags, err := driver.LoadProgram(opts.cwd, opts.tsconfig, driver.LoadProgramOptions{
+		ForceEmit:      opts.emit,
+		ForceNoEmit:    opts.noEmit,
+		OutDir:         opts.outDir,
+		SingleThreaded: opts.singleThreaded,
+		Checkers:       opts.checkers,
+		TsgoArgs:       opts.tsgoArgs,
+	})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "tssf metadata host: %v\n", err)
+		return 2
+	}
+	if prog != nil {
+		defer prog.Close()
+	}
+	if len(diags) > 0 {
+		driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+		return 2
+	}
+	if prog == nil {
+		fmt.Fprintln(os.Stderr, "tssf metadata host: failed to load program")
+		return 2
+	}
+	if diags := prog.Diagnostics(); len(diags) > 0 {
+		driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+		return 2
+	}
+	if opts.noEmit {
+		return 0
+	}
+
+	if err := prog.ApplyLinkedPlugins(); err != nil {
+		fmt.Fprintf(os.Stderr, "tssf metadata host: apply linked plugins: %v\n", err)
+		return 2
+	}
+	reg := collectRegistry(prog, opts.cwd)
+	plans, err := buildEmissionPlans(reg, prog)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "tssf metadata host: build emission plans: %v\n", err)
+		return 2
+	}
+	if !opts.quiet {
+		fmt.Fprintf(os.Stdout, "// tssf metadata host: files=%d classes=%d\n", len(reg.files), len(reg.classes))
+	}
+	emitDiags, err := prog.EmitWithPluginTransformers([]driver.PluginTransform{metadataTransform(plans)}, nil)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "tssf metadata host: emit: %v\n", err)
+		return 2
+	}
+	if len(emitDiags) > 0 {
+		driver.WritePrettyDiagnostics(os.Stderr, emitDiags, opts.cwd)
+	}
+	if driver.CountErrors(emitDiags) > 0 {
+		return 2
+	}
+	return 0
+}
+
+func parseHostOptions(command string, args []string) (hostOptions, bool) {
+	fs := flag.NewFlagSet(command, flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	cwd := fs.String("cwd", "", "project directory")
+	emit := fs.Bool("emit", false, "force emit")
+	noEmit := fs.Bool("noEmit", false, "force no emit")
+	outDir := fs.String("outDir", "", "emit directory override")
+	pluginsJSON := fs.String("plugins-json", "", "ttsc plugin manifest JSON")
+	quiet := fs.Bool("quiet", true, "suppress summary")
+	tsconfig := fs.String("tsconfig", "tsconfig.json", "project tsconfig")
+	verbose := fs.Bool("verbose", false, "print summary")
+	singleThreaded := fs.Bool("singleThreaded", false, "run TypeScript-Go single-threaded")
+	checkers := fs.Int("checkers", 0, "type-checker pool size")
+	tsgoArgsRaw := fs.String("tsgo-args", "", "JSON array of forwarded tsgo flags")
+	if err := fs.Parse(args); err != nil {
+		return hostOptions{}, false
+	}
+	var tsgoArgs []string
+	if strings.TrimSpace(*tsgoArgsRaw) != "" {
+		if err := json.Unmarshal([]byte(*tsgoArgsRaw), &tsgoArgs); err != nil {
+			fmt.Fprintf(os.Stderr, "tssf metadata host: invalid --tsgo-args: %v\n", err)
+			return hostOptions{}, false
+		}
+	}
+	resolvedCwd := *cwd
+	if resolvedCwd == "" {
+		var err error
+		resolvedCwd, err = os.Getwd()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "tssf metadata host: cwd: %v\n", err)
+			return hostOptions{}, false
+		}
+	}
+	if !filepath.IsAbs(resolvedCwd) {
+		abs, err := filepath.Abs(resolvedCwd)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "tssf metadata host: cwd: %v\n", err)
+			return hostOptions{}, false
+		}
+		resolvedCwd = abs
+	}
+	return hostOptions{
+		checkers:       *checkers,
+		cwd:            filepath.Clean(resolvedCwd),
+		emit:           *emit,
+		noEmit:         *noEmit,
+		outDir:         *outDir,
+		pluginsJSON:    *pluginsJSON,
+		quiet:          *quiet,
+		singleThreaded: *singleThreaded,
+		tsconfig:       *tsconfig,
+		tsgoArgs:       tsgoArgs,
+		verbose:        *verbose,
+	}, true
+}