typia 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

package/native/cmd/ttsc-typia/build.go

@@ -0,0 +1,252 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+func runBuild(args []string) int {
+	fs := flag.NewFlagSet("build", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	quiet := fs.Bool("quiet", true, "suppress the per-call diagnostic summary")
+	verbose := fs.Bool("verbose", false, "print the per-call diagnostic summary")
+	emit := fs.Bool("emit", false, "force emitted .js files")
+	noEmit := fs.Bool("noEmit", false, "force analysis-only run with no file writes")
+	outDir := fs.String("outDir", "", "override compilerOptions.outDir")
+	manifestPath := fs.String("manifest", "", "write emitted file list as JSON")
+	rewriteMode := fs.String("rewrite-mode", "typia", "native rewrite backend id")
+	_ = fs.String("plugins-json", "", "ordered ttsc plugin payload")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *emit && *noEmit {
+		fmt.Fprintln(stderr, "ttsc-typia build: --emit and --noEmit are mutually exclusive")
+		return 2
+	}
+	if *verbose {
+		*quiet = false
+	}
+	if *rewriteMode != "none" && *rewriteMode != "typia" {
+		fmt.Fprintf(stderr, "ttsc-typia build: unknown --rewrite-mode value %q\n", *rewriteMode)
+		return 2
+	}
+
+	cwd := *cwdOverride
+	if cwd == "" {
+		var err error
+		cwd, err = os.Getwd()
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc-typia build: cwd: %v\n", err)
+			return 2
+		}
+	}
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit:   *emit,
+		ForceNoEmit: *noEmit,
+		OutDir:      *outDir,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia build: %v\n", err)
+		return 2
+	}
+	if len(diags) > 0 {
+		driver.WritePrettyDiagnostics(stderr, diags, cwd)
+		return 2
+	}
+	defer prog.Close()
+	if diags := prog.Diagnostics(); len(diags) > 0 {
+		driver.WritePrettyDiagnostics(stderr, diags, cwd)
+		return 2
+	}
+
+	rewrites := driver.NewRewriteSet()
+	transformDiags := []typiaTransformDiagnostic{}
+	sites, recognized := 0, 0
+	shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
+	if *rewriteMode == "typia" {
+		sites, recognized, transformDiags = collectTypiaRewrites(
+			prog,
+			cwd,
+			shouldEmit,
+			*quiet,
+			"",
+			rewrites,
+			readTypiaPluginOptions(cwd, *tsconfigPath),
+		)
+	}
+	if !*quiet {
+		fmt.Fprintf(stdout, "// ttsc-typia build: tsconfig=%s cwd=%s sites=%d emit=%v rewrite=%s\n", *tsconfigPath, cwd, sites, shouldEmit, *rewriteMode)
+	}
+	if shouldEmit {
+		writeFile := shimcompiler.WriteFile(func(fileName, text string, data *shimcompiler.WriteFileData) error {
+			text = typiaadapter.CleanupTransformedText(text)
+			return driver.DefaultWriteFile(fileName, text)
+		})
+		res, eDiags, err := prog.EmitAll(rewrites, writeFile)
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc-typia build: emit failed: %v\n", err)
+			return 3
+		}
+		for _, d := range eDiags {
+			fmt.Fprintln(stderr, "  -", d.String())
+		}
+		if !*quiet {
+			fmt.Fprintf(stdout, "// ttsc-typia build: emitted=%d files\n", len(res.EmittedFiles))
+			for _, f := range res.EmittedFiles {
+				rel := f
+				if abs, err := filepath.Rel(cwd, f); err == nil {
+					rel = abs
+				}
+				fmt.Fprintln(stdout, "  +", rel)
+			}
+		}
+		if *manifestPath != "" {
+			data, err := json.Marshal(res.EmittedFiles)
+			if err != nil {
+				fmt.Fprintf(stderr, "ttsc-typia build: manifest marshal failed: %v\n", err)
+				return 3
+			}
+			if err := os.MkdirAll(filepath.Dir(*manifestPath), 0o755); err != nil {
+				fmt.Fprintf(stderr, "ttsc-typia build: manifest mkdir failed: %v\n", err)
+				return 3
+			}
+			if err := os.WriteFile(*manifestPath, data, 0o644); err != nil {
+				fmt.Fprintf(stderr, "ttsc-typia build: manifest write failed: %v\n", err)
+				return 3
+			}
+		}
+	}
+	if len(transformDiags) > 0 {
+		writeTypiaTransformDiagnostics(stderr, transformDiags, cwd)
+		return 3
+	}
+	if !*quiet {
+		fmt.Fprintf(stdout, "// ttsc-typia build: recognized=%d total=%d rewrites=%d\n", recognized, sites, rewrites.Len())
+	}
+	return 0
+}
+
+type typiaTransformDiagnostic struct {
+	File    string
+	Line    int
+	Column  int
+	Code    string
+	Message string
+}
+
+func (d typiaTransformDiagnostic) String(cwd string) string {
+	file := d.File
+	if rel, err := filepath.Rel(cwd, file); err == nil {
+		file = rel
+	}
+	if d.Line > 0 {
+		return fmt.Sprintf("%s:%d:%d - error TS(%s): %s", file, d.Line, d.Column, d.Code, d.Message)
+	}
+	return fmt.Sprintf("%s - error TS(%s): %s", file, d.Code, d.Message)
+}
+
+func writeTypiaTransformDiagnostics(out io.Writer, diagnostics []typiaTransformDiagnostic, cwd string) {
+	for _, diag := range diagnostics {
+		fmt.Fprintln(out, diag.String(cwd))
+	}
+}
+
+func newTypiaTransformDiagnostic(site typiaadapter.CallSite, message string) typiaTransformDiagnostic {
+	line, column := 0, 0
+	if site.File != nil && site.Call != nil {
+		pos := site.Call.AsNode().Pos()
+		if pos >= 0 {
+			l, c := shimscanner.GetECMALineAndByteOffsetOfPosition(site.File, pos)
+			line, column = l+1, c+1
+		}
+	}
+	return typiaTransformDiagnostic{
+		File:    site.FilePath,
+		Line:    line,
+		Column:  column,
+		Code:    "typia." + site.Module + "." + site.Method,
+		Message: message,
+	}
+}
+
+func collectTypiaRewrites(
+	prog *driver.Program,
+	cwd string,
+	emit bool,
+	quiet bool,
+	onlyFile string,
+	rewrites *driver.RewriteSet,
+	pluginOptions typiaadapter.PluginOptions,
+) (int, int, []typiaTransformDiagnostic) {
+	sites := typiaadapter.CollectCallSites(prog.SourceFiles(), prog.Checker)
+	recognized := 0
+	diagnostics := []typiaTransformDiagnostic{}
+	for _, site := range sites {
+		if onlyFile != "" && filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
+			continue
+		}
+		rel := site.FilePath
+		if abs, err := filepath.Rel(cwd, rel); err == nil {
+			rel = abs
+		}
+		if reason := typiaadapter.UnsupportedReason(site); reason != "" {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, reason))
+			continue
+		}
+		expr, handled, err := typiaadapter.EmitCallWithOptions(prog, site, pluginOptions)
+		if !handled {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, "method not covered"))
+			continue
+		}
+		if err != nil {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, err.Error()))
+			continue
+		}
+		rewrites.Add(driver.Rewrite{
+			File:          site.File,
+			RootName:      site.RootName,
+			Namespaces:    site.Namespaces,
+			Method:        site.Method,
+			Replacement:   expr,
+			ConsumeParens: true,
+		})
+		if !emit && !quiet {
+			fmt.Fprintf(stdout, "%s: typia.%s<T> -> %s\n", rel, site.Method, expr)
+		}
+		recognized++
+	}
+	return len(sites), recognized, diagnostics
+}
+
+func readTypiaPluginOptions(cwd, tsconfigPath string) typiaadapter.PluginOptions {
+	path := tsconfigPath
+	if !filepath.IsAbs(path) {
+		path = filepath.Join(cwd, path)
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return typiaadapter.PluginOptions{}
+	}
+	text := string(data)
+	if !regexp.MustCompile(`(?s)"transform"\s*:\s*"typia/lib/transform"`).MatchString(text) {
+		return typiaadapter.PluginOptions{}
+	}
+	return typiaadapter.PluginOptions{
+		Functional: regexp.MustCompile(`(?s)"functional"\s*:\s*true`).MatchString(text),
+		Numeric:    regexp.MustCompile(`(?s)"numeric"\s*:\s*true`).MatchString(text),
+		Finite:     regexp.MustCompile(`(?s)"finite"\s*:\s*true`).MatchString(text),
+		Undefined:  regexp.MustCompile(`(?s)"undefined"\s*:\s*true`).MatchString(text),
+	}
+}

