typia 13.1.0 → 13.1.19

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

@@ -40,19 +40,7 @@ func (protobufMessageProgrammerNamespace) Write(props ProtobufMessageProgrammer_
     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")
+  }
+}