@@ -77,7 +77,7 @@ func (ct *changeTracker) doAddExistingFix(
77
77
78
78
if defaultImport != nil {
79
79
debug .Assert (clause .Name () == nil , "Cannot add a default import to an import clause that already has one" )
80
- ct .insertNodeAt (sourceFile , core .TextPos (astnav .GetStartOfNode (clause , sourceFile , false )), ct .NodeFactory . NewIdentifier (defaultImport .name ), changeNodeOptions {suffix : ", " })
80
+ ct .insertNodeAt (sourceFile , core .TextPos (astnav .GetStartOfNode (clause , sourceFile , false )), ct .NewIdentifier (defaultImport .name ), changeNodeOptions {suffix : ", " })
81
81
}
82
82
83
83
if len (namedImports ) > 0 {
@@ -88,10 +88,10 @@ func (ct *changeTracker) doAddExistingFix(
88
88
if namedImport .propertyName != "" {
89
89
identifier = ct .NodeFactory .NewIdentifier (namedImport .propertyName ).AsIdentifier ().AsNode ()
90
90
}
91
- return ct .NodeFactory . NewImportSpecifier (
91
+ return ct .NewImportSpecifier (
92
92
(! importClause .IsTypeOnly || promoteFromTypeOnly ) && shouldUseTypeOnly (namedImport .addAsTypeOnly , preferences ),
93
93
identifier ,
94
- ct .NodeFactory . NewIdentifier (namedImport .name ),
94
+ ct .NewIdentifier (namedImport .name ),
95
95
)
96
96
}) // !!! sort with specifierComparer
97
97
@@ -137,7 +137,7 @@ func (ct *changeTracker) doAddExistingFix(
137
137
}
138
138
} else {
139
139
if len (newSpecifiers ) > 0 {
140
- namedImports := ct .NodeFactory . NewNamedImports (ct . NodeFactory .NewNodeList (newSpecifiers ))
140
+ namedImports := ct .NewNamedImports (ct .NewNodeList (newSpecifiers ))
141
141
if importClause .NamedBindings != nil {
142
142
ct .replaceNode (sourceFile , importClause .NamedBindings , namedImports , nil )
143
143
} else {
@@ -174,22 +174,22 @@ func (ct *changeTracker) addElementToBindingPattern(sourceFile *ast.SourceFile,
174
174
if len (bindingPattern .Elements ()) > 0 {
175
175
ct .insertNodeInListAfter (sourceFile , bindingPattern .Elements ()[len (bindingPattern .Elements ())- 1 ], element , nil )
176
176
} else {
177
- ct .replaceNode (sourceFile , bindingPattern , ct .NodeFactory . NewBindingPattern (
177
+ ct .replaceNode (sourceFile , bindingPattern , ct .NewBindingPattern (
178
178
ast .KindObjectBindingPattern ,
179
- ct .NodeFactory . NewNodeList ([]* ast.Node {element }),
179
+ ct .NewNodeList ([]* ast.Node {element }),
180
180
), nil )
181
181
}
182
182
}
183
183
184
184
func (ct * changeTracker ) newBindingElementFromNameAndPropertyName (name string , propertyName * string ) * ast.Node {
185
185
var newPropertyNameIdentifier * ast.Node
186
186
if propertyName != nil {
187
- newPropertyNameIdentifier = ct .NodeFactory . NewIdentifier (* propertyName )
187
+ newPropertyNameIdentifier = ct .NewIdentifier (* propertyName )
188
188
}
189
- return ct .NodeFactory . NewBindingElement (
189
+ return ct .NewBindingElement (
190
190
nil , /*dotDotDotToken*/
191
191
newPropertyNameIdentifier ,
192
- ct .NodeFactory . NewIdentifier (name ),
192
+ ct .NewIdentifier (name ),
193
193
nil , /* initializer */
194
194
)
195
195
}
@@ -241,13 +241,13 @@ func (ct *changeTracker) insertImports(sourceFile *ast.SourceFile, imports []*as
241
241
func (ct * changeTracker ) makeImport (defaultImport * ast.IdentifierNode , namedImports []* ast.Node , moduleSpecifier * ast.Expression , isTypeOnly bool ) * ast.Statement {
242
242
var newNamedImports * ast.Node
243
243
if len (namedImports ) > 0 {
244
- newNamedImports = ct .NodeFactory . NewNamedImports (ct . NodeFactory .NewNodeList (namedImports ))
244
+ newNamedImports = ct .NewNamedImports (ct .NewNodeList (namedImports ))
245
245
}
246
246
var importClause * ast.Node
247
247
if defaultImport != nil || newNamedImports != nil {
248
- importClause = ct .NodeFactory . NewImportClause (isTypeOnly , defaultImport , newNamedImports )
248
+ importClause = ct .NewImportClause (isTypeOnly , defaultImport , newNamedImports )
249
249
}
250
- return ct .NodeFactory . NewImportDeclaration ( /*modifiers*/ nil , importClause , moduleSpecifier , nil /*attributes*/ )
250
+ return ct .NewImportDeclaration ( /*modifiers*/ nil , importClause , moduleSpecifier , nil /*attributes*/ )
251
251
}
252
252
253
253
func (ct * changeTracker ) getNewImports (
@@ -259,7 +259,7 @@ func (ct *changeTracker) getNewImports(
259
259
compilerOptions * core.CompilerOptions ,
260
260
preferences * UserPreferences ,
261
261
) []* ast.Statement {
262
- moduleSpecifierStringLiteral := ct .NodeFactory . NewStringLiteral (moduleSpecifier )
262
+ moduleSpecifierStringLiteral := ct .NewStringLiteral (moduleSpecifier )
263
263
var statements []* ast.Statement // []AnyImportSyntax
264
264
if defaultImport != nil || len (namedImports ) > 0 {
265
265
// `verbatimModuleSyntax` should prefer top-level `import type` -
@@ -271,38 +271,38 @@ func (ct *changeTracker) getNewImports(
271
271
272
272
var defaultImportNode * ast.Node
273
273
if defaultImport != nil {
274
- defaultImportNode = ct .NodeFactory . NewIdentifier (defaultImport .name )
274
+ defaultImportNode = ct .NewIdentifier (defaultImport .name )
275
275
}
276
276
277
277
statements = append (statements , ct .makeImport (defaultImportNode , core .Map (namedImports , func (namedImport * Import ) * ast.Node {
278
278
var namedImportPropertyName * ast.Node
279
279
if namedImport .propertyName != "" {
280
- namedImportPropertyName = ct .NodeFactory . NewIdentifier (namedImport .propertyName )
280
+ namedImportPropertyName = ct .NewIdentifier (namedImport .propertyName )
281
281
}
282
- return ct .NodeFactory . NewImportSpecifier (
282
+ return ct .NewImportSpecifier (
283
283
! topLevelTypeOnly && shouldUseTypeOnly (namedImport .addAsTypeOnly , preferences ),
284
284
namedImportPropertyName ,
285
- ct .NodeFactory . NewIdentifier (namedImport .name ),
285
+ ct .NewIdentifier (namedImport .name ),
286
286
)
287
287
}), moduleSpecifierStringLiteral , topLevelTypeOnly ))
288
288
}
289
289
290
290
if namespaceLikeImport != nil {
291
291
var declaration * ast.Statement
292
292
if namespaceLikeImport .kind == ImportKindCommonJS {
293
- declaration = ct .NodeFactory . NewImportEqualsDeclaration (
293
+ declaration = ct .NewImportEqualsDeclaration (
294
294
/*modifiers*/ nil ,
295
295
shouldUseTypeOnly (namespaceLikeImport .addAsTypeOnly , preferences ),
296
- ct .NodeFactory . NewIdentifier (namespaceLikeImport .name ),
297
- ct .NodeFactory . NewExternalModuleReference (moduleSpecifierStringLiteral ),
296
+ ct .NewIdentifier (namespaceLikeImport .name ),
297
+ ct .NewExternalModuleReference (moduleSpecifierStringLiteral ),
298
298
)
299
299
} else {
300
- declaration = ct .NodeFactory . NewImportDeclaration (
300
+ declaration = ct .NewImportDeclaration (
301
301
/*modifiers*/ nil ,
302
- ct .NodeFactory . NewImportClause (
302
+ ct .NewImportClause (
303
303
shouldUseTypeOnly (namespaceLikeImport .addAsTypeOnly , preferences ),
304
304
/*name*/ nil ,
305
- ct .NodeFactory . NewNamespaceImport (ct . NodeFactory .NewIdentifier (namespaceLikeImport .name )),
305
+ ct .NewNamespaceImport (ct .NewIdentifier (namespaceLikeImport .name )),
306
306
),
307
307
moduleSpecifierStringLiteral ,
308
308
/*attributes*/ nil ,
0 commit comments