typia 13.1.1 → 13.2.0

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

@@ -531,7 +531,7 @@ func plainCloneProgrammer_decode_tuple_inline(props plainCloneProgrammer_decodeT
     explore := props.Explore
     explore.From = "array"
     explore.Postfix = postfix
-    elements = append(elements, plainCloneProgrammer_decode(struct {
+    value := plainCloneProgrammer_decode(struct {
       Context  nativecontext.ITypiaContext
       Config   nativeinternal.FeatureProgrammer_IConfig
       Functor  *nativehelpers.FunctionProgrammer
@@ -545,7 +545,18 @@ func plainCloneProgrammer_decode_tuple_inline(props plainCloneProgrammer_decodeT
       Input:    f.NewElementAccessExpression(props.Input, nil, nativefactories.ExpressionFactory.Number(index, props.Context.Emit), shimast.NodeFlagsNone),
       Metadata: elem,
       Explore:  explore,
-    }))
+    })
+    if elem.Optional {
+      // An omitted optional trailing element must not become a phantom
+      // `undefined`; gate it on presence so `clone(["a"])` stays `["a"]`.
+      value = nativehelpers.CloneJoiner.OptionalTupleElement(nativehelpers.CloneJoiner_OptionalElementProps{
+        Input: props.Input,
+        Value: value,
+        Index: index,
+        Emit:  props.Context.Emit,
+      })
+    }
+    elements = append(elements, value)
   }
   var rest *shimast.Node
   if len(props.Tuple.Elements) != 0 {
@@ -591,7 +602,7 @@ func plainCloneProgrammer_decode_native(props struct {
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(plainCloneProgrammer_factory, props.Context.Emit)
   switch props.Type {
-  case "Date", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigUint64Array", "Int8Array", "Int16Array", "Int32Array", "BigInt64Array", "Float32Array", "Float64Array", "RegExp":
+  case "Date", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigUint64Array", "Int8Array", "Int16Array", "Int32Array", "BigInt64Array", "Float32Array", "Float64Array":
     return f.NewNewExpression(
       f.NewIdentifier(props.Type),
       nil,
@@ -599,11 +610,13 @@ func plainCloneProgrammer_decode_native(props struct {
     )
   case "ArrayBuffer", "SharedArrayBuffer":
     return plainCloneProgrammer_decode_native_buffer(props.Type, props.Input, props.Context.Emit)
-  case "DataView":
-    return f.NewNewExpression(
-      f.NewIdentifier("DataView"),
+  case "DataView", "Blob", "File", "RegExp":
+    return f.NewCallExpression(
+      plainCloneProgrammer_internal(props.Context, "plainCloneAny"),
+      nil,
       nil,
-      f.NewNodeList([]*shimast.Node{nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Input, "buffer")}),
+      f.NewNodeList([]*shimast.Node{props.Input}),
+      shimast.NodeFlagsNone,
     )
   default:
     return f.NewCallExpression(

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

@@ -313,13 +313,27 @@ func plainPruneProgrammer_decode(props struct {
     })
   }
 
-  statements := make([]*shimast.Node, 0, len(unions))
-  for _, u := range unions {
-    statements = append(statements, f.NewIfStatement(
+  // Compose the arms as a mutually exclusive `if / else if` ladder rather than
+  // independent `if`s. The object arm is appended last and its guard is
+  // `IsObject` with CheckArray:false, which also matches arrays and native
+  // instances; with independent `if`s an array or native runs both its own arm
+  // and the object arm, and the object arm then deletes the keys of a value
+  // another arm already owns (a typed array throws, a plain array collapses to
+  // holes, a native loses its own properties). The ladder reaches the object
+  // arm only when every earlier arm missed, so each input is pruned by exactly
+  // one arm — the same shape clone/classify use.
+  var chain *shimast.Node
+  for i := len(unions) - 1; i >= 0; i-- {
+    u := unions[i]
+    chain = f.NewIfStatement(
       u.Is(),
       plainPruneProgrammer_to_statement(u.Value(), props.Context.Emit),
-      nil,
-    ))
+      chain,
+    )
+  }
+  statements := []*shimast.Node{}
+  if chain != nil {
+    statements = append(statements, chain)
   }
   return f.NewBlock(f.NewNodeList(statements), true)
 }

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

@@ -0,0 +1,25 @@
+package plain
+
+import (
+  "testing"
+
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// TestPlainTupleSeedRecoveryOwnership verifies impossible checker state panics.
+//
+// The caller proves tuple ownership before extracting a tuple seed. A missing
+// checker is therefore an invariant violation, not an ordinary field-copy
+// fallback, and must remain observable.
+//
+//  1. Supply a tuple-seed type with no owning checker.
+//  2. Invoke the ownership-only tuple seed helper.
+//  3. Require the checker invariant panic to escape.
+func TestPlainTupleSeedRecoveryOwnership(t *testing.T) {
+  defer func() {
+    if recover() == nil {
+      t.Fatal("unexpected tuple seed panic was swallowed")
+    }
+  }()
+  _ = plainClassifyProgrammer_tuple_seed(nil, &shimchecker.Type{})
+}

package/native/core/programmers/protobuf/ProtobufDecodeProgrammer.go

@@ -174,34 +174,25 @@ func protobufDecodeProgrammer_write_object_function(props struct {
   Object  *schemametadata.MetadataObjectType
 }) *shimast.Node {
   f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, props.Context.Emit)
-  lengthAssign := f.NewExpressionStatement(
-    protobufDecodeProgrammer_assignment(
-      f.NewIdentifier("length"),
-      shimast.KindEqualsToken,
-      nativefactories.ExpressionFactory.Conditional(
-        protobufDecodeProgrammer_lessThan(f.NewIdentifier("length"), nativefactories.ExpressionFactory.Number(0, props.Context.Emit), props.Context.Emit),
-        protobufDecodeProgrammer_callReader("size", nil, props.Context.Emit),
-        protobufDecodeProgrammer_add(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), f.NewIdentifier("length"), props.Context.Emit),
-        props.Context.Emit,
-      ),
-      props.Context.Emit,
-    ),
-  )
-  body := []*shimast.Node{lengthAssign}
-  body = append(body, protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
+  body := protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
     Context:   props.Context,
-    Condition: protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), f.NewIdentifier("length"), props.Context.Emit),
+    Condition: protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), protobufDecodeProgrammer_callReader("size", nil, props.Context.Emit), props.Context.Emit),
     Tag:       "tag",
     Output:    "output",
     Object:    props.Object,
-  })...)
+  })
+  body = append(body, f.NewIfStatement(
+    protobufDecodeProgrammer_lessThan(nativefactories.ExpressionFactory.Number(-1, props.Context.Emit), f.NewIdentifier("previous"), props.Context.Emit),
+    f.NewExpressionStatement(protobufDecodeProgrammer_callReader("close", []*shimast.Node{f.NewIdentifier("previous")}, props.Context.Emit)),
+    nil,
+  ))
   body = append(body, f.NewReturnStatement(f.NewIdentifier("output")))
   return f.NewArrowFunction(
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{
       nativefactories.IdentifierFactory.Parameter("reader", nil, nil, props.Context.Emit),
-      nativefactories.IdentifierFactory.Parameter("length", nativefactories.TypeFactory.Keyword("number", props.Context.Emit), nativefactories.ExpressionFactory.Number(-1, props.Context.Emit), props.Context.Emit),
+      nativefactories.IdentifierFactory.Parameter("previous", nativefactories.TypeFactory.Keyword("number", props.Context.Emit), nativefactories.ExpressionFactory.Number(-1, props.Context.Emit), props.Context.Emit),
     }),
     nativefactories.TypeFactory.Keyword("any", props.Context.Emit),
     nil,
