typia 13.0.0-dev.20260604.1 → 13.0.0-dev.20260605.1

package/native/core/context/EmitFactory.go

@@ -0,0 +1,39 @@
+package context
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+)
+
+// EmitFactory resolves the node factory a node-creating helper should use.
+//
+// When an emit EmitContext is present (emit stage / AST-integration mode) its
+// Factory is returned so every created node carries original-node tracking and
+// emit metadata (parent links, comments, source maps, const-enum constants,
+// namespace alias) that the tsgo emit pipeline relies on. When ec is nil (legacy
+// text emit, analysis-only or test paths) the caller's standalone fallback
+// factory is returned unchanged.
+//
+// This is the single-resolver form of ImportProgrammer's `if p.emit_ != nil`
+// branch: the embedded ast.NodeFactory inside printer.NodeFactory carries the
+// emit hooks, so &ec.Factory.NodeFactory produces metadata-bearing nodes while
+// printing identically to the fallback (token text/structure unchanged).
+func EmitFactory(ec *shimprinter.EmitContext, fallback *shimast.NodeFactory) *shimast.NodeFactory {
+  if ec != nil {
+    return &ec.Factory.NodeFactory
+  }
+  return fallback
+}
+
+// EmitFactoryOf is the variadic form for node-creating free helpers and shared
+// static factories that receive the emit context through an optional `emit
+// ...*EmitContext` parameter. Passing no context (or a nil one) selects the
+// standalone fallback, which is the legacy / analysis-only / test path; passing
+// a live context routes creation through ec.Factory. This lets call sites thread
+// the real context in progressively while the build stays green at every step.
+func EmitFactoryOf(fallback *shimast.NodeFactory, emit ...*shimprinter.EmitContext) *shimast.NodeFactory {
+  if len(emit) != 0 && emit[0] != nil {
+    return &emit[0].Factory.NodeFactory
+  }
+  return fallback
+}

package/native/core/context/ImportProgrammer.go

@@ -111,7 +111,7 @@ func (p *ImportProgrammer) Default(props ImportProgrammer_IDefault) *shimast.Nod
   if p.emit_ != nil {
     return p.member(asset, "default")
   }
