typia 13.0.0-dev.20260430 → 13.0.0-dev.20260501

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

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"os"
@@ -28,10 +29,6 @@ func runTransform(args []string) int {
 	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
@@ -63,6 +60,14 @@ func runTransform(args []string) int {
 	}
 	defer prog.Close()
 
+	if *file == "" {
+		if *out != "" {
+			fmt.Fprintln(stderr, "ttsc-typia transform: --out requires --file")
+			return 2
+		}
+		return runTransformProject(prog, cwd, *rewriteMode, *tsconfigPath)
+	}
+
 	absFile := *file
 	if !filepath.IsAbs(absFile) {
 		absFile = filepath.Join(cwd, absFile)
@@ -134,12 +139,92 @@ func defaultTransformOutput() string {
 	return "js"
 }
 
+type transformProjectOutput struct {
+	Diagnostics []transformCompilerDiagnostic `json:"diagnostics,omitempty"`
+	TypeScript  map[string]string             `json:"typescript"`
+}
+
+type transformCompilerDiagnostic struct {
+	File        *string `json:"file"`
+	Category    string  `json:"category"`
+	Code        string  `json:"code"`
+	Line        int     `json:"line,omitempty"`
+	Character   int     `json:"character,omitempty"`
+	MessageText string  `json:"messageText"`
+}
+
 type transformSourceRewrite struct {
 	start       int
 	end         int
 	replacement string
 }
 
+func runTransformProject(
+	prog *driver.Program,
+	cwd string,
+	rewriteMode string,
+	tsconfigPath string,
+) int {
+	rewrites := map[string][]transformSourceRewrite{}
+	diagnostics := []transformCompilerDiagnostic{}
+	if rewriteMode == "typia" {
+		grouped, diags := collectTypiaSourceRewriteMap(
+			prog,
+			readTypiaPluginOptions(cwd, tsconfigPath),
+		)
+		rewrites = grouped
+		for _, diag := range diags {
+			diagnostics = append(diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
+		}
+	}
+
+	output := transformProjectOutput{
+		Diagnostics: diagnostics,
+		TypeScript:  map[string]string{},
+	}
+	for _, file := range prog.SourceFiles() {
+		filename := filepath.ToSlash(file.FileName())
+		source, ok := sourceFileText(file)
+		if !ok {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(
+					filename,
+					0,
+					0,
+					"typia.transform",
+					"source text is unavailable",
+				),
+			)
+			continue
+		}
+		transformed, err := applySourceRewrites(source, rewrites[filename])
+		if err != nil {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(
+					filename,
+					0,
+					0,
+					"typia.transform",
+					err.Error(),
+				),
+			)
+			continue
+		}
+		output.TypeScript[sourceFileKey(cwd, filename)] = cleanupTypeScriptTransformText(transformed)
+	}
+
+	if err := json.NewEncoder(stdout).Encode(output); err != nil {
+		fmt.Fprintf(stderr, "ttsc-typia transform: encode output: %v\n", err)
+		return 3
+	}
+	if len(output.Diagnostics) > 0 {
+		return 3
+	}
+	return 0
+}
+
 func runTransformTypeScript(
 	prog *driver.Program,
 	cwd string,
@@ -241,6 +326,38 @@ func collectTypiaSourceRewrites(
 	return rewrites, diagnostics
 }
 
+func collectTypiaSourceRewriteMap(
+	prog *driver.Program,
+	pluginOptions typiaadapter.PluginOptions,
+) (map[string][]transformSourceRewrite, []typiaTransformDiagnostic) {
+	sites := typiaadapter.CollectCallSites(prog.SourceFiles(), prog.Checker)
+	rewrites := map[string][]transformSourceRewrite{}
+	diagnostics := []typiaTransformDiagnostic{}
+	for _, site := range sites {
+		file := filepath.ToSlash(site.FilePath)
+		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[file] = append(rewrites[file], transformSourceRewrite{
+			start:       node.Pos(),
+			end:         node.End(),
+			replacement: expr,
+		})
+	}
+	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
@@ -288,3 +405,45 @@ func cleanupTypeScriptTransformText(text string) string {
 	}
 	return text
 }
+
+func sourceFileKey(cwd string, file string) string {
+	rel, err := filepath.Rel(cwd, filepath.FromSlash(file))
+	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
+		return filepath.ToSlash(file)
+	}
+	return filepath.ToSlash(rel)
+}
+
+func transformDiagnosticToCompilerDiagnostic(
+	diag typiaTransformDiagnostic,
+) transformCompilerDiagnostic {
+	return newTransformCompilerDiagnostic(
+		diag.File,
+		diag.Line,
+		diag.Column,
+		diag.Code,
+		diag.Message,
+	)
+}
+
+func newTransformCompilerDiagnostic(
+	file string,
+	line int,
+	character int,
+	code string,
+	message string,
+) transformCompilerDiagnostic {
+	var ptr *string
+	if file != "" {
+		normalized := filepath.ToSlash(file)
+		ptr = &normalized
+	}
+	return transformCompilerDiagnostic{
+		File:        ptr,
+		Category:    "error",
+		Code:        code,
+		Line:        line,
+		Character:   character,
+		MessageText: message,
+	}
+}

package/native/core/factories/LiteralFactory.go

@@ -100,7 +100,7 @@ func literalFactory_fieldName(name string) string {
 func literalFactory_writeObject(obj map[string]any) *shimast.Node {
 	keys := make([]string, 0, len(obj))
 	for key, value := range obj {
-		if value == nil {
+		if literalFactory_isNilLike(value) {
 			continue
 		}
 		keys = append(keys, key)
@@ -190,6 +190,19 @@ func literalFactory_propertyRank(key string) int {
 	return 1_000
 }
 
+func literalFactory_isNilLike(value any) bool {
+	if value == nil {
+		return true
+	}
+	reflected := reflect.ValueOf(value)
+	switch reflected.Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
+		return reflected.IsNil()
+	default:
+		return false
+	}
+}
+
 func literalFactory_writeArray(array []any) *shimast.Node {
 	elements := make([]*shimast.Node, 0, len(array))
 	for _, elem := range array {

package/native/core/programmers/llm/LlmApplicationProgrammer.go

@@ -329,8 +329,7 @@ func llmApplicationProgrammer_writeParameters(props struct {
 }) any {
 	rawParameters, _ := props.Function["parameters"].([]any)
 	if len(rawParameters) == 0 {
-		return llmParametersProgrammer_write_parameters_expression(
-			props.Context,
+		return llmApplicationProgrammer_convertParameters(
 			props.Components,
 			nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "additionalProperties": false, "required": []any{}},
 			props.Config,
@@ -355,7 +354,7 @@ func llmApplicationProgrammer_writeParameters(props struct {
 			schema["description"] = description
 		}
 	}
-	return llmParametersProgrammer_write_parameters_expression(props.Context, props.Components, schema, props.Config)
+	return llmApplicationProgrammer_convertParameters(props.Components, schema, props.Config)
 }
 
 func llmApplicationProgrammer_writeOutput(props struct {
@@ -370,7 +369,20 @@ func llmApplicationProgrammer_writeOutput(props struct {
 			props.Schema["description"] = desc
 		}
 	}
-	return llmParametersProgrammer_write_parameters_expression(props.Context, props.Components, props.Schema, props.Config)
+	return llmApplicationProgrammer_convertParameters(props.Components, props.Schema, props.Config)
+}
+
+func llmApplicationProgrammer_convertParameters(
+	components *nativeiterate.OpenApi_IComponents,
+	schema nativeiterate.JsonSchema,
+	config map[string]any,
+) map[string]any {
+	defs := map[string]any{}
+	target := llmParametersProgrammer_dereference_schema(schema, components)
+	output := llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
+	output["additionalProperties"] = false
+	output["$defs"] = defs
+	return output
 }
 
 func llmApplicationProgrammer_writeValidator(props struct {

package/native/core/programmers/llm/LlmParametersProgrammer.go

@@ -45,27 +45,13 @@ func (llmParametersProgrammerNamespace) Write(props LlmParametersProgrammer_IWri
 }
 
 func (llmParametersProgrammerNamespace) WriteParametersExpression(props LlmParametersProgrammer_IWriteProps) *shimast.Node {
-	collection := nativejson.JsonSchemasProgrammer.WriteSchemas(struct {
-		Version   string
-		Metadatas []*schemametadata.MetadataSchema
+	return nativefactories.LiteralFactory.Write(LlmParametersProgrammer.WriteParameters(struct {
+		Metadata *schemametadata.MetadataSchema
+		Config   map[string]any
 	}{
-		Version:   "3.1",
-		Metadatas: []*schemametadata.MetadataSchema{props.Metadata},
-	})
-	if len(collection.Schemas) == 0 {
-		return llmParametersProgrammer_write_parameters_expression(
-			props.Context,
-			&nativeiterate.OpenApi_IComponents{Schemas: map[string]nativeiterate.JsonSchema{}},
-			nativeiterate.JsonSchema{"type": "object", "properties": map[string]any{}, "required": []any{}},
-			props.Config,
-		)
-	}
-	return llmParametersProgrammer_write_parameters_expression(
-		props.Context,
-		collection.Components,
-		llmParametersProgrammer_dereference_schema(collection.Schemas[0], collection.Components),
-		props.Config,
-	)
+		Metadata: props.Metadata,
+		Config:   props.Config,
+	}))
 }
 
 func (llmParametersProgrammerNamespace) WriteParameters(props struct {
@@ -84,14 +70,14 @@ func (llmParametersProgrammerNamespace) WriteParameters(props struct {
 	}
 	schema := collection.Schemas[0]
 	if typ, ok := schema["type"].(string); ok && typ == "object" {
-		return llmParametersProgrammer_convert_parameters(schema, collection.Components)
+		return llmParametersProgrammer_convert_parameters(schema, collection.Components, props.Config)
 	}
 	if ref, ok := schema["$ref"].(string); ok {
 		name := ref[strings.LastIndex(ref, "/")+1:]
 		if collection.Components != nil && collection.Components.Schemas != nil {
 			if target, found := collection.Components.Schemas[name]; found {
 				if typ, ok := target["type"].(string); ok && typ == "object" {
-					return llmParametersProgrammer_convert_parameters(target, collection.Components)
+					return llmParametersProgrammer_convert_parameters(target, collection.Components, props.Config)
 				}
 			}
 		}
@@ -133,28 +119,15 @@ func (llmParametersProgrammerNamespace) Validate(props struct {
 	return output
 }
 
-func llmParametersProgrammer_convert_parameters(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents) map[string]any {
+func llmParametersProgrammer_convert_parameters(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents, config map[string]any) map[string]any {
 	defs := map[string]any{}
 	target := llmParametersProgrammer_dereference_schema(schema, components)
-	output := llmSchemaProgrammer_convert_schema(target, components, defs)
+	output := llmSchemaProgrammer_convert_schema_config(target, components, defs, config)
 	output["additionalProperties"] = false
 	output["$defs"] = defs
 	return output
 }
 
-func llmParametersProgrammer_write_parameters_expression(
-	context nativecontext.ITypiaContext,
-	components *nativeiterate.OpenApi_IComponents,
-	schema nativeiterate.JsonSchema,
-	config map[string]any,
-) *shimast.Node {
-	return llmProgrammer_converter_result(context, "parameters", "typia.llm.parameters", []*shimast.Node{
-		llmProgrammer_object_property("config", llmProgrammer_config_expression(config)),
-		llmProgrammer_object_property("components", nativefactories.LiteralFactory.Write(components)),
-		llmProgrammer_object_property("schema", nativefactories.LiteralFactory.Write(schema)),
-	})
-}
-
 func llmParametersProgrammer_dereference_schema(schema nativeiterate.JsonSchema, components *nativeiterate.OpenApi_IComponents) nativeiterate.JsonSchema {
 	ref, ok := schema["$ref"].(string)
 	if ok == false || components == nil || components.Schemas == nil {