typia 13.0.0-rc.1 → 13.0.0

package/native/adapter/visit.go

@@ -1,173 +1,173 @@
-package adapter
-
-import (
-  "path/filepath"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-)
-
-type CallSite struct {
-  File       *shimast.SourceFile
-  FilePath   string
-  Module     string
-  Method     string
-  Call       *shimast.CallExpression
-  RootName   string
-  Namespaces []string
-}
-
-func CollectCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []CallSite {
-  sites := []CallSite{}
-  for _, file := range files {
-    if file == nil || file.IsDeclarationFile {
-      continue
-    }
-    file.ForEachChild(func(node *shimast.Node) bool {
-      visitCallSite(file, checker, node, &sites)
-      return false
-    })
-  }
-  return sites
-}
-
-func visitCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node, sites *[]CallSite) {
-  if node == nil {
-    return
-  }
-  if node.Kind == shimast.KindCallExpression {
-    if site, ok := tryCallSite(file, checker, node); ok {
-      *sites = append(*sites, site)
-    }
-  }
-  node.ForEachChild(func(child *shimast.Node) bool {
-    visitCallSite(file, checker, child, sites)
-    return false
-  })
-}
-
-func tryCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (CallSite, bool) {
-  if checker == nil {
-    return CallSite{}, false
-  }
-  if node.Kind != shimast.KindCallExpression {
-    return CallSite{}, false
-  }
-  call := node.AsCallExpression()
-  if call == nil {
-    return CallSite{}, false
-  }
-  signature := checker.GetResolvedSignature(node)
-  if signature == nil {
-    return CallSite{}, false
-  }
-  declaration := signature.Declaration()
-  if declaration == nil {
-    return CallSite{}, false
-  }
-  sourceFile := shimast.GetSourceFileOfNode(declaration)
-  if sourceFile == nil {
-    return CallSite{}, false
-  }
-  module, ok := matchTypiaModule(sourceFile.FileName())
-  if !ok {
-    return CallSite{}, false
-  }
-  method := callSiteMethodName(checker, declaration, call)
-  if method == "" {
-    return CallSite{}, false
-  }
-  root, namespaces, ok := extractRootAndNamespaces(call, method)
-  if !ok {
-    return CallSite{}, false
-  }
-  return CallSite{
-    File:       file,
-    FilePath:   file.FileName(),
-    Module:     module,
-    Method:     method,
-    Call:       call,
-    RootName:   root,
-    Namespaces: namespaces,
-  }, true
-}
-
-func matchTypiaModule(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 callSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
-  if name := declaration.Name(); name != nil {
-    if checker != 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 extractRootAndNamespaces(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
-}
+package adapter
+
+import (
+  "path/filepath"
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+type CallSite struct {
+  File       *shimast.SourceFile
+  FilePath   string
+  Module     string
+  Method     string
+  Call       *shimast.CallExpression
+  RootName   string
+  Namespaces []string
+}
+
+func CollectCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []CallSite {
+  sites := []CallSite{}
+  for _, file := range files {
+    if file == nil || file.IsDeclarationFile {
+      continue
+    }
+    file.ForEachChild(func(node *shimast.Node) bool {
+      visitCallSite(file, checker, node, &sites)
+      return false
+    })
+  }
+  return sites
+}
+
+func visitCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node, sites *[]CallSite) {
+  if node == nil {
+    return
+  }
+  if node.Kind == shimast.KindCallExpression {
+    if site, ok := tryCallSite(file, checker, node); ok {
+      *sites = append(*sites, site)
+    }
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    visitCallSite(file, checker, child, sites)
+    return false
+  })
+}
+
+func tryCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (CallSite, bool) {
+  if checker == nil {
+    return CallSite{}, false
+  }
+  if node.Kind != shimast.KindCallExpression {
+    return CallSite{}, false
+  }
+  call := node.AsCallExpression()
+  if call == nil {
+    return CallSite{}, false
+  }
+  signature := checker.GetResolvedSignature(node)
+  if signature == nil {
+    return CallSite{}, false
+  }
+  declaration := signature.Declaration()
+  if declaration == nil {
+    return CallSite{}, false
+  }
+  sourceFile := shimast.GetSourceFileOfNode(declaration)
+  if sourceFile == nil {
+    return CallSite{}, false
+  }
+  module, ok := matchTypiaModule(sourceFile.FileName())
+  if !ok {
+    return CallSite{}, false
+  }
+  method := callSiteMethodName(checker, declaration, call)
+  if method == "" {
+    return CallSite{}, false
+  }
+  root, namespaces, ok := extractRootAndNamespaces(call, method)
+  if !ok {
+    return CallSite{}, false
+  }
+  return CallSite{
+    File:       file,
+    FilePath:   file.FileName(),
+    Module:     module,
+    Method:     method,
+    Call:       call,
+    RootName:   root,
+    Namespaces: namespaces,
+  }, true
+}
+
+func matchTypiaModule(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 callSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
+  if name := declaration.Name(); name != nil {
+    if checker != 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 extractRootAndNamespaces(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
+}

package/native/adapter/visit_property_chain_edges_test.go

@@ -1,129 +1,129 @@
-//go:build typia_native_internal
-// +build typia_native_internal
-
-package adapter
-
-import (
-	"path/filepath"
-	"testing"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	shimparser "github.com/microsoft/typescript-go/shim/parser"
-)
-
-// TestVisitPropertyChainEdges verifies call-site property-chain parsing.
-//
-// Call-site discovery peels a TypeScript expression like
-// `typia.json.stringify()` into a root import name, namespace chain, and method.
-// Malformed or mismatched chains must be rejected without producing a site.
-//
-// 1. Build a nested property-access call expression.
-// 2. Extract the root name, namespace, and terminal method.
-// 3. Reject a method mismatch, a non-property call, and an empty member name.
-// 4. Verify nil nodes do not append call sites.
-func TestVisitPropertyChainEdges(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	namespace := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier("json"),
-		shimast.NodeFlagsNone,
-	)
-	method := factory.NewPropertyAccessExpression(
-		namespace,
-		nil,
-		factory.NewIdentifier("stringify"),
-		shimast.NodeFlagsNone,
-	)
-	call := factory.NewCallExpression(method, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-
-	root, namespaces, ok := extractRootAndNamespaces(call, "stringify")
-	if !ok || root != "typia" || len(namespaces) != 1 || namespaces[0] != "json" {
-		t.Fatalf("unexpected property-chain extraction: root=%q namespaces=%#v ok=%v", root, namespaces, ok)
-	}
-	if _, _, ok := extractRootAndNamespaces(call, "is"); ok {
-		t.Fatal("method mismatch should reject the call chain")
-	}
-	statement := factory.NewExpressionStatement(factory.NewIdentifier("noop"))
-	if method := callSiteMethodName(nil, statement, call); method != "stringify" {
-		t.Fatalf("property-access method fallback mismatch: %q", method)
-	}
-	declaration := factory.NewFunctionDeclaration(
-		nil,
-		nil,
-		factory.NewIdentifier("declared"),
-		nil,
-		nil,
-		nil,
-		nil,
-		nil,
-	)
-	if method := callSiteMethodName(nil, declaration, call); method != "declared" {
-		t.Fatalf("declaration-name fallback mismatch: %q", method)
-	}
-
-	plain := factory.NewCallExpression(
-		factory.NewIdentifier("plain"),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(plain, "plain"); ok {
-		t.Fatal("plain calls without a property chain should be rejected")
-	}
-	literal := factory.NewCallExpression(
-		factory.NewStringLiteral("call", shimast.TokenFlagsNone),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(literal, "call"); ok {
-		t.Fatal("non-identifier root expressions should be rejected")
-	}
-
-	emptyMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier(""),
-		shimast.NodeFlagsNone,
-	)
-	emptyCall := factory.NewCallExpression(emptyMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(emptyCall, ""); ok {
-		t.Fatal("empty property name should be rejected")
-	}
-	stringMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewStringLiteral("is", shimast.TokenFlagsNone),
-		shimast.NodeFlagsNone,
-	)
-	stringMemberCall := factory.NewCallExpression(stringMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(stringMemberCall, "is"); ok {
-		t.Fatal("non-identifier property names should be rejected")
-	}
-	sites := []CallSite{}
-	visitCallSite(nil, nil, nil, &sites)
-	if len(sites) != 0 {
-		t.Fatalf("nil node should not append call sites: %#v", sites)
-	}
-	file := shimparser.ParseSourceFile(
-		shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "visit.ts"))},
-		`typia.is(input);`,
-		shimcore.ScriptKindTS,
-	)
-	declFile := *file
-	declFile.IsDeclarationFile = true
-	if sites := CollectCallSites([]*shimast.SourceFile{nil, &declFile}, nil); len(sites) != 0 {
-		t.Fatalf("nil and declaration files should not produce call sites: %#v", sites)
-	}
-	if _, ok := tryCallSite(file, nil, call.AsNode()); ok {
-		t.Fatal("nil checker should reject call-site probing")
-	}
-	if _, ok := tryCallSite(file, &shimchecker.Checker{}, statement); ok {
-		t.Fatal("non-call nodes should reject call-site probing")
-	}
-}
+//go:build typia_native_internal
+// +build typia_native_internal
+
+package adapter
+
+import (
+	"path/filepath"
+	"testing"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	shimparser "github.com/microsoft/typescript-go/shim/parser"
+)
+
+// TestVisitPropertyChainEdges verifies call-site property-chain parsing.
+//
+// Call-site discovery peels a TypeScript expression like
+// `typia.json.stringify()` into a root import name, namespace chain, and method.
+// Malformed or mismatched chains must be rejected without producing a site.
+//
+// 1. Build a nested property-access call expression.
+// 2. Extract the root name, namespace, and terminal method.
+// 3. Reject a method mismatch, a non-property call, and an empty member name.
+// 4. Verify nil nodes do not append call sites.
+func TestVisitPropertyChainEdges(t *testing.T) {
+	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+	namespace := factory.NewPropertyAccessExpression(
+		factory.NewIdentifier("typia"),
+		nil,
+		factory.NewIdentifier("json"),
+		shimast.NodeFlagsNone,
+	)
+	method := factory.NewPropertyAccessExpression(
+		namespace,
+		nil,
+		factory.NewIdentifier("stringify"),
+		shimast.NodeFlagsNone,
+	)
+	call := factory.NewCallExpression(method, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
+
+	root, namespaces, ok := extractRootAndNamespaces(call, "stringify")
+	if !ok || root != "typia" || len(namespaces) != 1 || namespaces[0] != "json" {
+		t.Fatalf("unexpected property-chain extraction: root=%q namespaces=%#v ok=%v", root, namespaces, ok)
+	}
+	if _, _, ok := extractRootAndNamespaces(call, "is"); ok {
+		t.Fatal("method mismatch should reject the call chain")
+	}
+	statement := factory.NewExpressionStatement(factory.NewIdentifier("noop"))
+	if method := callSiteMethodName(nil, statement, call); method != "stringify" {
+		t.Fatalf("property-access method fallback mismatch: %q", method)
+	}
+	declaration := factory.NewFunctionDeclaration(
+		nil,
+		nil,
+		factory.NewIdentifier("declared"),
+		nil,
+		nil,
+		nil,
+		nil,
+		nil,
+	)
+	if method := callSiteMethodName(nil, declaration, call); method != "declared" {
+		t.Fatalf("declaration-name fallback mismatch: %q", method)
+	}
+
+	plain := factory.NewCallExpression(
+		factory.NewIdentifier("plain"),
+		nil,
+		nil,
+		factory.NewNodeList(nil),
+		shimast.NodeFlagsNone,
+	).AsCallExpression()
+	if _, _, ok := extractRootAndNamespaces(plain, "plain"); ok {
+		t.Fatal("plain calls without a property chain should be rejected")
+	}
+	literal := factory.NewCallExpression(
+		factory.NewStringLiteral("call", shimast.TokenFlagsNone),
+		nil,
+		nil,
+		factory.NewNodeList(nil),
+		shimast.NodeFlagsNone,
+	).AsCallExpression()
+	if _, _, ok := extractRootAndNamespaces(literal, "call"); ok {
+		t.Fatal("non-identifier root expressions should be rejected")
+	}
+
+	emptyMember := factory.NewPropertyAccessExpression(
+		factory.NewIdentifier("typia"),
+		nil,
+		factory.NewIdentifier(""),
+		shimast.NodeFlagsNone,
+	)
+	emptyCall := factory.NewCallExpression(emptyMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
+	if _, _, ok := extractRootAndNamespaces(emptyCall, ""); ok {
+		t.Fatal("empty property name should be rejected")
+	}
+	stringMember := factory.NewPropertyAccessExpression(
+		factory.NewIdentifier("typia"),
+		nil,
+		factory.NewStringLiteral("is", shimast.TokenFlagsNone),
+		shimast.NodeFlagsNone,
+	)
+	stringMemberCall := factory.NewCallExpression(stringMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
+	if _, _, ok := extractRootAndNamespaces(stringMemberCall, "is"); ok {
+		t.Fatal("non-identifier property names should be rejected")
+	}
+	sites := []CallSite{}
+	visitCallSite(nil, nil, nil, &sites)
+	if len(sites) != 0 {
+		t.Fatalf("nil node should not append call sites: %#v", sites)
+	}
+	file := shimparser.ParseSourceFile(
+		shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "visit.ts"))},
+		`typia.is(input);`,
+		shimcore.ScriptKindTS,
+	)
+	declFile := *file
+	declFile.IsDeclarationFile = true
+	if sites := CollectCallSites([]*shimast.SourceFile{nil, &declFile}, nil); len(sites) != 0 {
+		t.Fatalf("nil and declaration files should not produce call sites: %#v", sites)
+	}
+	if _, ok := tryCallSite(file, nil, call.AsNode()); ok {
+		t.Fatal("nil checker should reject call-site probing")
+	}
+	if _, ok := tryCallSite(file, &shimchecker.Checker{}, statement); ok {
+		t.Fatal("non-call nodes should reject call-site probing")
+	}
+}