typia 15.1.0 → 15.2.0

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

@@ -42,15 +42,13 @@ type compareLessProgrammerGenerator struct {
   Counter   int
 }
 
-var compareLessProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 // Write emits an `(x, y) => boolean` predicate that reports whether `x`
 // lexicographically precedes `y`. It builds a three-way comparator (negative /
 // zero / positive) over the declared structure of the type and returns
 // `cmp(x, y) < 0` so that `equal` and `less` together compose into an
 // Array.prototype.sort comparator.
 func (compareLessProgrammerNamespace) Write(props CompareLessProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(compareLessProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   method := nativehelpers.ModuloMethodText(props.Modulo)
   collection := schemametadata.NewMetadataCollection()
   result := nativefactories.MetadataFactory.Analyze(nativefactories.MetadataFactory_IProps{

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

@@ -70,8 +70,6 @@ type FunctionalAssertFunctionProgrammer_ErrorFactoryWrapperOutput struct {
   Variable *shimast.Node
 }
 
-var functionalAssertProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (functionalAssertFunctionProgrammerNamespace) Write(props FunctionalAssertFunctionProgrammer_IProps) *shimast.Node {
   wrapper := FunctionalAssertFunctionProgrammer.ErrorFactoryWrapper(struct {
     Context    nativecontext.ITypiaContext
@@ -97,7 +95,7 @@ func (functionalAssertFunctionProgrammerNamespace) Write(props FunctionalAssertF
     Declaration: props.Declaration,
     Wrapper:     wrapper.Name,
   })
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := []*shimast.Node{wrapper.Variable}
   statements = append(statements, p.Functions...)
   statements = append(statements, r.Functions...)
@@ -150,7 +148,7 @@ func (functionalAssertFunctionProgrammerNamespace) HookPath(props struct {
   Wrapper  string
   Replacer string
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   path := nativefactories.IdentifierFactory.Access(props.Context.Emit, f.NewIdentifier("p"), "path")
   return f.NewArrowFunction(
     nil,
@@ -207,5 +205,5 @@ func functionalAssertProgrammer_internal(context nativecontext.ITypiaContext, na
   if importer := context.Importer; importer != nil {
     return importer.Internal(name)
   }
-  return nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, context.Emit).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(context.Emit).NewIdentifier(name)
 }

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

@@ -107,7 +107,7 @@ func (functionalAssertParametersProgrammerNamespace) Write(props FunctionalAsser
     Parameters: functionalIsProgrammer_parameterNodes(props.Declaration),
     Init:       props.Init,
   })
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
@@ -142,7 +142,7 @@ func (functionalAssertParametersProgrammerNamespace) Write(props FunctionalAsser
 }
 
 func (functionalAssertParametersProgrammerNamespace) Decompose(props FunctionalAssertParametersProgrammer_IDecomposeProps) FunctionalAssertParametersProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   functions := make([]*shimast.Node, 0, len(props.Parameters))
   expressions := make([]*shimast.Node, 0, len(props.Parameters))
   for i, p := range props.Parameters {

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

@@ -122,7 +122,7 @@ func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnP
     Declaration: props.Declaration,
     Wrapper:     wrapper.Name,
   })
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := []*shimast.Node{wrapper.Variable}
   statements = append(statements, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
@@ -141,7 +141,7 @@ func (functionAssertReturnProgrammerNamespace) Write(props FunctionAssertReturnP
 }
 
 func (functionAssertReturnProgrammerNamespace) Decompose(props FunctionAssertReturnProgrammer_IDecomposeProps) FunctionAssertReturnProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalAssertProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,

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

@@ -50,7 +50,7 @@ type FunctionalIsFunctionProgrammer_IProps struct {
 }
 
 func (functionalIsFunctionProgrammerNamespace) Write(props FunctionalIsFunctionProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   p := FunctionalIsParametersProgrammer.Decompose(FunctionalIsParametersProgrammer_IDecomposeProps{
     Context:     props.Context,
     Config:      FunctionalIsParametersProgrammer_IConfig{Equals: props.Config.Equals},
@@ -103,7 +103,7 @@ func (functionalIsFunctionProgrammerNamespace) GetReturnTypeNode(props struct {
   if typ == nil {
     return nil
   }
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   nullType := f.NewTypeReferenceNode(f.NewIdentifier("null"), nil)
   if props.Async {
     var inner *shimast.Node

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

@@ -92,10 +92,8 @@ type FunctionalIsParametersProgrammer_IDecomposeOutput struct {
   Statements []*shimast.Node
 }
 
-var functionalIsProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParametersProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,
@@ -134,7 +132,7 @@ func (functionalIsParametersProgrammerNamespace) Write(props FunctionalIsParamet
 }
 
 func (functionalIsParametersProgrammerNamespace) Decompose(props FunctionalIsParametersProgrammer_IDecomposeProps) FunctionalIsParametersProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   parameters := functionalIsProgrammer_parameterNodes(props.Declaration)
   functions := make([]*shimast.Node, 0, len(parameters))
   statements := []*shimast.Node{}
@@ -176,7 +174,7 @@ func (functionalIsParametersProgrammerNamespace) Decompose(props FunctionalIsPar
 
 func functionalIsProgrammer_parameters(declaration *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.ParameterList {
   if declaration == nil || declaration.FunctionLikeData() == nil || declaration.FunctionLikeData().Parameters == nil {
-    return nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...).NewNodeList(nil)
+    return nativecontext.NodeFactoryOf(emit...).NewNodeList(nil)
   }
   return declaration.FunctionLikeData().Parameters
 }
@@ -203,7 +201,7 @@ func functionalIsProgrammer_function(
   returnType *shimast.Node,
   body *shimast.Node,
 ) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewFunctionExpression(
     functionalIsProgrammer_asyncModifiers(async, context.Emit),
     nil,
@@ -217,7 +215,7 @@ func functionalIsProgrammer_function(
 }
 
 func functionalIsProgrammer_call(context nativecontext.ITypiaContext, expression *shimast.Node, declaration *shimast.Node) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, context.Emit)
+  f := nativecontext.NodeFactoryOf(context.Emit)
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(context.Emit, f.NewIdentifier("Reflect"), "apply"),
     nil,
@@ -232,7 +230,7 @@ func functionalIsProgrammer_call(context nativecontext.ITypiaContext, expression
 }
 
 func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   parameters := functionalIsProgrammer_parameterNodes(declaration)
   output := make([]*shimast.Node, 0, len(parameters))
   for _, p := range parameters {
@@ -251,7 +249,7 @@ func functionalIsProgrammer_parameterIdentifiers(declaration *shimast.Node, emit
 // 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...)
+  f := nativecontext.NodeFactoryOf(emit...)
   list := functionalIsProgrammer_parameters(declaration, emit...)
   if list == nil {
     return list
@@ -357,7 +355,7 @@ func functionalIsProgrammer_asyncModifiers(async bool, emit ...*shimprinter.Emit
   if async == false {
     return nil
   }
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewModifierList([]*shimast.Node{
     f.NewModifier(shimast.KindAsyncKeyword),
   })

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

@@ -96,7 +96,7 @@ type FunctionalIsReturnProgrammer_IDecomposeOutput struct {
 }
 
 func (functionalIsReturnProgrammerNamespace) Write(props FunctionalIsReturnProgrammer_IProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   result := FunctionalIsReturnProgrammer.Decompose(FunctionalIsReturnProgrammer_IDecomposeProps{
     Context:     props.Context,
     Modulo:      props.Modulo,
@@ -129,7 +129,7 @@ func (functionalIsReturnProgrammerNamespace) Write(props FunctionalIsReturnProgr
 }
 
 func (functionalIsReturnProgrammerNamespace) Decompose(props FunctionalIsReturnProgrammer_IDecomposeProps) FunctionalIsReturnProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalIsProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,

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

@@ -49,8 +49,6 @@ type FunctionalValidateFunctionProgrammer_IProps struct {
   Expression *shimast.Node
 }
 
-var functionalValidateProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (functionalValidateFunctionProgrammerNamespace) Write(props FunctionalValidateFunctionProgrammer_IProps) *shimast.Node {
   p := FunctionalValidateParametersProgrammer.Decompose(FunctionalValidateParametersProgrammer_IDecomposeProps{
     Context:     props.Context,
@@ -65,7 +63,7 @@ func (functionalValidateFunctionProgrammerNamespace) Write(props FunctionalValid
     Expression:  props.Expression,
     Declaration: props.Declaration,
   })
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := append([]*shimast.Node{}, p.Functions...)
   statements = append(statements, r.Functions...)
   body := append([]*shimast.Node{}, p.Statements...)
@@ -98,7 +96,7 @@ func (functionalValidateFunctionProgrammerNamespace) HookErrors(props struct {
   Expression *shimast.Node
   Replacer   *shimast.Node
 }) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(props.Context.Emit, props.Expression, "map"),
     nil,
@@ -154,7 +152,7 @@ func (functionalValidateFunctionProgrammerNamespace) GetReturnTypeNode(props str
   if typ == nil {
     return nil
   }
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   if props.Async {
     var inner *shimast.Node
     if typ.Kind == shimast.KindTypeReference {
@@ -189,7 +187,7 @@ func functionalValidateProgrammer_import_type(context nativecontext.ITypiaContex
     return importer.Type(props)
   }
   if str, ok := props.Name.(string); ok {
-    f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, context.Emit)
+    f := nativecontext.NodeFactoryOf(context.Emit)
     return f.NewTypeReferenceNode(f.NewIdentifier(str), f.NewNodeList(props.Arguments))
   }
   return props.Name.(*shimast.Node)

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

@@ -101,7 +101,7 @@ func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalVal
     Config:      props.Config,
     Declaration: props.Declaration,
   })
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   caller := functionalIsProgrammer_call(props.Context, props.Expression, props.Declaration)
   data := caller
   if output.Async {
@@ -138,7 +138,7 @@ func (functionalValidateParametersProgrammerNamespace) Write(props FunctionalVal
 }
 
 func (functionalValidateParametersProgrammerNamespace) Decompose(props FunctionalValidateParametersProgrammer_IDecomposeProps) FunctionalValidateParametersProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   parameters := functionalIsProgrammer_parameterNodes(props.Declaration)
   resultName := functionalIsProgrammer_escapeDuplicate(functionalIsProgrammer_parameterNames(props.Declaration), "paramErrorResults")
   functions := make([]*shimast.Node, 0, len(parameters))

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

@@ -104,7 +104,7 @@ func (functionalValidateReturnProgrammerNamespace) Write(props FunctionalValidat
     Expression:  props.Expression,
     Declaration: props.Declaration,
   })
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   statements := append([]*shimast.Node{}, result.Functions...)
   statements = append(statements, f.NewReturnStatement(
     functionalIsProgrammer_function(
@@ -130,7 +130,7 @@ func (functionalValidateReturnProgrammerNamespace) Write(props FunctionalValidat
 }
 
 func (functionalValidateReturnProgrammerNamespace) Decompose(props FunctionalValidateReturnProgrammer_IDecomposeProps) FunctionalValidateReturnProgrammer_IDecomposeOutput {
-  f := nativecontext.EmitFactoryOf(functionalValidateProgrammer_factory, props.Context.Emit)
+  f := nativecontext.NodeFactoryOf(props.Context.Emit)
   output := functionalinternal.FunctionalGeneralProgrammer.GetReturnType(functionalinternal.FunctionalGeneralProgrammer_IProps{
     Checker:     props.Context.Checker,
     Declaration: props.Declaration,

package/native/core/programmers/helpers/ClassifyJoiner.go

@@ -33,8 +33,6 @@ type ClassifyJoiner_ObjectProps struct {
   Emit     *shimprinter.EmitContext
 }
 
-var classifyJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 // Object reconstructs an object value for plain.classify.
 //
 // For an anonymous / interface (literal) shape there is no class to
@@ -67,7 +65,7 @@ func (classifyJoinerNamespace) Object(props ClassifyJoiner_ObjectProps) *shimast
       Emit:    props.Emit,
     })
   }
-  f := nativecontext.EmitFactoryOf(classifyJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
 
   regular := []IExpressionEntry{}
   dynamic := []IExpressionEntry{}

package/native/core/programmers/helpers/CloneJoiner.go

@@ -70,10 +70,8 @@ type CloneJoiner_ArrayProps struct {
   Emit  *shimprinter.EmitContext
 }
 
-var cloneJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (cloneJoinerNamespace) Object(props CloneJoiner_ObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   if len(props.Entries) == 0 {
     return f.NewIdentifier("{}")
   }
@@ -192,7 +190,7 @@ func cloneJoiner_optional_condition(entry IExpressionEntry, input *shimast.Expre
   if key == nil {
     return nativefactories.ExpressionFactory.IsRequired(entry.Input, emit...)
   }
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBinaryExpression(
     nil,
     nativefactories.ExpressionFactory.IsRequired(entry.Input, emit...),
@@ -209,7 +207,7 @@ func cloneJoiner_optional_condition(entry IExpressionEntry, input *shimast.Expre
 }
 
 func (cloneJoinerNamespace) Tuple(props CloneJoiner_TupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   elements := make([]*shimast.Node, 0, len(props.Elements)+1)
   for _, elem := range props.Elements {
     elements = append(elements, elem)
@@ -233,7 +231,7 @@ func (cloneJoinerNamespace) Tuple(props CloneJoiner_TupleProps) *shimast.Node {
 // for `[string, number?]` stays `["a"]` (length 1) and round-trips under
 // `compare.equals`, while a present optional keeps its value.
 func (cloneJoinerNamespace) OptionalTupleElement(props CloneJoiner_OptionalElementProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   condition := f.NewBinaryExpression(
     nil,
     nativefactories.ExpressionFactory.Number(props.Index, props.Emit),
@@ -252,9 +250,9 @@ func (cloneJoinerNamespace) OptionalTupleElement(props CloneJoiner_OptionalEleme
 }
 
 func (cloneJoinerNamespace) Array(props CloneJoiner_ArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, props.Input, "map"),
+    nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "map"),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{props.Arrow}),
@@ -263,18 +261,14 @@ func (cloneJoinerNamespace) Array(props CloneJoiner_ArrayProps) *shimast.Node {
 }
 
 func cloneJoiner_regular_skip(regular []IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(cloneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   elements := make([]*shimast.Node, 0, len(regular))
   for _, entry := range regular {
     elements = append(elements, f.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
   }
   return f.NewIfStatement(
     f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(
-        nil,
-        f.NewArrayLiteralExpression(f.NewNodeList(elements), false),
-        "some",
-      ),
+      f.NewPropertyAccessExpression(f.NewArrayLiteralExpression(f.NewNodeList(elements), false), nil, f.NewIdentifier("some"), shimast.NodeFlagsNone),
       nil,
       nil,
       f.NewNodeList([]*shimast.Node{

package/native/core/programmers/helpers/FunctionProgrammer.go

@@ -55,8 +55,6 @@ type functionProgrammer_union struct {
   value *shimast.Node
 }
 
-var functionProgrammer_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 // NewFunctionProgrammer returns an empty FunctionProgrammer labeled with the
 // typia method text and bound to an optional emit context.
 //
@@ -247,7 +245,7 @@ func (p *FunctionProgrammer) EmplaceVariable(name string, value *shimast.Express
     p.variableOrder_ = append(p.variableOrder_, name)
   }
   p.variables_[name] = value
-  return nativecontext.EmitFactoryOf(functionProgrammer_factory, p.emit_).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(p.emit_).NewIdentifier(name)
 }
 
 // EmplaceVariableByKey returns an identifier for the variable registered under
@@ -260,7 +258,7 @@ func (p *FunctionProgrammer) EmplaceVariable(name string, value *shimast.Express
 func (p *FunctionProgrammer) EmplaceVariableByKey(prefix string, key string, factory func(name string) *shimast.Expression) *shimast.Node {
   compound := prefix + "::" + key
   if name, ok := p.variableKeys_[compound]; ok {
-    return nativecontext.EmitFactoryOf(functionProgrammer_factory, p.emit_).NewIdentifier(name)
+    return nativecontext.NodeFactoryOf(p.emit_).NewIdentifier(name)
   }
   name := p.reserveGeneratedName(prefix)
   p.variableKeys_[compound] = name
@@ -268,7 +266,7 @@ func (p *FunctionProgrammer) EmplaceVariableByKey(prefix string, key string, fac
     p.variableOrder_ = append(p.variableOrder_, name)
   }
   p.variables_[name] = factory(name)
-  return nativecontext.EmitFactoryOf(functionProgrammer_factory, p.emit_).NewIdentifier(name)
+  return nativecontext.NodeFactoryOf(p.emit_).NewIdentifier(name)
 }
 
 func (p *FunctionProgrammer) reserveGeneratedName(prefix string) string {

package/native/core/programmers/helpers/NotationJoiner.go

@@ -57,10 +57,8 @@ type NotationJoiner_ArrayProps struct {
   Emit  *shimprinter.EmitContext
 }
 
-var notationJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(notationJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   if len(props.Entries) == 0 {
     return f.NewIdentifier("{}")
   }
@@ -215,7 +213,7 @@ func (notationJoinerNamespace) Object(props NotationJoiner_ObjectProps) *shimast
 }
 
 func (notationJoinerNamespace) Tuple(props NotationJoiner_TupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(notationJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   elements := make([]*shimast.Node, 0, len(props.Elements)+1)
   for _, elem := range props.Elements {
     elements = append(elements, elem)
@@ -233,9 +231,9 @@ func (notationJoinerNamespace) Tuple(props NotationJoiner_TupleProps) *shimast.N
 }
 
 func (notationJoinerNamespace) Array(props NotationJoiner_ArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(notationJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, props.Input, "map"),
+    nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "map"),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{props.Arrow}),
@@ -244,18 +242,14 @@ func (notationJoinerNamespace) Array(props NotationJoiner_ArrayProps) *shimast.N
 }
 
 func notationJoiner_regular_skip(regular []IExpressionEntry, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(notationJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   elements := make([]*shimast.Node, 0, len(regular))
   for _, entry := range regular {
     elements = append(elements, f.NewStringLiteral(*entry.Key.GetSoleLiteral(), shimast.TokenFlagsNone))
   }
   return f.NewIfStatement(
     f.NewCallExpression(
-      nativefactories.IdentifierFactory.Access(
-        nil,
-        f.NewArrayLiteralExpression(f.NewNodeList(elements), false),
-        "some",
-      ),
+      f.NewPropertyAccessExpression(f.NewArrayLiteralExpression(f.NewNodeList(elements), false), nil, f.NewIdentifier("some"), shimast.NodeFlagsNone),
       nil,
       nil,
       f.NewNodeList([]*shimast.Node{

package/native/core/programmers/helpers/PruneJoiner.go

@@ -52,10 +52,8 @@ type PruneJoiner_TupleProps struct {
   Emit     *shimprinter.EmitContext
 }
 
-var pruneJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (pruneJoinerNamespace) Object(props PruneJoiner_ObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   regular := []IExpressionEntry{}
   dynamic := []IExpressionEntry{}
   for _, entry := range props.Entries {
@@ -88,9 +86,9 @@ func (pruneJoinerNamespace) Object(props PruneJoiner_ObjectProps) *shimast.Node
 }
 
 func (pruneJoinerNamespace) Array(props PruneJoiner_ArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, props.Input, "forEach"),
+    nativefactories.IdentifierFactory.Access(props.Emit, props.Input, "forEach"),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{props.Arrow}),
@@ -99,7 +97,7 @@ func (pruneJoinerNamespace) Array(props PruneJoiner_ArrayProps) *shimast.Node {
 }
 
 func (pruneJoinerNamespace) Tuple(props PruneJoiner_TupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   entire := make([]*shimast.Node, 0, len(props.Elements)+1)
   for _, elem := range props.Elements {
     entire = append(entire, elem)
@@ -118,7 +116,7 @@ func (pruneJoinerNamespace) Tuple(props PruneJoiner_TupleProps) *shimast.Node {
 }
 
 func pruneJoiner_statements(node *shimast.Node, emit ...*shimprinter.EmitContext) []*shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   if node != nil && node.Kind == shimast.KindBlock {
     return append([]*shimast.Node{}, node.Statements()...)
   }
@@ -133,7 +131,7 @@ type pruneJoiner_iterate_dynamic_propertiesProps struct {
 }
 
 func pruneJoiner_iterate_dynamic_properties(props pruneJoiner_iterate_dynamic_propertiesProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   statements := []*shimast.Node{
     f.NewIfStatement(
       f.NewBinaryExpression(
@@ -190,7 +188,7 @@ func pruneJoiner_iterate_dynamic_properties(props pruneJoiner_iterate_dynamic_pr
   }
   return f.NewCallExpression(
     nativefactories.IdentifierFactory.Access(
-      nil,
+      props.Emit,
       f.NewCallExpression(
         f.NewIdentifier("Object.entries"),
         nil,
@@ -220,7 +218,7 @@ func pruneJoiner_iterate_dynamic_properties(props pruneJoiner_iterate_dynamic_pr
 }
 
 func pruneJoiner_binding_pattern(emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   return f.NewBindingPattern(
     shimast.KindArrayBindingPattern,
     f.NewNodeList([]*shimast.Node{
@@ -231,7 +229,7 @@ func pruneJoiner_binding_pattern(emit ...*shimprinter.EmitContext) *shimast.Node
 }
 
 func pruneJoiner_prune_object_properties(object *nativemetadata.MetadataObjectType, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   input := f.NewIdentifier("input")
   key := f.NewIdentifier("key")
   conditions := []*shimast.Node{}
@@ -296,7 +294,7 @@ func pruneJoiner_prune_object_properties(object *nativemetadata.MetadataObjectTy
 }
 
 func pruneJoiner_reduce(expressions []*shimast.Node, operator shimast.Kind, emit ...*shimprinter.EmitContext) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(pruneJoiner_factory, emit...)
+  f := nativecontext.NodeFactoryOf(emit...)
   output := expressions[0]
   for _, next := range expressions[1:] {
     output = f.NewBinaryExpression(

package/native/core/programmers/helpers/RandomJoiner.go

@@ -113,10 +113,8 @@ type randomJoiner_DynamicPropertyProps struct {
   Emit     *shimprinter.EmitContext
 }
 
-var randomJoiner_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-
 func (randomJoinerNamespace) Array(props RandomJoiner_ArrayProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   properties := []*shimast.Node{}
   if props.Schema != nil {
     keys := make([]string, 0, len(props.Schema))
@@ -728,7 +726,7 @@ func randomJoiner_is_recursive_metadata(
 }
 
 func (randomJoinerNamespace) Tuple(props RandomJoiner_TupleProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   elements := make([]*shimast.Node, 0, len(props.Elements))
   for _, elem := range props.Elements {
     if elem != nil && elem.Rest != nil {
@@ -763,7 +761,7 @@ func (randomJoinerNamespace) Tuple(props RandomJoiner_TupleProps) *shimast.Node
 }
 
 func (randomJoinerNamespace) Object(props RandomJoiner_ObjectProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   if len(props.Object.Properties) == 0 {
     return nativefactories.LiteralFactory.Write(map[string]any{}, props.Emit)
   }
@@ -822,7 +820,7 @@ func (randomJoinerNamespace) Object(props RandomJoiner_ObjectProps) *shimast.Nod
 }
 
 func randomJoiner_dynamicProperty(props randomJoiner_DynamicPropertyProps) *shimast.Node {
-  f := nativecontext.EmitFactoryOf(randomJoiner_factory, props.Emit)
+  f := nativecontext.NodeFactoryOf(props.Emit)
   tuple := nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
     Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
       Name:      fmt.Sprintf("[%s, %s]", props.Property.Key.GetName(), props.Property.Value.GetName()),
@@ -848,7 +846,7 @@ func randomJoiner_dynamicProperty(props randomJoiner_DynamicPropertyProps) *shim
   metadata := nativemetadata.MetadataSchema_initialize()
   metadata.Arrays = []*nativemetadata.MetadataArray{array}
   return f.NewCallExpression(
-    nativefactories.IdentifierFactory.Access(nil, f.NewIdentifier("Object"), "fromEntries"),
+    nativefactories.IdentifierFactory.Access(props.Emit, f.NewIdentifier("Object"), "fromEntries"),
     nil,
     nil,
     f.NewNodeList([]*shimast.Node{