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

package/native/transform/FileTransformer.go

@@ -0,0 +1,172 @@
+package transform
+
+import (
+	"sync"
+
+	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"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+)
+
+type fileTransformerNamespace struct{}
+
+var FileTransformer = fileTransformerNamespace{}
+
+type FileTransformer_IEnvironments struct {
+	Program         any
+	CompilerOptions any
+	Checker         any
+	Printer         any
+	Options         nativecontext.ITransformOptions
+	Extras          nativecontext.ITypiaContext_Extras
+}
+
+type FileTransformer_Type func(file *shimast.SourceFile) *shimast.SourceFile
+
+var fileTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+var fileTransformer_jsDocParsingMode sync.Map
+
+func (fileTransformerNamespace) Transform(environments FileTransformer_IEnvironments) func(transformer any) FileTransformer_Type {
+	return func(transformer any) FileTransformer_Type {
+		return func(file *shimast.SourceFile) *shimast.SourceFile {
+			if file == nil || file.IsDeclarationFile {
+				return file
+			}
+			importer := nativeprogrammers.NewImportProgrammer(nativeprogrammers.ImportProgrammer_IOptions{
+				InternalPrefix: "typia_transform_",
+				Runtime:        environments.Options.Runtime,
+			})
+			context := nativecontext.ITypiaContext{
+				Program:         fileTransformer_program(environments.Program),
+				CompilerOptions: fileTransformer_compilerOptions(environments.CompilerOptions),
+				Checker:         fileTransformer_checker(environments.Checker),
+				Printer:         environments.Printer,
+				Options:         environments.Options,
+				Transformer:     transformer,
+				Importer:        importer,
+				Extras:          environments.Extras,
+			}
+			fileTransformer_checkJsDocParsingMode(context, file)
+			visited := fileTransformer_iterate_file(context, file)
+			return fileTransformer_inject_imports(visited, importer.ToStatements())
+		}
+	}
+}
+
+func fileTransformer_iterate_file(context nativecontext.ITypiaContext, file *shimast.SourceFile) *shimast.SourceFile {
+	var visitor *shimast.NodeVisitor
+	visitor = shimast.NewNodeVisitor(func(node *shimast.Node) *shimast.Node {
+		if node == nil {
+			return nil
+		}
+		next := fileTransformer_try_transform_node(FileTransformer_TryTransformNodeProps{
+			Context: context,
+			Node:    node,
+		})
+		if next == nil {
+			next = node
+		}
+		return visitor.VisitEachChild(next)
+	}, fileTransformer_factory, shimast.NodeVisitorHooks{})
+	output := visitor.VisitNode(file.AsNode())
+	if output == nil {
+		return file
+	}
+	return output.AsSourceFile()
+}
+
+type FileTransformer_TryTransformNodeProps struct {
+	Context nativecontext.ITypiaContext
+	Node    *shimast.Node
+}
+
+func fileTransformer_try_transform_node(props FileTransformer_TryTransformNodeProps) (output *shimast.Node) {
+	defer func() {
+		if exp := recover(); exp != nil {
+			if _, ok := exp.(*TransformerError); ok {
+				fileTransformer_addDiagnostic(props)
+				output = nil
+				return
+			}
+			panic(exp)
+		}
+	}()
+	return NodeTransformer.Transform(NodeTransformer_TransformProps{
+		Context: props.Context,
+		Node:    props.Node,
+	})
+}
+
+func fileTransformer_addDiagnostic(props FileTransformer_TryTransformNodeProps) {
+	if props.Context.Extras.AddDiagnostic == nil {
+		return
+	}
+	props.Context.Extras.AddDiagnostic(&shimast.Diagnostic{})
+}
+
+func fileTransformer_inject_imports(file *shimast.SourceFile, imports []*shimast.Node) *shimast.SourceFile {
+	if file == nil || len(imports) == 0 {
+		return file
+	}
+	index := fileTransformer_find_import_injection_index(file)
+	nodes := make([]*shimast.Node, 0, len(file.Statements.Nodes)+len(imports))
+	nodes = append(nodes, file.Statements.Nodes[:index]...)
+	nodes = append(nodes, imports...)
+	nodes = append(nodes, file.Statements.Nodes[index:]...)
+	return fileTransformer_factory.UpdateSourceFile(
+		file,
+		fileTransformer_factory.NewNodeList(nodes),
+		file.EndOfFileToken,
+	).AsSourceFile()
+}
+
+func fileTransformer_find_import_injection_index(file *shimast.SourceFile) int {
+	i := 0
+	for ; i < len(file.Statements.Nodes); i++ {
+		stmt := file.Statements.Nodes[i]
+		if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+			break
+		}
+		expression := stmt.AsExpressionStatement().Expression
+		if expression == nil || expression.Kind != shimast.KindStringLiteral {
+			break
+		}
+		if text := expression.AsStringLiteral().Text; len(text) < 4 || text[:4] != "use " {
+			break
+		}
+	}
+	return i
+}
+
+func fileTransformer_checkJsDocParsingMode(context nativecontext.ITypiaContext, file *shimast.SourceFile) {
+	if file == nil || context.Extras.AddDiagnostic == nil {
+		return
+	}
+	if _, loaded := fileTransformer_jsDocParsingMode.LoadOrStore(file.FileName(), struct{}{}); loaded {
+		return
+	}
+}
+
+func fileTransformer_program(value any) *driver.Program {
+	if cast, ok := value.(*driver.Program); ok {
+		return cast
+	}
+	return nil
+}
+
+func fileTransformer_compilerOptions(value any) *shimcore.CompilerOptions {
+	if cast, ok := value.(*shimcore.CompilerOptions); ok {
+		return cast
+	}
+	return nil
+}
+
+func fileTransformer_checker(value any) *shimchecker.Checker {
+	if cast, ok := value.(*shimchecker.Checker); ok {
+		return cast
+	}
+	return nil
+}