-  return importProgrammer_factory.NewIdentifier(asset.Default.Name)
+  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(asset.Default.Name)
 }
 
 func (p *ImportProgrammer) Instance(props ImportProgrammer_IInstance) *shimast.Node {
@@ -127,7 +127,7 @@ func (p *ImportProgrammer) Instance(props ImportProgrammer_IInstance) *shimast.N
   if p.emit_ != nil {
     return p.member(asset, props.Name)
   }
-  return importProgrammer_factory.NewIdentifier(alias)
+  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(alias)
 }
 
 func (p *ImportProgrammer) Namespace(props ImportProgrammer_INamespace) *shimast.Node {
@@ -139,14 +139,15 @@ func (p *ImportProgrammer) Namespace(props ImportProgrammer_INamespace) *shimast
   if p.emit_ != nil {
     return p.emit_.Factory.NewGeneratedNameForNode(p.moduleSpecifier(asset))
   }
-  return importProgrammer_factory.NewIdentifier(asset.namespace.Name)
+  return EmitFactory(p.emit_, importProgrammer_factory).NewIdentifier(asset.namespace.Name)
 }
 
 func (p *ImportProgrammer) Type(props ImportProgrammer_TypeProps) *shimast.Node {
+  f := EmitFactory(p.emit_, importProgrammer_factory)
   var qualifier *shimast.EntityName
   switch name := props.Name.(type) {
   case string:
-    qualifier = importProgrammer_factory.NewIdentifier(name)
+    qualifier = f.NewIdentifier(name)
   case *shimast.Node:
     qualifier = name
   }
@@ -154,14 +155,14 @@ func (p *ImportProgrammer) Type(props ImportProgrammer_TypeProps) *shimast.Node
   for _, arg := range props.Arguments {
     args = append(args, arg)
   }
-  return importProgrammer_factory.NewImportTypeNode(
+  return f.NewImportTypeNode(
     false,
-    importProgrammer_factory.NewLiteralTypeNode(
-      importProgrammer_factory.NewStringLiteral(props.File, shimast.TokenFlagsNone),
+    f.NewLiteralTypeNode(
+      f.NewStringLiteral(props.File, shimast.TokenFlagsNone),
     ),
     nil,
     qualifier,
-    importProgrammer_factory.NewNodeList(args),
+    f.NewNodeList(args),
   )
 }
 
@@ -191,6 +192,7 @@ func (p *ImportProgrammer) GetInternalText(name string) string {
 }
 
 func (p *ImportProgrammer) ToStatements() []*shimast.Node {
+  f := EmitFactory(p.emit_, importProgrammer_factory)
   statements := []*shimast.Node{}
   order := append([]string{}, p.order_...)
   indices := map[string]int{}
@@ -224,14 +226,14 @@ func (p *ImportProgrammer) ToStatements() []*shimast.Node {
       continue
     }
     if asset.namespace != nil {
-      statements = append(statements, importProgrammer_factory.NewImportDeclaration(
+      statements = append(statements, f.NewImportDeclaration(
         nil,
-        importProgrammer_factory.NewImportClause(
+        f.NewImportClause(
           0,
           nil,
-          importProgrammer_factory.NewNamespaceImport(importProgrammer_factory.NewIdentifier(asset.namespace.Name)),
+          f.NewNamespaceImport(f.NewIdentifier(asset.namespace.Name)),
         ),
-        importProgrammer_factory.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
+        f.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
         nil,
       ))
     }
@@ -240,14 +242,14 @@ func (p *ImportProgrammer) ToStatements() []*shimast.Node {
       if asset.Default.Type {
         phase = shimast.KindTypeKeyword
       }
-      statements = append(statements, importProgrammer_factory.NewImportDeclaration(
+      statements = append(statements, f.NewImportDeclaration(
         nil,
-        importProgrammer_factory.NewImportClause(
+        f.NewImportClause(
           phase,
-          importProgrammer_factory.NewIdentifier(asset.Default.Name),
+          f.NewIdentifier(asset.Default.Name),
           nil,
         ),
-        importProgrammer_factory.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
+        f.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
         nil,
       ))
     }
@@ -257,22 +259,22 @@ func (p *ImportProgrammer) ToStatements() []*shimast.Node {
         ins := asset.instances[alias]
         var propertyName *shimast.ModuleExportName
         if ins.Alias != nil {
-          propertyName = importProgrammer_factory.NewIdentifier(ins.Name)
+          propertyName = f.NewIdentifier(ins.Name)
         }
-        specifiers = append(specifiers, importProgrammer_factory.NewImportSpecifier(
+        specifiers = append(specifiers, f.NewImportSpecifier(
           false,
           propertyName,
-          importProgrammer_factory.NewIdentifier(alias),
+          f.NewIdentifier(alias),
         ))
       }
-      statements = append(statements, importProgrammer_factory.NewImportDeclaration(
+      statements = append(statements, f.NewImportDeclaration(
         nil,
-        importProgrammer_factory.NewImportClause(
+        f.NewImportClause(
           0,
           nil,
-          importProgrammer_factory.NewNamedImports(importProgrammer_factory.NewNodeList(specifiers)),
+          f.NewNamedImports(f.NewNodeList(specifiers)),
         ),
-        importProgrammer_factory.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
+        f.NewStringLiteral(asset.file, shimast.TokenFlagsNone),
         nil,
       ))
     }

package/native/core/factories/ExpressionFactory.go

@@ -11,6 +11,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcore "github.com/microsoft/typescript-go/shim/core"
   shimparser "github.com/microsoft/typescript-go/shim/parser"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
@@ -53,75 +54,80 @@ type ExpressionFactory_GetEscapedTextProps struct {
 
 var expressionFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
-func (expressionFactoryNamespace) Number(value any) *shimast.Node {
+func (expressionFactoryNamespace) Number(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   text, numeric := expressionFactory_number_text(value)
   if numeric < 0 {
-    return expressionFactory_factory.NewPrefixUnaryExpression(
+    return f.NewPrefixUnaryExpression(
       shimast.KindMinusToken,
-      expressionFactory_factory.NewNumericLiteral(expressionFactory_number_abs_text(numeric), shimast.TokenFlagsNone),
+      f.NewNumericLiteral(expressionFactory_number_abs_text(numeric), shimast.TokenFlagsNone),
     )
   }
-  return expressionFactory_factory.NewNumericLiteral(text, shimast.TokenFlagsNone)
+  return f.NewNumericLiteral(text, shimast.TokenFlagsNone)
 }
 
-func (expressionFactoryNamespace) Bigint(value any) *shimast.Node {
-  return expressionFactory_factory.NewCallExpression(
-    expressionFactory_factory.NewIdentifier("BigInt"),
+func (expressionFactoryNamespace) Bigint(value any, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewCallExpression(
+    f.NewIdentifier("BigInt"),
     nil,
     nil,
-    expressionFactory_factory.NewNodeList([]*shimast.Node{
-      expressionFactory_factory.NewIdentifier(fmt.Sprint(value)),
+    f.NewNodeList([]*shimast.Node{
+      f.NewIdentifier(fmt.Sprint(value)),
     }),
     shimast.NodeFlagsNone,
   )
 }
 
-func (expressionFactoryNamespace) IsRequired(input *shimast.Expression) *shimast.Node {
-  return expressionFactory_factory.NewBinaryExpression(
+func (expressionFactoryNamespace) IsRequired(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewBinaryExpression(
     nil,
-    expressionFactory_factory.NewIdentifier("undefined"),
+    f.NewIdentifier("undefined"),
     nil,
-    expressionFactory_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+    f.NewToken(shimast.KindExclamationEqualsEqualsToken),
     input,
   )
 }
 
-func (expressionFactoryNamespace) IsArray(input *shimast.Expression) *shimast.Node {
-  return expressionFactory_factory.NewCallExpression(
-    expressionFactory_factory.NewIdentifier("Array.isArray"),
+func (expressionFactoryNamespace) IsArray(input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewCallExpression(
+    f.NewIdentifier("Array.isArray"),
     nil,
     nil,
-    expressionFactory_factory.NewNodeList([]*shimast.Node{input}),
+    f.NewNodeList([]*shimast.Node{input}),
     shimast.NodeFlagsNone,
   )
 }
 
-func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps) *shimast.Node {
+func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   conditions := []*shimast.Node{
-    expressionFactory_factory.NewBinaryExpression(
+    f.NewBinaryExpression(
       nil,
-      expressionFactory_factory.NewStringLiteral("object", shimast.TokenFlagsNone),
+      f.NewStringLiteral("object", shimast.TokenFlagsNone),
       nil,
-      expressionFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-      expressionFactory_factory.NewTypeOfExpression(props.Input),
+      f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      f.NewTypeOfExpression(props.Input),
     ),
   }
   if props.CheckNull {
-    conditions = append(conditions, expressionFactory_factory.NewBinaryExpression(
+    conditions = append(conditions, f.NewBinaryExpression(
       nil,
-      expressionFactory_factory.NewKeywordExpression(shimast.KindNullKeyword),
+      f.NewKeywordExpression(shimast.KindNullKeyword),
       nil,
-      expressionFactory_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+      f.NewToken(shimast.KindExclamationEqualsEqualsToken),
       props.Input,
     ))
   }
   if props.CheckArray {
-    conditions = append(conditions, expressionFactory_factory.NewBinaryExpression(
+    conditions = append(conditions, f.NewBinaryExpression(
       nil,
-      expressionFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+      f.NewKeywordExpression(shimast.KindFalseKeyword),
       nil,
-      expressionFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
-      ExpressionFactory.IsArray(props.Input),
+      f.NewToken(shimast.KindEqualsEqualsEqualsToken),
+      ExpressionFactory.IsArray(props.Input, emit...),
     ))
   }
   if len(conditions) == 1 {
@@ -129,79 +135,103 @@ func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps
   }
   output := conditions[0]
   for _, condition := range conditions[1:] {
-    output = expressionFactory_factory.NewBinaryExpression(
+    output = f.NewBinaryExpression(
       nil,
       output,
       nil,
-      expressionFactory_factory.NewToken(shimast.KindAmpersandAmpersandToken),
+      f.NewToken(shimast.KindAmpersandAmpersandToken),
       condition,
     )
   }
   return output
 }
 
-func (expressionFactoryNamespace) IsInstanceOf(t string, input *shimast.Expression) *shimast.Node {
-  return expressionFactory_factory.NewBinaryExpression(
+func (expressionFactoryNamespace) IsInstanceOf(t string, input *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewBinaryExpression(
     nil,
     input,
     nil,
-    expressionFactory_factory.NewToken(shimast.KindInstanceOfKeyword),
-    expressionFactory_factory.NewIdentifier(t),
+    f.NewToken(shimast.KindInstanceOfKeyword),
+    f.NewIdentifier(t),
   )
 }
 
-func (expressionFactoryNamespace) Coalesce(x *shimast.Expression, y *shimast.Expression) *shimast.Node {
-  return expressionFactory_factory.NewBinaryExpression(
+func (expressionFactoryNamespace) Coalesce(x *shimast.Expression, y *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewBinaryExpression(
     nil,
     x,
     nil,
-    expressionFactory_factory.NewToken(shimast.KindQuestionQuestionToken),
+    f.NewToken(shimast.KindQuestionQuestionToken),
     y,
   )
 }
 
-func (expressionFactoryNamespace) Currying(props ExpressionFactory_CurryingProps) *shimast.Node {
+// Conditional builds `condition ? whenTrue : whenFalse` with its operator tokens
+// supplied at construction. typia's programmers historically built conditional
+// expressions with nil `?`/`:` tokens and relied on a post-emit tree walk
+// (NormalizeSyntheticTokens) to fill them in; constructing them well-formed here
+// removes that workaround. The node is structurally identical to the patched-up
+// form, so emitted text is unchanged.
+func (expressionFactoryNamespace) Conditional(condition *shimast.Expression, whenTrue *shimast.Expression, whenFalse *shimast.Expression, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
+  return f.NewConditionalExpression(
+    condition,
+    f.NewToken(shimast.KindQuestionToken),
+    whenTrue,
+    f.NewToken(shimast.KindColonToken),
+    whenFalse,
+  )
+}
+
+func (expressionFactoryNamespace) Currying(props ExpressionFactory_CurryingProps, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   if len(props.Arguments) == 0 {
-    return expressionFactory_factory.NewCallExpression(props.Function, nil, nil, nil, shimast.NodeFlagsNone)
+    return f.NewCallExpression(props.Function, nil, nil, nil, shimast.NodeFlagsNone)
   }
-  prev := expressionFactory_factory.NewCallExpression(
+  prev := f.NewCallExpression(
     props.Function,
     nil,
     nil,
-    expressionFactory_factory.NewNodeList([]*shimast.Node{props.Arguments[0]}),
+    f.NewNodeList([]*shimast.Node{props.Arguments[0]}),
     shimast.NodeFlagsNone,
   )
   for _, param := range props.Arguments[1:] {
-    prev = expressionFactory_factory.NewCallExpression(
+    prev = f.NewCallExpression(
       prev,
       nil,
       nil,
-      expressionFactory_factory.NewNodeList([]*shimast.Node{param}),
+      f.NewNodeList([]*shimast.Node{param}),
       shimast.NodeFlagsNone,
     )
   }
   return prev
 }
 
-func (expressionFactoryNamespace) SelfCall(body *shimast.ConciseBody, typeNode ...*shimast.TypeNode) *shimast.Node {
+// SelfCall takes a required emit context (nil for context-free callers) for the
+// same reason as IdentifierFactory.Access: its trailing typeNode variadic blocks
+// the optional-emit form.
+func (expressionFactoryNamespace) SelfCall(ec *shimprinter.EmitContext, body *shimast.ConciseBody, typeNode ...*shimast.TypeNode) *shimast.Node {
   if body != nil && body.Kind == shimast.KindCallExpression {
     return body
   }
+  f := nativecontext.EmitFactory(ec, expressionFactory_factory)
   var output *shimast.TypeNode
   if len(typeNode) != 0 {
     output = typeNode[0]
   }
-  arrow := expressionFactory_factory.NewArrowFunction(
+  arrow := f.NewArrowFunction(
     nil,
     nil,
-    expressionFactory_factory.NewNodeList(nil),
+    f.NewNodeList(nil),
     output,
     nil,
-    expressionFactory_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+    f.NewToken(shimast.KindEqualsGreaterThanToken),
     body,
   )
-  return expressionFactory_factory.NewCallExpression(
-    expressionFactory_factory.NewParenthesizedExpression(arrow),
+  return f.NewCallExpression(
+    f.NewParenthesizedExpression(arrow),
     nil,
     nil,
     nil,
@@ -219,7 +249,8 @@ func (expressionFactoryNamespace) GetEscapedText(props ExpressionFactory_GetEsca
   return IdentifierFactory.GetName(props.Input)
 }
 
-func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspileProps) func(input *shimast.Expression) *shimast.Node {
+func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspileProps, emit ...*shimprinter.EmitContext) func(input *shimast.Expression) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(expressionFactory_factory, emit...)
   file := shimparser.ParseSourceFile(
     shimast.SourceFileParseOptions{FileName: filepath.Join(os.TempDir(), expressionFactory_random_format_uuid()+".ts")},
     props.Script,
@@ -232,7 +263,7 @@ func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspilePro
   if statement.Kind != shimast.KindExpressionStatement {
     panic("Error on ExpressionFactory.transpile(): statement is not an expression statement.")
   }
-  expression := expressionFactory_factory.DeepCloneNode(statement.AsExpressionStatement().Expression)
+  expression := f.DeepCloneNode(statement.AsExpressionStatement().Expression)
   return func(input *shimast.Expression) *shimast.Node {
     var visitor *shimast.NodeVisitor
     visitor = shimast.NewNodeVisitor(func(node *shimast.Node) *shimast.Node {
@@ -248,7 +279,7 @@ func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspilePro
         }
       }
       return node.VisitEachChild(visitor)
-    }, expressionFactory_factory, shimast.NodeVisitorHooks{})
+    }, f, shimast.NodeVisitorHooks{})
     return visitor.VisitNode(expression)
   }
 }

package/native/core/factories/IdentifierFactory.go

@@ -5,6 +5,8 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
 )
 
 type identifierFactoryNamespace struct{}
@@ -13,31 +15,37 @@ var IdentifierFactory = identifierFactoryNamespace{}
 
 var identifierFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
 
-func (identifierFactoryNamespace) Identifier(name string) *shimast.Node {
+func (identifierFactoryNamespace) Identifier(name string, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(identifierFactory_factory, emit...)
   if identifierFactory_variable(name) {
-    return identifierFactory_factory.NewIdentifier(name)
+    return f.NewIdentifier(name)
   }
-  return identifierFactory_factory.NewStringLiteral(name, shimast.TokenFlagsNone)
+  return f.NewStringLiteral(name, shimast.TokenFlagsNone)
 }
 
-func (identifierFactoryNamespace) Access(input *shimast.Expression, key string, chain ...bool) *shimast.Node {
-  postfix := IdentifierFactory.Identifier(key)
+// Access takes a required emit context (nil for genuinely context-free callers)
+// because its trailing `chain` variadic blocks the optional-emit form the other
+// factories use; a required parameter also makes a forgotten context a compile
+// error rather than a silent metadata gap.
+func (identifierFactoryNamespace) Access(ec *shimprinter.EmitContext, input *shimast.Expression, key string, chain ...bool) *shimast.Node {
+  f := nativecontext.EmitFactory(ec, identifierFactory_factory)
+  postfix := IdentifierFactory.Identifier(key, ec)
   optional := len(chain) != 0 && chain[0]
   var questionDot *shimast.QuestionDotToken
   flags := shimast.NodeFlagsNone
   if optional {
-    questionDot = identifierFactory_factory.NewToken(shimast.KindQuestionDotToken)
+    questionDot = f.NewToken(shimast.KindQuestionDotToken)
     flags = shimast.NodeFlagsOptionalChain
   }
   if shimast.IsStringLiteral(postfix) {
-    return identifierFactory_factory.NewElementAccessExpression(
+    return f.NewElementAccessExpression(
       input,
       questionDot,
       postfix,
       flags,
     )
   }
-  return identifierFactory_factory.NewPropertyAccessExpression(
+  return f.NewPropertyAccessExpression(
     input,
     questionDot,
     postfix,
@@ -71,27 +79,28 @@ func (identifierFactoryNamespace) Postfix(str string) string {
   return "\"[" + quoted + "]\""
 }
 
-func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node) *shimast.Node {
+func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(identifierFactory_factory, emit...)
   var binding *shimast.BindingName
   switch v := name.(type) {
   case string:
-    binding = identifierFactory_factory.NewIdentifier(v)
+    binding = f.NewIdentifier(v)
   case *shimast.Node:
     binding = v
   default:
-    binding = identifierFactory_factory.NewIdentifier("input")
+    binding = f.NewIdentifier("input")
   }
   if typeNode == nil {
-    typeNode = TypeFactory.Keyword("any")
+    typeNode = TypeFactory.Keyword("any", emit...)
   }
   var question *shimast.QuestionToken
   var initializer *shimast.Expression
   if init != nil && init.Kind == shimast.KindQuestionToken {
-    question = identifierFactory_factory.NewToken(shimast.KindQuestionToken)
+    question = f.NewToken(shimast.KindQuestionToken)
   } else {
     initializer = init
   }
-  return identifierFactory_factory.NewParameterDeclaration(
+  return f.NewParameterDeclaration(
     nil,
     nil,
     binding,