typia 13.0.0-dev.20260430 → 13.0.0-dev.20260502-2

package/native/core/factories/MetadataTypeTagSchemaFactory.go

@@ -7,111 +7,111 @@ type metadataTypeTagSchemaFactoryNamespace struct{}
 var MetadataTypeTagSchemaFactory = metadataTypeTagSchemaFactoryNamespace{}
 
 func (metadataTypeTagSchemaFactoryNamespace) Object(props struct {
-	Report func(msg string) bool
-	Object *nativemetadata.MetadataObjectType
+  Report func(msg string) bool
+  Object *nativemetadata.MetadataObjectType
 }) map[string]any {
-	if props.Object.Recursive {
-		props.Report(props.Object.Name + " has recursive type")
-		return nil
-	}
-	output := map[string]any{}
-	for _, property := range props.Object.Properties {
-		key := property.Key.GetSoleLiteral()
-		if key == nil {
-			props.Report(props.Object.Name + " has non-literal key type: " + property.Key.GetName())
-			continue
-		}
-		value, ok := metadataTypeTagSchemaFactory_iterate(struct {
-			report   func(message string) bool
-			object   *nativemetadata.MetadataObjectType
-			key      string
-			metadata *nativemetadata.MetadataSchema
-		}{
-			report:   props.Report,
-			object:   props.Object,
-			key:      *key,
-			metadata: property.Value,
-		})
-		if ok {
-			output[*key] = value
-		}
-	}
-	return output
+  if props.Object.Recursive {
+    props.Report(props.Object.Name + " has recursive type")
+    return nil
+  }
+  output := map[string]any{}
+  for _, property := range props.Object.Properties {
+    key := property.Key.GetSoleLiteral()
+    if key == nil {
+      props.Report(props.Object.Name + " has non-literal key type: " + property.Key.GetName())
+      continue
+    }
+    value, ok := metadataTypeTagSchemaFactory_iterate(struct {
+      report   func(message string) bool
+      object   *nativemetadata.MetadataObjectType
+      key      string
+      metadata *nativemetadata.MetadataSchema
+    }{
+      report:   props.Report,
+      object:   props.Object,
+      key:      *key,
+      metadata: property.Value,
+    })
+    if ok {
+      output[*key] = value
+    }
+  }
+  return output
 }
 
 func metadataTypeTagSchemaFactory_iterate(props struct {
-	report   func(message string) bool
-	object   *nativemetadata.MetadataObjectType
-	key      string
-	metadata *nativemetadata.MetadataSchema
+  report   func(message string) bool
+  object   *nativemetadata.MetadataObjectType
+  key      string
+  metadata *nativemetadata.MetadataSchema
 }) (any, bool) {
-	if props.metadata.Any ||
-		len(props.metadata.Atomics) != 0 ||
-		len(props.metadata.Arrays) != 0 ||
-		len(props.metadata.Natives) != 0 ||
-		len(props.metadata.Functions) != 0 {
-		props.report(props.object.Name + "." + props.key + " has non-literal type")
-		return nil, true
-	}
-	if props.metadata.Size() > 1 {
-		props.report(props.object.Name + "." + props.key + " has union type")
-		return nil, true
-	}
-	if props.metadata.Size() == 0 {
-		if props.metadata.Nullable {
-			return nil, true
-		}
-		if props.metadata.IsRequired() {
-			props.report(props.object.Name + "." + props.key + " has non-literal type")
-			return nil, true
-		}
-		return nil, false
-	}
-	if len(props.metadata.Constants) != 0 {
-		return props.metadata.Constants[0].Values[0].Value, true
-	}
-	if len(props.metadata.Tuples) != 0 {
-		tuple := props.metadata.Tuples[0]
-		if tuple.Type.IsRest() {
-			props.report(props.object.Name + "." + props.key + " has rest tuple type")
-		} else if tuple.Type.Recursive {
-			props.report(props.object.Name + "." + props.key + " has recursive tuple type")
-		} else {
-			for _, elem := range tuple.Type.Elements {
-				if elem.Required == false {
-					props.report(props.object.Name + "." + props.key + " has optional tuple type")
-					break
-				}
-			}
-		}
-		array := []any{}
-		for _, elem := range tuple.Type.Elements {
-			value, ok := metadataTypeTagSchemaFactory_iterate(struct {
-				report   func(message string) bool
-				object   *nativemetadata.MetadataObjectType
-				key      string
-				metadata *nativemetadata.MetadataSchema
-			}{
-				report:   props.report,
-				object:   props.object,
-				key:      props.key,
-				metadata: elem,
-			})
-			if ok {
-				array = append(array, value)
-			}
-		}
-		return array, true
-	}
-	if len(props.metadata.Objects) != 0 {
-		return MetadataTypeTagSchemaFactory.Object(struct {
-			Report func(msg string) bool
-			Object *nativemetadata.MetadataObjectType
-		}{
-			Report: props.report,
-			Object: props.metadata.Objects[0].Type,
-		}), true
-	}
-	props.report(props.object.Name + "." + props.key + " has non-literal type")
-	return nil, true
+  if props.metadata.Any ||
+    len(props.metadata.Atomics) != 0 ||
+    len(props.metadata.Arrays) != 0 ||
+    len(props.metadata.Natives) != 0 ||
+    len(props.metadata.Functions) != 0 {
+    props.report(props.object.Name + "." + props.key + " has non-literal type")
+    return nil, true
+  }
+  if props.metadata.Size() > 1 {
+    props.report(props.object.Name + "." + props.key + " has union type")
+    return nil, true
+  }
+  if props.metadata.Size() == 0 {
+    if props.metadata.Nullable {
+      return nil, true
+    }
+    if props.metadata.IsRequired() {
+      props.report(props.object.Name + "." + props.key + " has non-literal type")
+      return nil, true
+    }
+    return nil, false
+  }
+  if len(props.metadata.Constants) != 0 {
+    return props.metadata.Constants[0].Values[0].Value, true
+  }
+  if len(props.metadata.Tuples) != 0 {
+    tuple := props.metadata.Tuples[0]
+    if tuple.Type.IsRest() {
+      props.report(props.object.Name + "." + props.key + " has rest tuple type")
+    } else if tuple.Type.Recursive {
+      props.report(props.object.Name + "." + props.key + " has recursive tuple type")
+    } else {
+      for _, elem := range tuple.Type.Elements {
+        if elem.Required == false {
+          props.report(props.object.Name + "." + props.key + " has optional tuple type")
+          break
+        }
+      }
+    }
+    array := []any{}
+    for _, elem := range tuple.Type.Elements {
+      value, ok := metadataTypeTagSchemaFactory_iterate(struct {
+        report   func(message string) bool
+        object   *nativemetadata.MetadataObjectType
+        key      string
+        metadata *nativemetadata.MetadataSchema
+      }{
+        report:   props.report,
+        object:   props.object,
+        key:      props.key,
+        metadata: elem,
+      })
+      if ok {
+        array = append(array, value)
+      }
+    }
+    return array, true
+  }
+  if len(props.metadata.Objects) != 0 {
+    return MetadataTypeTagSchemaFactory.Object(struct {
+      Report func(msg string) bool
+      Object *nativemetadata.MetadataObjectType
+    }{
+      Report: props.report,
+      Object: props.metadata.Objects[0].Type,
+    }), true
+  }
+  props.report(props.object.Name + "." + props.key + " has non-literal type")
+  return nil, true
 }