package/native/transform/ITransformProps.go

@@ -0,0 +1,5 @@
+package transform
+
+import nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+
+type ITransformProps = nativeinternal.ITransformProps

package/native/transform/ImportTransformer.go

@@ -0,0 +1,282 @@
+package transform
+
+import (
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type importTransformerNamespace struct{}
+
+var ImportTransformer = importTransformerNamespace{}
+
+type ImportTransformer_TransformProps struct {
+	From string
+	To   string
+}
+
+type ImportTransformer_Type func(file *shimast.SourceFile) *shimast.SourceFile
+
+type importTransformer_transformFileProps struct {
+	Top     string
+	To      string
+	Context any
+	File    *shimast.SourceFile
+}
+
+type importTransformer_transformNodeProps struct {
+	Top  string
+	From string
+	To   string
+	Node *shimast.Node
+}
+
+type importTransformer_importMetadata struct {
+	Declaration *shimast.ImportDeclaration
+	Default     bool
+}
+
+var importTransformer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (importTransformerNamespace) Transform(props ImportTransformer_TransformProps) func(context any) ImportTransformer_Type {
+	return func(context any) ImportTransformer_Type {
+		return func(file *shimast.SourceFile) *shimast.SourceFile {
+			return importTransformer_transform_file(importTransformer_transformFileProps{
+				Top:     props.From,
+				To:      props.To,
+				Context: context,
+				File:    file,
+			})
+		}
+	}
+}
+
+func importTransformer_transform_file(props importTransformer_transformFileProps) *shimast.SourceFile {
+	if props.File == nil || props.File.IsDeclarationFile {
+		return props.File
+	}
+	from := get_directory_path(filepath.Clean(props.File.FileName()))
+	to := strings.Replace(from, filepath.Clean(props.Top), filepath.Clean(props.To), 1)
+
+	var visitor *shimast.NodeVisitor
+	visitor = shimast.NewNodeVisitor(func(node *shimast.Node) *shimast.Node {
+		if node == nil {
+			return nil
+		}
+		next := importTransformer_transform_node(importTransformer_transformNodeProps{
+			Top:  props.Top,
+			From: from,
+			To:   to,
+			Node: node,
+		})
+		return visitor.VisitEachChild(next)
+	}, importTransformer_factory, shimast.NodeVisitorHooks{})
+
+	transformed := visitor.VisitNode(props.File.AsNode())
+	if transformed == nil {
+		return props.File
+	}
+	return removeUnusedTypiaImports(transformed.AsSourceFile())
+}
+
+func importTransformer_transform_node(props importTransformer_transformNodeProps) *shimast.Node {
+	if props.Node == nil || props.Node.Kind != shimast.KindImportDeclaration {
+		return props.Node
+	}
+	decl := props.Node.AsImportDeclaration()
+	if decl == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+		return props.Node
+	}
+	text := decl.ModuleSpecifier.AsStringLiteral().Text
+	if text == "" || text[0] != '.' {
+		return props.Node
+	}
+
+	location := filepath.Clean(filepath.Join(props.From, text))
+	top := filepath.Clean(props.Top)
+	if strings.HasPrefix(location, top) {
+		return props.Node
+	}
+
+	replaced, err := filepath.Rel(props.To, location)
+	if err != nil {
+		return props.Node
+	}
+	replaced = filepath.ToSlash(replaced)
+	if strings.HasPrefix(replaced, ".") == false {
+		replaced = "./" + replaced
+	}
+	return importTransformer_factory.UpdateImportDeclaration(
+		decl,
+		decl.Modifiers(),
+		decl.ImportClause,
+		importTransformer_factory.NewStringLiteral(replaced, shimast.TokenFlagsNone),
+		decl.Attributes,
+	)
+}
+
+func get_directory_path(file string) string {
+	return filepath.Clean(filepath.Dir(file))
+}
+
+func removeUnusedTypiaImports(file *shimast.SourceFile) *shimast.SourceFile {
+	if file == nil || file.Statements == nil {
+		return file
+	}
+	imports := map[string]importTransformer_importMetadata{}
+	for _, stmt := range file.Statements.Nodes {
+		decl := importTransformer_typiaImport(stmt)
+		if decl == nil || decl.ImportClause == nil {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil {
+			continue
+		}
+		if name := importTransformer_identifierText(clause.Name()); name != "" {
+			imports[name] = importTransformer_importMetadata{Declaration: decl, Default: true}
+		}
+		if clause.NamedBindings != nil && clause.NamedBindings.Kind == shimast.KindNamedImports {
+			named := clause.NamedBindings.AsNamedImports()
+			if named != nil && named.Elements != nil {
+				for _, elem := range named.Elements.Nodes {
+					if elem == nil {
+						continue
+					}
+					spec := elem.AsImportSpecifier()
+					if spec == nil {
+						continue
+					}
+					if name := importTransformer_identifierText(spec.Name()); name != "" {
+						imports[name] = importTransformer_importMetadata{Declaration: decl, Default: false}
+					}
+				}
+			}
+		}
+	}
+	if len(imports) == 0 {
+		return file
+	}
+
+	nonTransformableUsage := map[string]bool{}
+	var checkUsage func(node *shimast.Node)
+	checkUsage = func(node *shimast.Node) {
+		if node == nil {
+			return
+		}
+		if node.Kind == shimast.KindIdentifier {
+			identifier := node.AsIdentifier().Text
+			if _, ok := imports[identifier]; ok {
+				parent := node.Parent
+				if parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+					access := parent.AsPropertyAccessExpression()
+					if access != nil && access.Expression == node {
+						if importTransformer_isLikelyTransformableCall(parent) == false {
+							nonTransformableUsage[identifier] = true
+						}
+					}
+				} else {
+					nonTransformableUsage[identifier] = true
+				}
+			}
+		}
+		node.ForEachChild(func(child *shimast.Node) bool {
+			checkUsage(child)
+			return false
+		})
+	}
+	for _, stmt := range file.Statements.Nodes {
+		if importTransformer_typiaImport(stmt) == nil {
+			checkUsage(stmt)
+		}
+	}
+
+	nodes := make([]*shimast.Node, 0, len(file.Statements.Nodes))
+	for _, stmt := range file.Statements.Nodes {
+		decl := importTransformer_typiaImport(stmt)
+		if decl == nil || decl.ImportClause == nil {
+			nodes = append(nodes, stmt)
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil {
+			nodes = append(nodes, stmt)
+			continue
+		}
+		name := clause.Name()
+		if importTransformer_identifierText(name) != "" && nonTransformableUsage[importTransformer_identifierText(name)] == false {
+			name = nil
+		}
+		namedBindings := clause.NamedBindings
+		if name == nil && namedBindings == nil {
+			continue
+		}
+		nextImportClause := importTransformer_factory.NewImportClause(
+			clause.PhaseModifier,
+			name,
+			namedBindings,
+		).AsImportClause()
+		nodes = append(nodes, importTransformer_factory.UpdateImportDeclaration(
+			decl,
+			decl.Modifiers(),
+			nextImportClause.AsNode(),
+			decl.ModuleSpecifier,
+			decl.Attributes,
+		))
+	}
+	return importTransformer_factory.UpdateSourceFile(
+		file,
+		importTransformer_factory.NewNodeList(nodes),
+		file.EndOfFileToken,
+	).AsSourceFile()
+}
+
+func importTransformer_typiaImport(stmt *shimast.Node) *shimast.ImportDeclaration {
+	if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+		return nil
+	}
+	decl := stmt.AsImportDeclaration()
+	if decl == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+		return nil
+	}
+	if decl.ModuleSpecifier.AsStringLiteral().Text != "typia" {
+		return nil
+	}
+	return decl
+}
+
+func importTransformer_isLikelyTransformableCall(node *shimast.Node) bool {
+	current := node
+	for current != nil && current.Kind == shimast.KindPropertyAccessExpression {
+		current = current.Parent
+	}
+	if current == nil || current.Kind != shimast.KindCallExpression {
+		return false
+	}
+	call := current.AsCallExpression()
+	if call == nil {
+		return false
+	}
+	if call.Expression == node {
+		return true
+	}
+	return call.Expression != nil &&
+		call.Expression.Kind == shimast.KindPropertyAccessExpression &&
+		importTransformer_isTypiaPropertyChain(call.Expression)
+}
+
+func importTransformer_isTypiaPropertyChain(node *shimast.Node) bool {
+	current := node
+	for current != nil && current.Kind == shimast.KindPropertyAccessExpression {
+		current = current.AsPropertyAccessExpression().Expression
+	}
+	return importTransformer_identifierText(current) == "typia"
+}
+
+func importTransformer_identifierText(node *shimast.Node) string {
+	if node == nil || node.Kind != shimast.KindIdentifier {
+		return ""
+	}
+	return node.AsIdentifier().Text
+}

