typia 14.0.3 → 14.0.5

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

@@ -0,0 +1,173 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestReflectSchemaBigintTransform verifies the metadata a reflect operation
+// hands back carries a bigint constant as a bigint.
+//
+// `IMetadataSchema.IValue<Atomic.Type>` declares `value: bigint` for a bigint
+// constant, but this transformer lowered the whole metadata tree through
+// `encoding/json` before writing it. JSON has no bigint, so that one member
+// could not survive the trip: it arrived as whatever object its fields happened
+// to spell. The trip was also redundant -- it marshaled structs into maps and
+// lowercased each key's initial, which is what `LiteralFactory` already does
+// when it reflects a struct -- so writing the tree directly both fixes the
+// value and removes the step.
+//
+// `literals` and `schema` reach the emit by different routes, so a case on one
+// says nothing about the other.
+//
+//  1. Reflect a bigint constant union through `schema` and through `schemas`.
+//  2. Execute the emitted CommonJS.
+//  3. Assert each reported value is `typeof "bigint"` and exact, and that the
+//     surrounding metadata still reports the constant and its neighbors.
+func TestReflectSchemaBigintTransform(t *testing.T) {
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "reflect-schema-bigint-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(reflectSchemaBigintSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  ttscTypiaTestTypecheck(t, dir)
+
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("reflect.schema bigint transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  runtimeDir := filepath.Join(dir, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(reflectSchemaBigintRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("reflect.schema bigint runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const reflectSchemaBigintSource = `import typia, { tags } from "typia";
+
+export const unit = typia.reflect.schema<1n | 9007199254740993n>();
+export const collection = typia.reflect.schemas<[2n, "a" | 3]>();
+export const objects = typia.reflect.schema<{ big: 7n; name: string }>();
+
+// A tag reaches a constant by matching the child's value against the merged
+// parent's, so the constant value has to compare by value. The number and
+// string constants are the controls that were never at risk.
+export const tagged = typia.reflect.schema<(1n | 2n) & tags.Type<"int64">>();
+export const taggedNumber = typia.reflect.schema<(1 | 2) & tags.Type<"uint32">>();
+`
+
+const reflectSchemaBigintRunner = `const mod = require("./main.cjs");
+
+const render = (value) =>
+  typeof value === "bigint" ? value.toString() + "n" : JSON.stringify(value);
+
+const constantsOf = (schema, type) => {
+  const constant = (schema.constants ?? []).find((c) => c.type === type);
+  return constant === undefined ? [] : constant.values.map((v) => v.value);
+};
+
+const check = (label, actual, expected) => {
+  if (actual.length !== expected.length) {
+    throw new Error(
+      label + ": expected " + expected.map(render).join(", ") +
+        ", got " + actual.map(render).join(", "),
+    );
+  }
+  actual.forEach((item, index) => {
+    if (typeof item !== typeof expected[index] || item !== expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected " + render(expected[index]) +
+          " (" + typeof expected[index] + "), got " + render(item) +
+          " (" + typeof item + ")",
+      );
+    }
+  });
+};
+
+check("schema", constantsOf(mod.unit.schema, "bigint"), [1n, 9007199254740993n]);
+check("schemas[0]", constantsOf(mod.collection.schemas[0], "bigint"), [2n]);
+
+// A neighboring constant kind must keep its own representation.
+check("schemas[1] string", constantsOf(mod.collection.schemas[1], "string"), ["a"]);
+check("schemas[1] number", constantsOf(mod.collection.schemas[1], "number"), [3]);
+
+// The surrounding tree still reports the object and its members.
+const object = mod.objects.components.objects[0];
+if (object === undefined || object.properties.length !== 2) {
+  throw new Error("object metadata was not emitted: " + JSON.stringify(mod.objects, (k, v) => typeof v === "bigint" ? v.toString() : v));
+}
+const big = object.properties.find(
+  (p) => constantsOf(p.key, "string")[0] === "big",
+);
+if (big === undefined) {
+  throw new Error("the 'big' property is missing from the object metadata");
+}
+check("object property", constantsOf(big.value, "bigint"), [7n]);
+
+const tagNames = (schema, type) => {
+  const constant = (schema.constants ?? []).find((c) => c.type === type);
+  if (constant === undefined) {
+    throw new Error("no " + type + " constant was emitted");
+  }
+  return constant.values.map((v) =>
+    (v.tags ?? []).flat().map((t) => t.name).join(","),
+  );
+};
+
+// Every member keeps the tag the intersection put on it.
+const expectTags = (label, actual, expected) => {
+  if (actual.length === 0 || actual.some((names) => names !== expected)) {
+    throw new Error(
+      label + ": expected every member tagged " + expected +
+        ", got " + JSON.stringify(actual),
+    );
+  }
+};
+expectTags("bigint constant", tagNames(mod.tagged.schema, "bigint"), 'Type<"int64">');
+expectTags("number constant", tagNames(mod.taggedNumber.schema, "number"), 'Type<"uint32">');
+
+console.log("ok");
+`

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

@@ -0,0 +1,88 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestWrongTypeTagTargetDiagnostic verifies a rejected tag names its declared
+// target once and leaves a compatible tag untouched.
+func TestWrongTypeTagTargetDiagnostic(t *testing.T) {
+  project := wrongTypeTagTargetDiagnosticProject(t)
+  _, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code == 0 {
+    t.Fatal("wrong-target tag unexpectedly transformed without diagnostics")
+  }
+  const expected = `the property ["typia.tag"] target must contain array type.`
+  if count := strings.Count(errText, expected); count != 1 {
+    t.Fatalf("wrong-target diagnostic count mismatch: got %d, want 1\n%s", count, errText)
+  }
+  if count := strings.Count(errText, "Payload.invalid:"); count != 1 {
+    t.Fatalf("diagnostic ownership mismatch: got %d, want 1\n%s", count, errText)
+  }
+  if strings.Contains(errText, "target must contain boolean type") {
+    t.Fatalf("diagnostic named the host type:\n%s", errText)
+  }
+  if strings.Contains(errText, "Payload.valid:") {
+    t.Fatalf("valid array control produced a diagnostic:\n%s", errText)
+  }
+}
+
+func wrongTypeTagTargetDiagnosticProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  project, err := os.MkdirTemp(base, "wrong-tag-target-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(project) })
+  src := filepath.Join(project, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(project, "tsconfig.json"), []byte(wrongTypeTagTargetDiagnosticTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(wrongTypeTagTargetDiagnosticSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return project
+}
+
+const wrongTypeTagTargetDiagnosticTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const wrongTypeTagTargetDiagnosticSource = `import typia, { tags } from "typia";
+
+interface Payload {
+  invalid: boolean & tags.MinItems<1>;
+  valid: string[] & tags.MinItems<1>;
+}
+
+export const test = (input: unknown) => typia.is<Payload>(input);
+`

package/native/core/factories/ExpressionFactory.go

@@ -66,6 +66,16 @@ func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitCon
   return f.NewNumericLiteral(text, shimast.TokenFlagsNone)
 }
 
+// Bigint emits `BigInt("<value>")` for a bigint literal.
+//
+// The argument has to stay a string literal. This used to spell the digits as a
+// bare `number` literal, so `9007199254740993n` reached the emit as
+// `BigInt(9007199254740993)` and JavaScript rounded the literal to
+// 9007199254740992 before `BigInt` ever parsed it -- exactly the rounding
+// `numericRangeFactory_bigint_literal` and `_isTypeInt64Bigint` already spell
+// out and avoid. Every bigint an argument can carry is exact in base 10, and
+// `BigInt` parses the digits of a string directly, so the string form is exact
+// at any magnitude.
 func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   return f.NewCallExpression(
@@ -73,7 +83,7 @@ func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitCon
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
-      f.NewIdentifier(fmt.Sprint(value)),
+      f.NewStringLiteral(fmt.Sprint(value), shimast.TokenFlagsNone),
     }),
     shimast.NodeFlagsNone,
   )

package/native/core/factories/LiteralFactory.go

@@ -11,6 +11,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type literalFactoryNamespace struct{}
@@ -93,6 +94,8 @@ func (literalFactoryNamespace) Write(input any, emit ...*shimprinter.EmitContext
   switch value := input.(type) {
   case bool:
     return literalFactory_writeBoolean(value, emit...)
+  case schemametadata.MetadataBigint:
+    return literalFactory_writeBigint(value, emit...)
   case *big.Int:
     return literalFactory_writeBigint(value, emit...)
   case int:

package/native/core/factories/MetadataTypeTagFactory.go

@@ -2,6 +2,7 @@ package factories
 
 import (
   "fmt"
+  "reflect"
   "strings"
 
   schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
@@ -162,12 +163,15 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
     if tag == nil {
       continue
     }
-    target := ""
-    if metadataTypeTagFactory_includes(tag.Target, props.Type) {
-      target = props.Type
+    if metadataTypeTagFactory_includes(tag.Target, props.Type) == false {
+      report(struct {
+        Property *string
+        Message  string
+      }{Property: nil, Message: metadataTypeTagFactory_target_message(tag.Target)})
+      continue
     }
     output = append(output, schemametadata.IMetadataTypeTag{
-      Target:    target,
+      Target:    props.Type,
       Name:      tag.Name,
       Kind:      tag.Kind,
       Value:     tag.Value,
@@ -195,7 +199,7 @@ func (metadataTypeTagFactoryNamespace) Analyze(props struct {
       for _, object := range props.Objects {
         names = append(names, object.Name)
       }
-      *props.Errors = append(*props.Errors, MetadataFactory_IError{
+      metadataTypeTagFactory_append_error(props.Errors, MetadataFactory_IError{
         Name:     strings.Join(names, " & "),
         Explore:  props.Explore,
         Messages: messages,
@@ -218,10 +222,14 @@ func (metadataTypeTagFactoryNamespace) Validate(props struct {
   for _, tag := range props.Tags {
     if tag.Target != props.Type {
       if success {
+        target := tag.Target
+        if target == "" {
+          target = props.Type
+        }
         success = props.Report(struct {
           Property *string
           Message  string
-        }{Property: nil, Message: "target must contain " + props.Type + " type"})
+        }{Property: nil, Message: metadataTypeTagFactory_target_message([]string{target})})
       }
     }
   }
@@ -570,3 +578,16 @@ func metadataTypeTagFactory_essentialFieldsMessage() string {
   }
   return strings.Join(values, ", ")
 }
+
+func metadataTypeTagFactory_target_message(targets []string) string {
+  return "target must contain " + strings.Join(targets, " or ") + " type"
+}
+
+func metadataTypeTagFactory_append_error(errors *[]MetadataFactory_IError, next MetadataFactory_IError) {
+  for _, previous := range *errors {
+    if reflect.DeepEqual(previous, next) {
+      return
+    }
+  }
+  *errors = append(*errors, next)
+}

package/native/core/factories/internal/metadata/iterate_metadata_constant.go

@@ -50,6 +50,9 @@ func Iterate_metadata_constant(props IMetadataIteratorProps) bool {
       typ = "number"
     } else if filter(nativechecker.TypeFlagsBigIntLiteral) {
       typ = "bigint"
+      // Normalize away the checker's unnameable `jsnum.PseudoBigInt`; see
+      // MetadataBigint for why the stand-in has to be a comparable value.
+      value = schemametadata.MetadataBigint{Text: fmt.Sprint(value)}
     }
     constant := iterate_metadata_constant_take(props.Metadata, typ)
     info := comment()

package/native/core/programmers/RandomProgrammer.go

@@ -345,11 +345,14 @@ func randomProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, array := range props.Collection.Arrays() {
+  for _, array := range props.Collection.Arrays() {
     if array.Recursive == false {
       continue
     }
-    index := i
+    index := 0
+    if array.Index != nil {
+      index = *array.Index
+    }
     array := array
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
       Name: randomProgrammer_prefix_array(index),
@@ -396,11 +399,14 @@ func randomProgrammer_write_tuple_functions(props struct {
   f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
   _, unsatisfiableTuples := nativehelpers.RandomJoiner.UnsatisfiableRecursives(props.Collection.Objects(), props.Collection.Tuples())
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
-    index := i
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     tuple := tuple
     if unsatisfiableTuples[tuple] {
       panic(nativecontext.NewTransformerError(nativecontext.TransformerError_IProps{

package/native/core/programmers/internal/CheckerProgrammer.go

@@ -181,13 +181,17 @@ func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
   arrays := props.Collection.Arrays()
   output := []*shimast.Node{}
-  for i, typ := range arrays {
+  for _, typ := range arrays {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     input := f.NewIdentifier("input")
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -200,7 +204,7 @@ func (checkerProgrammerNamespace) Write_array_functions(props CheckerProgrammer_
         nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
-        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i), checkerProgrammer_decode_array_inline(checkerProgrammer_decodeArrayInlineProps{
+        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index), checkerProgrammer_decode_array_inline(checkerProgrammer_decodeArrayInlineProps{
           Config:  props.Config,
           Context: props.Context,
           Functor: props.Functor,
@@ -226,13 +230,17 @@ func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_
   f := nativecontext.EmitFactoryOf(checkerProgrammer_factory, props.Context.Emit)
   tuples := props.Collection.Tuples()
   output := []*shimast.Node{}
-  for i, tuple := range tuples {
+  for _, tuple := range tuples {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     input := f.NewIdentifier("input")
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -245,7 +253,7 @@ func (checkerProgrammerNamespace) Write_tuple_functions(props CheckerProgrammer_
         nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
-        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i), checkerProgrammer_decode_tuple_inline(checkerProgrammer_decodeTupleInlineProps{
+        checkerProgrammer_visit_guard(FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index), checkerProgrammer_decode_tuple_inline(checkerProgrammer_decodeTupleInlineProps{
           Config:  props.Config,
           Context: props.Context,
           Functor: props.Functor,

package/native/core/programmers/json/JsonStringifyProgrammer.go

@@ -100,12 +100,16 @@ func jsonStringifyProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(jsonStringifyProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, typ := range props.Collection.Arrays() {
+  for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -118,7 +122,7 @@ func jsonStringifyProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSerialize(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           jsonStringifyProgrammer_circular_thrower(props.Context, props.Functor),
           jsonStringifyProgrammer_decode_array_inline(jsonStringifyProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -153,12 +157,16 @@ func jsonStringifyProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(jsonStringifyProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -171,7 +179,7 @@ func jsonStringifyProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardSerialize(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           jsonStringifyProgrammer_circular_thrower(props.Context, props.Functor),
           jsonStringifyProgrammer_decode_tuple_inline(jsonStringifyProgrammer_decodeTupleInlineProps{
             Context:   props.Context,

package/native/core/programmers/notations/NotationGeneralProgrammer.go

@@ -131,12 +131,16 @@ func notationGeneralProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(notationGeneralProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, typ := range props.Collection.Arrays() {
+  for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -149,7 +153,7 @@ func notationGeneralProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           true,
           notationGeneralProgrammer_decode_array_inline(notationGeneralProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -184,12 +188,16 @@ func notationGeneralProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(notationGeneralProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -202,7 +210,7 @@ func notationGeneralProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           true,
           notationGeneralProgrammer_decode_tuple_inline(notationGeneralProgrammer_decodeTupleInlineProps{
             Context: props.Context,

package/native/core/programmers/plain/PlainClassifyProgrammer.go

@@ -135,12 +135,16 @@ func plainClassifyProgrammer_write_array_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainClassifyProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, typ := range props.Collection.Arrays() {
+  for _, typ := range props.Collection.Arrays() {
     if typ.Recursive == false {
       continue
     }
+    index := 0
+    if typ.Index != nil {
+      index = *typ.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%sa%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -153,7 +157,7 @@ func plainClassifyProgrammer_write_array_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "a", index),
           true,
           plainClassifyProgrammer_decode_array_inline(plainClassifyProgrammer_decodeArrayProps{
             Context: props.Context,
@@ -187,12 +191,16 @@ func plainClassifyProgrammer_write_tuple_functions(props struct {
 }) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(plainClassifyProgrammer_factory, props.Context.Emit)
   output := []*shimast.Node{}
-  for i, tuple := range props.Collection.Tuples() {
+  for _, tuple := range props.Collection.Tuples() {
     if tuple.Recursive == false {
       continue
     }
+    index := 0
+    if tuple.Index != nil {
+      index = *tuple.Index
+    }
     output = append(output, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
-      Name: fmt.Sprintf("%st%d", props.Config.Prefix, i),
+      Name: fmt.Sprintf("%st%d", props.Config.Prefix, index),
       Value: f.NewArrowFunction(
         nil,
         nil,
@@ -205,7 +213,7 @@ func plainClassifyProgrammer_write_tuple_functions(props struct {
         nil,
         f.NewToken(shimast.KindEqualsGreaterThanToken),
         nativeinternal.FeatureProgrammer.VisitGuardRebuild(
-          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", i),
+          nativeinternal.FeatureProgrammer.VisitKey(props.Config.Prefix, "t", index),
           true,
           plainClassifyProgrammer_decode_tuple_inline(plainClassifyProgrammer_decodeTupleInlineProps{
             Context: props.Context,