@nestia/core 12.0.0-rc.4 → 12.1.0

package/native/transform/node_transform.go

@@ -15,8 +15,7 @@ import (
 // runtime references resolve to namespace imports tsgo's module-transform
 // aliases), injects those imports, and normalizes the synthetic operator tokens
 // typia's programmers leave nil. A diagnostic is appended for any site whose
-// generation raises a (recovered) transform error, matching the legacy text
-// path's swallow-and-report behavior.
+// generation raises a (recovered) transform error.
 //
 // addDiagnostic receives one entry per failed site; the build command turns a
 // non-empty diagnostic slice into a non-zero exit.
@@ -97,8 +96,7 @@ func nestiaCoreNodeTransform(
 		result = nestiaCoreInjectImports(result, importer.ToStatements(), ec)
 		// The node path prints through tsgo's printer, which dereferences the
 		// conditional ?/: operator tokens typia's programmers leave nil; the
-		// legacy text path filled them via normalizeNestiaSyntheticTokens before
-		// printing, so do the same here.
+		// so normalizeNestiaSyntheticTokens fills them before printing.
 		normalizeNestiaSyntheticTokens(result.AsNode())
 		return result
 	}
@@ -211,7 +209,7 @@ func nestiaCoreCollectMethodReplacements(
 		}
 		// @WebSocketRoute carries no injected validator (it is not a method kind),
 		// but its acceptor/driver parameter shapes are validated here, mirroring the
-		// legacy visitNestiaCoreNode path. Validate against the parse-tree method so
+		// collection pass. Validate against the parse-tree method so
 		// parameter type text resolves even when typia rebuilt this method.
 		if len(canonical) != 0 && canonical[len(canonical)-1] == "WebSocketRoute" {
 			for _, diag := range validateNestiaCoreWebSocketRoute(state.prog, context, nestiaCoreOriginalNode(state.ec, node), call, canonical) {

package/native/transform/printer.go

@@ -2,227 +2,10 @@ package transform
 
 import (
 	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimprinter "github.com/microsoft/typescript-go/shim/printer"
 )
 
 const nestiaKindColonToken = shimast.KindQuestionToken + 1
 
-func emitNestiaWithIdentifierSubstitutions(
-	node *shimast.Node,
-	sourceFile *shimast.SourceFile,
-	substitutions map[string]string,
-) string {
-	node = stripNestiaTypeSyntax(node)
-	node = rewriteNestiaIdentifiers(node, substitutions)
-	normalizeNestiaSyntheticTokens(node)
-	return emitNestiaNode(node, sourceFile)
-}
-
-func emitNestiaPreservingTypesWithIdentifierSubstitutions(
-	node *shimast.Node,
-	sourceFile *shimast.SourceFile,
-	substitutions map[string]string,
-) string {
-	node = rewriteNestiaIdentifiers(node, substitutions)
-	normalizeNestiaSyntheticTokens(node)
-	return emitNestiaNode(node, sourceFile)
-}
-
-func emitNestiaNode(node *shimast.Node, sourceFile *shimast.SourceFile) string {
-	return shimprinter.NewPrinter(shimprinter.PrinterOptions{
-		RemoveComments: true,
-		NewLine:        2,
-	}, shimprinter.PrintHandlers{}, nil).Emit(node, sourceFile)
-}
-
-func stripNestiaTypeSyntax(node *shimast.Node) *shimast.Node {
-	if node == nil {
-		return nil
-	}
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	var visitor *shimast.NodeVisitor
-	visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
-		if current == nil {
-			return nil
-		}
-		switch current.Kind {
-		case shimast.KindAsExpression, shimast.KindSatisfiesExpression, shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
-			return visitor.VisitNode(current.Expression())
-		case shimast.KindVariableDeclaration:
-			decl := current.AsVariableDeclaration()
-			return factory.UpdateVariableDeclaration(
-				decl,
-				visitor.VisitNode(decl.Name()),
-				nil,
-				nil,
-				visitor.VisitNode(decl.Initializer),
-			)
-		case shimast.KindParameter:
-			parameter := current.AsParameterDeclaration()
-			return factory.UpdateParameterDeclaration(
-				parameter,
-				visitor.VisitModifiers(parameter.Modifiers()),
-				visitor.VisitNode(parameter.DotDotDotToken),
-				visitor.VisitNode(parameter.Name()),
-				nil,
-				nil,
-				visitor.VisitNode(parameter.Initializer),
-			)
-		case shimast.KindArrowFunction:
-			arrow := current.AsArrowFunction()
-			return factory.UpdateArrowFunction(
-				arrow,
-				visitor.VisitModifiers(arrow.Modifiers()),
-				nil,
-				visitor.VisitNodes(arrow.Parameters),
-				nil,
-				nil,
-				visitor.VisitNode(arrow.EqualsGreaterThanToken),
-				visitor.VisitNode(arrow.Body),
-			)
-		case shimast.KindCallExpression:
-			call := current.AsCallExpression()
-			return factory.UpdateCallExpression(
-				call,
-				visitor.VisitNode(call.Expression),
-				visitor.VisitNode(call.QuestionDotToken),
-				nil,
-				visitor.VisitNodes(call.Arguments),
-				call.Flags,
-			)
-		case shimast.KindNewExpression:
-			expr := current.AsNewExpression()
-			return factory.UpdateNewExpression(
-				expr,
-				visitor.VisitNode(expr.Expression),
-				nil,
-				visitor.VisitNodes(expr.Arguments),
-			)
-		default:
-			return visitor.VisitEachChild(current)
-		}
-	}, factory, shimast.NodeVisitorHooks{})
-	return visitor.VisitNode(node)
-}
-
-func rewriteNestiaIdentifiers(
-	node *shimast.Node,
-	substitutions map[string]string,
-) *shimast.Node {
-	if node == nil || len(substitutions) == 0 {
-		return node
-	}
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	var visitor *shimast.NodeVisitor
-	visitor = shimast.NewNodeVisitor(func(current *shimast.Node) *shimast.Node {
-		if current == nil {
-			return nil
-		}
-		switch current.Kind {
-		case shimast.KindIdentifier:
-			if replacement, ok := substitutions[current.Text()]; ok {
-				return rewriteNestiaIdentifierExpression(factory, replacement)
-			}
-			return current
-		case shimast.KindVariableDeclaration:
-			decl := current.AsVariableDeclaration()
-			return factory.UpdateVariableDeclaration(
-				decl,
-				decl.Name(),
-				nil,
-				nil,
-				visitor.VisitNode(decl.Initializer),
-			)
-		case shimast.KindParameter:
-			parameter := current.AsParameterDeclaration()
-			return factory.UpdateParameterDeclaration(
-				parameter,
-				parameter.Modifiers(),
-				parameter.DotDotDotToken,
-				parameter.Name(),
-				nil,
-				nil,
-				visitor.VisitNode(parameter.Initializer),
-			)
-		case shimast.KindPropertyAssignment:
-			assignment := current.AsPropertyAssignment()
-			return factory.UpdatePropertyAssignment(
-				assignment,
-				assignment.Modifiers(),
-				assignment.Name(),
-				assignment.PostfixToken,
-				nil,
-				visitor.VisitNode(assignment.Initializer),
-			)
-		case shimast.KindShorthandPropertyAssignment:
-			assignment := current.AsShorthandPropertyAssignment()
-			name := assignment.Name()
-			if name != nil && name.Kind == shimast.KindIdentifier {
-				if replacement, ok := substitutions[name.Text()]; ok &&
-					assignment.ObjectAssignmentInitializer == nil {
-					return factory.NewPropertyAssignment(
-						assignment.Modifiers(),
-						name,
-						assignment.PostfixToken,
-						nil,
-						rewriteNestiaIdentifierExpression(factory, replacement),
-					)
-				}
-			}
-			return factory.UpdateShorthandPropertyAssignment(
-				assignment,
-				assignment.Modifiers(),
-				name,
-				assignment.PostfixToken,
-				nil,
-				nil,
-				visitor.VisitNode(assignment.ObjectAssignmentInitializer),
-			)
-		case shimast.KindPropertyAccessExpression:
-			access := current.AsPropertyAccessExpression()
-			return factory.UpdatePropertyAccessExpression(
-				access,
-				visitor.VisitNode(access.Expression),
-				access.QuestionDotToken,
-				access.Name(),
-				access.Flags,
-			)
-		default:
-			return visitor.VisitEachChild(current)
-		}
-	}, factory, shimast.NodeVisitorHooks{})
-	return visitor.VisitNode(node)
-}
-
-func rewriteNestiaIdentifierExpression(
-	factory *shimast.NodeFactory,
-	replacement string,
-) *shimast.Node {
-	parts := []string{}
-	start := 0
-	for i := 0; i <= len(replacement); i++ {
-		if i == len(replacement) || replacement[i] == '.' {
-			if start < i {
-				parts = append(parts, replacement[start:i])
-			}
-			start = i + 1
-		}
-	}
-	if len(parts) == 0 {
-		return factory.NewIdentifier(replacement)
-	}
-	output := factory.NewIdentifier(parts[0])
-	for _, part := range parts[1:] {
-		output = factory.NewPropertyAccessExpression(
-			output,
-			nil,
-			factory.NewIdentifier(part),
-			shimast.NodeFlagsNone,
-		)
-	}
-	return output
-}
-
 func normalizeNestiaSyntheticTokens(node *shimast.Node) {
 	if node == nil {
 		return

package/native/transform/transform.go

@@ -8,7 +8,6 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"sort"
 	"strings"
 
 	shimast "github.com/microsoft/typescript-go/shim/ast"
@@ -74,13 +73,12 @@ func runTransform(args []string) int {
 	// contributor's per-file node transformers run inside one shared EmitContext
 	// and the result SourceFile is printed back as TypeScript (no JS script
 	// transformers), mirroring typia's `transform` subcommand. Injected namespace
-	// imports stay as ES imports the caller can type-strip per file, so there is
-	// no text-splice RewriteSet.
+	// imports stay as ES imports the caller can type-strip per file.
 	transformDiags := []Diagnostic{}
 	addDiagnostic := func(diag Diagnostic) {
 		transformDiags = append(transformDiags, diag)
 	}
-	typiaTransform := nestiaTypiaNodeTransform(prog, readTypiaPluginOptions(cwd, *tsconfigPath), addDiagnostic)
+	typiaTransform := nestiaTypiaNodeTransform(prog, readTypiaPluginOptions(plan), addDiagnostic)
 	coreTransform := nestiaCoreNodeTransform(prog, plan, addDiagnostic)
 	contributorTransforms, contributorDiags := collectContributorEmitTransforms(prog, plan)
 	if len(contributorDiags) > 0 {
@@ -196,32 +194,6 @@ func writeSingleOutput(text, outPath string) int {
 	return 0
 }
 
-type SourceRewrite struct {
-	start       int
-	end         int
-	replacement string
-}
-
-func ApplySourceRewrites(source string, rewrites []SourceRewrite) (string, error) {
-	sort.SliceStable(rewrites, func(i, j int) bool {
-		return rewrites[i].start > rewrites[j].start
-	})
-	for i := 0; i < len(rewrites)-1; i++ {
-		if rewrites[i+1].end > rewrites[i].start {
-			return "", fmt.Errorf("overlapping rewrites: [%d,%d) vs [%d,%d)",
-				rewrites[i+1].start, rewrites[i+1].end, rewrites[i].start, rewrites[i].end)
-		}
-	}
-	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 SourceFileText(target any) (string, bool) {
 	type sourceText interface {
 		Text() string
@@ -244,53 +216,11 @@ var (
 	cleanupInputIsParenPattern      = regexp.MustCompile(`input is \(([A-Za-z_$][A-Za-z0-9_$.]*)\)`)
 	cleanupCollapseBlankCallPattern = regexp.MustCompile(`\n\n([A-Za-z_$][A-Za-z0-9_$]*\([^;\n]*\);?)`)
 )
-
-func cleanupTypeScriptTransformText(text string) string {
-	text = cleanupTransformedText(text)
-	text = normalizeParenthesizedTypeAnnotations(text)
-	text = cleanupImportTypeBlockPattern.ReplaceAllStringFunc(text, func(line string) string {
-		return cleanupImportTypeLinePattern.ReplaceAllString(line, "import type { $1 } from")
-	})
-	text = cleanupImportBlankLinePattern.ReplaceAllString(text, "$1$2")
-	text = strings.ReplaceAll(text, "=(() =>", "= (() =>")
-	text = strings.ReplaceAll(text, ": (any) =>", ": any =>")
-	text = strings.ReplaceAll(text, ": (boolean) =>", ": boolean =>")
-	text = cleanupInputIsParenPattern.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 = cleanupCollapseBlankCallPattern.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
-}
-
 var (
 	normalizeParenArrowTypePattern = regexp.MustCompile(`: \(([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)\)(\s*=>)`)
 	normalizeParenNullishPattern   = regexp.MustCompile(`\| \((null|undefined)\)`)
 )
 
-func normalizeParenthesizedTypeAnnotations(text string) string {
-	text = normalizeParenArrowTypePattern.ReplaceAllString(text, ": $1$3")
-	text = normalizeParenNullishPattern.ReplaceAllString(text, "| $1")
-	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)) {
@@ -298,25 +228,6 @@ func sourceFileKey(cwd string, file string) string {
 	}
 	return filepath.ToSlash(rel)
 }
-
-func newTransformCompilerDiagnostic(
-	file string,
-	code string,
-	message string,
-) transformCompilerDiagnostic {
-	var ptr *string
-	if file != "" {
-		normalized := filepath.ToSlash(file)
-		ptr = &normalized
-	}
-	return transformCompilerDiagnostic{
-		File:        ptr,
-		Category:    "error",
-		Code:        code,
-		MessageText: message,
-	}
-}
-
 func transformDiagnosticToCompilerDiagnostic(
 	diag Diagnostic,
 ) transformCompilerDiagnostic {