typia 15.0.0 → 15.1.0

package/native/core/programmers/compare/CompareEqualProgrammer.go

@@ -20,15 +20,38 @@ type compareEqualProgrammerNamespace struct{}
 
 var CompareEqualProgrammer = compareEqualProgrammerNamespace{}
 
+// CompareEqualProgrammer_IConfig selects the generator's variants: Cover is the
+// covering form, where a missing property on the right side passes.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type CompareEqualProgrammer_IConfig struct {
+  // Cover permits absent right-side members during directional comparison.
   Cover bool
 }
 
+// CompareEqualProgrammer_IProps is the input of Write for the compare equal
+// generator: Context (the transform context), Modulo (the call's callee
+// expression), Type (the type to generate for) and Config (the configuration).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the type to generate for and the configuration, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 4 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type CompareEqualProgrammer_IProps struct {
+  // Context borrows the checker and emitter for this transform.
   Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    *shimchecker.Type
-  Config  CompareEqualProgrammer_IConfig
+
+  // Modulo supplies the public comparison method name for diagnostics.
+  Modulo *shimast.Node
+
+  // Type is the declared operand structure analyzed into comparison metadata.
+  Type *shimchecker.Type
+
+  // Config selects equality or directional covering within the shared generator.
+  Config CompareEqualProgrammer_IConfig
 }
 
 type compareEqualProgrammerGenerator struct {

package/native/core/programmers/compare/CompareLessProgrammer.go

@@ -18,10 +18,23 @@ type compareLessProgrammerNamespace struct{}
 
 var CompareLessProgrammer = compareLessProgrammerNamespace{}
 
+// CompareLessProgrammer_IProps is the input of Write for the compare less
+// generator: Context (the transform context), Modulo (the call's callee
+// expression) and Type (the type to generate for).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression and the type to generate for, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 3 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type CompareLessProgrammer_IProps struct {
+  // Context borrows the checker and emitter for this transform.
   Context nativecontext.ITypiaContext
-  Modulo  *shimast.Node
-  Type    *shimchecker.Type
+
+  // Modulo supplies the public comparison method name for diagnostics.
+  Modulo *shimast.Node
+
+  // Type is the declared operand structure analyzed into comparison metadata.
+  Type *shimchecker.Type
 }
 
 type compareLessProgrammerGenerator struct {
@@ -238,7 +251,8 @@ func (g *compareLessProgrammerGenerator) native(name string, x string, y string)
   }
 }
 
-// bytes compares two typed arrays / buffers lexicographically by byte.
+// bytes compares Uint8Array projections lexicographically. For a typed-array
+// operand, that constructor copies element values into unsigned-byte slots.
 func (g *compareLessProgrammerGenerator) bytes(x string, y string) string {
   bx := g.local("bx")
   by := g.local("by")

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

@@ -11,21 +11,62 @@ type functionalAssertFunctionProgrammerNamespace struct{}
 
 var FunctionalAssertFunctionProgrammer = functionalAssertFunctionProgrammerNamespace{}
 
+// FunctionalAssertFunctionProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalAssertFunctionProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalAssertFunctionProgrammer_IProps is the input of Write for the assert
+// function generator: Context (the transform context), Modulo (the call's callee
+// expression), Config (the configuration), Declaration (the function
+// declaration), Expression (the function expression) and Init (the optional
+// initializer of the error factory parameter).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration, the function expression and the optional initializer of the error factory parameter, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalAssertFunctionProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalAssertFunctionProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalAssertFunctionProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Init initializes the error factory; nil selects the functional default.
+  Init *shimast.Node
 }
 
+// FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput is what the
+// generator returns: Name is the generated error-factory wrapper variable name
+// and Variable is its constant declaration statement.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 2 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput struct {
-  Name     string
+  // Name is the error factory binding, disambiguated against parameter names.
+  Name string
+
+  // Variable declares the shared factory once around the returned wrapper.
   Variable *shimast.Node
 }
 

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

@@ -12,29 +12,88 @@ type functionalAssertParametersProgrammerNamespace struct{}
 
 var FunctionalAssertParametersProgrammer = functionalAssertParametersProgrammerNamespace{}
 
+// FunctionalAssertParametersProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalAssertParametersProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalAssertParametersProgrammer_IProps is the input of Write for the
+// assert parameters generator: Context (the transform context), Modulo (the
+// call's callee expression), Config (the configuration), Declaration (the
+// function declaration), Expression (the function expression) and Init (the
+// optional initializer of the error factory parameter).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration, the function expression and the optional initializer of the error factory parameter, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalAssertParametersProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalAssertParametersProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalAssertParametersProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Init initializes the error factory; nil selects the functional default.
+  Init *shimast.Node
 }
 
+// FunctionalAssertParametersProgrammer_IDecomposeProps is the input of Decompose
+// for the assert parameters generator: Context (the transform context), Config
+// (the configuration), Modulo (the call's callee expression), Parameters (the
+// parameter nodes) and Wrapper (the name of the error factory wrapper variable).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the configuration, the call's callee expression, the parameter nodes and the name of the error factory wrapper variable, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalAssertParametersProgrammer_IDecomposeProps struct {
-  Context    nativecontext.ITypiaContext
-  Config     FunctionalAssertParametersProgrammer_IConfig
-  Modulo     *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalAssertParametersProgrammer_IConfig
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Parameters contains runtime arguments in declaration order, excluding erased this.
   Parameters []*shimast.Node
-  Wrapper    string
+
+  // Wrapper names the shared error factory binding used to rewrite failure paths.
+  Wrapper string
 }
 