package/native/transform/NodeTransformer.go

@@ -0,0 +1,25 @@
+package transform
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+)
+
+type nodeTransformerNamespace struct{}
+
+var NodeTransformer = nodeTransformerNamespace{}
+
+type NodeTransformer_TransformProps struct {
+	Context nativecontext.ITypiaContext
+	Node    *shimast.Node
+}
+
+func (nodeTransformerNamespace) Transform(props NodeTransformer_TransformProps) *shimast.Node {
+	if props.Node != nil && props.Node.Kind == shimast.KindCallExpression && props.Node.Parent != nil {
+		return CallExpressionTransformer.Transform(CallExpressionTransformer_TransformProps{
+			Context:    props.Context,
+			Expression: props.Node.AsCallExpression(),
+		})
+	}
+	return props.Node
+}

package/native/transform/TransformerError.go

@@ -0,0 +1,11 @@
+package transform
+
+import nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+
+type TransformerError = nativeinternal.TransformerError
+type TransformerError_IProps = nativeinternal.TransformerError_IProps
+type TransformerError_MetadataFactory_IError = nativeinternal.TransformerError_MetadataFactory_IError
+type TransformerError_MetadataFactory_IExplore = nativeinternal.TransformerError_MetadataFactory_IExplore
+
+var NewTransformerError = nativeinternal.NewTransformerError
+var TransformerError_from = nativeinternal.TransformerError_from

