typia 13.2.0 → 14.0.0

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

@@ -70,34 +70,11 @@ func metadata_type_full_name(
   return result
 }
 
-// metadata_type_symbol_name mirrors TypeFactory.getFullName({ aliasTypeArguments:
-// false }) from legacy typia: the name is derived from the type's *symbol*, not
-// from checker.typeToString. This matters for alias chains (e.g. MapAlias.MAP =
-// Map<K, V>) where typeToString prints the alias name ("MapAlias.MAP<...>")
-// instead of "Map<...>", which would defeat the Map/Set prefix guards.
-func metadata_type_symbol_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
-  if checker == nil || typ == nil {
-    return ""
-  }
-  symbol := typ.Symbol()
-  if symbol == nil {
-    return checker.TypeToString(typ)
-  }
-  name := metadata_symbol_name(symbol)
-  generic := metadata_get_type_arguments(checker, typ)
-  if len(generic) == 0 {
-    return name
-  }
-  if name == "Promise" {
-    return metadata_type_symbol_name(checker, generic[0])
-  }
-  names := make([]string, 0, len(generic))
-  for _, child := range generic {
-    names = append(names, metadata_type_symbol_name(checker, child))
-  }
-  return name + "<" + strings.Join(names, ", ") + ">"
-}
-
+// metadata_type_symbol_base_name derives the name from the type's own *symbol*,
+// never from checker.TypeToString. The Map / Set / native guards test this name
+// against a prefix, and an alias chain (e.g. `type MAP = Map<K, V>`) makes
+// TypeToString print the alias name ("MapAlias.MAP<...>") instead of "Map<...>",
+// which would defeat those guards.
 func metadata_type_symbol_base_name(typ *nativechecker.Type) string {
   if typ == nil {
     return ""

package/native/core/factories/metadata_comment_tag_factory_rejects_out_of_range_integer_test.go

@@ -0,0 +1,124 @@
+package factories
+
+import "testing"
+
+// TestMetadataCommentTagFactoryRejectsOutOfRangeInteger pins the boundary of the
+// float64-to-int conversion behind every numeric JSDoc tag.
+//
+// `metadataCommentTagFactory_parse_integer` used to end in a bare `int(parsed)`.
+// A float64 outside the destination range converts by an implementation-defined
+// rule rather than by wrapping, so on amd64 both `1e19` and `-1e19` became
+// -9223372036854775808 -- a magnitude and its negation collapsing to the same
+// wrong number, silently, inside `@minItems` and `@maxItems`.
+//
+// The destination is int64, not int. `int` is 32 bits on the 32-bit platforms
+// ttsc publishes a binary for (`@ttsc/linux-arm`), so bounding by `int` would
+// leave the same defect at 2**31 there while closing it at 2**63 on x64 -- and
+// would make `@minimum 3000000000` on a `bigint` mean one thing per platform.
+// Case 4 is what holds the boundary platform-independent.
+//
+// The guard has to be exclusive at 2**63 rather than inclusive at
+// math.MaxInt64. An untyped constant 9223372036854775807.0 rounds to 2**63 once
+// it meets a float64 operand, so an inclusive comparison lets exactly the one
+// value through that int64 cannot hold. This test is what keeps that distinction
+// from being "simplified" back.
+//
+//  1. Reject magnitudes at and beyond 2**63 in both directions.
+//  2. Accept the true minimum and the largest float64 below the maximum, and
+//     require the value carried through to be the value parsed.
+//  3. Keep the existing non-integer and unsigned diagnostics untouched.
+//  4. Require the accepted range to be int64's on every platform, not the
+//     compiling platform's `int`.
+func TestMetadataCommentTagFactoryRejectsOutOfRangeInteger(t *testing.T) {
+  parse := func(value string, unsigned bool) (*int64, []string) {
+    messages := []string{}
+    report := func(msg string) any {
+      messages = append(messages, msg)
+      return nil
+    }
+    return metadataCommentTagFactory_parse_integer(struct {
+      Report   func(msg string) any
+      Unsigned bool
+      Value    string
+    }{Report: report, Unsigned: unsigned, Value: value}), messages
+  }
+
+  //----
+  // 1. out of range, both directions
+  //----
+  for _, value := range []string{
+    "9223372036854775808",   // 2**63 exactly -- the value an inclusive guard let through
+    "10000000000000000000",  // 1e19
+    "-10000000000000000000", // -1e19, which collapsed to the same int as +1e19
+    "1e30",
+  } {
+    parsed, messages := parse(value, false)
+    if parsed != nil {
+      t.Fatalf("%s must be rejected, got %d", value, *parsed)
+    }
+    if len(messages) == 0 {
+      t.Fatalf("%s must be reported, not dropped silently", value)
+    }
+  }
+
+  //----
+  // 2. in range, carried through unchanged
+  //----
+  for _, tuple := range []struct {
+    value    string
+    expected int64
+  }{
+    {value: "0", expected: 0},
+    {value: "1", expected: 1},
+    {value: "-1", expected: -1},
+    {value: "-9223372036854775808", expected: -9223372036854775808}, // the true minimum
+    {value: "9223372036854774784", expected: 9223372036854774784},   // largest float64 below 2**63
+  } {
+    parsed, messages := parse(tuple.value, false)
+    if parsed == nil {
+      t.Fatalf("%s must be accepted, reports=%#v", tuple.value, messages)
+    }
+    if *parsed != tuple.expected {
+      t.Fatalf("%s must parse to %d, got %d", tuple.value, tuple.expected, *parsed)
+    }
+    if len(messages) != 0 {
+      t.Fatalf("%s must report nothing, got %#v", tuple.value, messages)
+    }
+  }
+
+  //----
+  // 3. the diagnostics that already existed
+  //----
+  if parsed, messages := parse("1.5", false); parsed != nil || len(messages) == 0 {
+    t.Fatalf("a non-integer must still be rejected: %#v %#v", parsed, messages)
+  }
+  if parsed, messages := parse("-1", true); parsed != nil || len(messages) == 0 {
+    t.Fatalf("a negative unsigned integer must still be rejected: %#v %#v", parsed, messages)
+  }
+
+  //----
+  // 4. the boundary is int64's on every platform, not the compiling one's int
+  //----
+  // These sit above int32 and below int64. A guard written against `int`
+  // accepts them here and converts them out of range on `@ttsc/linux-arm` --
+  // the same defect this test closes, moved to a platform the suite does not
+  // usually run on. `GOARCH=arm go vet ./core/factories/` is what executes this
+  // case for real; on a 64-bit host it is the declared type that carries it.
+  for _, tuple := range []struct {
+    value    string
+    expected int64
+  }{
+    {value: "2147483648", expected: 2147483648},   // 2**31
+    {value: "-2147483649", expected: -2147483649}, // -2**31 - 1
+    {value: "4294967296", expected: 4294967296},   // 2**32, past uint32 too
+    {value: "3000000000", expected: 3000000000},   // a plausible @minimum on a bigint
+  } {
+    parsed, messages := parse(tuple.value, false)
+    if parsed == nil {
+      t.Fatalf("%s is inside int64 and must be accepted on every platform, reports=%#v", tuple.value, messages)
+    }
+    if *parsed != tuple.expected {
+      t.Fatalf("%s must parse to %d, got %d", tuple.value, tuple.expected, *parsed)
+    }
+  }
+}

package/native/core/programmers/AssertProgrammer.go

@@ -65,13 +65,13 @@ func (assertProgrammerNamespace) Decompose(props AssertProgrammer_DecomposeProps
     Type:    props.Type,
     Name:    props.Name,
     Config: nativeinternal.CheckerProgrammer_IConfig{
-      Prefix:  "_a",
-      Path:    true,
-      Trace:   true,
-      Numeric: nativehelpers.OptionPredicator.Numeric(props.Context.Options),
-      Equals:  props.Config.Equals,
+      Prefix:        "_a",
+      Path:          true,
+      Trace:         true,
+      Numeric:       nativehelpers.OptionPredicator.Numeric(props.Context.Options),
+      Equals:        props.Config.Equals,
       ObjectParents: props.Config.Equals == false,
-      Atomist: assertProgrammer_atomist(props),
+      Atomist:       assertProgrammer_atomist(props),
       Combiner: assertProgrammer_combiner(struct {
         Config  AssertProgrammer_IConfig
         Context nativecontext.ITypiaContext
@@ -323,6 +323,20 @@ func assertProgrammer_assert_object(props assertProgrammer_assertObjectProps) *s
           Input:    input,
         })
       },
+      InvalidKey: func(input *shimast.Expression, expected string, description *shimast.Expression) *shimast.Node {
+        return assertProgrammer_create_guard_call(assertProgrammer_createGuardCallProps{
+          Context: props.Context,
+          Functor: props.Functor,
+          Path: assertProgrammer_binary(
+            f.NewIdentifier("_path"),
+            shimast.KindPlusToken,
+            f.NewCallExpression(assertProgrammer_internal(props.Context, "accessExpressionAsString"), nil, nil, f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}), shimast.NodeFlagsNone),
+            props.Context.Emit,
+          ),
+          Expected: expected,
+          Input:    input,
+        })
+      },
       Halt: func(expr *shimast.Expression) *shimast.Node {
         return assertProgrammer_or(
           assertProgrammer_equal(f.NewKeywordExpression(shimast.KindFalseKeyword), f.NewIdentifier("_exceptionable"), props.Context.Emit),

package/native/core/programmers/RandomProgrammer.go

@@ -546,6 +546,26 @@ func randomProgrammer_decode(props randomProgrammer_decodeProps) *shimast.Node {
   if len(expressions) == 1 {
     return expressions[0]
   }
+  if escape := randomProgrammer_recursion_escape(props); escape != nil {
+    return nativefactories.ExpressionFactory.Conditional(
+      f.NewBinaryExpression(
+        nil,
+        nativefactories.ExpressionFactory.Number(nativehelpers.RandomJoiner_RECURSION_CUTOFF, props.Context.Emit),
+        nil,
+        f.NewToken(shimast.KindGreaterThanEqualsToken),
+        f.NewIdentifier("_depth"),
+      ),
+      randomProgrammer_decode_pick(props, expressions),
+      escape,
+      props.Context.Emit,
+    )
+  }
+  return randomProgrammer_decode_pick(props, expressions)
+}
+
+// randomProgrammer_decode_pick draws one of the candidate expressions uniformly.
+func randomProgrammer_decode_pick(props randomProgrammer_decodeProps, expressions []*shimast.Node) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
   pickers := make([]*shimast.Node, 0, len(expressions))
   for _, expr := range expressions {
     value := expr
@@ -576,6 +596,50 @@ func randomProgrammer_decode(props randomProgrammer_decodeProps) *shimast.Node {
   )
 }
 
+// randomProgrammer_recursion_escape reports the terminating candidate a
+// recursive leaf must take once the depth cutoff is reached, or nil when the
+// leaf has none to force.
+//
+// A recursive array already stops at the cutoff -- RandomJoiner emits
+// `CUTOFF >= _depth ? … : []` around it. The nullable and optional escapes had
+// no such guard: `null` and `undefined` were simply two more candidates in the
+// uniform `_randomPick`, so the depth of a `self?: T` or `self: T | null` chain
+// was geometric with no bound at all. Measured before this guard, 20,000 draws
+// of `{ value: string; self?: Self }` reached depth 16, and exceeded 8 on 44 of
+// them -- which is why a suite asserting a depth bound failed at random.
+//
+// The guard needs `_depth` in scope, so it applies only inside a generated
+// function (`Explore.Function`) reached recursively (`Explore.Recursive`), and
+// only where the leaf actually recurses through an object or tuple. A leaf that
+// is merely nullable, with no recursive candidate, keeps drawing uniformly.
+func randomProgrammer_recursion_escape(props randomProgrammer_decodeProps) *shimast.Node {
+  if props.Explore.Function == false || props.Explore.Recursive == false {
+    return nil
+  }
+  recursive := false
+  for _, object := range props.Metadata.Objects {
+    if object.Type != nil && object.Type.Recursive {
+      recursive = true
+    }
+  }
+  for _, tuple := range props.Metadata.Tuples {
+    if tuple.Type != nil && tuple.Type.Recursive {
+      recursive = true
+    }
+  }
+  if recursive == false {
+    return nil
+  }
+  f := nativecontext.EmitFactoryOf(randomProgrammer_factory, props.Context.Emit)
+  if props.Metadata.Nullable {
+    return f.NewKeywordExpression(shimast.KindNullKeyword)
+  }
+  if props.Metadata.IsRequired() == false {
+    return f.NewIdentifier("undefined")
+  }
+  return nil
+}
+
 func randomProgrammer_decode_atomic(props randomProgrammer_decodeAtomicProps) []*shimast.Node {
   var schemaList []nativeiterate.JsonSchema
   if props.Atomic.Type == "boolean" {
@@ -1441,9 +1505,20 @@ func randomProgrammer_is_typed_array(name string) bool {
 // copy of the 64-bit bound that is deliberately inexact. They become `minimum` and
 // `maximum` comment tags on a number-typed JSON schema, and `number` cannot
 // represent 2**63 - 1 or 2**64 - 1 -- both arrive rounded up to the next power of
-// two. That costs nothing here: the generator only picks a value from the range,
-// and the TypedArray constructor wraps whatever it is handed. Validation owns
-// exactness instead, in _isTypeInt64Bigint and its siblings.
+// two. That costs nothing here, and not because the generator is careless: it
+// draws Math.floor(Math.random() * (maximum - minimum + 1)) + minimum, and that
+// span is 2**64 either way, where consecutive doubles are 2048 apart. So the
+// largest draw is 2**63 - 2048 for int64 and 2**64 - 2048 for uint64, both
+// inside the width. (Nearer the int64 maximum itself the spacing is 1024, which
+// is why the largest double below 2**63 is 2**63 - 1024; the span is what bounds
+// the draw.) The TypedArray constructor then wraps whatever it is handed anyway.
+//
+// Only the `bigint` path is exact, in _isTypeInt64Bigint and _isTypeUint64Bigint,
+// which take the true inclusive bound through a BigInt string a `number` literal
+// here could not spell. _isTypeInt64 and _isTypeUint64 on the `number` path
+// carry the same rounding this table does: their maxima are written 2**63 - 1
+// and 2**64 - 1, which are the powers of two as doubles, so each accepts one
+// value above its width -- the only float form that maximum has.
 func randomProgrammer_typed_array_range(name string) (string, string, string) {
   switch name {
   case "Uint8Array", "Uint8ClampedArray":

package/native/core/programmers/ValidateProgrammer.go

@@ -55,13 +55,13 @@ func (validateProgrammerNamespace) Decompose(props ValidateProgrammer_DecomposeP
     Type:    props.Type,
     Name:    props.Name,
     Config: nativeinternal.CheckerProgrammer_IConfig{
-      Prefix:  "_v",
-      Path:    true,
-      Trace:   true,
-      Numeric: nativehelpers.OptionPredicator.Numeric(props.Context.Options),
-      Equals:  props.Config.Equals,
+      Prefix:        "_v",
+      Path:          true,
+      Trace:         true,
+      Numeric:       nativehelpers.OptionPredicator.Numeric(props.Context.Options),
+      Equals:        props.Config.Equals,
       ObjectParents: props.Config.Equals == false,
-      Atomist: validateProgrammer_atomist(props),
+      Atomist:       validateProgrammer_atomist(props),
       Combiner: validateProgrammer_combine(struct {
         Config  ValidateProgrammer_IConfig
         Context nativecontext.ITypiaContext
@@ -312,6 +312,21 @@ func validateProgrammer_validate_object(props validateProgrammer_validateObjectP
           Emit:        props.Context.Emit,
         })
       },
+      InvalidKey: func(input *shimast.Expression, expected string, description *shimast.Expression) *shimast.Node {
+        return validateProgrammer_create_report_call(validateProgrammer_createReportCallProps{
+          Path: validateProgrammer_binary(
+            f.NewIdentifier("_path"),
+            shimast.KindPlusToken,
+            f.NewCallExpression(validateProgrammer_internal(props.Context, "accessExpressionAsString"), nil, nil, f.NewNodeList([]*shimast.Node{f.NewIdentifier("key")}), shimast.NodeFlagsNone),
+            props.Context.Emit,
+          ),
+          Expected:    expected,
+          Value:       input,
+          Description: description,
+          Functor:     props.Functor,
+          Emit:        props.Context.Emit,
+        })
+      },
       Halt: func(expr *shimast.Expression) *shimast.Node {
         return validateProgrammer_or(validateProgrammer_equal(f.NewKeywordExpression(shimast.KindFalseKeyword), f.NewIdentifier("_exceptionable"), props.Context.Emit), expr, props.Context.Emit)
       },

package/native/core/programmers/helpers/RandomJoiner.go

@@ -15,6 +15,13 @@ type randomJoinerNamespace struct{}
 
 var RandomJoiner = randomJoinerNamespace{}
 
+// RandomJoiner_RECURSION_CUTOFF is the `_depth` past which a recursive draw
+// stops descending: a recursive array empties, and a recursive leaf with a
+// nullable or optional escape takes it. One constant because one number decides
+// both -- a recursive value that stopped at two different depths depending on
+// which escape it happened to own would make a depth bound unstatable.
+const RandomJoiner_RECURSION_CUTOFF = 5
+
 type RandomJoiner_Decoder func(metadata *nativemetadata.MetadataSchema) *shimast.Node
 
 type RandomJoiner_ArrayProps struct {
@@ -126,7 +133,7 @@ func (randomJoinerNamespace) Array(props RandomJoiner_ArrayProps) *shimast.Node
   return nativefactories.ExpressionFactory.Conditional(
     f.NewBinaryExpression(
       nil,
-      nativefactories.ExpressionFactory.Number(5, props.Emit),
+      nativefactories.ExpressionFactory.Number(RandomJoiner_RECURSION_CUTOFF, props.Emit),
       nil,
       f.NewToken(shimast.KindGreaterThanEqualsToken),
       f.NewIdentifier("_depth"),

package/native/core/programmers/iterate/check_dynamic_properties.go

@@ -1,11 +1,14 @@
 package iterate
 
 import (
+  "strings"
+
   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"
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Check_dynamic_propertiesProps struct {
@@ -126,7 +129,11 @@ func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
       nil,
     ))
   }
-  broken := false
+  // terminated marks that `statements` already ends in an unconditional return,
+  // so nothing after it could run. A signature that accepts every key sets it
+  // from the loop; a declared key type that covers every key sets it from the
+  // tail below.
+  terminated := false
 
   if len(props.Regular) != 0 {
     add(is_regular_property(props.Regular, props.Context.Emit), props.Config.Positive)
@@ -156,13 +163,58 @@ func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
     })
     if condition.Kind == shimast.KindTrueKeyword {
       statements = append(statements, f.NewReturnStatement(entry.Expression))
-      broken = true
+      terminated = true
       break
     }
     add(condition, entry.Expression)
   }
 
-  if !broken {
+  if !terminated {
+    // Reaching here means the key satisfied no dynamic signature. Two different
+    // things bring a key here, and they are not the same failure.
+    //
+    // A key whose *declared type* no signature covers -- `wrong` against
+    // `[key: `prefix_${string}`]` -- is an extra property. Nothing declares it,
+    // so `is` accepts it as it accepts any surplus property, and `equals`
+    // reports it through `Superfluous`.
+    //
+    // A key the declaration does cover but whose *type tag* it breaks -- `ab`
+    // against `[key: string & tags.MinLength<3>]` -- is a declared property
+    // with an invalid key. It used to reach the same accepting tail, which made
+    // every key tag inert: `[key: string & tags.Format<"uuid">]` accepted any
+    // key at all, while the emitted check sat right above, used only to decide
+    // *which* signature's value type to apply (#2347).
+    //
+    // So the tag failure is separated out first, by re-asking the same key
+    // question with every type tag removed. What is left is exactly the
+    // declared key type, and a key that answers it is a member of the object
+    // whose key broke a constraint -- never a surplus property.
+    shape := check_dynamic_properties_key_shape(props, key)
+    if shape != nil {
+      var invalid *shimast.Node
+      if props.Config.InvalidKey != nil {
+        invalid = props.Config.InvalidKey(
+          value,
+          check_dynamic_properties_key_expected(props.Dynamic),
+          check_dynamic_properties_invalid_key_description(props.Context.Emit),
+        )
+      } else {
+        // A programmer with no better report reduces both to the same answer,
+        // as `is` does with `false`.
+        invalid = props.Config.Superfluous(value, check_dynamic_properties_superfluous_description(props.Context.Emit))
+      }
+      if shape.Kind == shimast.KindTrueKeyword {
+        // Every key the signature accepts is covered -- a string index
+        // signature covers every key `Object.keys` can yield -- so the surplus
+        // tail below is unreachable and is not emitted.
+        statements = append(statements, f.NewReturnStatement(invalid))
+        terminated = true
+      } else {
+        add(shape, invalid)
+      }
+    }
+  }
+  if !terminated {
     output := props.Config.Positive
     if props.Config.Equals {
       output = props.Config.Superfluous(value, check_dynamic_properties_superfluous_description(props.Context.Emit))
@@ -257,6 +309,128 @@ func check_dynamic_properties_internal(context nativecontext.ITypiaContext, name
   return f.NewIdentifier(name)
 }
 
+// The condition that the key belongs to some index signature's declared key
+// type while breaking that signature's type tags -- the question the tail has
+// to answer to tell an invalid key from a surplus property.
+//
+// It is the same `Check_dynamic_key` question asked of every signature with its
+// type tags removed, joined with `||`. The tail runs only after each full
+// condition returned false, so a signature whose declared type still answers
+// yes is one whose tags are what the key broke.
+//
+// Nil when no signature carries a key tag. Then each stripped condition equals
+// the full one the tail already refuted, so the check could never fire, and an
+// object with untagged index signatures emits exactly what it emitted before.
+func check_dynamic_properties_key_shape(props Check_dynamic_propertiesProps, key *shimast.Expression) *shimast.Node {
+  tagged := false
+  for _, entry := range props.Dynamic {
+    if check_dynamic_properties_key_tagged(entry.Key) {
+      tagged = true
+      break
+    }
+  }
+  if !tagged {
+    return nil
+  }
+  conditions := make([]*shimast.Node, 0, len(props.Dynamic))
+  for _, entry := range props.Dynamic {
+    condition := Check_dynamic_key(Check_dynamic_keyProps{
+      Context:  props.Context,
+      Metadata: check_dynamic_properties_key_untagged(entry.Key),
+      Input:    key,
+    })
+    if condition.Kind == shimast.KindTrueKeyword {
+      return condition
+    }
+    conditions = append(conditions, condition)
+  }
+  return check_dynamic_key_reduce(conditions, shimast.KindBarBarToken, props.Context.Emit)
+}
+
+// Whether the key declaration constrains more than its own type, which is what
+// makes the stripped question differ from the full one.
+//
+// One tag carrying a runtime check is enough, and the row it sits in need not
+// carry them all. `Check_string` and `Check_number` filter per tag, so
+// `[key: number & Minimum<0> & <a tag with no runtime check>]` still emits the
+// minimum -- reading the row as all-or-nothing here would have declared that
+// key untagged and left its minimum inert, which is the defect #2347 closed.
+//
+// Answering yes where the stripped question turns out identical costs an
+// unreachable branch, never a wrong answer: the tail is reached only after
+// every full condition refused the key, so a stripped condition equal to one of
+// them refuses it too.
+func check_dynamic_properties_key_tagged(metadata *nativemetadata.MetadataSchema) bool {
+  for _, atomic := range metadata.Atomics {
+    for _, row := range atomic.Tags {
+      for _, tag := range row {
+        if tag.Validate != "" {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+// The key declaration with its type tags removed, leaving the declared type
+// alone. Templates, constants, and natives carry no tags, so only the atomics
+// are rebuilt; the clone keeps the original reportable name untouched.
+func check_dynamic_properties_key_untagged(metadata *nativemetadata.MetadataSchema) *nativemetadata.MetadataSchema {
+  clone := *metadata
+  clone.Atomics = make([]*nativemetadata.MetadataAtomic, 0, len(metadata.Atomics))
+  for _, atomic := range metadata.Atomics {
+    clone.Atomics = append(clone.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{
+      Type: atomic.Type,
+    }))
+  }
+  return &clone
+}
+
+// The type every declared key would have satisfied, for the report. Several
+// signatures join with `|`, which is how the declaration reads.
+func check_dynamic_properties_key_expected(dynamic []nativehelpers.IExpressionEntry) string {
+  names := make([]string, 0, len(dynamic))
+  for _, entry := range dynamic {
+    names = append(names, entry.Key.GetName())
+  }
+  return strings.Join(names, " | ")
+}
+
+// The advice `Superfluous` gives -- remove the property -- is wrong here. The
+// property is declared; its key is what broke.
+func check_dynamic_properties_invalid_key_description(emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(
+      nil,
+      f.NewArrayLiteralExpression(
+        f.NewNodeList([]*shimast.Node{
+          f.NewTemplateExpression(
+            f.NewTemplateHead("The key `", "The key \\`", shimast.TokenFlagsNone),
+            f.NewNodeList([]*shimast.Node{
+              f.NewTemplateSpan(
+                f.NewIdentifier("key"),
+                f.NewTemplateTail("` does not satisfy the type its index signature declares.", "\\` does not satisfy the type its index signature declares.", shimast.TokenFlagsNone),
+              ),
+            }),
+          ),
+          f.NewStringLiteral("", shimast.TokenFlagsNone),
+          f.NewStringLiteral("Please correct the key next time.", shimast.TokenFlagsNone),
+        }),
+        true,
+      ),
+      "join",
+    ),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewStringLiteral("\n", shimast.TokenFlagsNone),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
 func check_dynamic_properties_superfluous_description(emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
   return f.NewCallExpression(

package/native/core/programmers/iterate/check_object.go

@@ -22,7 +22,18 @@ type Check_object_IConfig struct {
   Reduce      func(a *shimast.Expression, b *shimast.Expression) *shimast.Node
   Positive    *shimast.Expression
   Superfluous func(value *shimast.Expression, description *shimast.Expression) *shimast.Node
-  Entries     *shimast.Expression
+  // InvalidKey reports a dynamic key an index signature declares but whose type
+  // tag it breaks. A key no signature declares at all is a surplus property and
+  // goes to `Superfluous` instead.
+  //
+  // `Superfluous` is the wrong report for this one: it says the property is not
+  // defined in the object type and advises removing it, which is false and
+  // unhelpful when the property *is* declared and only its key broke a
+  // constraint. A programmer that has no better answer may leave this nil, and
+  // `Superfluous` is used instead -- the outcome is identical, only the message
+  // differs.
+  InvalidKey func(value *shimast.Expression, expected string, description *shimast.Expression) *shimast.Node
+  Entries    *shimast.Expression
 }
 
 func Check_object(props Check_objectProps) *shimast.Node {