typia 15.0.0 → 15.0.1

package/native/core/factories/metadata_comment_tag_factory_reads_javascript_numbers_test.go

@@ -0,0 +1,158 @@
+package factories
+
+import (
+  "reflect"
+  "testing"
+
+  schemametadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestMetadataCommentTagFactoryReadsJavaScriptNumbers verifies numeric JSDoc
+// comment tags read JavaScript numbers and splice their values.
+//
+// The tags used Go's float syntax, and each record spliced the raw tag text into
+// the emitted validator (samchon/typia#2442). Go-only spellings therefore became
+// broken JavaScript: `@minimum inf` emitted `inf <= $input`, a ReferenceError,
+// while `@minimum 0x10`, which JavaScript reads as 16, was rejected. The bigint
+// splice appended `n` to the text, so an integer spelled `1e3` emitted `1e3n`,
+// which is no BigInt literal. A non-finite value has no JSON spelling for the
+// schema keyword and is reported (samchon/typia#2452). The expectations are the
+// values `Number(text)` yields in JavaScript.
+//
+//  1. Read `0x10`, `1e3`, `+5`, and `.5` as their JavaScript values, and splice
+//     the value into both the number and the bigint records, with integer
+//     spellings keeping their exact digits.
+//  2. Report Go-only spellings as invalid numbers and infinities as non-finite.
+//  3. Keep ordinary spellings byte-identical, and every tag name in its source
+//     spelling.
+func TestMetadataCommentTagFactoryReadsJavaScriptNumbers(t *testing.T) {
+  parse := func(name string, value string) (metadataCommentTagFactory_TagRecord, []string) {
+    messages := []string{}
+    record := metadataCommentTagFactory_parse(struct {
+      Report func(msg string) any
+      Tag    schemametadata.IJsDocTagInfo
+    }{
+      Report: func(msg string) any {
+        messages = append(messages, msg)
+        return nil
+      },
+      Tag: schemametadata.IJsDocTagInfo{
+        Name: name,
+        Text: []schemametadata.IJsDocTagInfo_IText{{Text: value, Kind: "text"}},
+      },
+    })
+    return record, messages
+  }
+  single := func(record metadataCommentTagFactory_TagRecord, target string) schemametadata.IMetadataTypeTag {
+    t.Helper()
+    tags := record[target]
+    if len(tags) != 1 {
+      t.Fatalf("expected one %s record, got %#v", target, record)
+    }
+    return tags[0]
+  }
+
+  //----
+  // 1. JavaScript spellings, spliced as values
+  //----
+  for _, item := range []struct {
+    name     string
+    value    string
+    target   string
+    number   float64
+    validate string
+  }{
+    {"minimum", "0x10", "number", 16, "16 <= $input"},
+    {"minimum", "0x10", "bigint", 16, "16 <= $input"},
+    {"maximum", "+5", "number", 5, "$input <= 5"},
+    {"exclusiveMinimum", ".5", "number", 0.5, "0.5 < $input"},
+    {"multipleOf", "1e3", "bigint", 1000, "$input % 1000n === 0n"},
+    {"multipleOf", "1.0", "bigint", 1, "$input % 1n === 0n"},
+    {"multipleOf", "1e3", "number", 1000, "$importInternal(\"_isMultipleOf\")($input, 1000)"},
+    {"minItems", "0b11", "array", 3, "3 <= $input.length"},
+    {"minLength", "0o7", "string", 7, "$importInternal(\"_stringLengthGte\")($input, 7)"},
+    {"multipleOf", "+5", "bigint", 5, "$input % 5n === 0n"},
+    {"multipleOf", "007", "bigint", 7, "$input % 7n === 0n"},
+    // Beyond 2^53 a bigint keeps an integer a double represents exactly; any
+    // other value gets an empty bigint record, which `Analyze` reports
+    // (samchon/typia#2457).
+    {"multipleOf", "18014398509481984", "bigint", 18014398509481984, "$input % 18014398509481984n === 0n"},
+    {"maximum", "0.0000001", "number", 1e-7, "$input <= 1e-7"},
+  } {
+    record, messages := parse(item.name, item.value)
+    if len(messages) != 0 {
+      t.Fatalf("@%s %s must be accepted, reports=%#v", item.name, item.value, messages)
+    }
+    tag := single(record, item.target)
+    if tag.Validate != item.validate {
+      t.Fatalf("@%s %s on %s should validate %q, got %q", item.name, item.value, item.target, item.validate, tag.Validate)
+    }
+    var value float64
+    switch v := tag.Value.(type) {
+    case float64:
+      value = v
+    case int64:
+      value = float64(v)
+    default:
+      t.Fatalf("@%s %s on %s carried a %T value", item.name, item.value, item.target, tag.Value)
+    }
+    if value != item.number {
+      t.Fatalf("@%s %s on %s should carry %v, got %v", item.name, item.value, item.target, item.number, value)
+    }
+  }
+
+  //----
+  // 2. Go-only spellings and infinities
+  //----
+  for _, item := range []struct {
+    name    string
+    value   string
+    message string
+  }{
+    {"minimum", "inf", "invalid number"},
+    {"minimum", "NaN", "invalid number"},
+    {"minimum", "0x1p4", "invalid number"},
+    {"maximum", "1_000", "invalid number"},
+    {"multipleOf", "-0x10", "invalid number"},
+    {"minimum", "Infinity", "non-finite number"},
+    {"exclusiveMaximum", "-Infinity", "non-finite number"},
+    {"maximum", "1e400", "non-finite number"},
+  } {
+    _, messages := parse(item.name, item.value)
+    found := false
+    for _, message := range messages {
+      if message == item.message {
+        found = true
+      }
+    }
+    if found == false {
+      t.Fatalf("@%s %s should report %q, got %#v", item.name, item.value, item.message, messages)
+    }
+  }
+
+  //----
+  // 3. ordinary spellings are unchanged
+  //----
+  record, messages := parse("minimum", "3")
+  if len(messages) != 0 {
+    t.Fatalf("@minimum 3 must be accepted, reports=%#v", messages)
+  }
+  expected := schemametadata.IMetadataTypeTag{
+    Name:      "Minimum<3>",
+    Target:    "number",
+    Kind:      "minimum",
+    Value:     float64(3),
+    Validate:  "3 <= $input",
+    Exclusive: metadataCommentTagFactory_exclusive("minimum"),
+    Schema:    map[string]any{"minimum": float64(3)},
+  }
+  if actual := single(record, "number"); reflect.DeepEqual(actual, expected) == false {
+    t.Fatalf("@minimum 3 changed:\nexpected %#v\nactual   %#v", expected, actual)
+  }
+  // Only the splice is respelled; the tag name keeps the source spelling, so
+  // validation messages and reflected metadata do not change.
+  record, _ = parse("minimum", "1.0")
+  if tag := single(record, "number"); tag.Name != "Minimum<1.0>" || tag.Validate != "1 <= $input" {
+    t.Fatalf("@minimum 1.0 should keep its name and splice 1, got %q / %q", tag.Name, tag.Validate)
+  }
+}

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

@@ -96,9 +96,7 @@ func (functionalAssertParametersProgrammerNamespace) Decompose(props FunctionalA
           Equals: props.Config.Equals,
           Guard:  false,
         },
-        Type: props.Context.Checker.GetTypeFromTypeNode(
-          functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-        ),
+        Type: functionalIsProgrammer_parameterCheckerType(props.Context, p),
         Init: FunctionalAssertFunctionProgrammer.HookPath(struct {
           Context  nativecontext.ITypiaContext
           Wrapper  string

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

@@ -2,6 +2,7 @@ package functional
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
   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"
@@ -91,9 +92,7 @@ func (functionalIsParametersProgrammerNamespace) Decompose(props FunctionalIsPar
         Context: props.Context,
         Modulo:  props.Modulo,
         Config:  nativeprogrammers.IsProgrammer_IConfig{Equals: props.Config.Equals},
-        Type: props.Context.Checker.GetTypeFromTypeNode(
-          functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-        ),
+        Type:    functionalIsProgrammer_parameterCheckerType(props.Context, p),
       }),
     }, props.Context.Emit))
     statements = append(statements, f.NewIfStatement(
@@ -157,7 +156,7 @@ func functionalIsProgrammer_function(
     nil,
     nil,
     nil,
-    functionalIsProgrammer_parameters(declaration, context.Emit),
+    functionalIsProgrammer_wrapperParameters(declaration, context.Emit),
     returnType,
     nil,
     body,
@@ -184,13 +183,84 @@ func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit
   parameters := functionalIsProgrammer_parameterNodes(declaration)
   output := make([]*shimast.Node, 0, len(parameters))
   for _, p := range parameters {
-    output = append(output, f.NewIdentifier(functionalIsProgrammer_parameterName(p)))
+    identifier := f.NewIdentifier(functionalIsProgrammer_parameterName(p))
+    // a rest parameter received its arguments as an array; spread them back
+    if p.Kind == shimast.KindParameter && p.AsParameterDeclaration().DotDotDotToken != nil {
+      identifier = f.NewSpreadElement(identifier)
+    }
+    output = append(output, identifier)
   }
   return output
 }
 
+// functionalIsProgrammer_wrapperParameters is the declaration's parameter list
+// for the wrapper, a destructuring pattern renamed to the identifier
+// functionalIsProgrammer_parameterName gives it: the wrapper validates and
+// forwards the whole argument, and a pattern names no single value.
+func functionalIsProgrammer_wrapperParameters(declaration *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.ParameterList {
+  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
+  list := functionalIsProgrammer_parameters(declaration, emit...)
+  if list == nil {
+    return list
+  }
+  if functionalIsProgrammer_hasBindingPattern(declaration) == false {
+    return list
+  }
+  // A default may read a name an earlier pattern binds (`({ a }, b = a)`),
+  // which the renamed wrapper no longer binds. So no default is copied: the
+  // wrapper forwards what it received, the function applies its own
+  // defaults, and a defaulted argument may be `undefined`; see
+  // functionalIsProgrammer_parameterCheckerType.
+  output := make([]*shimast.Node, 0, len(list.Nodes))
+  for _, param := range list.Nodes {
+    if param.Kind == shimast.KindParameter && param.Name() != nil && functionalIsProgrammer_parameterName(param) != "this" {
+      data := param.AsParameterDeclaration()
+      param = f.NewParameterDeclaration(
+        nil,
+        data.DotDotDotToken,
+        f.NewIdentifier(functionalIsProgrammer_parameterName(param)),
+        data.QuestionToken,
+        data.Type,
+        nil,
+      )
+    }
+    output = append(output, param)
+  }
+  return f.NewNodeList(output)
+}
+
+// functionalIsProgrammer_hasBindingPattern reports whether any parameter of
+// declaration destructures its argument.
+func functionalIsProgrammer_hasBindingPattern(declaration *shimast.Node) bool {
+  if list := functionalIsProgrammer_parameters(declaration); list != nil {
+    for _, param := range list.Nodes {
+      if param.Name() != nil && functionalIsProgrammer_isBindingPattern(param.Name()) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
 func functionalIsProgrammer_parameterName(param *shimast.Node) string {
   if param != nil && param.Name() != nil {
+    // A destructuring pattern has no name; the wrapper gives it one by its
+    // position (samchon/typia#2461), apart from every other parameter's name,
+    // or the wrapper would declare it twice.
+    if functionalIsProgrammer_isBindingPattern(param.Name()) {
+      index := 0
+      names := []string{}
+      if parent := param.Parent; parent != nil && parent.FunctionLikeData() != nil && parent.FunctionLikeData().Parameters != nil {
+        for i, sibling := range parent.FunctionLikeData().Parameters.Nodes {
+          if sibling == param {
+            index = i
+          } else if sibling.Name() != nil && functionalIsProgrammer_isBindingPattern(sibling.Name()) == false {
+            names = append(names, sibling.Name().Text())
+          }
+        }
+      }
+      return functionalIsProgrammer_escapeDuplicate(names, "__param"+functionalIsProgrammer_itoa(index))
+    }
     text := param.Name().Text()
     if text != "" {
       return text
@@ -200,13 +270,34 @@ func functionalIsProgrammer_parameterName(param *shimast.Node) string {
   return "input"
 }
 
-func functionalIsProgrammer_parameterType(param *shimast.Node, fallback *shimast.Node) *shimast.Node {
-  if param != nil && param.Kind == shimast.KindParameter {
-    if typ := param.AsParameterDeclaration().Type; typ != nil {
+// functionalIsProgrammer_parameterCheckerType is the type an argument must
+// satisfy: the parameter symbol's type, which adds `undefined` to an optional
+// parameter and reads a type inferred from a default. The written annotation
+// alone made `y?: string` require a `string` (samchon/typia#2461).
+func functionalIsProgrammer_parameterCheckerType(context nativecontext.ITypiaContext, param *shimast.Node) *shimchecker.Type {
+  typ := functionalIsProgrammer_declaredType(context, param)
+  // A wrapper beside a destructured parameter copies no default, so a
+  // defaulted argument arrives as sent, `undefined` included.
+  if param.Kind == shimast.KindParameter &&
+    param.AsParameterDeclaration().Initializer != nil &&
+    functionalIsProgrammer_hasBindingPattern(param.Parent) {
+    return context.Checker.GetUnionType([]*shimchecker.Type{typ, context.Checker.GetUndefinedType()})
+  }
+  return typ
+}
+
+func functionalIsProgrammer_declaredType(context nativecontext.ITypiaContext, param *shimast.Node) *shimchecker.Type {
+  if symbol := param.Symbol(); symbol != nil {
+    if typ := context.Checker.GetTypeOfSymbol(symbol); typ != nil {
       return typ
     }
   }
-  return fallback
+  if param.Kind == shimast.KindParameter {
+    if typ := param.AsParameterDeclaration().Type; typ != nil {
+      return context.Checker.GetTypeFromTypeNode(typ)
+    }
+  }
+  return context.Checker.GetAnyType()
 }
 
 func functionalIsProgrammer_asyncModifiers(async bool, emit ...*shimprinter.EmitContext) *shimast.ModifierList {
@@ -255,3 +346,10 @@ func functionalIsProgrammer_itoa(value int) string {
   }
   return string(digits)
 }
+
+// functionalIsProgrammer_isBindingPattern reports whether name destructures
+// an object or an array. It compares the kind itself because the shim of the
+// oldest supported ttsc exports no IsBindingPattern.
+func functionalIsProgrammer_isBindingPattern(name *shimast.Node) bool {
+  return name.Kind == shimast.KindObjectBindingPattern || name.Kind == shimast.KindArrayBindingPattern
+}

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

@@ -97,9 +97,7 @@ func (functionalValidateParametersProgrammerNamespace) Decompose(props Functiona
         Context: props.Context,
         Modulo:  props.Modulo,
         Config:  nativeprogrammers.ValidateProgrammer_IConfig{Equals: props.Config.Equals},
-        Type: props.Context.Checker.GetTypeFromTypeNode(
-          functionalIsProgrammer_parameterType(p, nativefactories.TypeFactory.Keyword("any", props.Context.Emit)),
-        ),
+        Type:    functionalIsProgrammer_parameterCheckerType(props.Context, p),
       }),
     }, props.Context.Emit))
     results = append(results, f.NewAsExpression(

package/native/core/programmers/http/HttpFormDataProgrammer.go

@@ -5,6 +5,7 @@ import (
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimchecker "github.com/microsoft/typescript-go/shim/checker"
+  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"
@@ -240,11 +241,13 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
           httpFormDataProgrammer_decode_value(struct {
             Context  nativecontext.ITypiaContext
             Type     string
+            Nullable bool
             Coalesce bool
             Input    *shimast.Node
           }{
             Context:  props.Context,
             Type:     typ,
+            Nullable: httpProgrammer_decode_nullable(value),
             Coalesce: false,
             Input:    f.NewIdentifier("elem"),
           }),
@@ -265,12 +268,14 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
     input = httpFormDataProgrammer_decode_value(struct {
       Context  nativecontext.ITypiaContext
       Type     string
+      Nullable bool
       Coalesce bool
       Input    *shimast.Node
     }{
       Context:  props.Context,
       Type:     typ,
-      Coalesce: value.Nullable == false && value.IsRequired() == false,
+      Nullable: httpProgrammer_decode_nullable(value),
+      Coalesce: value.Nullable == false && value.Any == false && value.IsRequired() == false,
       Input:    input,
     })
   }
@@ -286,6 +291,7 @@ func httpFormDataProgrammer_decode_regular_property(props struct {
 func httpFormDataProgrammer_decode_value(props struct {
   Context  nativecontext.ITypiaContext
   Type     string
+  Nullable bool
   Coalesce bool
   Input    *shimast.Node
 }) *shimast.Node {
@@ -294,7 +300,7 @@ func httpFormDataProgrammer_decode_value(props struct {
     httpParameterProgrammer_internal(props.Context, "httpFormDataRead"+httpParameterProgrammer_capitalize(props.Type)),
     nil,
     nil,
-    f.NewNodeList([]*shimast.Node{props.Input}),
+    f.NewNodeList(httpProgrammer_read_arguments(props.Type, props.Nullable, props.Input, props.Context.Emit)),
     shimast.NodeFlagsNone,
   )
   if props.Coalesce == false {
@@ -373,6 +379,39 @@ func httpProgrammer_property_key(property *schemametadata.MetadataProperty) stri
   return ""
 }
 
+// httpProgrammer_decode_nullable tells whether one decoded unit admits `null`:
+// the element for an array property, the property itself otherwise. `any` and
+// `unknown` admit it as well, and decode through the string reader.
+func httpProgrammer_decode_nullable(value *schemametadata.MetadataSchema) bool {
+  admits := func(unit *schemametadata.MetadataSchema) bool {
+    return unit != nil && (unit.Nullable || unit.Any)
+  }
+  if value == nil {
+    return false
+  }
+  if len(value.Arrays) != 0 {
+    return admits(value.Arrays[0].Type.Value)
+  }
+  if len(value.Tuples) != 0 && len(value.Tuples[0].Type.Elements) != 0 {
+    return admits(value.Tuples[0].Type.Elements[0])
+  }
+  return admits(value)
+}
+
+// httpProgrammer_read_arguments lists the arguments of one `_http*Read*` call.
+//
+// A string reader turns the text `"null"` into `null` unless told the type does
+// not admit it (samchon/typia#2450), so a non-nullable string passes `false`.
+// Every other call keeps the single argument, and so does a nullable string,
+// whose emit stays byte-identical to what earlier versions produced.
+func httpProgrammer_read_arguments(typ string, nullable bool, input *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
+  if typ != "string" || nullable {
+    return []*shimast.Node{input}
+  }
+  f := nativecontext.EmitFactoryOf(httpFormDataProgrammer_factory, emit...)
+  return []*shimast.Node{input, f.NewKeywordExpression(shimast.KindFalseKeyword)}
+}
+
 func httpProgrammer_decode_type(value *schemametadata.MetadataSchema, blob bool) (string, bool) {
   return httpProgrammer_decode_type_from_metadata(value, blob, false)
 }

package/native/core/programmers/http/HttpHeadersProgrammer.go

@@ -243,7 +243,13 @@ func httpHeadersProgrammer_decode_object(props struct {
         nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
         nil,
         f.NewToken(shimast.KindEqualsEqualsEqualsToken),
-        nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length"),
+        f.NewBinaryExpression(
+          nil,
+          nativefactories.IdentifierFactory.Access(props.Context.Emit, access, "length", true),
+          nil,
+          f.NewToken(shimast.KindQuestionQuestionToken),
+          nativefactories.ExpressionFactory.Number(0, props.Context.Emit),
+        ),
       ),
       f.NewExpressionStatement(
         f.NewDeleteExpression(access),
@@ -272,8 +278,10 @@ func httpHeadersProgrammer_decode_regular_property(props struct {
   )
   var decoded *shimast.Node
   if isArray {
-    if key == "set-cookie" {
-      decoded = input
+    // The input is read by the key's lowercase name, so a declared
+    // `"Set-Cookie": string[]` is the same header.
+    if strings.ToLower(key) == "set-cookie" {
+      decoded = httpHeadersProgrammer_decode_set_cookie(props.Context, typ, input, value.IsRequired())
     } else {
       decoded = httpHeadersProgrammer_decode_array(struct {
         Context nativecontext.ITypiaContext
@@ -309,6 +317,50 @@ func httpHeadersProgrammer_decode_regular_property(props struct {
   )
 }
 
+// httpHeadersProgrammer_decode_set_cookie decodes `set-cookie` without the
+// list decoder: cookie attributes such as `Expires` contain `", "`, so a value
+// is never split or trimmed. It still yields an array like every other array
+// header does: a lone string is one cookie, an absent required header is `[]`
+// (samchon/typia#2447), and a non-string element type is read by the same
+// reader other array headers use.
+func httpHeadersProgrammer_decode_set_cookie(context nativecontext.ITypiaContext, typ string, input *shimast.Node, required bool) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(httpHeadersProgrammer_factory, context.Emit)
+  array := input
+  single := input
+  if typ != "string" {
+    reader := httpParameterProgrammer_internal(context, "httpHeaderRead"+httpParameterProgrammer_capitalize(typ))
+    array = f.NewCallExpression(
+      nativefactories.IdentifierFactory.Access(context.Emit, input, "map"),
+      nil,
+      nil,
+      f.NewNodeList([]*shimast.Node{reader}),
+      shimast.NodeFlagsNone,
+    )
+    single = f.NewCallExpression(reader, nil, nil, f.NewNodeList([]*shimast.Node{input}), shimast.NodeFlagsNone)
+  }
+  absent := f.NewIdentifier("undefined")
+  if required {
+    absent = f.NewArrayLiteralExpression(f.NewNodeList(nil), false)
+  }
+  return nativefactories.ExpressionFactory.Conditional(
+    nativefactories.ExpressionFactory.IsArray(input, context.Emit),
+    array,
+    nativefactories.ExpressionFactory.Conditional(
+      f.NewBinaryExpression(
+        nil,
+        f.NewIdentifier("undefined"),
+        nil,
+        f.NewToken(shimast.KindExclamationEqualsEqualsToken),
+        input,
+      ),
+      f.NewArrayLiteralExpression(f.NewNodeList([]*shimast.Node{single}), false),
+      absent,
+      context.Emit,
+    ),
+    context.Emit,
+  )
+}
+
 func httpHeadersProgrammer_decode_value(props struct {
   Context nativecontext.ITypiaContext
   Type    string
@@ -362,7 +414,7 @@ func httpHeadersProgrammer_decode_array(props struct {
     reader = httpParameterProgrammer_internal(props.Context, "httpHeaderRead"+httpParameterProgrammer_capitalize(props.Type))
   }
   delimiter := ", "
-  if props.Key == "cookie" {
+  if strings.ToLower(props.Key) == "cookie" {
     delimiter = "; "
   }
   split := f.NewCallExpression(

package/native/core/programmers/http/HttpParameterProgrammer.go

@@ -68,9 +68,7 @@ func (httpParameterProgrammerNamespace) Write(props nativecontext.IProgrammerPro
         httpParameterProgrammer_internal(props.Context, "httpParameterRead"+httpParameterProgrammer_capitalize(atomic)),
         nil,
         nil,
-        f.NewNodeList([]*shimast.Node{
-          f.NewIdentifier("input"),
-        }),
+        f.NewNodeList(httpProgrammer_read_arguments(atomic, result.Data.Nullable, f.NewIdentifier("input"), props.Context.Emit)),
         shimast.NodeFlagsNone,
       ),
     }, props.Context.Emit),