typia 13.1.0 → 13.1.19

package/native/core/programmers/compare/CompareEqualProgrammer.go

@@ -34,6 +34,10 @@ type compareEqualProgrammerGenerator struct {
   Config    CompareEqualProgrammer_IConfig
   Recursive bool
   Counter   int
+  // Member-resolution checkers (`_ui<index>`) emitted on demand for the object
+  // unions that need the is-match ladder, keyed by the object's collection index.
+  Matchers     []string
+  MatcherIndex map[int]bool
 }
 
 var compareEqualProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
@@ -71,8 +75,9 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
   }
 
   generator := &compareEqualProgrammerGenerator{
-    Config:    props.Config,
-    Recursive: nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    Config:       props.Config,
+    Recursive:    nativeinternal.FeatureProgrammer.CollectionRecursive(collection),
+    MatcherIndex: map[int]bool{},
   }
   body := generator.schema(result.Data, "x", "y")
   statements := []string{}
@@ -89,6 +94,12 @@ func (compareEqualProgrammerNamespace) Write(props CompareEqualProgrammer_IProps
       statements = append(statements, generator.tupleFunction(tuple))
     }
   }
+  // The member matchers are collected last because every generation step above
+  // may request one. They are `const` arrow functions in the same scope as the
+  // `_eo`/`_ea`/`_et` helpers and are only ever called after this IIFE returns,
+  // so declaring them at the end is free of temporal-dead-zone hazards — the
+  // same placement `is` uses for the `_io` checkers it appends after `_cu`.
+  statements = append(statements, generator.Matchers...)
   if generator.Recursive {
     statements = append(statements, "return (x, y) => { const _vctx = {}; return "+body+"; };")
   } else {
@@ -155,8 +166,28 @@ func (g *compareEqualProgrammerGenerator) schema(metadata *schemametadata.Metada
   for _, array := range metadata.Arrays {
     branches = append(branches, g.array(array, x, y))
   }
-  for _, object := range metadata.Objects {
-    branches = append(branches, g.objectCall(object.Type, x, y))
+  // A union of two or more object types must discriminate: route each operand
+  // to exactly one member and compare within that single member. A flat OR of
+  // member comparators lets a wrong member's comparator match spuriously — its
+  // literal discriminant is satisfied by the always-present `x[k] === y[k]`
+  // branch and its absent payload keys compare `undefined === undefined`. The
+  // discrimination reuses the shared UnionPredicator specialization the sibling
+  // programmers (is/clone/classify/...) route through, so `equals` agrees with
+  // `is` on which member a value is. A union no discriminant can split (every
+  // distinguishing key optional, e.g. `{ a?: number } | { b?: string }`) routes
+  // through the first-is-match ladder instead — never a flat OR, which admits
+  // the same spurious match through absent keys comparing
+  // `undefined === undefined` (issue #2225).
+  if len(metadata.Objects) >= 2 {
+    expr := g.objectUnion(metadata.Objects, x, y)
+    if guard := g.notNatives(metadata.Natives, x, y); guard != "" {
+      expr = g.and(guard, expr)
+    }
+    branches = append(branches, expr)
+  } else {
+    for _, object := range metadata.Objects {
+      branches = append(branches, g.objectFlatBranch(object.Type, metadata.Natives, x, y))
+    }
   }
   for _, alias := range metadata.Aliases {
     branches = append(branches, g.schema(alias.Type.Value, x, y))
@@ -233,7 +264,27 @@ func (g *compareEqualProgrammerGenerator) tupleInline(tuple *schemametadata.Meta
     g.same(g.access(x, "length"), g.access(y, "length")),
   }
   if rest == nil {
-    checks = append(checks, g.same(g.access(x, "length"), strconv.Itoa(fixed)))
+    // An omitted optional trailing element makes the tuple's length a range
+    // [required, fixed] — exactly the gate `is` emits. A hard `=== fixed`
+    // rejects a value `is` accepts and breaks reflexivity of `equals`; the
+    // per-element `x[i] === y[i]` prefix already treats both-absent as equal,
+    // so only the length gate needs the range. A fully-required tuple keeps
+    // its byte-identical `x.length === fixed`.
+    required := 0
+    allRequired := true
+    for i := 0; i < fixed; i++ {
+      if tuple.Elements[i].Optional {
+        allRequired = false
+      } else {
+        required++
+      }
+    }
+    if allRequired {
+      checks = append(checks, g.same(g.access(x, "length"), strconv.Itoa(fixed)))
+    } else {
+      length := g.access(x, "length")
+      checks = append(checks, fmt.Sprintf("%d <= %s && %d >= %s", required, length, fixed, length))
+    }
   } else {
     checks = append(checks, fmt.Sprintf("%s.length >= %d", g.wrap(x), fixed))
   }
@@ -256,6 +307,328 @@ func (g *compareEqualProgrammerGenerator) objectCall(object *schemametadata.Meta
   return fmt.Sprintf("_eo%d(%s, %s)", object.Index, g.wrap(x), g.wrap(y))
 }
 
+// objectFlatBranch renders one member of an object union as a guarded member
+// comparator (the pre-discrimination form). It is used for a single-object
+// "union" and as the fallback for a union no supported predicate can split.
+func (g *compareEqualProgrammerGenerator) objectFlatBranch(object *schemametadata.MetadataObjectType, natives []*schemametadata.MetadataNative, x string, y string) string {
+  // Guard the object branch against the sibling native instances. `_eo` admits
+  // any `typeof === "object" && !Array.isArray` value, so a native (a Date is
+  // an object) would be compared by the object's declared keys, which the
+  // native lacks — two different Dates then look equal on their absent keys and
+  // the OR wrongly accepts. Excluding what a native branch owns makes the arms
+  // mutually exclusive, matching the clone/classify ladder whose object arm is
+  // unreachable once a native arm matches.
+  call := g.objectCall(object, x, y)
+  if guard := g.notNatives(natives, x, y); guard != "" {
+    call = g.and(guard, call)
+  }
+  return call
+}
+
+// objectUnion renders a discriminated comparison for a union of two or more
+// object types. It mirrors the is/clone/classify discrimination: each operand is
+// routed to exactly one member, and only when both land on the same member does
+// that member's comparator run. This replaces the flat OR whose wrong-member
+// comparator could match spuriously.
+//
+// Routing prefers the shared UnionPredicator discriminants (issue #2214). When
+// no discriminant splits the members — every distinguishing key is optional, so
+// UnionPredicator yields no specialization, or more than one member is left
+// unspecialized — routing falls back to the first-is-match ladder that
+// clone/classify/prune reach through Decode_union_object (issue #2225). There is
+// no flat-OR fallback: the flat OR is the defect both issues describe.
+func (g *compareEqualProgrammerGenerator) objectUnion(objects []*schemametadata.MetadataObject, x string, y string) string {
+  types := make([]*schemametadata.MetadataObjectType, 0, len(objects))
+  for _, object := range objects {
+    types = append(types, object.Type)
+  }
+  ladder, ok := g.discriminantLadder(types)
+  if ok == false {
+    ladder = g.matchLadder(types)
+  }
+
+  tag := g.local("utag")
+  tx := g.local("utx")
+  // Dispatch: with the shared member index, run only that member's comparator.
+  dispatch := "false"
+  for i := len(types) - 1; i >= 0; i-- {
+    dispatch = fmt.Sprintf("%s === %d ? %s : %s", tx, types[i].Index, g.objectCall(types[i], "x", "y"), dispatch)
+  }
+  body := fmt.Sprintf(
+    "((x, y) => { const %s = (v) => (%s) ? (%s) : -1; const %s = %s(x); return %s !== -1 && %s === %s(y) && (%s); })(%s, %s)",
+    tag, g.isObject("v"), ladder, tx, tag, tx, tx, tag, dispatch, g.wrap(x), g.wrap(y),
+  )
+  return body
+}
+
+// discriminantLadder renders the routing ternary from the shared UnionPredicator
+// specialization: `<discriminant of member i> ? <index of member i> : ...`,
+// ending in the lone unspecialized member (the unconditional else the
+// discriminant ladder leaves) or -1 for "no member". It reports ok=false when
+// the members carry no usable discriminant, when more than one member is left
+// unspecialized, or when a discriminant value cannot be rendered as a check —
+// the caller then routes by is-match instead.
+func (g *compareEqualProgrammerGenerator) discriminantLadder(types []*schemametadata.MetadataObjectType) (string, bool) {
+  specs := nativehelpers.UnionPredicator.Object(types)
+  if len(specs) == 0 {
+    return "", false
+  }
+  specialized := map[*schemametadata.MetadataObjectType]bool{}
+  for _, spec := range specs {
+    specialized[spec.Object] = true
+  }
+  remained := []*schemametadata.MetadataObjectType{}
+  for _, object := range types {
+    if specialized[object] == false {
+      remained = append(remained, object)
+    }
+  }
+  if len(remained) > 1 {
+    return "", false
+  }
+  fallback := "-1"
+  if len(remained) == 1 {
+    fallback = strconv.Itoa(remained[0].Index)
+  }
+  ladder := fallback
+  for i := len(specs) - 1; i >= 0; i-- {
+    check, ok := g.discriminant(specs[i], "v")
+    if ok == false {
+      return "", false
+    }
+    ladder = fmt.Sprintf("%s ? %d : %s", check, specs[i].Object.Index, ladder)
+  }
+  return ladder, true
+}
+
+// matchLadder renders the routing ternary for a union no discriminant splits:
+// the first member the value is-matches wins, exactly as `clone`/`classify`/
+// `prune` resolve membership through Decode_union_object's `if (_io0(input))
+// return ...; if (_io1(input)) ...` ladder. A value matching no member yields
+// -1, which makes `equals` false rather than letting a wrong member's comparator
+// decide.
+func (g *compareEqualProgrammerGenerator) matchLadder(types []*schemametadata.MetadataObjectType) string {
+  calls := make([]string, 0, len(types))
+  for _, object := range types {
+    // Declared in member order so the emitted matchers read in the same order
+    // as the ladder that calls them; the ladder itself is folded back to front.
+    calls = append(calls, g.matchCall(object, "v"))
+  }
+  ladder := "-1"
+  for i := len(types) - 1; i >= 0; i-- {
+    ladder = fmt.Sprintf("%s ? %d : %s", calls[i], types[i].Index, ladder)
+  }
+  return ladder
+}
+
+// matchCall returns a call to the member's `_ui<index>` matcher, declaring the
+// matcher on first request. The index is registered before the body is rendered
+// so a recursive member refers to its own matcher instead of recursing forever
+// at generation time.
+func (g *compareEqualProgrammerGenerator) matchCall(object *schemametadata.MetadataObjectType, v string) string {
+  name := fmt.Sprintf("_ui%d", object.Index)
+  if g.MatcherIndex[object.Index] == false {
+    g.MatcherIndex[object.Index] = true
+    g.Matchers = append(g.Matchers, fmt.Sprintf("const %s = (v) => %s;", name, g.matchObject(object, "v")))
+  }
+  return fmt.Sprintf("%s(%s)", name, g.wrap(v))
+}
+
+// matchObject renders the structural is-check of one object member: every
+// declared regular key must hold a value of its declared type (an optional key
+// may be absent), and every extra key a dynamic index signature declares must
+// hold a value of the signature's type. It mirrors the `_io` checkers `is`
+// emits, at the abstraction level the rest of this programmer works at — shape
+// and typeof, not the value constraints (`typia.tags.*`, template patterns)
+// `compare` deliberately ignores.
+func (g *compareEqualProgrammerGenerator) matchObject(object *schemametadata.MetadataObjectType, v string) string {
+  checks := []string{}
+  regularKeys := []string{}
+  dynamic := []*schemametadata.MetadataProperty{}
+  for _, property := range object.Properties {
+    if compareProgrammer_isMethod(property) {
+      continue // methods carry no comparable data, so they do not route either
+    }
+    if sole := property.Key.GetSoleLiteral(); sole != nil {
+      regularKeys = append(regularKeys, *sole)
+      checks = append(checks, g.matchSlot(property.Value, g.property(v, *sole)))
+    } else {
+      dynamic = append(dynamic, property)
+    }
+  }
+  if len(dynamic) != 0 {
+    key := g.local("key")
+    regularCheck := compareEqualProgrammer_regularKeyCheck(regularKeys)
+    conditions := []string{}
+    for _, property := range dynamic {
+      conditions = append(conditions, g.and(g.dynamicKey(property.Key, key), g.matchSlot(property.Value, g.index(v, key))))
+    }
+    checks = append(checks, fmt.Sprintf("Object.keys(%s).every((%s) => %s)", g.wrap(v), key, g.or(regularCheck(key), g.or(conditions...))))
+  }
+  return g.and(checks...)
+}
+
+// matchSlot renders the is-check of a value slot — an object property or a tuple
+// element — allowing the slot to be absent when it is optional.
+func (g *compareEqualProgrammerGenerator) matchSlot(metadata *schemametadata.MetadataSchema, v string) string {
+  check := g.match(metadata, v)
+  if metadata != nil && metadata.IsRequired() == false {
+    return g.or(g.same(v, "undefined"), check)
+  }
+  return check
+}
+
+// match renders the structural is-check of one metadata schema as the OR of its
+// buckets, the same bucket walk `schema` compares over. An unconstrained bucket
+// (anything the compare feature already rejects, or a bucket carrying no shape
+// to test) renders as "true", which keeps the ladder's first-match order the
+// deciding factor exactly as it is in `is`.
+func (g *compareEqualProgrammerGenerator) match(metadata *schemametadata.MetadataSchema, v string) string {
+  if metadata == nil {
+    return "true"
+  }
+  metadata = schemametadata.MetadataSchema_unalias(metadata)
+  if metadata.Any {
+    return "true"
+  }
+  branches := []string{}
+  if metadata.Nullable {
+    branches = append(branches, g.same(v, "null"))
+  }
+  for _, constant := range metadata.Constants {
+    for _, value := range constant.Values {
+      branches = append(branches, g.same(v, compareEqualProgrammer_literal(value.Value, constant.Type)))
+    }
+  }
+  for _, atomic := range metadata.Atomics {
+    branches = append(branches, g.typeof(v, atomic.Type))
+  }
+  if len(metadata.Templates) != 0 {
+    branches = append(branches, g.typeof(v, "string"))
+  }
+  if len(metadata.Functions) != 0 {
+    branches = append(branches, g.typeof(v, "function"))
+  }
+  for _, native := range metadata.Natives {
+    branches = append(branches, g.instanceof(v, native.Name))
+  }
+  for _, tuple := range metadata.Tuples {
+    branches = append(branches, g.matchTuple(tuple.Type, v))
+  }
+  for _, array := range metadata.Arrays {
+    elem := g.local("elem")
+    branches = append(branches, g.and(g.isArray(v), fmt.Sprintf("%s.every((%s) => %s)", g.wrap(v), elem, g.match(array.Type.Value, elem))))
+  }
+  if len(metadata.Objects) != 0 {
+    calls := []string{}
+    for _, object := range metadata.Objects {
+      calls = append(calls, g.matchCall(object.Type, v))
+    }
+    branches = append(branches, g.and(g.isObject(v), g.or(calls...)))
+  }
+  for _, alias := range metadata.Aliases {
+    branches = append(branches, g.match(alias.Type.Value, v))
+  }
+  if metadata.Escaped != nil {
+    branches = append(branches, g.match(metadata.Escaped.Original, v))
+  }
+  if metadata.Rest != nil {
+    branches = append(branches, g.match(metadata.Rest, v))
+  }
+  if len(branches) == 0 {
+    return "true"
+  }
+  return g.or(branches...)
+}
+
+// matchTuple renders the is-check of a tuple: the array gate, the length range
+// an omitted optional trailing element makes legal (the same range `tupleInline`
+// compares over), and each element's own check.
+func (g *compareEqualProgrammerGenerator) matchTuple(tuple *schemametadata.MetadataTupleType, v string) string {
+  fixed := len(tuple.Elements)
+  var rest *schemametadata.MetadataSchema
+  if fixed != 0 && tuple.Elements[fixed-1].Rest != nil {
+    rest = tuple.Elements[fixed-1].Rest
+    fixed--
+  }
+  checks := []string{g.isArray(v)}
+  length := g.access(v, "length")
+  if rest == nil {
+    required := 0
+    allRequired := true
+    for i := 0; i < fixed; i++ {
+      if tuple.Elements[i].Optional {
+        allRequired = false
+      } else {
+        required++
+      }
+    }
+    if allRequired {
+      checks = append(checks, g.same(length, strconv.Itoa(fixed)))
+    } else {
+      checks = append(checks, fmt.Sprintf("%d <= %s && %d >= %s", required, length, fixed, length))
+    }
+  } else {
+    checks = append(checks, fmt.Sprintf("%s >= %d", length, fixed))
+  }
+  for i := 0; i < fixed; i++ {
+    checks = append(checks, g.matchSlot(tuple.Elements[i], g.index(v, strconv.Itoa(i))))
+  }
+  if rest != nil {
+    elem := g.local("elem")
+    checks = append(checks, fmt.Sprintf("%s.slice(%d).every((%s) => %s)", g.wrap(v), fixed, elem, g.match(rest, elem)))
+  }
+  return g.and(checks...)
+}
+
+// discriminant renders the routing predicate for one specialized union member,
+// matching how `is` decides membership: presence (`v[key] !== undefined`) for a
+// key unique to this member, or a value check (literal equality for constants,
+// typeof for atomics/templates) for a shared key whose value distinguishes it.
+// It returns ok=false for any discriminant value it cannot render as such a
+// check, so the caller falls back rather than emit a weaker predicate.
+func (g *compareEqualProgrammerGenerator) discriminant(spec nativehelpers.UnionPredicator_ISpecialized, v string) (string, bool) {
+  sole := spec.Property.Key.GetSoleLiteral()
+  if sole == nil {
+    return "", false
+  }
+  access := g.property(v, *sole)
+  if spec.Neighbor == false {
+    return fmt.Sprintf("%s !== undefined", g.wrap(access)), true
+  }
+  meta := schemametadata.MetadataSchema_unalias(spec.Property.Value)
+  if meta == nil || meta.Any {
+    return "", false
+  }
+  if len(meta.Objects) != 0 || len(meta.Arrays) != 0 || len(meta.Tuples) != 0 ||
+    len(meta.Natives) != 0 || len(meta.Sets) != 0 || len(meta.Maps) != 0 ||
+    len(meta.Aliases) != 0 || len(meta.Functions) != 0 || meta.Escaped != nil || meta.Rest != nil {
+    return "", false
+  }
+  checks := []string{}
+  if meta.Nullable {
+    // A nullable discriminant (e.g. `type: "a" | null`) routes a null value to
+    // this member exactly as `is` does, so `equals(null-arm, null-arm)` stays
+    // reflexive rather than falling through to no member.
+    checks = append(checks, g.same(access, "null"))
+  }
+  for _, constant := range meta.Constants {
+    for _, value := range constant.Values {
+      checks = append(checks, g.same(access, compareEqualProgrammer_literal(value.Value, constant.Type)))
+    }
+  }
+  for _, atomic := range meta.Atomics {
+    checks = append(checks, g.typeof(access, atomic.Type))
+  }
+  if len(meta.Templates) != 0 {
+    checks = append(checks, g.typeof(access, "string"))
+  }
+  if len(checks) == 0 {
+    return "", false
+  }
+  return g.or(checks...), true
+}
+
 func (g *compareEqualProgrammerGenerator) arrayCall(array *schemametadata.MetadataArrayType, x string, y string) string {
   index := 0
   if array.Index != nil {
@@ -409,6 +782,21 @@ func (g *compareEqualProgrammerGenerator) objectGuard(x string, y string) string
   return g.and(g.isObject(x), g.isObject(y))
 }
 
+// notNatives builds "neither x nor y is one of the union's native instances",
+// so the object branch never claims a value a native branch owns. Empty when
+// the union declares no native, keeping the object-only output unchanged.
+func (g *compareEqualProgrammerGenerator) notNatives(natives []*schemametadata.MetadataNative, x string, y string) string {
+  if len(natives) == 0 {
+    return ""
+  }
+  checks := []string{}
+  for _, native := range natives {
+    checks = append(checks, "!"+g.wrap(g.instanceof(x, native.Name)))
+    checks = append(checks, "!"+g.wrap(g.instanceof(y, native.Name)))
+  }
+  return g.and(checks...)
+}
+
 func (g *compareEqualProgrammerGenerator) isObject(input string) string {
   return fmt.Sprintf("typeof %s === \"object\" && %s !== null && !Array.isArray(%s)", g.wrap(input), g.wrap(input), g.wrap(input))
 }

package/native/core/programmers/compare/CompareLessProgrammer.go

@@ -219,9 +219,11 @@ func (g *compareLessProgrammerGenerator) core(metadata *schemametadata.MetadataS
 }
 
 // primitive renders the scalar three-way comparator (works for number, string,
-// boolean and bigint via the relational operators).
+// boolean and bigint via the relational operators). Self-inequality detects NaN
+// without coercing other scalar types and places it after every ordinary number.
 func (g *compareLessProgrammerGenerator) primitive(x string, y string) string {
-  return fmt.Sprintf("(%s < %s ? -1 : %s > %s ? 1 : 0)", g.wrap(x), g.wrap(y), g.wrap(x), g.wrap(y))
+  return fmt.Sprintf("(%s !== %s ? (%s !== %s ? 0 : 1) : %s !== %s ? -1 : %s < %s ? -1 : %s > %s ? 1 : 0)",
+    g.wrap(x), g.wrap(x), g.wrap(y), g.wrap(y), g.wrap(y), g.wrap(y), g.wrap(x), g.wrap(y), g.wrap(x), g.wrap(y))
 }
 
 func (g *compareLessProgrammerGenerator) native(name string, x string, y string) string {

package/native/core/programmers/functional/FunctionalAssertFunctionProgrammer.go

@@ -66,13 +66,11 @@ func (functionalAssertFunctionProgrammerNamespace) Write(props FunctionalAssertF
   }
   body = append(body, f.NewReturnStatement(r.Value))
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(r.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      r.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalAssertParametersProgrammer.go

@@ -66,21 +66,13 @@ func (functionalAssertParametersProgrammerNamespace) Write(props FunctionalAsser
   for _, exp := range result.Expressions {
     body = append(body, f.NewExpressionStatement(exp))
   }
-  body = append(body, f.NewReturnStatement(f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )))
+  body = append(body, f.NewReturnStatement(functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)))
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(output.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      output.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalAssertReturnProgrammer.go

@@ -62,14 +62,12 @@ func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnP
   statements := []*shimast.Node{wrapper.Variable}
   statements = append(statements, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(result.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      result.Async,
       functionalAssertProgrammer_returnType(props.Declaration),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
-      result.Value,
+      f.NewBlock(f.NewNodeList([]*shimast.Node{f.NewReturnStatement(result.Value)}), true),
     ),
   ))
   return nativefactories.ExpressionFactory.SelfCall(
@@ -84,13 +82,7 @@ func (functionAssertReturnProgrammerNamespace) Decompose(props FunctionAssertRet
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
   })
-  caller := f.NewCallExpression(
-    props.Expression,
-    nil,
-    nil,
-    f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-    shimast.NodeFlagsNone,
-  )
+  caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   value := caller
   if output.Async {
     value = f.NewAwaitExpression(caller)

package/native/core/programmers/functional/FunctionalIsFunctionProgrammer.go

@@ -43,10 +43,10 @@ func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionP
   body := append([]*shimast.Node{}, p.Statements...)
   body = append(body, r.Statements...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(r.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      r.Async,
       FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -56,8 +56,6 @@ func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionP
         Declaration: props.Declaration,
         Async:       r.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(body), true),
     ),
   ))

package/native/core/programmers/functional/FunctionalIsParametersProgrammer.go

@@ -54,10 +54,10 @@ func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParamet
   })
   statements := append([]*shimast.Node{}, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
-    f.NewArrowFunction(
-      functionalIsProgrammer_asyncModifiers(output.Async, props.Context.Emit),
-      nil,
-      functionalIsProgrammer_parameters(props.Declaration, props.Context.Emit),
+    functionalIsProgrammer_function(
+      props.Context,
+      props.Declaration,
+      output.Async,
       FunctionalIsFunctionProgrammer.GetReturnTypeNode(struct {
         Context     nativecontext.ITypiaContext
         Declaration *shimast.Node
@@ -67,17 +67,9 @@ func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParamet
         Declaration: props.Declaration,
         Async:       output.Async,
       }),
-      nil,
-      f.NewToken(shimast.KindEqualsGreaterThanToken),
       f.NewBlock(f.NewNodeList(append(
         append([]*shimast.Node{}, result.Statements...),
-        f.NewReturnStatement(f.NewCallExpression(
-          props.Expression,
-          nil,
-          nil,
-          f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(props.Declaration, props.Context.Emit)),
-          shimast.NodeFlagsNone,
-        )),
+        f.NewReturnStatement(functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)),
       )), true),
     ),
   ))
@@ -139,11 +131,54 @@ func functionalIsProgrammer_parameters(declaration *shimast.Node, emit ...*shimp
 
 func functionalIsProgrammer_parameterNodes(declaration *shimast.Node) []*shimast.Node {
   if params := functionalIsProgrammer_parameters(declaration); params != nil {
-    return params.Nodes
+    output := make([]*shimast.Node, 0, len(params.Nodes))
+    for _, param := range params.Nodes {
+      // TypeScript's explicit `this` parameter declares a receiver type but is
+      // erased at runtime. It is neither validated nor forwarded as an argument.
+      if functionalIsProgrammer_parameterName(param) != "this" {
+        output = append(output, param)
+      }
+    }
+    return output
   }
   return nil
 }
 
+func functionalIsProgrammer_function(
+  context nativecontext.ITypiaContext,
+  declaration *shimast.Node,
+  async bool,
+  returnType *shimast.Node,
+  body *shimast.Node,
+) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  return f.NewFunctionExpression(
+    functionalIsProgrammer_asyncModifiers(async, context.Emit),
+    nil,
+    nil,
+    nil,
+    functionalIsProgrammer_parameters(declaration, context.Emit),
+    returnType,
+    nil,
+    body,
+  )
+}
+
+func functionalIsProgrammer_call(context nativecontext.ITypiaContext, expression *shimast.Node, declaration *shimast.Node) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(context.Emit, f.NewIdentifier("Reflect"), "apply"),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      expression,
+      f.NewKeywordExpression(shimast.KindThisKeyword),
+      f.NewArrayLiteralExpression(f.NewNodeList(functionalIsProgrammer_parameterIdentifiers(declaration, context.Emit)), false),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
 func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
   f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
   parameters := functionalIsProgrammer_parameterNodes(declaration)