+// FunctionalAssertParametersProgrammer_IDecomposeOutput is what the generator
+// returns: Functions is the helper function statements and Expressions is the
+// call expressions.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 2 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionalAssertParametersProgrammer_IDecomposeOutput struct {
-  Functions   []*shimast.Node
+  // Functions contains helper declarations placed outside the returned wrapper.
+  Functions []*shimast.Node
+
+  // Expressions contains argument assertions executed before the original call.
   Expressions []*shimast.Node
 }
 
@@ -96,9 +155,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/FunctionalAssertReturnProgrammer.go

@@ -12,32 +12,96 @@ type functionAssertReturnProgrammerNamespace struct{}
 
 var FunctionAssertReturnProgrammer = functionAssertReturnProgrammerNamespace{}
 
+// FunctionAssertReturnProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionAssertReturnProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionAssertReturnProgrammer_IProps is the input of Write for the assert
+// return generator: Context (the transform context), Modulo (the call's callee
+// expression), Config (the configuration), Expression (the function expression),
+// Declaration (the function declaration) and Init (the optional initializer of
+// the error factory parameter).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function expression, the function declaration and the optional initializer of the error factory parameter, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionAssertReturnProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionAssertReturnProgrammer_IConfig
-  Expression  *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionAssertReturnProgrammer_IConfig
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Init        *shimast.Node
+
+  // Init initializes the error factory; nil selects the functional default.
+  Init *shimast.Node
 }
 
+// FunctionAssertReturnProgrammer_IDecomposeProps is the input of Decompose for
+// the assert return generator: Context (the transform context), Modulo (the
+// call's callee expression), Config (the configuration), Expression (the
+// function expression), Declaration (the function declaration) and Wrapper (the
+// name of the error factory wrapper variable).
+//
+// @evidence contracts/common.md#principled-implementation Decompose needs the transform context, the call's callee expression, the configuration, the function expression, the function declaration and the name of the error factory wrapper variable, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 6 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionAssertReturnProgrammer_IDecomposeProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionAssertReturnProgrammer_IConfig
-  Expression  *shimast.Node
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionAssertReturnProgrammer_IConfig
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Wrapper     string
+
+  // Wrapper names the shared error factory binding used to rewrite failure paths.
+  Wrapper string
 }
 
+// FunctionAssertReturnProgrammer_IDecomposeOutput is what the generator returns:
+// Async is whether the wrapped function is asynchronous, Functions is the helper
+// function statements and Value is the generated value expression.
+//
+// @evidence contracts/common.md#principled-implementation The generator returns its pieces separately so the caller can place helper functions, statements and values where its own wrapper needs them.
+// @evidence contracts/common.md#clear-and-simple-design A record of 3 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states each returned part.
 type FunctionAssertReturnProgrammer_IDecomposeOutput struct {
-  Async     bool
+  // Async requests an async wrapper and awaiting of the original return value.
+  Async bool
+
+  // Functions contains helper declarations placed outside the returned wrapper.
   Functions []*shimast.Node
-  Value     *shimast.Node
+
+  // Value calls the return assertion on the original or awaited result.
+  Value *shimast.Node
 }
 
 func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnProgrammer_IProps) *shimast.Node {

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

@@ -10,17 +10,43 @@ type functionalIsFunctionProgrammerNamespace struct{}
 
 var FunctionalIsFunctionProgrammer = functionalIsFunctionProgrammerNamespace{}
 
+// FunctionalIsFunctionProgrammer_IConfig selects the generator's variants:
+// Equals is the strict form that also rejects properties the type does not
+// declare.
+//
+// @evidence contracts/common.md#principled-implementation Each variant of the generator is one boolean or option on a record, so the transformers pick a form by naming the field and no second code path is copied.
+// @evidence contracts/common.md#clear-and-simple-design A record of 1 field.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc states what each field selects.
 type FunctionalIsFunctionProgrammer_IConfig struct {
+  // Equals rejects surplus properties in addition to checking declared values.
   Equals bool
 }
 
+// FunctionalIsFunctionProgrammer_IProps is the input of Write for the is
+// function generator: Context (the transform context), Modulo (the call's
+// callee expression), Config (the configuration), Declaration (the function
+// declaration) and Expression (the function expression).
+//
+// @evidence contracts/common.md#principled-implementation Write needs the transform context, the call's callee expression, the configuration, the function declaration and the function expression, and the record carries them in one argument.
+// @evidence contracts/common.md#clear-and-simple-design A flat argument record of 5 fields.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts A data record.
+// @evidence contracts/common.md#meaningful-documentation The doc names each field.
 type FunctionalIsFunctionProgrammer_IProps struct {
-  Context     nativecontext.ITypiaContext
-  Modulo      *shimast.Node
-  Config      FunctionalIsFunctionProgrammer_IConfig
+  // Context borrows the checker, emitter and importer for this transform.
+  Context nativecontext.ITypiaContext
+
+  // Modulo identifies the typia call for helper naming and diagnostics.
+  Modulo *shimast.Node
+
+  // Config selects ordinary validation or rejection of surplus properties.
+  Config FunctionalIsFunctionProgrammer_IConfig
+
+  // Declaration supplies parameter bindings and the checker return signature.
   Declaration *shimast.Node
-  Expression  *shimast.Node
-  Init        *shimast.Node
+
+  // Expression is the original callable, invoked with the wrapper receiver.
+  Expression *shimast.Node
 }
 
 func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionProgrammer_IProps) *shimast.Node {