package/native/core/factories/NumericRangeFactory.go

@@ -9,112 +9,112 @@ var NumericRangeFactory = numericRangeFactoryNamespace{}
 var numericRangeFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
 func (numericRangeFactoryNamespace) Number(t string, input *shimast.Expression) *shimast.Node {
-	switch t {
-	case "int32":
-		return numericRangeFactory_number_int32(input)
-	case "uint32":
-		return numericRangeFactory_number_uint32(input)
-	case "int64":
-		return numericRangeFactory_number_int64(input)
-	case "uint64":
-		return numericRangeFactory_number_uint64(input)
-	case "float":
-		return numericRangeFactory_between("-1.175494351e38", "3.4028235e38")(input)
-	default:
-		return numericRangeFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
-	}
+  switch t {
+  case "int32":
+    return numericRangeFactory_number_int32(input)
+  case "uint32":
+    return numericRangeFactory_number_uint32(input)
+  case "int64":
+    return numericRangeFactory_number_int64(input)
+  case "uint64":
+    return numericRangeFactory_number_uint64(input)
+  case "float":
+    return numericRangeFactory_between("-1.175494351e38", "3.4028235e38")(input)
+  default:
+    return numericRangeFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+  }
 }
 
 func (numericRangeFactoryNamespace) Bigint(t string, input *shimast.Expression) *shimast.Node {
-	if t == "uint64" {
-		return numericRangeFactory_factory.NewBinaryExpression(
-			nil,
-			numericRangeFactory_factory.NewCallExpression(
-				numericRangeFactory_factory.NewIdentifier("BigInt"),
-				nil,
-				nil,
-				numericRangeFactory_factory.NewNodeList([]*shimast.Node{ExpressionFactory.Number(0)}),
-				shimast.NodeFlagsNone,
-			),
-			nil,
-			numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
-			input,
-		)
-	}
-	return numericRangeFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
+  if t == "uint64" {
+    return numericRangeFactory_factory.NewBinaryExpression(
+      nil,
+      numericRangeFactory_factory.NewCallExpression(
+        numericRangeFactory_factory.NewIdentifier("BigInt"),
+        nil,
+        nil,
+        numericRangeFactory_factory.NewNodeList([]*shimast.Node{ExpressionFactory.Number(0)}),
+        shimast.NodeFlagsNone,
+      ),
+      nil,
+      numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
+      input,
+    )
+  }
+  return numericRangeFactory_factory.NewKeywordExpression(shimast.KindTrueKeyword)
 }
 
 func numericRangeFactory_number_int32(input *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_logical_and(
-		numericRangeFactory_integer(input),
-		numericRangeFactory_between("-2147483648", "2147483647")(input),
-	)
+  return numericRangeFactory_logical_and(
+    numericRangeFactory_integer(input),
+    numericRangeFactory_between("-2147483648", "2147483647")(input),
+  )
 }
 
 func numericRangeFactory_number_uint32(input *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_logical_and(
-		numericRangeFactory_integer(input),
-		numericRangeFactory_between("0", "4294967295")(input),
-	)
+  return numericRangeFactory_logical_and(
+    numericRangeFactory_integer(input),
+    numericRangeFactory_between("0", "4294967295")(input),
+  )
 }
 
 func numericRangeFactory_number_int64(input *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_logical_and(
-		numericRangeFactory_integer(input),
-		numericRangeFactory_between("-9223372036854775808", "9223372036854775807")(input),
-	)
+  return numericRangeFactory_logical_and(
+    numericRangeFactory_integer(input),
+    numericRangeFactory_between("-9223372036854775808", "9223372036854775807")(input),
+  )
 }
 
 func numericRangeFactory_number_uint64(input *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_logical_and(
-		numericRangeFactory_integer(input),
-		numericRangeFactory_between("0", "18446744073709551615")(input),
-	)
+  return numericRangeFactory_logical_and(
+    numericRangeFactory_integer(input),
+    numericRangeFactory_between("0", "18446744073709551615")(input),
+  )
 }
 
 func numericRangeFactory_integer(input *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_factory.NewBinaryExpression(
-		nil,
-		numericRangeFactory_factory.NewCallExpression(
-			numericRangeFactory_factory.NewIdentifier("Math.floor"),
-			nil,
-			nil,
-			numericRangeFactory_factory.NewNodeList([]*shimast.Node{input}),
-			shimast.NodeFlagsNone,
-		),
-		nil,
-		numericRangeFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-		input,
-	)
+  return numericRangeFactory_factory.NewBinaryExpression(
+    nil,
+    numericRangeFactory_factory.NewCallExpression(
+      numericRangeFactory_factory.NewIdentifier("Math.floor"),
+      nil,
+      nil,
+      numericRangeFactory_factory.NewNodeList([]*shimast.Node{input}),
+      shimast.NodeFlagsNone,
+    ),
+    nil,
+    numericRangeFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+    input,
+  )
 }
 
 func numericRangeFactory_between(x string, y string) func(input *shimast.Expression) *shimast.Node {
-	return func(input *shimast.Expression) *shimast.Node {
-		return numericRangeFactory_logical_and(
-			numericRangeFactory_factory.NewBinaryExpression(
-				nil,
-				numericRangeFactory_factory.NewIdentifier(x),
-				nil,
-				numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
-				input,
-			),
-			numericRangeFactory_factory.NewBinaryExpression(
-				nil,
-				input,
-				nil,
-				numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
-				numericRangeFactory_factory.NewIdentifier(y),
-			),
-		)
-	}
+  return func(input *shimast.Expression) *shimast.Node {
+    return numericRangeFactory_logical_and(
+      numericRangeFactory_factory.NewBinaryExpression(
+        nil,
+        numericRangeFactory_factory.NewIdentifier(x),
+        nil,
+        numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
+        input,
+      ),
+      numericRangeFactory_factory.NewBinaryExpression(
+        nil,
+        input,
+        nil,
+        numericRangeFactory_factory.NewToken(shimast.KindLessThanEqualsToken),
+        numericRangeFactory_factory.NewIdentifier(y),
+      ),
+    )
+  }
 }
 
 func numericRangeFactory_logical_and(x *shimast.Expression, y *shimast.Expression) *shimast.Node {
-	return numericRangeFactory_factory.NewBinaryExpression(
-		nil,
-		x,
-		nil,
-		numericRangeFactory_factory.NewToken(shimast.KindAmpersandAmpersandToken),
-		y,
-	)
+  return numericRangeFactory_factory.NewBinaryExpression(
+    nil,
+    x,
+    nil,
+    numericRangeFactory_factory.NewToken(shimast.KindAmpersandAmpersandToken),
+    y,
+  )
 }