package/native/transform/TypiaGenerator.go

@@ -0,0 +1,168 @@
+package transform
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+)
+
+type typiaGeneratorNamespace struct{}
+
+var TypiaGenerator = typiaGeneratorNamespace{}
+
+type TypiaGenerator_ILocation struct {
+	Input   string
+	Output  string
+	Project string
+}
+
+type typiaGenerator_gatherProps struct {
+	Location  TypiaGenerator_ILocation
+	Container *[]string
+	From      string
+	To        string
+}
+
+var typiaGenerator_TS_PATTERN = regexp.MustCompile(`\.[cm]?tsx?$`)
+var typiaGenerator_DTS_PATTERN = regexp.MustCompile(`\.d\.[cm]?tsx?$`)
+
+func (typiaGeneratorNamespace) Build(location TypiaGenerator_ILocation) error {
+	var err error
+	location.Input, err = filepath.Abs(location.Input)
+	if err != nil {
+		return err
+	}
+	location.Output, err = filepath.Abs(location.Output)
+	if err != nil {
+		return err
+	}
+	location.Project, err = filepath.Abs(location.Project)
+	if err != nil {
+		return err
+	}
+
+	if ok, err := typiaGenerator_is_directory(location.Input); err != nil || ok == false {
+		return errors.New("Error on TypiaGenerator.generate(): input path is not a directory.")
+	}
+	if _, err := os.Stat(location.Output); errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(location.Output, 0o755); err != nil {
+			return err
+		}
+	} else if err != nil {
+		return err
+	} else if ok, err := typiaGenerator_is_directory(location.Output); err != nil || ok == false {
+		parent := filepath.Join(location.Output, "..")
+		if ok, err := typiaGenerator_is_directory(parent); err != nil || ok == false {
+			return errors.New("Error on TypiaGenerator.generate(): output path is not a directory.")
+		}
+		if err := os.Mkdir(location.Output, 0o755); err != nil && errors.Is(err, os.ErrExist) == false {
+			return err
+		}
+	}
+
+	container := []string{}
+	if err := typiaGenerator_gather(typiaGenerator_gatherProps{
+		Location:  location,
+		Container: &container,
+		From:      location.Input,
+		To:        location.Output,
+	}); err != nil {
+		return err
+	}
+
+	program, diagnostics, err := driver.LoadProgram(filepath.Dir(location.Project), filepath.Base(location.Project), driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		return err
+	}
+	if program != nil {
+		defer program.Close()
+	}
+	if len(diagnostics) != 0 {
+		return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
+	}
+
+	plugin := Transform(program, nil, nativecontext.ITypiaContext_Extras{
+		AddDiagnostic: func(diag *shimast.Diagnostic) int {
+			diagnostics = append(diagnostics, driver.Diagnostic{Message: "typia transform diagnostic"})
+			return len(diagnostics)
+		},
+	})
+	for _, file := range container {
+		if source := program.SourceFile(filepath.ToSlash(file)); source != nil {
+			plugin(source)
+		}
+		if len(diagnostics) != 0 {
+			return fmt.Errorf("TypiaGenerator.generate(): %s", diagnostics[0].String())
+		}
+		to := filepath.Join(location.Output, strings.TrimPrefix(file, location.Input))
+		if err := typiaGenerator_copy(file, to); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func typiaGenerator_is_directory(current string) (bool, error) {
+	stat, err := os.Stat(current)
+	if err != nil {
+		return false, err
+	}
+	return stat.IsDir(), nil
+}
+
+func typiaGenerator_gather(props typiaGenerator_gatherProps) error {
+	if filepath.Clean(props.From) == filepath.Clean(props.Location.Output) {
+		return nil
+	}
+	if _, err := os.Stat(props.To); errors.Is(err, os.ErrNotExist) {
+		if err := os.MkdirAll(props.To, 0o755); err != nil {
+			return err
+		}
+	}
+	files, err := os.ReadDir(props.From)
+	if err != nil {
+		return err
+	}
+	for _, file := range files {
+		next := filepath.Join(props.From, file.Name())
+		if file.IsDir() {
+			if err := typiaGenerator_gather(typiaGenerator_gatherProps{
+				Location:  props.Location,
+				Container: props.Container,
+				From:      next,
+				To:        filepath.Join(props.To, file.Name()),
+			}); err != nil {
+				return err
+			}
+			continue
+		}
+		if typiaGenerator_is_supported_extension(file.Name()) {
+			*props.Container = append(*props.Container, next)
+		}
+	}
+	return nil
+}
+
+func typiaGenerator_is_supported_extension(filename string) bool {
+	return typiaGenerator_TS_PATTERN.MatchString(filename) && typiaGenerator_DTS_PATTERN.MatchString(filename) == false
+}
+
+func typiaGenerator_copy(from string, to string) error {
+	data, err := os.ReadFile(from)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(to), 0o755); err != nil {
+		return err
+	}
+	return os.WriteFile(to, data, 0o644)
+}