@@ -301,6 +292,12 @@ func protobufDecodeProgrammer_write_property_default_value(value *schemametadata
     )
   } else if protobufDecodeProgrammer_hasStringDefault(value) {
     expression = f.NewStringLiteral("", shimast.TokenFlagsNone)
+  } else if protobufDecodeProgrammer_hasAtomicDefault(value, "number") {
+    expression = f.NewNumericLiteral("0", shimast.TokenFlagsNone)
+  } else if protobufDecodeProgrammer_hasAtomicDefault(value, "boolean") {
+    expression = f.NewKeywordExpression(shimast.KindFalseKeyword)
+  } else if protobufDecodeProgrammer_hasAtomicDefault(value, "bigint") {
+    expression = f.NewBigIntLiteral("0n", shimast.TokenFlagsNone)
   } else if protobufDecodeProgrammer_hasDynamicObject(value) {
     expression = f.NewObjectLiteralExpression(nil, false)
   } else {
@@ -460,12 +457,13 @@ func protobufDecodeProgrammer_decode_array(props protobufDecodeProgrammer_decode
       f.NewBlock(f.NewNodeList([]*shimast.Node{
         nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
           Name:  "piece",
-          Value: protobufDecodeProgrammer_add(protobufDecodeProgrammer_callReader("uint32", nil, emit), protobufDecodeProgrammer_callReader("index", nil, emit), emit),
+          Value: protobufDecodeProgrammer_callReader("fork", nil, emit),
         }, emit),
         f.NewWhileStatement(
-          protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, emit), f.NewIdentifier("piece"), emit),
+          protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, emit), protobufDecodeProgrammer_callReader("size", nil, emit), emit),
           f.NewExpressionStatement(protobufDecodeProgrammer_arrayPush(props.Accessor, decoder, emit)),
         ),
