@nestia/core 11.2.1 → 12.0.0-dev.20260520.1

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

@@ -0,0 +1,387 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/samchon/nestia/packages/core/native/plugin"
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+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"`
+}
+
+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 to PATH")
+	output := fs.String("output", "ts", "transform output kind: ts")
+	pluginsJSON := fs.String("plugins-json", "", "ordered ttsc plugin payload")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *output != "ts" {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: unknown --output value %q\n", *output)
+		return 2
+	}
+	plan, err := plugin.ParsePlan(*pluginsJSON)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: %v\n", err)
+		return 2
+	}
+
+	cwd, ok := resolveCWD("ttsc-nestia transform", *cwdOverride)
+	if !ok {
+		return 2
+	}
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceNoEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: %v\n", err)
+		return 2
+	}
+	if len(diags) > 0 {
+		driver.WritePrettyDiagnostics(stderr, diags, cwd)
+		return 2
+	}
+	defer prog.Close()
+
+	if *file == "" {
+		if *out != "" {
+			fmt.Fprintln(stderr, "ttsc-nestia transform: --out requires --file")
+			return 2
+		}
+		return runTransformProject(prog, cwd, *tsconfigPath, plan)
+	}
+
+	absFile := *file
+	if !filepath.IsAbs(absFile) {
+		absFile = filepath.Join(cwd, absFile)
+	}
+	absFile = filepath.ToSlash(absFile)
+	target := prog.SourceFile(absFile)
+	if target == nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source file is not in program: %s\n", absFile)
+		return 2
+	}
+	rewrites, diagnostics := collectTypiaSourceRewrites(
+		prog,
+		cwd,
+		absFile,
+		readTypiaPluginOptions(cwd, *tsconfigPath),
+	)
+	if len(diagnostics) > 0 {
+		writeTypiaTransformDiagnostics(stderr, diagnostics, cwd)
+		return 3
+	}
+	coreRewriteMap, coreDiagnostics := collectNestiaCoreSourceRewriteMap(prog, plan, absFile)
+	if len(coreDiagnostics) > 0 {
+		writeTypiaTransformDiagnostics(stderr, coreDiagnostics, cwd)
+		return 3
+	}
+	rewrites = append(rewrites, coreRewriteMap[filepath.ToSlash(absFile)]...)
+	sdkRewriteMap, sdkDiagnostics := collectNestiaSDKSourceRewriteMap(prog, plan, absFile)
+	if len(sdkDiagnostics) > 0 {
+		writeTypiaTransformDiagnostics(stderr, sdkDiagnostics, cwd)
+		return 3
+	}
+	rewrites = append(rewrites, sdkRewriteMap[filepath.ToSlash(absFile)]...)
+	source, ok := sourceFileText(target)
+	if !ok {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source text is unavailable for %s\n", absFile)
+		return 3
+	}
+	source, err = applySourceRewrites(source, rewrites)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: source rewrite: %v\n", err)
+		return 3
+	}
+	source = cleanupTypeScriptTransformText(source)
+	if *out == "" {
+		if _, err := bytes.NewBufferString(source).WriteTo(stdout); err != nil {
+			fmt.Fprintf(stderr, "ttsc-nestia transform: write stdout: %v\n", err)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(*out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc-nestia transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(*out, []byte(source), 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc-nestia transform: write %s: %v\n", *out, err)
+		return 3
+	}
+	return 0
+}
+
+func runTransformProject(prog *driver.Program, cwd string, tsconfigPath string, plan plugin.Plan) int {
+	rewrites, diags := collectTypiaSourceRewriteMap(
+		prog,
+		readTypiaPluginOptions(cwd, tsconfigPath),
+	)
+	coreRewriteMap, coreDiags := collectNestiaCoreSourceRewriteMap(prog, plan, "")
+	for file, entries := range coreRewriteMap {
+		rewrites[file] = append(rewrites[file], entries...)
+	}
+	diags = append(diags, coreDiags...)
+	sdkRewriteMap, sdkDiags := collectNestiaSDKSourceRewriteMap(prog, plan, "")
+	for file, entries := range sdkRewriteMap {
+		rewrites[file] = append(rewrites[file], entries...)
+	}
+	diags = append(diags, sdkDiags...)
+	output := transformProjectOutput{
+		Diagnostics: make([]transformCompilerDiagnostic, 0, len(diags)),
+		TypeScript:  map[string]string{},
+	}
+	for _, diag := range diags {
+		output.Diagnostics = append(output.Diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
+	}
+	for _, file := range prog.SourceFiles() {
+		filename := filepath.ToSlash(file.FileName())
+		source, ok := sourceFileText(file)
+		if !ok {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(filename, "nestia.transform", "source text is unavailable"),
+			)
+			continue
+		}
+		transformed, err := applySourceRewrites(source, rewrites[filename])
+		if err != nil {
+			output.Diagnostics = append(
+				output.Diagnostics,
+				newTransformCompilerDiagnostic(filename, "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-nestia transform: encode output: %v\n", err)
+		return 3
+	}
+	if len(output.Diagnostics) > 0 {
+		return 3
+	}
+	return 0
+}
+
+type transformSourceRewrite struct {
+	start       int
+	end         int
+	replacement string
+}
+
+func collectTypiaSourceRewrites(
+	prog *driver.Program,
+	cwd string,
+	onlyFile string,
+	pluginOptions typiaadapter.PluginOptions,
+) ([]transformSourceRewrite, []typiaTransformDiagnostic) {
+	sites := collectNestiaTypiaCallSites(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
+		}
+		expr = parenthesizeTypiaReplacement(site, expr)
+		node := site.Call.AsNode()
+		rewrites = append(rewrites, transformSourceRewrite{
+			start:       node.Pos(),
+			end:         node.End(),
+			replacement: expr,
+		})
+		_ = cwd
+	}
+	return rewrites, diagnostics
+}
+
+func collectTypiaSourceRewriteMap(
+	prog *driver.Program,
+	pluginOptions typiaadapter.PluginOptions,
+) (map[string][]transformSourceRewrite, []typiaTransformDiagnostic) {
+	sites := collectNestiaTypiaCallSites(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
+		}
+		expr = parenthesizeTypiaReplacement(site, expr)
+		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
+	})
+	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
+	}
+	file, ok := target.(sourceText)
+	if !ok {
+		return "", false
+	}
+	return file.Text(), true
+}
+
+func cleanupTypeScriptTransformText(text string) string {
+	text = cleanupTransformedText(text)
+	text = normalizeParenthesizedTypeAnnotations(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
+}
+
+func normalizeParenthesizedTypeAnnotations(text string) string {
+	typeAtom := `([A-Za-z_$][A-Za-z0-9_$.]*(<[^()\n;{}]*>)?)`
+	text = regexp.MustCompile(`: \(`+typeAtom+`\)(\s*=>)`).ReplaceAllString(text, ": $1$3")
+	text = regexp.MustCompile(`\| \((null|undefined)\)`).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)) {
+		return filepath.ToSlash(file)
+	}
+	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 typiaTransformDiagnostic,
+) transformCompilerDiagnostic {
+	var ptr *string
+	if diag.File != "" {
+		normalized := filepath.ToSlash(diag.File)
+		ptr = &normalized
+	}
+	return transformCompilerDiagnostic{
+		File:        ptr,
+		Category:    "error",
+		Code:        diag.Code,
+		Line:        diag.Line,
+		Character:   diag.Column,
+		MessageText: diag.Message,
+	}
+}