package/native/cmd/ttsc-typia/main.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+)
+
+var (
+	version = "0.1.0-dev"
+	commit  = "dev"
+	date    = "unknown"
+)
+
+var (
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+)
+
+func main() {
+	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 "check":
+		return runBuild(append([]string{"--noEmit"}, args[1:]...))
+	case "transform":
+		return runTransform(args[1:])
+	case "-p", "--project":
+		if len(args) < 2 {
+			fmt.Fprintln(stderr, "ttsc-typia: -p/--project requires a path argument")
+			return 2
+		}
+		return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
+	default:
+		return runBuild(args)
+	}
+}
+
+func printVersion(w io.Writer) {
+	fmt.Fprintf(
+		w,
+		"ttsc-typia %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(`
+ttsc-typia - typia native backend for the standalone ttsc host.
+
+Usage:
+  ttsc-typia [command] [options]
+
+Commands:
+  build         Compile every .ts in a project and emit typia-rewritten .js.
+  check         Run the analyzer without emitting.
+  transform     Emit a single file's typia-rewritten JS.
+  demo          Run a backend smoke path.
+  version       Print version, build info, and platform.
+  help          Show this help.
+`))
+}
+
+func runDemo(args []string) int {
+	fs := flag.NewFlagSet("demo", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	fmt.Fprintln(stdout, "// demo emitted by typia native backend")
+	return 0
+}

package/native/cmd/ttsc-typia/transform.go

@@ -0,0 +1,290 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+func runTransform(args []string) int {
+	fs := flag.NewFlagSet("transform", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "tsconfig.json owning --file")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	out := fs.String("out", "", "write output JS to PATH")
+	rewriteMode := fs.String("rewrite-mode", "typia", "native rewrite backend id")
+	output := fs.String("output", defaultTransformOutput(), "transform output kind: js or ts")
+	_ = fs.String("plugins-json", "", "ordered ttsc plugin payload")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *file == "" {
+		fmt.Fprintln(stderr, "ttsc-typia transform: --file is required")
+		return 2
+	}
+	if *rewriteMode != "none" && *rewriteMode != "typia" {
+		fmt.Fprintf(stderr, "ttsc-typia transform: unknown --rewrite-mode value %q\n", *rewriteMode)
+		return 2
+	}
+	if *output != "js" && *output != "ts" {
+		fmt.Fprintf(stderr, "ttsc-typia transform: unknown --output value %q\n", *output)
+		return 2
+	}
+	cwd := *cwdOverride
+	if cwd == "" {
+		var err error
+		cwd, err = os.Getwd()
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc-typia transform: cwd: %v\n", err)
+			return 2
+		}
+	}
+
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: %v\n", err)
+		return 2
+	}
+	if len(diags) > 0 {
+		driver.WritePrettyDiagnostics(stderr, diags, cwd)
+		return 2
+	}
+	defer prog.Close()
+
+	absFile := *file
+	if !filepath.IsAbs(absFile) {
+		absFile = filepath.Join(cwd, absFile)
+	}
+	absFile = filepath.ToSlash(absFile)
+
+	rewrites := driver.NewRewriteSet()
+	if *rewriteMode == "typia" {
+		if _, _, diagnostics := collectTypiaRewrites(prog, cwd, true, true, absFile, rewrites, readTypiaPluginOptions(cwd, *tsconfigPath)); len(diagnostics) > 0 {
+			writeTypiaTransformDiagnostics(stderr, diagnostics, cwd)
+			return 3
+		}
+	}
+
+	target := prog.SourceFile(absFile)
+	if target == nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: source file is not in program: %s\n", absFile)
+		return 2
+	}
+	if *output == "ts" {
+		return runTransformTypeScript(prog, cwd, absFile, target, *rewriteMode, *tsconfigPath, *out)
+	}
+
+	var captured []byte
+	capture := func(name, text string, data *shimcompiler.WriteFileData) error {
+		rel := filepath.ToSlash(name)
+		if !strings.HasSuffix(rel, ".js") {
+			return nil
+		}
+		captured = []byte(typiaadapter.CleanupTransformedText(text))
+		return nil
+	}
+	_, eDiags, err := prog.EmitFile(rewrites, target, capture)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: emit: %v\n", err)
+		return 3
+	}
+	for _, d := range eDiags {
+		fmt.Fprintln(stderr, "  -", d.String())
+	}
+	if captured == nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: no output produced for %s\n", absFile)
+		return 3
+	}
+	if *out == "" {
+		if _, werr := bytes.NewReader(captured).WriteTo(stdout); werr != nil {
+			fmt.Fprintf(stderr, "ttsc-typia transform: write stdout: %v\n", werr)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(*out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc-typia transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(*out, captured, 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: write %s: %v\n", *out, err)
+		return 3
+	}
+	return 0
+}
+
+func defaultTransformOutput() string {
+	if os.Getenv("TYPIA_TTSC_TRANSFORM_OUTPUT") == "ts" {
+		return "ts"
+	}
+	return "js"
+}
+
+type transformSourceRewrite struct {
+	start       int
+	end         int
+	replacement string
+}
+
+func runTransformTypeScript(
+	prog *driver.Program,
+	cwd string,
+	absFile string,
+	target any,
+	rewriteMode string,
+	tsconfigPath string,
+	out string,
+) int {
+	source, ok := sourceFileText(target)
+	if !ok {
+		fmt.Fprintf(stderr, "ttsc-typia transform: source text is unavailable for %s\n", absFile)
+		return 3
+	}
+	rewrites := []transformSourceRewrite{}
+	if rewriteMode == "typia" {
+		var diagnostics []typiaTransformDiagnostic
+		rewrites, diagnostics = collectTypiaSourceRewrites(
+			prog,
+			cwd,
+			absFile,
+			readTypiaPluginOptions(cwd, tsconfigPath),
+		)
+		if len(diagnostics) > 0 {
+			writeTypiaTransformDiagnostics(stderr, diagnostics, cwd)
+			return 3
+		}
+	}
+	transformed, err := applySourceRewrites(source, rewrites)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: source rewrite: %v\n", err)
+		return 3
+	}
+	transformed = cleanupTypeScriptTransformText(transformed)
+	if out == "" {
+		if _, werr := bytes.NewBufferString(transformed).WriteTo(stdout); werr != nil {
+			fmt.Fprintf(stderr, "ttsc-typia transform: write stdout: %v\n", werr)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc-typia transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(out, []byte(transformed), 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: write %s: %v\n", out, err)
+		return 3
+	}
+	return 0
+}
+
+func sourceFileText(target any) (string, bool) {
+	type sourceText interface {
+		Text() string
+	}
+	if file, ok := target.(sourceText); ok {
+		return file.Text(), true
+	}
+	return "", false
+}
+
+func collectTypiaSourceRewrites(
+	prog *driver.Program,
+	cwd string,
+	onlyFile string,
+	pluginOptions typiaadapter.PluginOptions,
+) ([]transformSourceRewrite, []typiaTransformDiagnostic) {
+	sites := typiaadapter.CollectCallSites(prog.SourceFiles(), prog.Checker)
+	rewrites := []transformSourceRewrite{}
+	diagnostics := []typiaTransformDiagnostic{}
+	for _, site := range sites {
+		if filepath.ToSlash(site.FilePath) != filepath.ToSlash(onlyFile) {
+			continue
+		}
+		if reason := typiaadapter.UnsupportedReason(site); reason != "" {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, reason))
+			continue
+		}
+		expr, handled, err := typiaadapter.EmitCallWithOptionsPreservingTypes(prog, site, pluginOptions)
+		if !handled {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, "method not covered"))
+			continue
+		}
+		if err != nil {
+			diagnostics = append(diagnostics, newTypiaTransformDiagnostic(site, err.Error()))
+			continue
+		}
+		node := site.Call.AsNode()
+		rewrites = append(rewrites, transformSourceRewrite{
+			start:       node.Pos(),
+			end:         node.End(),
+			replacement: expr,
+		})
+		_ = cwd
+	}
+	return rewrites, diagnostics
+}
+
+func applySourceRewrites(source string, rewrites []transformSourceRewrite) (string, error) {
+	sort.SliceStable(rewrites, func(i, j int) bool {
+		return rewrites[i].start > rewrites[j].start
+	})
+	output := source
+	for _, rewrite := range rewrites {
+		if rewrite.start < 0 || rewrite.end < rewrite.start || rewrite.end > len(output) {
+			return "", fmt.Errorf("invalid rewrite range [%d,%d)", rewrite.start, rewrite.end)
+		}
+		output = output[:rewrite.start] + rewrite.replacement + output[rewrite.end:]
+	}
+	return output, nil
+}
+
+func cleanupTypeScriptTransformText(text string) string {
+	text = typiaadapter.CleanupTransformedText(text)
+	text = regexp.MustCompile(`(?m)^import type \{([^{}\n]+)\} from`).ReplaceAllStringFunc(text, func(line string) string {
+		return regexp.MustCompile(`^import type \{\s*([^{}\n]+?)\s*\} from`).ReplaceAllString(line, "import type { $1 } from")
+	})
+	text = regexp.MustCompile(`(?m)(^import [^\n]+;\n)\n+(const |let |var |export )`).ReplaceAllString(text, "$1$2")
+	text = strings.ReplaceAll(text, "=(() =>", "= (() =>")
+	text = strings.ReplaceAll(text, ": (any) =>", ": any =>")
+	text = strings.ReplaceAll(text, ": (boolean) =>", ": boolean =>")
+	text = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`).ReplaceAllString(text, "input is $1")
+	text = strings.ReplaceAll(text, "return (success ? ", "return success ? ")
+	text = strings.ReplaceAll(text, "}) as any;", "} as any;")
+	text = strings.ReplaceAll(text, "(() => {\n    const ", "(() => { const ")
+	text = strings.ReplaceAll(text, "(() => {\n    let ", "(() => { let ")
+	text = strings.ReplaceAll(text, "(() => {\n    return ", "(() => { return ")
+	text = strings.ReplaceAll(text, ";\n    const ", "; const ")
+	text = strings.ReplaceAll(text, ";\n    let ", "; let ")
+	text = strings.ReplaceAll(text, ";\n    return ", "; return ")
+	text = strings.ReplaceAll(text, "\n    };\n})()", "\n}; })()")
+	text = strings.ReplaceAll(text, "\n    });\n})()", "\n}); })()")
+	text = strings.ReplaceAll(text, "\n    }); let ", "\n}); let ")
+	text = strings.ReplaceAll(text, ";\n})()", "; })()")
+	text = strings.ReplaceAll(text, "\n        ", "\n    ")
+	text = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`).ReplaceAllString(text, "\n$1")
+	trimmed := strings.TrimRight(text, " \t\r\n")
+	if strings.HasSuffix(trimmed, ")") && !strings.HasSuffix(trimmed, ";") {
+		return trimmed + ";\n"
+	}
+	if text != "" && !strings.HasSuffix(text, "\n") {
+		return text + "\n"
+	}
+	return text
+}

package/native/core/context/IProgrammerProps.go

@@ -0,0 +1,14 @@
+package context
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type IProgrammerProps struct {
+	Context ITypiaContext
+	Modulo  *shimast.Node
+	Type    *shimchecker.Type
+	Name    *string
+	Init    *shimast.Node
+}

package/native/core/context/ITransformOptions.go

@@ -0,0 +1,9 @@
+package context
+
+type ITransformOptions struct {
+	Finite     *bool
+	Numeric    *bool
+	Functional *bool
+	Undefined  *bool
+	Runtime    string
+}

package/native/core/context/ITypiaContext.go

@@ -0,0 +1,23 @@
+package context
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+type ITypiaContext struct {
+	Program         *driver.Program
+	CompilerOptions *shimcore.CompilerOptions
+	Checker         *shimchecker.Checker
+	Printer         any
+	Options         ITransformOptions
+	Transformer     any
+	Importer        any
+	Extras          ITypiaContext_Extras
+}
+
+type ITypiaContext_Extras struct {
+	AddDiagnostic func(diag *shimast.Diagnostic) int
+}