+        f.NewExpressionStatement(protobufDecodeProgrammer_callReader("close", []*shimast.Node{f.NewIdentifier("piece")}, emit)),
       }), true),
       f.NewExpressionStatement(protobufDecodeProgrammer_arrayPush(props.Accessor, decoder, emit)),
     ))
@@ -486,7 +484,7 @@ func protobufDecodeProgrammer_decode_regular_object(props struct {
   }
   args := []*shimast.Node{f.NewIdentifier("reader")}
   if props.Top == false {
-    args = append(args, protobufDecodeProgrammer_callReader("uint32", nil, emit))
+    args = append(args, protobufDecodeProgrammer_callReader("fork", nil, emit))
   }
   return f.NewCallExpression(
     f.NewIdentifier(fmt.Sprintf("%so%d", protobufDecodeProgrammer_PREFIX, index)),
@@ -507,11 +505,11 @@ func protobufDecodeProgrammer_decode_map(props protobufDecodeProgrammer_decodeMa
   }
   statements = append(statements, nativefactories.StatementFactory.Constant(nativefactories.StatementFactory_ConstantProps{
     Name:  "piece",
-    Value: protobufDecodeProgrammer_add(protobufDecodeProgrammer_callReader("uint32", nil, props.Context.Emit), protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), props.Context.Emit),
+    Value: protobufDecodeProgrammer_callReader("fork", nil, props.Context.Emit),
   }, props.Context.Emit))
   statements = append(statements, protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
     Context:   props.Context,
-    Condition: protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), f.NewIdentifier("piece"), props.Context.Emit),
+    Condition: protobufDecodeProgrammer_lessThan(protobufDecodeProgrammer_callReader("index", nil, props.Context.Emit), protobufDecodeProgrammer_callReader("size", nil, props.Context.Emit), props.Context.Emit),
     Tag:       "kind",
     Output:    "entry",
     Object: protobufDecodeProgrammer_createObjectType([]struct {
@@ -522,6 +520,7 @@ func protobufDecodeProgrammer_decode_map(props protobufDecodeProgrammer_decodeMa
       {Key: "value", Value: props.Value},
     }),
   })...)