package/native/cmd/ttsc-nestia/typia_fast.go

@@ -0,0 +1,326 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	typiaadapter "github.com/samchon/typia/packages/typia/native/adapter"
+)
+
+type nestiaTypiaImportRoot struct {
+	module string
+}
+
+func collectNestiaTypiaCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []typiaadapter.CallSite {
+	sites := []typiaadapter.CallSite{}
+	for _, file := range files {
+		if file == nil || file.IsDeclarationFile {
+			continue
+		}
+		roots, fallback := nestiaTypiaImportRoots(file)
+		if len(roots) == 0 {
+			if fallback {
+				sites = append(sites, typiaadapter.CollectCallSites([]*shimast.SourceFile{file}, checker)...)
+			}
+			continue
+		}
+		file.ForEachChild(func(node *shimast.Node) bool {
+			visitNestiaTypiaCallSite(file, checker, roots, node, &sites)
+			return false
+		})
+	}
+	return sites
+}
+
+func visitNestiaTypiaCallSite(
+	file *shimast.SourceFile,
+	checker *shimchecker.Checker,
+	roots map[string]nestiaTypiaImportRoot,
+	node *shimast.Node,
+	sites *[]typiaadapter.CallSite,
+) {
+	if node == nil {
+		return
+	}
+	if node.Kind == shimast.KindCallExpression {
+		call := node.AsCallExpression()
+		if call != nil && nestiaTypiaCallLooksPossible(call, roots) {
+			if site, ok := tryNestiaTypiaCallSite(file, checker, node); ok {
+				*sites = append(*sites, site)
+			}
+		}
+	}
+	node.ForEachChild(func(child *shimast.Node) bool {
+		visitNestiaTypiaCallSite(file, checker, roots, child, sites)
+		return false
+	})
+}
+
+func nestiaTypiaImportRoots(file *shimast.SourceFile) (map[string]nestiaTypiaImportRoot, bool) {
+	roots := map[string]nestiaTypiaImportRoot{}
+	fallback := false
+	if file == nil || file.Statements == nil {
+		return roots, fallback
+	}
+	for _, stmt := range file.Statements.Nodes {
+		if stmt == nil || stmt.Kind != shimast.KindImportDeclaration {
+			continue
+		}
+		decl := stmt.AsImportDeclaration()
+		if decl == nil || decl.ImportClause == nil || decl.ModuleSpecifier == nil || decl.ModuleSpecifier.Kind != shimast.KindStringLiteral {
+			continue
+		}
+		moduleText := decl.ModuleSpecifier.Text()
+		module, ok := nestiaTypiaImportModule(moduleText)
+		if ok == false {
+			continue
+		}
+		clause := decl.ImportClause.AsImportClause()
+		if clause == nil || clause.PhaseModifier == shimast.KindTypeKeyword {
+			continue
+		}
+		if name := clause.Name(); name != nil {
+			roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+		}
+		if clause.NamedBindings == nil {
+			continue
+		}
+		if clause.NamedBindings.Kind == shimast.KindNamespaceImport {
+			if name := clause.NamedBindings.Name(); name != nil {
+				roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+			}
+			continue
+		}
+		if clause.NamedBindings.Kind != shimast.KindNamedImports {
+			continue
+		}
+		named := clause.NamedBindings.AsNamedImports()
+		if named == nil || named.Elements == nil {
+			continue
+		}
+		for _, elem := range named.Elements.Nodes {
+			if elem == nil {
+				continue
+			}
+			spec := elem.AsImportSpecifier()
+			if spec == nil || spec.IsTypeOnly {
+				continue
+			}
+			name := spec.Name()
+			if name == nil {
+				continue
+			}
+			imported := name.Text()
+			if spec.PropertyName != nil {
+				imported = spec.PropertyName.Text()
+			}
+			if module == "" {
+				if nestiaTypiaKnownModule(imported) == false {
+					continue
+				}
+				roots[name.Text()] = nestiaTypiaImportRoot{module: imported}
+			} else {
+				roots[name.Text()] = nestiaTypiaImportRoot{module: module}
+			}
+		}
+	}
+	return roots, fallback
+}
+
+func nestiaTypiaImportModule(specifier string) (string, bool) {
+	switch specifier {
+	case "typia":
+		return "", true
+	}
+	for _, prefix := range []string{"typia/lib/", "typia/src/"} {
+		if strings.HasPrefix(specifier, prefix) {
+			name := strings.TrimPrefix(specifier, prefix)
+			if strings.Contains(name, "/") || nestiaTypiaKnownModule(name) == false {
+				return "", false
+			}
+			return name, true
+		}
+	}
+	return "", false
+}
+
+func nestiaTypiaKnownModule(name string) bool {
+	switch name {
+	case "functional", "http", "json", "llm", "misc", "module", "notations", "protobuf", "reflect":
+		return true
+	default:
+		return false
+	}
+}
+
+func nestiaTypiaCallLooksPossible(call *shimast.CallExpression, roots map[string]nestiaTypiaImportRoot) bool {
+	root, parts, ok := nestiaTypiaCallSegments(call)
+	if ok == false {
+		return false
+	}
+	info, ok := roots[root]
+	if ok == false || len(parts) == 0 {
+		return false
+	}
+	if info.module != "" {
+		return true
+	}
+	if len(parts) == 1 {
+		return true
+	}
+	return nestiaTypiaKnownModule(parts[0])
+}
+
+func nestiaTypiaCallSegments(call *shimast.CallExpression) (string, []string, bool) {
+	if call == nil {
+		return "", nil, false
+	}
+	expression := call.Expression
+	parts := []string{}
+	for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
+		property := expression.AsPropertyAccessExpression()
+		if property == nil {
+			return "", nil, false
+		}
+		name := property.Name()
+		if name == nil || name.Kind != shimast.KindIdentifier {
+			return "", nil, false
+		}
+		id := name.AsIdentifier()
+		if id == nil || id.Text == "" {
+			return "", nil, false
+		}
+		parts = append([]string{id.Text}, parts...)
+		expression = property.Expression
+	}
+	if expression == nil || expression.Kind != shimast.KindIdentifier {
+		return "", nil, false
+	}
+	root := expression.AsIdentifier()
+	if root == nil || root.Text == "" {
+		return "", nil, false
+	}
+	return root.Text, parts, true
+}
+
+func tryNestiaTypiaCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (typiaadapter.CallSite, bool) {
+	if checker == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	call := node.AsCallExpression()
+	if call == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	signature := checker.GetResolvedSignature(node)
+	if signature == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	declaration := signature.Declaration()
+	if declaration == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	sourceFile := shimast.GetSourceFileOfNode(declaration)
+	if sourceFile == nil {
+		return typiaadapter.CallSite{}, false
+	}
+	module, ok := nestiaTypiaMatchModule(sourceFile.FileName())
+	if !ok {
+		return typiaadapter.CallSite{}, false
+	}
+	method := nestiaTypiaCallSiteMethodName(checker, declaration, call)
+	if method == "" {
+		return typiaadapter.CallSite{}, false
+	}
+	root, namespaces, ok := nestiaTypiaExtractRootAndNamespaces(call, method)
+	if !ok {
+		return typiaadapter.CallSite{}, false
+	}
+	return typiaadapter.CallSite{
+		File:       file,
+		FilePath:   file.FileName(),
+		Module:     module,
+		Method:     method,
+		Call:       call,
+		RootName:   root,
+		Namespaces: namespaces,
+	}, true
+}
+
+func nestiaTypiaMatchModule(location string) (string, bool) {
+	location = filepath.ToSlash(location)
+	for _, suffix := range []string{".d.ts", ".ts"} {
+		for _, middle := range []string{"typia/lib/", "typia/src/", "packages/typia/src/"} {
+			index := strings.LastIndex(location, middle)
+			if index < 0 {
+				continue
+			}
+			name := location[index+len(middle):]
+			if !strings.HasSuffix(name, suffix) {
+				continue
+			}
+			name = strings.TrimSuffix(name, suffix)
+			if strings.Contains(name, "/") {
+				continue
+			}
+			return name, true
+		}
+	}
+	return "", false
+}
+
+func nestiaTypiaCallSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
+	if name := declaration.Name(); name != nil {
+		if symbol := checker.GetSymbolAtLocation(name); symbol != nil && symbol.Name != "" {
+			return symbol.Name
+		}
+		if name.Kind == shimast.KindIdentifier {
+			if id := name.AsIdentifier(); id != nil {
+				return id.Text
+			}
+		}
+	}
+	if call.Expression != nil && call.Expression.Kind == shimast.KindPropertyAccessExpression {
+		if property := call.Expression.AsPropertyAccessExpression(); property != nil {
+			if name := property.Name(); name != nil && name.Kind == shimast.KindIdentifier {
+				if id := name.AsIdentifier(); id != nil {
+					return id.Text
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func nestiaTypiaExtractRootAndNamespaces(call *shimast.CallExpression, method string) (string, []string, bool) {
+	expression := call.Expression
+	segments := []string{}
+	for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
+		property := expression.AsPropertyAccessExpression()
+		if property == nil {
+			break
+		}
+		name := property.Name()
+		if name == nil || name.Kind != shimast.KindIdentifier {
+			return "", nil, false
+		}
+		id := name.AsIdentifier()
+		if id == nil || id.Text == "" {
+			return "", nil, false
+		}
+		segments = append([]string{id.Text}, segments...)
+		expression = property.Expression
+	}
+	if expression == nil || expression.Kind != shimast.KindIdentifier {
+		return "", nil, false
+	}
+	root := expression.AsIdentifier()
+	if root == nil || root.Text == "" || len(segments) == 0 {
+		return "", nil, false
+	}
+	if segments[len(segments)-1] != method {
+		return "", nil, false
+	}
+	return root.Text, segments[:len(segments)-1], true
+}