typia 14.0.6 → 15.0.1

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

@@ -7,6 +7,7 @@ import (
   "io"
   "os"
   "path/filepath"
+  "sync"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -114,6 +115,7 @@ func runBuild(args []string) int {
   transformDiags := []typiaTransformDiagnostic{}
   transformOptions := pluginOptions.TransformOptions()
   extras := nativecontext.ITypiaContext_Extras{
+    Shared: &sync.Map{},
     AddDiagnostic: func(diag *nativecontext.ITypiaDiagnostic) int {
       transformDiags = append(transformDiags, typiaTransformDiagnosticFrom(diag))
       return len(transformDiags)

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

@@ -54,7 +54,7 @@ func TestDynamicKeyTagsTransform(t *testing.T) {
   }
   // The key is read into a local before it is tested, so its predicate is the
   // one place the emitted text can show the check exists at all.
-  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLength") {
+  if !strings.Contains(out, "RegExp(") || !strings.Contains(out, "_stringLengthGte") {
     t.Fatalf("emitted checker should test the dynamic key, not only its value:\n%s", out)
   }
   dynamicKeyTagsRunRuntimeCases(t, project, out)

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

@@ -0,0 +1,27 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability verifies both
+// supported JSDoc placements compile with the upper probability boundary.
+//
+// Primitive aliases may erase their name, but a final decision property's
+// comment and enum members' comments remain attached to their declarations.
+//
+//  1. Declare an aliased boolean and a probability-annotated enum.
+//  2. Put probability one on the final boolean decision property.
+//  3. Require successful compilation.
+func TestLlmEvaluationAcceptsPropertyAndEnumMemberProbability(t *testing.T) {
+  llmEvaluationAccepts(t, "property-probability-valid", `import typia from "typia";
+
+type Urgency = boolean;
+enum Choice {
+  /** @probability 1 */ yes = "yes",
+  /** @probability 0.2 */ no = "no",
+}
+typia.llm.evaluation<{
+  /** Urgent? @probability 1 */ urgent: Urgency;
+  /** Choice? */ choice: Choice;
+}>();
+`)
+}

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

@@ -0,0 +1,26 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationAcceptsUnselectedSourceProbability verifies a comment on
+// an unrelated property does not constrain an indexed-access decision.
+//
+// Indexed access extracts a property type, not its JSDoc. An annotation on a
+// different source property must not reject an otherwise valid evaluation.
+//
+//  1. Declare an annotated and an unannotated source property.
+//  2. Extract the unannotated property's type for an evaluation decision.
+//  3. Require successful compilation.
+func TestLlmEvaluationAcceptsUnselectedSourceProbability(t *testing.T) {
+  llmEvaluationAccepts(t, "unselected-source-probability", `import typia from "typia";
+interface Source {
+  /** @probability 0.8 */ ignored: boolean;
+  selected: boolean;
+}
+type Value = Source["selected"];
+typia.llm.evaluation<{
+  /** Is it urgent? */
+  urgent: Value;
+}>();
+`)
+}

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

@@ -0,0 +1,96 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// Evaluation promises to decode the entire T. Every required member must
+// become a question or fail compilation, including inherited/nested members.
+func TestLlmEvaluationCompleteObjectShape(t *testing.T) {
+  accepted := map[string]string{
+    "getter only": `class Decision {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }`,
+    "class getter": `class Decision {
+      /** Is it active? */ active!: boolean;
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }`,
+    "inherited getter": `class Base {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }
+    class Decision extends Base {
+      /** Is it active? */
+      active!: boolean;
+    }`,
+    "interface getter": `interface Decision {
+      /** Is it active? */ active: boolean;
+      /** Is it urgent? @probability 1 */ get urgent(): boolean;
+    }`,
+    "nested getter": `class Child {
+      /** Is it urgent? @probability 1 */ get urgent(): boolean { return true; }
+    }
+    interface Decision { child: Child; }`,
+    "setter": `class Decision {
+      /** Is it active? */ active!: boolean;
+      /** Is it urgent? @probability 1 */ set urgent(value: boolean) {}
+    }`,
+  }
+  for name, declaration := range accepted {
+    t.Run(name, func(t *testing.T) {
+      source := `import typia from "typia";` + declaration + `
+        export const evaluation = typia.llm.evaluation<Decision>();`
+      project := llmEvaluationProject(t, "complete-"+strings.ReplaceAll(name, " ", "-"), source)
+      out, diagnostic, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{"--cwd", project, "--tsconfig", "tsconfig.json", "--file", "src/main.ts", "--output", "js"})
+      })
+      if code != 0 || !strings.Contains(out, "threshold: 1") || !strings.Contains(out, `"urgent"`) {
+        t.Fatalf("getter is not in the plan: code=%d threshold=%t urgent=%t diagnostic=%s", code, strings.Contains(out, "threshold: 1"), strings.Contains(out, `"urgent"`), diagnostic)
+      }
+    })
+  }
+
+  rejected := map[string]struct{ declaration, diagnostic string }{
+    "method":        {`interface Decision { /** Is it active? */ active: boolean; execute(): void; }`, "function"},
+    "private":       {`class Decision { /** Is it active? */ active!: boolean; private token = 1; }`, "private"},
+    "protected":     {`class Decision { /** Is it active? */ active!: boolean; protected token = 1; }`, "protected"},
+    "sharp private": {`class Decision { /** Is it active? */ active!: boolean; #token = 1; }`, "private"},
+    "symbol":        {`declare const token: unique symbol; interface Decision { /** Is it active? */ active: boolean; [token]: boolean; }`, "symbol-keyed"},
+    "symbol index":  {`interface Decision { /** Is it active? */ active: boolean; [key: symbol]: boolean; }`, "symbol-keyed"},
+    "call":          {`interface Decision { /** Is it active? */ active: boolean; (): void; }`, "callable"},
+    "construct":     {`interface Decision { /** Is it active? */ active: boolean; new(): Decision; }`, "constructable"},
+    "nested method": {`interface Child { /** Is it urgent? */ urgent: boolean; execute(): void; }
+      interface Decision { child: Child; }`, "function"},
+    "inherited private": {`class Base { private token = 1; }
+      class Decision extends Base { /** Is it active? */ active!: boolean; }`, "private"},
+    "generic private": {`class Base<T> { private token!: T; }
+      class Decision extends Base<boolean> { /** Is it active? */ active!: boolean; }`, "private"},
+    "generic sharp private": {`class Base<T> { #token!: T; }
+      class Decision extends Base<boolean> { /** Is it active? */ active!: boolean; }`, "private"},
+    "interface extends private class": {`class Base { private token!: boolean; }
+      interface Decision extends Base { active: boolean; }`, "private"},
+    "internal": {`interface Decision {
+      /** Is it active? */ active: boolean;
+      /** @internal */ secret: boolean;
+    }`, "hidden properties"},
+    "intersection internal": {`type Decision = {
+      /** Is it active? */ active: boolean;
+    } & {
+      /** @internal */ secret: boolean;
+    };`, "hidden properties"},
+    "overlapping intersection internal": {`type Decision = {
+      /** Is it active? */ active: boolean;
+      /** @internal */ secret: boolean;
+    } & { secret: boolean };`, "hidden properties"},
+  }
+  for name, testcase := range rejected {
+    t.Run(name, func(t *testing.T) {
+      source := `import typia from "typia";` + testcase.declaration + `
+        export const evaluation = typia.llm.evaluation<Decision>();`
+      diagnostic := llmEvaluationDiagnosticsBuild(t, "complete-"+strings.ReplaceAll(name, " ", "-"), source)
+      if !strings.Contains(diagnostic, testcase.diagnostic) {
+        t.Fatalf("missing %q diagnostic: %s", testcase.diagnostic, diagnostic)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,18 @@
+package main
+
+import "testing"
+
+// TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall verifies a
+// program without evaluation calls does not trigger JEV-specific diagnostics.
+//
+// The placement scanner is owned by the evaluation transformer, so merely
+// declaring a JSDoc tag must not alter ordinary TypeScript compilation.
+//
+//  1. Declare a tagged primitive alias.
+//  2. Omit every evaluation call.
+//  3. Require successful compilation.
+func TestLlmEvaluationIgnoresDeclarationProbabilityWithoutCall(t *testing.T) {
+  llmEvaluationAccepts(t, "no-evaluation-call", `/** @probability 0.8 */
+export type Urgency = boolean;
+`)
+}

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

@@ -0,0 +1,90 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationPlanEmissionTransform verifies typia.llm.evaluation emits
+// one deterministic plan call with the documented description sources.
+//
+// The transform replaces the call with `_createLlmEvaluation(plan)`, whose
+// plan carries every question's text. A property or enum member `@description`
+// tag overrides its summary, as it does in typia's JSON schemas, and repository
+// formatting rewrites that tag in TypeScript sources, so this fixture pins it
+// here. The same source must also emit byte-identical output on every run,
+// because the plan feeds build caches and published bundles.
+//
+//  1. Transform a decision type with `@description` overrides on a property and
+//     an enum member, a threshold, and a member minimum.
+//  2. Transform the same project again.
+//  3. Assert the runtime helper call, the overridden texts, the requirements,
+//     and identical output across runs.
+func TestLlmEvaluationPlanEmissionTransform(t *testing.T) {
+  project := llmEvaluationProject(t, "emission", llmEvaluationEmissionSource)
+  transform := func() string {
+    out, errText, code := ttscTypiaTestCapture(func() int {
+      return runTransform([]string{
+        "--cwd", project,
+        "--tsconfig", "tsconfig.json",
+        "--file", "src/main.ts",
+        "--output", "js",
+      })
+    })
+    if code != 0 {
+      t.Fatalf("llm.evaluation transform failed: code=%d stderr=\n%s", code, errText)
+    }
+    return out
+  }
+  first := transform()
+  for _, expected := range []string{
+    "_createLlmEvaluation",
+    `instructions: "Overridden question"`,
+    `description: "Overridden member"`,
+    `description: "Plain member"`,
+    "threshold: 0.8",
+    "minimum: 0.75",
+  } {
+    if !strings.Contains(first, expected) {
+      t.Fatalf("llm.evaluation emission missing %q:\n%s", expected, first)
+    }
+  }
+  for _, unexpected := range []string{`instructions: "Summary`, `description: "Summary`, "typia.llm.evaluation"} {
+    if strings.Contains(first, unexpected) {
+      t.Fatalf("llm.evaluation emission must not contain %q:\n%s", unexpected, first)
+    }
+  }
+  if second := transform(); second != first {
+    t.Fatalf("llm.evaluation emission is not deterministic:\n--- first\n%s\n--- second\n%s", first, second)
+  }
+}
+
+const llmEvaluationEmissionSource = `import typia, { tags } from "typia";
+
+enum Team {
+  /**
+   * Plain member
+   *
+   * @probability 0.5
+   */
+  billing = "billing",
+  /**
+   * Summary to be overridden
+   *
+   * @description Overridden member
+   * @probability 0.75
+   */
+  technical = "technical",
+}
+
+export const evaluation = typia.llm.evaluation<{
+  /**
+   * Summary to be overridden
+   *
+   * @description Overridden question
+   */
+  team: Team;
+  /** Is a refund requested? */
+  refund: boolean & tags.Probability<0.8>;
+}>();
+`

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

@@ -0,0 +1,69 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "slices"
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationProgramScanDependencies verifies a successful evaluation
+// transform watches source files used by its program-wide placement check.
+//
+// An unrelated source has no tag today but may gain an illegal declaration
+// tag tomorrow. A complete dependency list must then invalidate the old emit.
+//
+//  1. Transform a decision beside an unrelated, untagged source module.
+//  2. Require the decision's complete dependency list to include that module.
+//  3. Add an illegal tag in that module and require a new diagnostic.
+func TestLlmEvaluationProgramScanDependencies(t *testing.T) {
+  dir := llmEvaluationProject(t, "program-scan-dependencies", `import typia from "typia";
+interface IDecision {
+  /** Is it urgent? */
+  urgent: boolean;
+}
+typia.llm.evaluation<IDecision>();
+`)
+  unused := `export type Unused = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "unused.ts"), []byte(unused), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  output, diagnostics, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  var result transformProjectOutput
+  if err := json.Unmarshal([]byte(output), &result); err != nil {
+    t.Fatal(err)
+  }
+  if code != 0 {
+    t.Fatalf("valid project must transform: code=%d\ndiagnostics=%+v\nstderr=%s", code, result.Diagnostics, diagnostics)
+  }
+  if !slices.Contains(result.DependenciesComplete, "src/main.ts") {
+    t.Fatalf("decision transform unexpectedly lacks complete dependencies: %+v", result.DependenciesComplete)
+  }
+  if !slices.Contains(result.Dependencies["src/main.ts"], "src/unused.ts") {
+    t.Fatalf("program-wide scan dependency is missing: %+v", result.Dependencies["src/main.ts"])
+  }
+  tagged := `/** @probability 0.8 */
+export type Unused = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "unused.ts"), []byte(tagged), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  output, diagnostics, code = ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 3 {
+    t.Fatalf("new invalid tag must fail: code=%d\nstderr=%s", code, diagnostics)
+  }
+  result = transformProjectOutput{}
+  if err := json.Unmarshal([]byte(output), &result); err != nil {
+    t.Fatal(err)
+  }
+  if len(result.Diagnostics) != 1 || !strings.Contains(result.Diagnostics[0].MessageText, "type alias Unused") {
+    t.Fatalf("changed source must affect evaluation diagnostic: %+v", result.Diagnostics)
+  }
+}

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

@@ -0,0 +1,44 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsDeclarationProbability verifies JSDoc on a type
+// declaration cannot silently become a decision requirement.
+//
+// A primitive alias resolves to the same primitive as an unannotated alias,
+// so the compiler must reject unsupported declaration-level placements.
+//
+//  1. Annotate several declaration kinds, including unused declarations.
+//  2. Compile a neighboring evaluation call.
+//  3. Require a normal diagnostic for every invalid placement.
+func TestLlmEvaluationRejectsDeclarationProbability(t *testing.T) {
+  diagnostics := llmEvaluationDiagnosticsBuild(t, "declaration-probability", `import typia from "typia";
+
+/** @probability 0.8 */
+type Urgency = boolean;
+/** @probability invalid */
+type Unused = boolean;
+/** @probability 0.6 */
+interface Nested { /** Answer? */ answer: boolean }
+/** @probability 0.7 */
+enum Choice { yes = "yes", no = "no" }
+/** @probability 0.4 */
+class Container { /** Answer? */ answer = true; }
+/** @probability 0.3 */
+function unrelated(): boolean { return true; }
+
+typia.llm.evaluation<{
+  /** Urgent? */ urgent: Urgency;
+  /** Nested? */ nested: Nested;
+  /** Choice? */ choice: Choice;
+}>();
+`)
+  for _, name := range []string{"type alias Urgency", "type alias Unused", "interface Nested", "enum Choice", "class Container", "declaration unrelated"} {
+    if !strings.Contains(diagnostics, name) {
+      t.Fatalf("misplaced declaration tag %q was not diagnosed:\n%s", name, diagnostics)
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsAliasRefinement verifies a named alias cannot hide
+// a validation tag from the evaluation compiler.
+//
+// An alias of a boolean refinement still denotes a constrained boolean. The
+// decoder does not enforce that constraint, while an annotation-only alias is
+// safe and must remain accepted.
+//
+//  1. Declare a validation refinement behind a named alias.
+//  2. Require a decision-path diagnostic.
+//  3. Accept a neighboring annotation-only alias.
+func TestLlmEvaluationRejectsAliasRefinement(t *testing.T) {
+  errText := llmEvaluationDiagnosticsBuild(t, "alias-refinement", `import typia, { tags } from "typia";
+
+type TrueOnly = tags.TagBase<{
+  target: "boolean";
+  kind: "trueOnly";
+  value: undefined;
+  validate: "$input === true";
+}>;
+type Guarded = boolean & TrueOnly;
+typia.llm.evaluation<{
+  /** Is it allowed? */
+  allowed: Guarded;
+}>();
+`)
+  expected := "- $input.allowed\n  - LLM evaluation does not support type tag \"trueOnly\", because decode() cannot enforce its constraint."
+  if !strings.Contains(errText, expected) {
+    t.Fatalf("missing aliased refinement diagnostic:\n%s", errText)
+  }
+  llmEvaluationAccepts(t, "alias-refinement-control", `import typia, { tags } from "typia";
+
+type Annotated = boolean & tags.Default<true>;
+typia.llm.evaluation<{
+  /** Is it allowed? */
+  allowed: Annotated;
+}>();
+`)
+}

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

@@ -0,0 +1,30 @@
+package main
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsComputedMethodProbability verifies an unsupported
+// computed method annotation produces a diagnostic instead of a panic.
+//
+// A computed property name is not a text-bearing identifier in the parser.
+// Reading its name as plain text used to crash the compiler's diagnostic path.
+//
+//  1. Annotate a computed class method with @probability.
+//  2. Build an otherwise valid evaluation call.
+//  3. Require a normal transform diagnostic.
+func TestLlmEvaluationRejectsComputedMethodProbability(t *testing.T) {
+  diagnostics := llmEvaluationDiagnosticsBuild(t, "computed-method-probability", `import typia from "typia";
+class Source {
+  /** @probability 0.8 */ [Symbol.iterator]() { return []; }
+}
+typia.llm.evaluation<{
+  /** Is it urgent? */
+  urgent: boolean;
+}>();
+`)
+  if !strings.Contains(diagnostics, "@probability") {
+    t.Fatalf("computed method tag must produce a diagnostic:\n%s", diagnostics)
+  }
+}

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

@@ -0,0 +1,48 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestLlmEvaluationRejectsImportedDeclarationProbability verifies the
+// placement diagnostic crosses an imported source-file boundary.
+//
+// A local-only syntax scan would miss an alias declared in another file while
+// the checker still resolves that alias at the evaluation decision.
+//
+//  1. Define an annotated primitive alias in an imported module.
+//  2. Use it in evaluation calls in two source files.
+//  3. Require the imported declaration's diagnostic from both CLI paths.
+func TestLlmEvaluationRejectsImportedDeclarationProbability(t *testing.T) {
+  dir := llmEvaluationProject(t, "imported-declaration-probability", `import typia from "typia";
+import type { Urgency } from "./urgency";
+typia.llm.evaluation<{ /** Urgent? */ urgent: Urgency }>();
+`)
+  source := `/** @probability 0.8 */
+export type Urgency = boolean;
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "urgency.ts"), []byte(source), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  second := `import typia from "typia";
+typia.llm.evaluation<{ /** Is it urgent? */ urgent: boolean }>();
+`
+  if err := os.WriteFile(filepath.Join(dir, "src", "second.ts"), []byte(second), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  _, diagnostics, code := ttscTypiaTestCapture(func() int {
+    return runBuild([]string{"--cwd", dir, "--tsconfig", "tsconfig.json", "--emit", "--outDir", filepath.Join(dir, "dist")})
+  })
+  if code != 3 || strings.Count(diagnostics, "type alias Urgency") != 2 {
+    t.Fatalf("imported declaration tag must fail in both files: code=%d\n%s", code, diagnostics)
+  }
+  output, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{"--cwd", dir, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 3 || strings.Count(output, "type alias Urgency") != 2 {
+    t.Fatalf("transform path must diagnose both files: code=%d\nstdout=%s\nstderr=%s", code, output, errText)
+  }
+}