package/native/transform/features/AssertTransformer.go

@@ -0,0 +1,39 @@
+package features
+
+import (
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+	nativeprogrammers "github.com/samchon/typia/packages/typia/native/core/programmers"
+	nativeinternal "github.com/samchon/typia/packages/typia/native/transform/internal"
+)
+
+type assertTransformerNamespace struct{}
+
+var AssertTransformer = assertTransformerNamespace{}
+
+func (assertTransformerNamespace) Transform(config nativeprogrammers.AssertProgrammer_IConfig) func(props nativeinternal.ITransformProps) *shimast.Node {
+	return func(props nativeinternal.ITransformProps) *shimast.Node {
+		method := "assert"
+		if config.Equals && config.Guard {
+			method = "assertGuardEquals"
+		} else if config.Equals {
+			method = "assertEquals"
+		} else if config.Guard {
+			method = "assertGuard"
+		}
+		return nativeinternal.GenericTransformer.Scalar(nativeinternal.GenericTransformer_IProps{
+			ITransformProps: props,
+			Method:          method,
+			Write: func(x nativecontext.IProgrammerProps) *shimast.Node {
+				return nativeprogrammers.AssertProgrammer.Write(nativeprogrammers.AssertProgrammer_IProps{
+					Context: x.Context,
+					Modulo:  x.Modulo,
+					Type:    x.Type,
+					Name:    x.Name,
+					Init:    x.Init,
+					Config:  config,
+				})
+			},
+		})
+	}
+}