+  statements = append(statements, f.NewExpressionStatement(protobufDecodeProgrammer_callReader("close", []*shimast.Node{f.NewIdentifier("piece")}, props.Context.Emit)))
   if props.Required == false {
     statements = append(statements, f.NewExpressionStatement(
       protobufDecodeProgrammer_assignment(props.Accessor, shimast.KindQuestionQuestionEqualsToken, props.Initializer, props.Context.Emit),
@@ -633,6 +632,21 @@ func protobufDecodeProgrammer_hasStringDefault(value *schemametadata.MetadataSch
   return false
 }
 
+// protobufDecodeProgrammer_hasAtomicDefault reports whether an absent required
+// field of this schema decodes to the proto3 typed default of the given atomic
+// kind. proto3 does not write a singular scalar equal to its default, so an
+// absent number/boolean/bigint must seed 0/false/0n the same way an absent
+// string seeds "" through protobufDecodeProgrammer_hasStringDefault; the atomic
+// kind is read exactly as hasStringDefault reads its own atomic branch.
+func protobufDecodeProgrammer_hasAtomicDefault(value *schemametadata.MetadataSchema, typ string) bool {
+  for _, atomic := range value.Atomics {
+    if atomic.Type == typ {
+      return true
+    }
+  }
+  return false
+}
+
 func protobufDecodeProgrammer_hasDynamicObject(value *schemametadata.MetadataSchema) bool {
   if len(value.Objects) == 0 {
     return false
@@ -678,11 +692,6 @@ func protobufDecodeProgrammer_lessThan(left *shimast.Node, right *shimast.Node,
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindLessThanToken), right)
 }
 
-func protobufDecodeProgrammer_add(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
-  return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindPlusToken), right)
-}
-
 func protobufDecodeProgrammer_unsigned_right_shift(left *shimast.Node, right *shimast.Node, emit *shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(protobufDecodeProgrammer_factory, emit)
   return f.NewBinaryExpression(nil, left, nil, f.NewToken(shimast.KindGreaterThanGreaterThanGreaterThanToken), right)

package/native/core/programmers/protobuf/ProtobufMessageProgrammer.go

@@ -35,24 +35,12 @@ func (protobufMessageProgrammerNamespace) Write(props ProtobufMessageProgrammer_
   f := nativecontext.EmitFactoryOf(protobufMessageProgrammer_factory, props.Context.Emit)
   collection := schemametadata.NewMetadataCollection()
   nativefactories.ProtobufFactory.Metadata(nativefactories.ProtobufFactory_IProps{
-    Method:     "message",
+    Method:     "typia.protobuf.message",
     Checker:    props.Context.Checker,
     Components: collection,
     Type:       props.Type,
   })
-  hierarchies := map[string]*protobufMessageProgrammer_Hierarchy{}
-  order := []string{}
-  for _, object := range collection.Objects() {
-    if protobufMessageProgrammer_is_dynamic_object(object) {
-      continue
-    }
-    order = protobufMessageProgrammer_emplace(hierarchies, order, object)
-  }
-  bodies := []string{}
-  for _, key := range order {
-    bodies = append(bodies, protobufMessageProgrammer_write_hierarchy(hierarchies[key]))
-  }
-  content := "syntax = \"proto3\";\n\n" + strings.Join(bodies, "\n\n")
+  content := ProtobufMessageProgrammer.Document(collection.Objects())
   lines := strings.Split(content, "\n")
   elements := make([]*shimast.Node, 0, len(lines))
   for _, line := range lines {
@@ -73,6 +61,28 @@ func (protobufMessageProgrammerNamespace) Write(props ProtobufMessageProgrammer_
   )
 }
 
+// Document renders the `.proto` text for the given protobuf metadata objects.
+//
+// The rendered text is the artifact `typia.protobuf.message<T>()` hands to
+// another language, so it is kept separate from the AST wrapping above: a
+// document is testable against a real Protobuf compiler, an emitted call
+// expression is not.
+func (protobufMessageProgrammerNamespace) Document(objects []*schemametadata.MetadataObjectType) string {
+  hierarchies := map[string]*protobufMessageProgrammer_Hierarchy{}
+  order := []string{}
+  for _, object := range objects {
+    if protobufMessageProgrammer_is_dynamic_object(object) {
+      continue
+    }
+    order = protobufMessageProgrammer_emplace(hierarchies, order, object)
+  }
+  bodies := []string{}
+  for _, key := range order {
+    bodies = append(bodies, protobufMessageProgrammer_write_hierarchy(hierarchies[key]))
+  }
+  return "syntax = \"proto3\";\n\n" + strings.Join(bodies, "\n\n")
+}
+
 func protobufMessageProgrammer_emplace(hierarchies map[string]*protobufMessageProgrammer_Hierarchy, order []string, object *schemametadata.MetadataObjectType) []string {
   current := hierarchies
   currentOrder := &order
@@ -136,11 +146,9 @@ func protobufMessageProgrammer_write_object(obj *schemametadata.MetadataObjectTy
     }
     lines = append(lines, protobufMessageProgrammer_decodeProperty(struct {
       Key   string
-      Value *schemametadata.MetadataSchema
       Union []schemaprotobuf.IProtobufPropertyType
     }{
       Key:   key,
-      Value: p.Value,
       Union: p.Of_protobuf_.Union,
     }))
   }
@@ -149,18 +157,29 @@ func protobufMessageProgrammer_write_object(obj *schemametadata.MetadataObjectTy
 
 func protobufMessageProgrammer_decodeProperty(props struct {
   Key   string
-  Value *schemametadata.MetadataSchema
   Union []schemaprotobuf.IProtobufPropertyType
 }) string {
   if len(props.Union) == 1 {
     top := props.Union[0]
     words := []string{}
+    // Every singular field carries proto3 explicit presence.
+    //
+    // proto3 removed `required`, so a required non-nullable property cannot keep
+    // that label; a compiler rejects the whole document over it. `optional` is
+    // the label that matches what the codecs already do, rather than the merely
+    // legal one: ProtobufEncodeProgrammer writes a required non-nullable field
+    // unguarded, so it emits the field even when the value equals the scalar
+    // default, and ProtobufDecodeProgrammer defaults an absent required number
+    // or boolean to `undefined`. A bare field means implicit presence, which
+    // licenses a peer to drop default values from the wire and would decode back
+    // into a property the declared type says is always there. `optional` keeps
+    // that presence explicit on both sides.
+    //
+    // Requiredness itself is a TypeScript-level guarantee that proto3 has no
+    // label for; `protobuf.assertEncode` / `assertDecode` remain the place it is
+    // enforced.
     if protobufMessageProgrammer_schemaType(top) != "array" && protobufMessageProgrammer_schemaType(top) != "map" {
-      if props.Value.IsRequired() && props.Value.Nullable == false {
-        words = append(words, "required")
-      } else {
-        words = append(words, "optional")
-      }
+      words = append(words, "optional")
     }
     words = append(words, protobufMessageProgrammer_decodeSchema(top), props.Key, "=", protobufMessageProgrammer_index(top)+";")
     return strings.Join(words, " ")

package/native/core/programmers/protobuf/protobuf_programmer_helper_coverage_test.go

@@ -267,6 +267,32 @@ func TestProtobufProgrammerHelperCoverage(t *testing.T) {
 			t.Fatal("protobuf decode default value returned nil")
 		}
 	}
+	// #2179: an absent required number/boolean/bigint seeds its proto3 typed
+	// default (0/false/0n), just as an absent required string seeds "". Each
+	// seed is wrapped in an `as any`, so unwrap it and pin the literal so a
+	// regression to `undefined` cannot pass.
+	for _, expected := range []struct {
+		typ  string
+		kind shimast.Kind
+		text string
+	}{
+		{typ: "number", kind: shimast.KindNumericLiteral, text: "0"},
+		{typ: "boolean", kind: shimast.KindFalseKeyword, text: ""},
+		{typ: "bigint", kind: shimast.KindBigIntLiteral, text: "0n"},
+		{typ: "string", kind: shimast.KindStringLiteral, text: ""},
+	} {
+		seed := protobufDecodeProgrammer_write_property_default_value(protobufProgrammerAtomic(expected.typ), emit)
+		if seed == nil || seed.Kind != shimast.KindAsExpression {
+			t.Fatalf("protobuf %s default should be an as-expression", expected.typ)
+		}
+		inner := seed.Expression()
+		if inner == nil || inner.Kind != expected.kind {
+			t.Fatalf("protobuf %s default seeded the wrong node kind", expected.typ)
+		}
+		if expected.text != "" && inner.Text() != expected.text {
+			t.Fatalf("protobuf %s default seeded %q instead of %q", expected.typ, inner.Text(), expected.text)
+		}
+	}
 	if protobufDecodeProgrammer_write_object_function_body(protobufDecodeProgrammer_objectBodyProps{
 		Context: nativecontext.ITypiaContext{},
 		Condition: protobufDecodeProgrammer_factory.NewKeywordExpression(

package/native/core/programmers/random_programmer_length_argument_test.go

@@ -0,0 +1,53 @@
+package programmers
+
+import (
+  "testing"
+
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativeiterate "github.com/samchon/typia/packages/typia/native/core/programmers/iterate"
+)
+
+// TestRandomProgrammerComposeAtomicThreadsLength locks the length forwarding
+// for constrained string leaves.
+//
+// A string leaf that combines a format or pattern with minLength/maxLength used
+// to lose the length bounds because only the plain-string fall-through carried
+// the full schema, so the generated value failed its own validator (#2189). The
+// format and pattern branches now forward a length object, and the format-only
+// and pattern-only branches must stay byte-identical (no extra argument).
+//
+// 1. A format or pattern without a length tag emits no length argument.
+// 2. A format or pattern with a length tag forwards exactly one length object.
+// 3. The length-argument helper is nil without a length tag.
+func TestRandomProgrammerComposeAtomicThreadsLength(t *testing.T) {
+  emit := shimprinter.NewEmitContext()
+
+  formatPlain := randomProgrammer_compose_atomic("string", nativeiterate.JsonSchema{"type": "string", "format": "email"}, emit)
+  if len(formatPlain.Arguments) != 0 {
+    t.Fatalf("email format without length must emit no argument, got %d", len(formatPlain.Arguments))
+  }
+  patternPlain := randomProgrammer_compose_atomic("string", nativeiterate.JsonSchema{"type": "string", "pattern": "^[0-9]+$"}, emit)
+  if len(patternPlain.Arguments) != 1 {
+    t.Fatalf("pattern without length must emit only the RegExp, got %d", len(patternPlain.Arguments))
+  }
+
+  formatLength := randomProgrammer_compose_atomic("string", nativeiterate.JsonSchema{"type": "string", "format": "email", "minLength": 40}, emit)
+  if len(formatLength.Arguments) != 1 {
+    t.Fatalf("email format with length must forward the length object, got %d", len(formatLength.Arguments))
+  }
+  datetimeLength := randomProgrammer_compose_atomic("string", nativeiterate.JsonSchema{"type": "string", "format": "date-time", "maxLength": 10}, emit)
+  if datetimeLength.Internal != "randomFormatDatetime" || len(datetimeLength.Arguments) != 1 {
+    t.Fatalf("date-time format with length must forward the length object, got %d", len(datetimeLength.Arguments))
+  }
+  patternLength := randomProgrammer_compose_atomic("string", nativeiterate.JsonSchema{"type": "string", "pattern": "^[0-9]+$", "minLength": 10, "maxLength": 20}, emit)
+  if len(patternLength.Arguments) != 2 {
+    t.Fatalf("pattern with length must emit RegExp and the length object, got %d", len(patternLength.Arguments))
+  }
+
+  if randomProgrammer_length_argument(nativeiterate.JsonSchema{"type": "string"}, emit) != nil {
+    t.Fatal("length argument must be nil without minLength/maxLength")
+  }
+  if got := randomProgrammer_length_argument(nativeiterate.JsonSchema{"type": "string", "maxLength": 3}, emit); got == nil || len(got) != 1 {
+    t.Fatal("length argument must forward a single object when a length tag is present")
+  }
+}