1 | "use strict";
|
2 | Object.defineProperty(exports, "__esModule", { value: true });
|
3 | class Visitor {
|
4 | visitProgram(n) {
|
5 | switch (n.type) {
|
6 | case "Module":
|
7 | return this.visitModule(n);
|
8 | case "Script":
|
9 | return this.visitScript(n);
|
10 | }
|
11 | }
|
12 | visitModule(m) {
|
13 | m.body = this.visitModuleItems(m.body);
|
14 | return m;
|
15 | }
|
16 | visitScript(m) {
|
17 | m.body = this.visitStatements(m.body);
|
18 | return m;
|
19 | }
|
20 | visitModuleItems(items) {
|
21 | return items.map(this.visitModuleItem.bind(this));
|
22 | }
|
23 | visitModuleItem(n) {
|
24 | switch (n.type) {
|
25 | case "ExportDeclaration":
|
26 | case "ExportDefaultDeclaration":
|
27 | case "ExportNamedDeclaration":
|
28 | case "ExportDefaultExpression":
|
29 | case "ImportDeclaration":
|
30 | case "ExportAllDeclaration":
|
31 | case "TsImportEqualsDeclaration":
|
32 | case "TsExportAssignment":
|
33 | case "TsNamespaceExportDeclaration":
|
34 | return this.visitModuleDeclaration(n);
|
35 | default:
|
36 | return this.visitStatement(n);
|
37 | }
|
38 | }
|
39 | visitModuleDeclaration(n) {
|
40 | switch (n.type) {
|
41 | case "ExportDeclaration":
|
42 | return this.visitExportDeclaration(n);
|
43 | case "ExportDefaultDeclaration":
|
44 | return this.visitExportDefaultDeclaration(n);
|
45 | case "ExportNamedDeclaration":
|
46 | return this.visitExportNamedDeclration(n);
|
47 | case "ExportDefaultExpression":
|
48 | return this.visitExportDefaultExpression(n);
|
49 | case "ImportDeclaration":
|
50 | return this.visitImportDeclaration(n);
|
51 | case "ExportAllDeclaration":
|
52 | return this.visitExportAllDeclration(n);
|
53 | case "TsImportEqualsDeclaration":
|
54 | return this.visitTsImportEqualsDeclaration(n);
|
55 | case "TsExportAssignment":
|
56 | return this.visitTsExportAssignment(n);
|
57 | case "TsNamespaceExportDeclaration":
|
58 | return this.visitTsNamespaceExportDeclaration(n);
|
59 | }
|
60 | }
|
61 | visitTsNamespaceExportDeclaration(n) {
|
62 | n.id = this.visitBindingIdentifier(n.id);
|
63 | return n;
|
64 | }
|
65 | visitTsExportAssignment(n) {
|
66 | n.expression = this.visitExpression(n.expression);
|
67 | return n;
|
68 | }
|
69 | visitTsImportEqualsDeclaration(n) {
|
70 | n.id = this.visitBindingIdentifier(n.id);
|
71 | n.moduleRef = this.visitTsModuleReference(n.moduleRef);
|
72 | return n;
|
73 | }
|
74 | visitTsModuleReference(n) {
|
75 | switch (n.type) {
|
76 | case "Identifier":
|
77 | return this.visitIdentifierReference(n);
|
78 | case "TsExternalModuleReference":
|
79 | return this.visitTsExternalModuleReference(n);
|
80 | case "TsQualifiedName":
|
81 | return this.visitTsQualifiedName(n);
|
82 | }
|
83 | }
|
84 | visitTsExternalModuleReference(n) {
|
85 | n.expression = this.visitExpression(n.expression);
|
86 | return n;
|
87 | }
|
88 | visitExportAllDeclration(n) {
|
89 | n.source = this.visitStringLiteral(n.source);
|
90 | return n;
|
91 | }
|
92 | visitExportDefaultExpression(n) {
|
93 | n.expression = this.visitExpression(n.expression);
|
94 | return n;
|
95 | }
|
96 | visitExportNamedDeclration(n) {
|
97 | n.specifiers = this.visitExportSpecifiers(n.specifiers);
|
98 | n.source = this.visitOptionalStringLiteral(n.source);
|
99 | return n;
|
100 | }
|
101 | visitExportSpecifiers(nodes) {
|
102 | return nodes.map(this.visitExportSpecifier.bind(this));
|
103 | }
|
104 | visitExportSpecifier(n) {
|
105 | switch (n.type) {
|
106 | case "ExportDefaultSpecifier":
|
107 | return this.visitExportDefaultSpecifier(n);
|
108 | case "ExportNamespaceSpecifer":
|
109 | return this.visitExportNamespaceSpecifier(n);
|
110 | case "ExportSpecifier":
|
111 | return this.visitNamedExportSpecifier(n);
|
112 | }
|
113 | }
|
114 | visitNamedExportSpecifier(n) {
|
115 | if (n.exported) {
|
116 | n.exported = this.visitBindingIdentifier(n.exported);
|
117 | }
|
118 | n.orig = this.visitIdentifierReference(n.orig);
|
119 | return n;
|
120 | }
|
121 | visitExportNamespaceSpecifier(n) {
|
122 | n.name = this.visitBindingIdentifier(n.name);
|
123 | return n;
|
124 | }
|
125 | visitExportDefaultSpecifier(n) {
|
126 | n.exported = this.visitBindingIdentifier(n.exported);
|
127 | return n;
|
128 | }
|
129 | visitOptionalStringLiteral(n) {
|
130 | if (n) {
|
131 | return this.visitStringLiteral(n);
|
132 | }
|
133 | }
|
134 | visitExportDefaultDeclaration(n) {
|
135 | n.decl = this.visitDefaultDeclaration(n.decl);
|
136 | return n;
|
137 | }
|
138 | visitDefaultDeclaration(n) {
|
139 | switch (n.type) {
|
140 | case "ClassExpression":
|
141 | return this.visitClassExpression(n);
|
142 | case "FunctionExpression":
|
143 | return this.visitFunctionExpression(n);
|
144 | case "TsInterfaceDeclaration":
|
145 | return this.visitTsInterfaceDeclaration(n);
|
146 | }
|
147 | }
|
148 | visitFunctionExpression(n) {
|
149 | n = this.visitFunction(n);
|
150 | if (n.identifier) {
|
151 | n.identifier = this.visitBindingIdentifier(n.identifier);
|
152 | }
|
153 | return n;
|
154 | }
|
155 | visitClassExpression(n) {
|
156 | n = this.visitClass(n);
|
157 | if (n.identifier) {
|
158 | n.identifier = this.visitBindingIdentifier(n.identifier);
|
159 | }
|
160 | return n;
|
161 | }
|
162 | visitExportDeclaration(n) {
|
163 | n.declaration = this.visitDeclaration(n.declaration);
|
164 | return n;
|
165 | }
|
166 | visitArrayExpression(e) {
|
167 | if (e.elements) {
|
168 | e.elements = e.elements.map(this.visitArrayElement.bind(this));
|
169 | }
|
170 | return e;
|
171 | }
|
172 | visitArrayElement(e) {
|
173 | if (e && e.type === "SpreadElement") {
|
174 | return this.visitSpreadElement(e);
|
175 | }
|
176 | return this.visitOptionalExpression(e);
|
177 | }
|
178 | visitSpreadElement(e) {
|
179 | e.arguments = this.visitExpression(e.arguments);
|
180 | return e;
|
181 | }
|
182 | visitOptionalExpression(e) {
|
183 | if (e) {
|
184 | return this.visitExpression(e);
|
185 | }
|
186 | }
|
187 | visitArrowFunctionExpression(e) {
|
188 | e.body = this.visitArrowBody(e.body);
|
189 | e.params = this.visitPatterns(e.params);
|
190 | e.returnType = this.visitTsTypeAnnotation(e.returnType);
|
191 | e.typeParameters = this.visitTsTypeParameterDeclaration(e.typeParameters);
|
192 | return e;
|
193 | }
|
194 | visitArrowBody(body) {
|
195 | switch (body.type) {
|
196 | case "BlockStatement":
|
197 | return this.visitBlockStatement(body);
|
198 | default:
|
199 | return this.visitExpression(body);
|
200 | }
|
201 | }
|
202 | visitBlockStatement(block) {
|
203 | block.stmts = this.visitStatements(block.stmts);
|
204 | return block;
|
205 | }
|
206 | visitStatements(stmts) {
|
207 | return stmts.map(this.visitStatement.bind(this));
|
208 | }
|
209 | visitStatement(stmt) {
|
210 | switch (stmt.type) {
|
211 | case "ClassDeclaration":
|
212 | case "FunctionDeclaration":
|
213 | case "TsEnumDeclaration":
|
214 | case "TsInterfaceDeclaration":
|
215 | case "TsModuleDeclaration":
|
216 | case "TsTypeAliasDeclaration":
|
217 | case "VariableDeclaration":
|
218 | return this.visitDeclaration(stmt);
|
219 | case "BreakStatement":
|
220 | return this.visitBreakStatement(stmt);
|
221 | case "BlockStatement":
|
222 | return this.visitBlockStatement(stmt);
|
223 | case "ContinueStatement":
|
224 | return this.visitContinueStatement(stmt);
|
225 | case "DebuggerStatement":
|
226 | return this.visitDebuggerStatement(stmt);
|
227 | case "DoWhileStatement":
|
228 | return this.visitDoWhileStatement(stmt);
|
229 | case "EmptyStatement":
|
230 | return this.visitEmptyStatement(stmt);
|
231 | case "ForInStatement":
|
232 | return this.visitForInStatement(stmt);
|
233 | case "ForOfStatement":
|
234 | return this.visitForOfStatement(stmt);
|
235 | case "ForStatement":
|
236 | return this.visitForStatement(stmt);
|
237 | case "IfStatement":
|
238 | return this.visitIfStatement(stmt);
|
239 | case "LabeledStatement":
|
240 | return this.visitLabeledStatement(stmt);
|
241 | case "ReturnStatement":
|
242 | return this.visitReturnStatement(stmt);
|
243 | case "SwitchStatement":
|
244 | return this.visitSwitchStatement(stmt);
|
245 | case "ThrowStatement":
|
246 | return this.visitThrowStatement(stmt);
|
247 | case "TryStatement":
|
248 | return this.visitTryStatement(stmt);
|
249 | case "WhileStatement":
|
250 | return this.visitWhileStatement(stmt);
|
251 | case "WithStatement":
|
252 | return this.visitWithStatement(stmt);
|
253 | case "ExpressionStatement":
|
254 | return this.visitExpressionStatement(stmt);
|
255 | default:
|
256 | throw new Error(`Unknown statement type: ` + stmt.type);
|
257 | }
|
258 | }
|
259 | visitSwitchStatement(stmt) {
|
260 | stmt.discriminant = this.visitExpression(stmt.discriminant);
|
261 | stmt.cases = this.visitSwitchCases(stmt.cases);
|
262 | return stmt;
|
263 | }
|
264 | visitSwitchCases(cases) {
|
265 | return cases.map(this.visitSwitchCase.bind(this));
|
266 | }
|
267 | visitSwitchCase(c) {
|
268 | c.test = this.visitOptionalExpression(c.test);
|
269 | c.consequent = this.visitStatements(c.consequent);
|
270 | return c;
|
271 | }
|
272 | visitIfStatement(stmt) {
|
273 | stmt.test = this.visitExpression(stmt.test);
|
274 | stmt.consequent = this.visitStatement(stmt.consequent);
|
275 | stmt.alternate = this.visitOptionalStatement(stmt.alternate);
|
276 | return stmt;
|
277 | }
|
278 | visitOptionalStatement(stmt) {
|
279 | if (stmt) {
|
280 | return this.visitStatement(stmt);
|
281 | }
|
282 | }
|
283 | visitBreakStatement(stmt) {
|
284 | if (stmt.label) {
|
285 | stmt.label = this.visitLabelIdentifier(stmt.label);
|
286 | }
|
287 | return stmt;
|
288 | }
|
289 | visitWhileStatement(stmt) {
|
290 | stmt.test = this.visitExpression(stmt.test);
|
291 | stmt.body = this.visitStatement(stmt.body);
|
292 | return stmt;
|
293 | }
|
294 | visitTryStatement(stmt) {
|
295 | stmt.block = this.visitBlockStatement(stmt.block);
|
296 | stmt.handler = this.visitCatchClause(stmt.handler);
|
297 | if (stmt.finalizer) {
|
298 | stmt.finalizer = this.visitBlockStatement(stmt.finalizer);
|
299 | }
|
300 | return stmt;
|
301 | }
|
302 | visitCatchClause(handler) {
|
303 | if (handler) {
|
304 | if (handler.param) {
|
305 | handler.param = this.visitPattern(handler.param);
|
306 | }
|
307 | handler.body = this.visitBlockStatement(handler.body);
|
308 | }
|
309 | return handler;
|
310 | }
|
311 | visitThrowStatement(stmt) {
|
312 | stmt.argument = this.visitExpression(stmt.argument);
|
313 | return stmt;
|
314 | }
|
315 | visitReturnStatement(stmt) {
|
316 | if (stmt.argument) {
|
317 | stmt.argument = this.visitExpression(stmt.argument);
|
318 | }
|
319 | return stmt;
|
320 | }
|
321 | visitLabeledStatement(stmt) {
|
322 | stmt.label = this.visitLabelIdentifier(stmt.label);
|
323 | stmt.body = this.visitStatement(stmt.body);
|
324 | return stmt;
|
325 | }
|
326 | visitForStatement(stmt) {
|
327 | if (stmt.init) {
|
328 | if (stmt.init.type === "VariableDeclaration") {
|
329 | stmt.init = this.visitVariableDeclaration(stmt.init);
|
330 | }
|
331 | else {
|
332 | stmt.init = this.visitOptionalExpression(stmt.init);
|
333 | }
|
334 | }
|
335 | stmt.test = this.visitOptionalExpression(stmt.test);
|
336 | stmt.update = this.visitOptionalExpression(stmt.update);
|
337 | stmt.body = this.visitStatement(stmt.body);
|
338 | return stmt;
|
339 | }
|
340 | visitForOfStatement(stmt) {
|
341 | if (stmt.left.type === "VariableDeclaration") {
|
342 | stmt.left = this.visitVariableDeclaration(stmt.left);
|
343 | }
|
344 | else {
|
345 | stmt.left = this.visitPattern(stmt.left);
|
346 | }
|
347 | stmt.right = this.visitExpression(stmt.right);
|
348 | stmt.body = this.visitStatement(stmt.body);
|
349 | return stmt;
|
350 | }
|
351 | visitForInStatement(stmt) {
|
352 | if (stmt.left.type === "VariableDeclaration") {
|
353 | stmt.left = this.visitVariableDeclaration(stmt.left);
|
354 | }
|
355 | else {
|
356 | stmt.left = this.visitPattern(stmt.left);
|
357 | }
|
358 | stmt.right = this.visitExpression(stmt.right);
|
359 | stmt.body = this.visitStatement(stmt.body);
|
360 | return stmt;
|
361 | }
|
362 | visitEmptyStatement(stmt) {
|
363 | return stmt;
|
364 | }
|
365 | visitDoWhileStatement(stmt) {
|
366 | stmt.body = this.visitStatement(stmt.body);
|
367 | stmt.test = this.visitExpression(stmt.test);
|
368 | return stmt;
|
369 | }
|
370 | visitDebuggerStatement(stmt) {
|
371 | return stmt;
|
372 | }
|
373 | visitWithStatement(stmt) {
|
374 | stmt.object = this.visitExpression(stmt.object);
|
375 | stmt.body = this.visitStatement(stmt.body);
|
376 | return stmt;
|
377 | }
|
378 | visitDeclaration(decl) {
|
379 | switch (decl.type) {
|
380 | case "ClassDeclaration":
|
381 | return this.visitClassDeclartion(decl);
|
382 | case "FunctionDeclaration":
|
383 | return this.visitFunctionDeclaration(decl);
|
384 | case "TsEnumDeclaration":
|
385 | return this.visitTsEnumDeclaration(decl);
|
386 | case "TsInterfaceDeclaration":
|
387 | return this.visitTsInterfaceDeclaration(decl);
|
388 | case "TsModuleDeclaration":
|
389 | return this.visitTsModuleDeclaration(decl);
|
390 | case "TsTypeAliasDeclaration":
|
391 | return this.visitTsTypeAliasDeclaration(decl);
|
392 | case "VariableDeclaration":
|
393 | return this.visitVariableDeclaration(decl);
|
394 | }
|
395 | }
|
396 | visitVariableDeclaration(n) {
|
397 | n.declarations = this.visitVariableDeclarators(n.declarations);
|
398 | return n;
|
399 | }
|
400 | visitVariableDeclarators(nodes) {
|
401 | return nodes.map(this.visitVariableDeclarator.bind(this));
|
402 | }
|
403 | visitVariableDeclarator(n) {
|
404 | n.id = this.visitPattern(n.id);
|
405 | n.init = this.visitOptionalExpression(n.init);
|
406 | return n;
|
407 | }
|
408 | visitTsTypeAliasDeclaration(n) {
|
409 | n.id = this.visitBindingIdentifier(n.id);
|
410 | n.typeAnnotation = this.visitTsType(n.typeAnnotation);
|
411 | n.typeParams = this.visitTsTypeParameterDeclaration(n.typeParams);
|
412 | return n;
|
413 | }
|
414 | visitTsModuleDeclaration(n) {
|
415 | n.id = this.visitTsModuleName(n.id);
|
416 | if (n.body) {
|
417 | n.body = this.visitTsNamespaceBody(n.body);
|
418 | }
|
419 | return n;
|
420 | }
|
421 | visitTsModuleName(n) {
|
422 | switch (n.type) {
|
423 | case "Identifier":
|
424 | return this.visitBindingIdentifier(n);
|
425 | case "StringLiteral":
|
426 | return this.visitStringLiteral(n);
|
427 | }
|
428 | }
|
429 | visitTsNamespaceBody(n) {
|
430 | if (n) {
|
431 | switch (n.type) {
|
432 | case "TsModuleBlock":
|
433 | return this.visitTsModuleBlock(n);
|
434 | case "TsNamespaceDeclaration":
|
435 | return this.visitTsNamespaceDeclaration(n);
|
436 | }
|
437 | }
|
438 | }
|
439 | visitTsNamespaceDeclaration(n) {
|
440 | const body = this.visitTsNamespaceBody(n.body);
|
441 | if (body) {
|
442 | n.body = body;
|
443 | }
|
444 | n.id = this.visitBindingIdentifier(n.id);
|
445 | return n;
|
446 | }
|
447 | visitTsModuleBlock(n) {
|
448 | n.body = this.visitModuleItems(n.body);
|
449 | return n;
|
450 | }
|
451 | visitTsInterfaceDeclaration(n) {
|
452 | n.id = this.visitBindingIdentifier(n.id);
|
453 | n.typeParams = this.visitTsTypeParameterDeclaration(n.typeParams);
|
454 | n.extends = this.visitTsExpressionsWithTypeArguments(n.extends);
|
455 | n.body = this.visitTsInterfaceBody(n.body);
|
456 | return n;
|
457 | }
|
458 | visitTsInterfaceBody(n) {
|
459 | n.body = this.visitTsTypeElements(n.body);
|
460 | return n;
|
461 | }
|
462 | visitTsTypeElements(nodes) {
|
463 | return nodes.map(this.visitTsTypeElement.bind(this));
|
464 | }
|
465 | visitTsTypeElement(n) {
|
466 | n.params = this.visitTsFnParameters(n.params);
|
467 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
468 | return n;
|
469 | }
|
470 | visitTsEnumDeclaration(n) {
|
471 | n.id = this.visitIdentifier(n.id);
|
472 | n.member = this.visitTsEnumMembers(n.member);
|
473 | return n;
|
474 | }
|
475 | visitTsEnumMembers(nodes) {
|
476 | return nodes.map(this.visitTsEnumMember.bind(this));
|
477 | }
|
478 | visitTsEnumMember(n) {
|
479 | n.id = this.visitTsEnumMemberId(n.id);
|
480 | n.init = this.visitOptionalExpression(n.init);
|
481 | return n;
|
482 | }
|
483 | visitTsEnumMemberId(n) {
|
484 | switch (n.type) {
|
485 | case "Identifier":
|
486 | return this.visitBindingIdentifier(n);
|
487 | case "StringLiteral":
|
488 | return this.visitStringLiteral(n);
|
489 | }
|
490 | }
|
491 | visitFunctionDeclaration(decl) {
|
492 | decl.ident = this.visitIdentifier(decl.ident);
|
493 | decl = this.visitFunction(decl);
|
494 | return decl;
|
495 | }
|
496 | visitClassDeclartion(decl) {
|
497 | decl = this.visitClass(decl);
|
498 | decl.identifier = this.visitIdentifier(decl.identifier);
|
499 | return decl;
|
500 | }
|
501 | visitClassBody(members) {
|
502 | return members.map(this.visitClassMember.bind(this));
|
503 | }
|
504 | visitClassMember(member) {
|
505 | switch (member.type) {
|
506 | case "ClassMethod":
|
507 | return this.visitClassMethod(member);
|
508 | case "ClassProperty":
|
509 | return this.visitClassProperty(member);
|
510 | case "Constructor":
|
511 | return this.visitConstructor(member);
|
512 | case "PrivateMethod":
|
513 | return this.visitPrivateMethod(member);
|
514 | case "PrivateProperty":
|
515 | return this.visitPrivateProperty(member);
|
516 | case "TsIndexSignature":
|
517 | return this.visitTsIndexSignature(member);
|
518 | }
|
519 | }
|
520 | visitTsIndexSignature(n) {
|
521 | n.params = this.visitTsFnParameters(n.params);
|
522 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
523 | return n;
|
524 | }
|
525 | visitTsFnParameters(params) {
|
526 | return params.map(this.visitTsFnParameter.bind(this));
|
527 | }
|
528 | visitTsFnParameter(n) {
|
529 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
530 | return n;
|
531 | }
|
532 | visitPrivateProperty(n) {
|
533 | n.decorators = this.visitDecorators(n.decorators);
|
534 | n.key = this.visitPrivateName(n.key);
|
535 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
536 | n.value = this.visitOptionalExpression(n.value);
|
537 | return n;
|
538 | }
|
539 | visitPrivateMethod(n) {
|
540 | n.accessibility = this.visitAccessibility(n.accessibility);
|
541 | n.function = this.visitFunction(n.function);
|
542 | n.key = this.visitPrivateName(n.key);
|
543 | return n;
|
544 | }
|
545 | visitPrivateName(n) {
|
546 | return n;
|
547 | }
|
548 | visitConstructor(n) {
|
549 | n.accessibility = this.visitAccessibility(n.accessibility);
|
550 | n.key = this.visitPropertyName(n.key);
|
551 | n.params = this.visitConstructorParameters(n.params);
|
552 | if (n.body) {
|
553 | n.body = this.visitBlockStatement(n.body);
|
554 | }
|
555 | return n;
|
556 | }
|
557 | visitConstructorParameters(nodes) {
|
558 | return nodes.map(this.visitConstructorParameter.bind(this));
|
559 | }
|
560 | visitConstructorParameter(n) {
|
561 | switch (n.type) {
|
562 | case "TsParameterProperty":
|
563 | return this.visitTsParameterProperty(n);
|
564 | default:
|
565 | return this.visitParameter(n);
|
566 | }
|
567 | }
|
568 | visitTsParameterProperty(n) {
|
569 | n.accessibility = this.visitAccessibility(n.accessibility);
|
570 | n.decorators = this.visitDecorators(n.decorators);
|
571 | n.param = this.visitTsParameterPropertyParameter(n.param);
|
572 | return n;
|
573 | }
|
574 | visitTsParameterPropertyParameter(n) {
|
575 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
576 | return n;
|
577 | }
|
578 | visitPropertyName(key) {
|
579 | switch (key.type) {
|
580 | case "Identifier":
|
581 | return this.visitBindingIdentifier(key);
|
582 | case "StringLiteral":
|
583 | return this.visitStringLiteral(key);
|
584 | case "NumericLiteral":
|
585 | return this.visitNumericLiteral(key);
|
586 | default:
|
587 | return this.visitComputedPropertyKey(key);
|
588 | }
|
589 | }
|
590 | visitAccessibility(n) {
|
591 | return n;
|
592 | }
|
593 | visitClassProperty(n) {
|
594 | n.accessibility = this.visitAccessibility(n.accessibility);
|
595 | n.decorators = this.visitDecorators(n.decorators);
|
596 | n.key = this.visitExpression(n.key);
|
597 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
598 | n.value = this.visitOptionalExpression(n.value);
|
599 | return n;
|
600 | }
|
601 | visitClassMethod(n) {
|
602 | n.accessibility = this.visitAccessibility(n.accessibility);
|
603 | n.function = this.visitFunction(n.function);
|
604 | n.key = this.visitPropertyName(n.key);
|
605 | return n;
|
606 | }
|
607 | visitPropertName(n) {
|
608 | switch (n.type) {
|
609 | case "Identifier":
|
610 | return this.visitIdentifier(n);
|
611 | case "NumericLiteral":
|
612 | return this.visitNumericLiteral(n);
|
613 | case "StringLiteral":
|
614 | return this.visitStringLiteral(n);
|
615 | case "Computed":
|
616 | return this.visitComputedPropertyKey(n);
|
617 | }
|
618 | }
|
619 | visitComputedPropertyKey(n) {
|
620 | n.expression = this.visitExpression(n.expression);
|
621 | return n;
|
622 | }
|
623 | visitClass(n) {
|
624 | n.decorators = this.visitDecorators(n.decorators);
|
625 | n.superClass = this.visitOptionalExpression(n.superClass);
|
626 | n.superTypeParams = this.visitTsTypeParameterInstantiation(n.superTypeParams);
|
627 | if (n.implements) {
|
628 | n.implements = this.visitTsExpressionsWithTypeArguments(n.implements);
|
629 | }
|
630 | n.body = this.visitClassBody(n.body);
|
631 | return n;
|
632 | }
|
633 | visitFunction(n) {
|
634 | n.decorators = this.visitDecorators(n.decorators);
|
635 | n.params = this.visitParameters(n.params);
|
636 | if (n.body) {
|
637 | n.body = this.visitBlockStatement(n.body);
|
638 | }
|
639 | n.returnType = this.visitTsTypeAnnotation(n.returnType);
|
640 | n.typeParameters = this.visitTsTypeParameterDeclaration(n.typeParameters);
|
641 | return n;
|
642 | }
|
643 | visitTsExpressionsWithTypeArguments(nodes) {
|
644 | return nodes.map(this.visitTsExpressionWithTypeArguments.bind(this));
|
645 | }
|
646 | visitTsExpressionWithTypeArguments(n) {
|
647 | n.expression = this.visitTsEntityName(n.expression);
|
648 | n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
|
649 | return n;
|
650 | }
|
651 | visitTsTypeParameterInstantiation(n) {
|
652 | if (n) {
|
653 | n.params = this.visitTsTypes(n.params);
|
654 | }
|
655 | return n;
|
656 | }
|
657 | visitTsTypes(nodes) {
|
658 | return nodes.map(this.visitTsType.bind(this));
|
659 | }
|
660 | visitTsEntityName(n) {
|
661 | switch (n.type) {
|
662 | case "Identifier":
|
663 | return this.visitBindingIdentifier(n);
|
664 | case "TsQualifiedName":
|
665 | return this.visitTsQualifiedName(n);
|
666 | }
|
667 | }
|
668 | visitTsQualifiedName(n) {
|
669 | n.left = this.visitTsEntityName(n.left);
|
670 | n.right = this.visitIdentifier(n.right);
|
671 | return n;
|
672 | }
|
673 | visitDecorators(nodes) {
|
674 | if (nodes) {
|
675 | return nodes.map(this.visitDecorator.bind(this));
|
676 | }
|
677 | }
|
678 | visitDecorator(n) {
|
679 | n.expression = this.visitExpression(n.expression);
|
680 | return n;
|
681 | }
|
682 | visitExpressionStatement(stmt) {
|
683 | stmt.expression = this.visitExpression(stmt.expression);
|
684 | return stmt;
|
685 | }
|
686 | visitContinueStatement(stmt) {
|
687 | if (stmt.label) {
|
688 | stmt.label = this.visitLabelIdentifier(stmt.label);
|
689 | }
|
690 | return stmt;
|
691 | }
|
692 | visitExpression(n) {
|
693 | switch (n.type) {
|
694 | case "ArrayExpression":
|
695 | return this.visitArrayExpression(n);
|
696 | case "ArrowFunctionExpression":
|
697 | return this.visitArrowFunctionExpression(n);
|
698 | case "AssignmentExpression":
|
699 | return this.visitAssignmentExpression(n);
|
700 | case "AwaitExpression":
|
701 | return this.visitAwaitExpression(n);
|
702 | case "BinaryExpression":
|
703 | return this.visitBinaryExpression(n);
|
704 | case "BooleanLiteral":
|
705 | return this.visitBooleanLiteral(n);
|
706 | case "CallExpression":
|
707 | return this.visitCallExpression(n);
|
708 | case "ClassExpression":
|
709 | return this.visitClassExpression(n);
|
710 | case "ConditionalExpression":
|
711 | return this.visitConditionalExpression(n);
|
712 | case "FunctionExpression":
|
713 | return this.visitFunctionExpression(n);
|
714 | case "Identifier":
|
715 | return this.visitIdentifierReference(n);
|
716 | case "JSXElement":
|
717 | return this.visitJSXElement(n);
|
718 | case "JSXEmptyExpression":
|
719 | return this.visitJSXEmptyExpression(n);
|
720 | case "JSXFragment":
|
721 | return this.visitJSXFragment(n);
|
722 | case "JSXMemberExpression":
|
723 | return this.visitJSXMemberExpression(n);
|
724 | case "JSXNamespacedName":
|
725 | return this.visitJSXNamespacedName(n);
|
726 | case "JSXText":
|
727 | return this.visitJSXText(n);
|
728 | case "MemberExpression":
|
729 | return this.visitMemberExpression(n);
|
730 | case "MetaProperty":
|
731 | return this.visitMetaProperty(n);
|
732 | case "NewExpression":
|
733 | return this.visitNewExpression(n);
|
734 | case "NullLiteral":
|
735 | return this.visitNullLiteral(n);
|
736 | case "NumericLiteral":
|
737 | return this.visitNumericLiteral(n);
|
738 | case "ObjectExpression":
|
739 | return this.visitObjectExpression(n);
|
740 | case "ParenthesisExpression":
|
741 | return this.visitParenthesisExpression(n);
|
742 | case "PrivateName":
|
743 | return this.visitPrivateName(n);
|
744 | case "RegExpLiteral":
|
745 | return this.visitRegExpLiteral(n);
|
746 | case "SequenceExpression":
|
747 | return this.visitSequenceExpression(n);
|
748 | case "StringLiteral":
|
749 | return this.visitStringLiteral(n);
|
750 | case "TaggedTemplateExpression":
|
751 | return this.visitTaggedTemplateExpression(n);
|
752 | case "TemplateLiteral":
|
753 | return this.visitTemplateLiteral(n);
|
754 | case "ThisExpression":
|
755 | return this.visitThisExpression(n);
|
756 | case "TsAsExpression":
|
757 | return this.visitTsAsExpression(n);
|
758 | case "TsNonNullExpression":
|
759 | return this.visitTsNonNullExpression(n);
|
760 | case "TsTypeAssertion":
|
761 | return this.visitTsTypeAssertion(n);
|
762 | case "TsTypeCastExpression":
|
763 | return this.visitTsTypeCastExpression(n);
|
764 | case "UnaryExpression":
|
765 | return this.visitUnaryExpression(n);
|
766 | case "UpdateExpression":
|
767 | return this.visitUpdateExpression(n);
|
768 | case "YieldExpression":
|
769 | return this.visitYieldExpression(n);
|
770 | case "OptionalChainingExpression":
|
771 | return this.visitOptionalChainingExpression(n);
|
772 | case "Invalid":
|
773 | return n;
|
774 | }
|
775 | }
|
776 | visitOptionalChainingExpression(n) {
|
777 | n.expr = this.visitExpression(n.expr);
|
778 | return n;
|
779 | }
|
780 | visitAssignmentExpression(n) {
|
781 | n.left = this.visitPatternOrExpressison(n.left);
|
782 | n.right = this.visitExpression(n.right);
|
783 | return n;
|
784 | }
|
785 | visitPatternOrExpressison(n) {
|
786 | switch (n.type) {
|
787 | case "ObjectPattern":
|
788 | case "ArrayPattern":
|
789 | case "Identifier":
|
790 | case "AssignmentPattern":
|
791 | case "RestElement":
|
792 | return this.visitPattern(n);
|
793 | default:
|
794 | return this.visitExpression(n);
|
795 | }
|
796 | }
|
797 | visitYieldExpression(n) {
|
798 | n.argument = this.visitOptionalExpression(n.argument);
|
799 | return n;
|
800 | }
|
801 | visitUpdateExpression(n) {
|
802 | n.argument = this.visitExpression(n.argument);
|
803 | return n;
|
804 | }
|
805 | visitUnaryExpression(n) {
|
806 | n.argument = this.visitExpression(n.argument);
|
807 | return n;
|
808 | }
|
809 | visitTsTypeCastExpression(n) {
|
810 | n.expression = this.visitExpression(n.expression);
|
811 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
812 | return n;
|
813 | }
|
814 | visitTsTypeAssertion(n) {
|
815 | n.expression = this.visitExpression(n.expression);
|
816 | n.typeAnnotation = this.visitTsType(n.typeAnnotation);
|
817 | return n;
|
818 | }
|
819 | visitTsNonNullExpression(n) {
|
820 | n.expression = this.visitExpression(n.expression);
|
821 | return n;
|
822 | }
|
823 | visitTsAsExpression(n) {
|
824 | n.expression = this.visitExpression(n.expression);
|
825 | n.typeAnnotation = this.visitTsType(n.typeAnnotation);
|
826 | return n;
|
827 | }
|
828 | visitThisExpression(n) {
|
829 | return n;
|
830 | }
|
831 | visitTemplateLiteral(n) {
|
832 | n.expressions = n.expressions.map(this.visitExpression.bind(this));
|
833 | return n;
|
834 | }
|
835 | visitParameters(n) {
|
836 | return n.map(this.visitParameter.bind(this));
|
837 | }
|
838 | visitParameter(n) {
|
839 | n.pat = this.visitPattern(n.pat);
|
840 | return n;
|
841 | }
|
842 | visitTaggedTemplateExpression(n) {
|
843 | n.tag = this.visitExpression(n.tag);
|
844 | n.expressions = n.expressions.map(this.visitExpression.bind(this));
|
845 | return n;
|
846 | }
|
847 | visitSequenceExpression(n) {
|
848 | n.expressions = n.expressions.map(this.visitExpression.bind(this));
|
849 | return n;
|
850 | }
|
851 | visitRegExpLiteral(n) {
|
852 | return n;
|
853 | }
|
854 | visitParenthesisExpression(n) {
|
855 | n.expression = this.visitExpression(n.expression);
|
856 | return n;
|
857 | }
|
858 | visitObjectExpression(n) {
|
859 | if (n.properties) {
|
860 | n.properties = this.visitObjectProperties(n.properties);
|
861 | }
|
862 | return n;
|
863 | }
|
864 | visitObjectProperties(nodes) {
|
865 | return nodes.map(this.visitObjectProperty.bind(this));
|
866 | }
|
867 | visitObjectProperty(n) {
|
868 | switch (n.type) {
|
869 | case "SpreadElement":
|
870 | return this.visitSpreadElement(n);
|
871 | default:
|
872 | return this.visitProperty(n);
|
873 | }
|
874 | }
|
875 | visitProperty(n) {
|
876 | switch (n.type) {
|
877 | case "Identifier":
|
878 | return this.visitIdentifier(n);
|
879 | case "AssignmentProperty":
|
880 | return this.visitAssignmentProperty(n);
|
881 | case "GetterProperty":
|
882 | return this.visitGetterProperty(n);
|
883 | case "KeyValueProperty":
|
884 | return this.visitKeyValueProperty(n);
|
885 | case "MethodProperty":
|
886 | return this.visitMethodProperty(n);
|
887 | case "SetterProperty":
|
888 | return this.visitSetterProperty(n);
|
889 | }
|
890 | }
|
891 | visitSetterProperty(n) {
|
892 | n.key = this.visitPropertyName(n.key);
|
893 | n.param = this.visitPattern(n.param);
|
894 | if (n.body) {
|
895 | n.body = this.visitBlockStatement(n.body);
|
896 | }
|
897 | return n;
|
898 | }
|
899 | visitMethodProperty(n) {
|
900 | n.key = this.visitPropertyName(n.key);
|
901 | if (n.body) {
|
902 | n.body = this.visitBlockStatement(n.body);
|
903 | }
|
904 | n.decorators = this.visitDecorators(n.decorators);
|
905 | n.params = this.visitParameters(n.params);
|
906 | n.returnType = this.visitTsTypeAnnotation(n.returnType);
|
907 | n.typeParameters = this.visitTsTypeParameterDeclaration(n.typeParameters);
|
908 | return n;
|
909 | }
|
910 | visitKeyValueProperty(n) {
|
911 | n.key = this.visitPropertyName(n.key);
|
912 | n.value = this.visitExpression(n.value);
|
913 | return n;
|
914 | }
|
915 | visitGetterProperty(n) {
|
916 | n.key = this.visitPropertyName(n.key);
|
917 | if (n.body) {
|
918 | n.body = this.visitBlockStatement(n.body);
|
919 | }
|
920 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
921 | return n;
|
922 | }
|
923 | visitAssignmentProperty(n) {
|
924 | n.key = this.visitIdentifier(n.key);
|
925 | n.value = this.visitExpression(n.value);
|
926 | return n;
|
927 | }
|
928 | visitNullLiteral(n) {
|
929 | return n;
|
930 | }
|
931 | visitNewExpression(n) {
|
932 | n.callee = this.visitExpression(n.callee);
|
933 | if (n.arguments) {
|
934 | n.arguments = this.visitArguments(n.arguments);
|
935 | }
|
936 | n.typeArguments = this.visitTsTypeArguments(n.typeArguments);
|
937 | return n;
|
938 | }
|
939 | visitTsTypeArguments(n) {
|
940 | if (n) {
|
941 | n.params = this.visitTsTypes(n.params);
|
942 | }
|
943 | return n;
|
944 | }
|
945 | visitArguments(nodes) {
|
946 | return nodes.map(this.visitArgument.bind(this));
|
947 | }
|
948 | visitArgument(n) {
|
949 | n.expression = this.visitExpression(n.expression);
|
950 | return n;
|
951 | }
|
952 | visitMetaProperty(n) {
|
953 | n.meta = this.visitIdentifierReference(n.meta);
|
954 | n.property = this.visitIdentifier(n.property);
|
955 | return n;
|
956 | }
|
957 | visitMemberExpression(n) {
|
958 | n.object = this.visitExpressionOrSuper(n.object);
|
959 | n.property = this.visitExpression(n.property);
|
960 | return n;
|
961 | }
|
962 | visitExpressionOrSuper(n) {
|
963 | if (n.type === "Super") {
|
964 | return n;
|
965 | }
|
966 | return this.visitExpression(n);
|
967 | }
|
968 | visitJSXText(n) {
|
969 | return n;
|
970 | }
|
971 | visitJSXNamespacedName(n) {
|
972 | n.namespace = this.visitIdentifierReference(n.namespace);
|
973 | n.name = this.visitIdentifierReference(n.name);
|
974 | return n;
|
975 | }
|
976 | visitJSXMemberExpression(n) {
|
977 | n.object = this.visitJSXObject(n.object);
|
978 | n.property = this.visitIdentifierReference(n.property);
|
979 | return n;
|
980 | }
|
981 | visitJSXObject(n) {
|
982 | switch (n.type) {
|
983 | case "Identifier":
|
984 | return this.visitIdentifierReference(n);
|
985 | case "JSXMemberExpression":
|
986 | return this.visitJSXMemberExpression(n);
|
987 | }
|
988 | }
|
989 | visitJSXFragment(n) {
|
990 | n.opening = this.visitJSXOpeningFragment(n.opening);
|
991 | if (n.children) {
|
992 | n.children = this.visitJSXElementChildren(n.children);
|
993 | }
|
994 | n.closing = this.visitJSXClosingFragment(n.closing);
|
995 | return n;
|
996 | }
|
997 | visitJSXClosingFragment(n) {
|
998 | return n;
|
999 | }
|
1000 | visitJSXElementChildren(nodes) {
|
1001 | return nodes.map(this.visitJSXElementChild.bind(this));
|
1002 | }
|
1003 | visitJSXElementChild(n) {
|
1004 | switch (n.type) {
|
1005 | case "JSXElement":
|
1006 | return this.visitJSXElement(n);
|
1007 | case "JSXExpressionContainer":
|
1008 | return this.visitJSXExpressionContainer(n);
|
1009 | case "JSXFragment":
|
1010 | return this.visitJSXFragment(n);
|
1011 | case "JSXSpreadChild":
|
1012 | return this.visitJSXSpreadChild(n);
|
1013 | case "JSXText":
|
1014 | return this.visitJSXText(n);
|
1015 | }
|
1016 | }
|
1017 | visitJSXExpressionContainer(n) {
|
1018 | n.expression = this.visitExpression(n.expression);
|
1019 | return n;
|
1020 | }
|
1021 | visitJSXSpreadChild(n) {
|
1022 | n.expression = this.visitExpression(n.expression);
|
1023 | return n;
|
1024 | }
|
1025 | visitJSXOpeningFragment(n) {
|
1026 | return n;
|
1027 | }
|
1028 | visitJSXEmptyExpression(n) {
|
1029 | return n;
|
1030 | }
|
1031 | visitJSXElement(n) {
|
1032 | n.opening = this.visitJSXOpeningElement(n.opening);
|
1033 | n.children = this.visitJSXElementChildren(n.children);
|
1034 | n.closing = this.visitJSXClosingElement(n.closing);
|
1035 | return n;
|
1036 | }
|
1037 | visitJSXClosingElement(n) {
|
1038 | if (n) {
|
1039 | n.name = this.visitJSXElementName(n.name);
|
1040 | }
|
1041 | return n;
|
1042 | }
|
1043 | visitJSXElementName(n) {
|
1044 | switch (n.type) {
|
1045 | case "Identifier":
|
1046 | return this.visitIdentifierReference(n);
|
1047 | case "JSXMemberExpression":
|
1048 | return this.visitJSXMemberExpression(n);
|
1049 | case "JSXNamespacedName":
|
1050 | return this.visitJSXNamespacedName(n);
|
1051 | }
|
1052 | }
|
1053 | visitJSXOpeningElement(n) {
|
1054 | n.name = this.visitJSXElementName(n.name);
|
1055 | n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
|
1056 | n.attrs = this.visitJSXAttributes(n.attrs);
|
1057 | return n;
|
1058 | }
|
1059 | visitJSXAttributes(attrs) {
|
1060 | if (attrs)
|
1061 | return attrs.map(this.visitJSXAttributeOrSpread.bind(this));
|
1062 | }
|
1063 | visitJSXAttributeOrSpread(n) {
|
1064 | switch (n.type) {
|
1065 | case "JSXAttribute":
|
1066 | return this.visitJSXAttribute(n);
|
1067 | case "SpreadElement":
|
1068 | return this.visitSpreadElement(n);
|
1069 | }
|
1070 | }
|
1071 | visitJSXAttribute(n) {
|
1072 | n.name = this.visitJSXAttributeName(n.name);
|
1073 | n.value = this.visitJSXAttributeValue(n.value);
|
1074 | return n;
|
1075 | }
|
1076 | visitJSXAttributeValue(n) {
|
1077 | if (!n)
|
1078 | return n;
|
1079 | switch (n.type) {
|
1080 | case "BooleanLiteral":
|
1081 | return this.visitBooleanLiteral(n);
|
1082 | case "NullLiteral":
|
1083 | return this.visitNullLiteral(n);
|
1084 | case "NumericLiteral":
|
1085 | return this.visitNumericLiteral(n);
|
1086 | case "JSXText":
|
1087 | return this.visitJSXText(n);
|
1088 | case "StringLiteral":
|
1089 | return this.visitStringLiteral(n);
|
1090 | case "JSXElement":
|
1091 | return this.visitJSXElement(n);
|
1092 | case "JSXExpressionContainer":
|
1093 | return this.visitJSXExpressionContainer(n);
|
1094 | case "JSXFragment":
|
1095 | return this.visitJSXFragment(n);
|
1096 | }
|
1097 | return n;
|
1098 | }
|
1099 | visitJSXAttributeName(n) {
|
1100 | switch (n.type) {
|
1101 | case "Identifier":
|
1102 | return this.visitIdentifierReference(n);
|
1103 | case "JSXNamespacedName":
|
1104 | return this.visitJSXNamespacedName(n);
|
1105 | }
|
1106 | }
|
1107 | visitConditionalExpression(n) {
|
1108 | n.test = this.visitExpression(n.test);
|
1109 | n.consequent = this.visitExpression(n.consequent);
|
1110 | n.alternate = this.visitExpression(n.alternate);
|
1111 | return n;
|
1112 | }
|
1113 | visitCallExpression(n) {
|
1114 | n.callee = this.visitExpressionOrSuper(n.callee);
|
1115 | n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
|
1116 | if (n.arguments) {
|
1117 | n.arguments = this.visitArguments(n.arguments);
|
1118 | }
|
1119 | return n;
|
1120 | }
|
1121 | visitBooleanLiteral(n) {
|
1122 | return n;
|
1123 | }
|
1124 | visitBinaryExpression(n) {
|
1125 | n.left = this.visitExpression(n.left);
|
1126 | n.right = this.visitExpression(n.right);
|
1127 | return n;
|
1128 | }
|
1129 | visitAwaitExpression(n) {
|
1130 | n.argument = this.visitExpression(n.argument);
|
1131 | return n;
|
1132 | }
|
1133 | visitTsTypeParameterDeclaration(n) {
|
1134 | if (n) {
|
1135 | n.parameters = this.visitTsTypeParameters(n.parameters);
|
1136 | }
|
1137 | return n;
|
1138 | }
|
1139 | visitTsTypeParameters(nodes) {
|
1140 | return nodes.map(this.visitTsTypeParameter.bind(this));
|
1141 | }
|
1142 | visitTsTypeParameter(n) {
|
1143 | if (n.constraint) {
|
1144 | n.constraint = this.visitTsType(n.constraint);
|
1145 | }
|
1146 | if (n.default) {
|
1147 | n.default = this.visitTsType(n.default);
|
1148 | }
|
1149 | n.name = this.visitIdentifierReference(n.name);
|
1150 | return n;
|
1151 | }
|
1152 | visitTsTypeAnnotation(a) {
|
1153 | if (a) {
|
1154 | a.typeAnnotation = this.visitTsType(a.typeAnnotation);
|
1155 | }
|
1156 | return a;
|
1157 | }
|
1158 | visitTsType(n) {
|
1159 | throw new Error("Method visitTsType not implemented.");
|
1160 | }
|
1161 | visitPatterns(nodes) {
|
1162 | return nodes.map(this.visitPattern.bind(this));
|
1163 | }
|
1164 | visitImportDeclaration(n) {
|
1165 | n.source = this.visitStringLiteral(n.source);
|
1166 | n.specifiers = this.visitImportSpecifiers(n.specifiers || []);
|
1167 | return n;
|
1168 | }
|
1169 | visitImportSpecifiers(nodes) {
|
1170 | return nodes.map(this.visitImportSpecifier.bind(this));
|
1171 | }
|
1172 | visitImportSpecifier(node) {
|
1173 | switch (node.type) {
|
1174 | case "ImportDefaultSpecifier":
|
1175 | return this.visitImportDefaultSpecifier(node);
|
1176 | case "ImportNamespaceSpecifier":
|
1177 | return this.visitImportNamespaceSpecifier(node);
|
1178 | case "ImportSpecifier":
|
1179 | return this.visitNamedImportSpecifier(node);
|
1180 | }
|
1181 | }
|
1182 | visitNamedImportSpecifier(node) {
|
1183 | node.local = this.visitBindingIdentifier(node.local);
|
1184 | if (node.imported) {
|
1185 | node.imported = this.visitIdentifierReference(node.imported);
|
1186 | }
|
1187 | return node;
|
1188 | }
|
1189 | visitImportNamespaceSpecifier(node) {
|
1190 | node.local = this.visitBindingIdentifier(node.local);
|
1191 | return node;
|
1192 | }
|
1193 | visitImportDefaultSpecifier(node) {
|
1194 | node.local = this.visitBindingIdentifier(node.local);
|
1195 | return node;
|
1196 | }
|
1197 | visitBindingIdentifier(i) {
|
1198 | return this.visitIdentifier(i);
|
1199 | }
|
1200 | visitIdentifierReference(i) {
|
1201 | return this.visitIdentifier(i);
|
1202 | }
|
1203 | visitLabelIdentifier(label) {
|
1204 | return this.visitIdentifier(label);
|
1205 | }
|
1206 | visitIdentifier(n) {
|
1207 | return n;
|
1208 | }
|
1209 | visitStringLiteral(n) {
|
1210 | return n;
|
1211 | }
|
1212 | visitNumericLiteral(n) {
|
1213 | return n;
|
1214 | }
|
1215 | visitPattern(n) {
|
1216 | switch (n.type) {
|
1217 | case "Identifier":
|
1218 | return this.visitBindingIdentifier(n);
|
1219 | case "ArrayPattern":
|
1220 | return this.visitArrayPattern(n);
|
1221 | case "ObjectPattern":
|
1222 | return this.visitObjectPattern(n);
|
1223 | case "AssignmentPattern":
|
1224 | return this.visitAssignmentPattern(n);
|
1225 | case "RestElement":
|
1226 | return this.visitRestElement(n);
|
1227 | default:
|
1228 | return this.visitExpression(n);
|
1229 | }
|
1230 | }
|
1231 | visitRestElement(n) {
|
1232 | n.argument = this.visitPattern(n.argument);
|
1233 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
1234 | return n;
|
1235 | }
|
1236 | visitAssignmentPattern(n) {
|
1237 | n.left = this.visitPattern(n.left);
|
1238 | n.right = this.visitExpression(n.right);
|
1239 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
1240 | return n;
|
1241 | }
|
1242 | visitObjectPattern(n) {
|
1243 | n.props = this.visitObjectPatternProperties(n.props);
|
1244 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
1245 | return n;
|
1246 | }
|
1247 | visitObjectPatternProperties(nodes) {
|
1248 | return nodes.map(this.visitObjectPatternProperty.bind(this));
|
1249 | }
|
1250 | visitObjectPatternProperty(n) {
|
1251 | switch (n.type) {
|
1252 | case "AssignmentPatternProperty":
|
1253 | return this.visitAssignmentPatternProperty(n);
|
1254 | case "KeyValuePatternProperty":
|
1255 | return this.visitKeyValuePatternProperty(n);
|
1256 | case "RestElement":
|
1257 | return this.visitRestElement(n);
|
1258 | }
|
1259 | }
|
1260 | visitKeyValuePatternProperty(n) {
|
1261 | n.key = this.visitPropertyName(n.key);
|
1262 | n.value = this.visitPattern(n.value);
|
1263 | return n;
|
1264 | }
|
1265 | visitAssignmentPatternProperty(n) {
|
1266 | n.key = this.visitBindingIdentifier(n.key);
|
1267 | n.value = this.visitOptionalExpression(n.value);
|
1268 | return n;
|
1269 | }
|
1270 | visitArrayPattern(n) {
|
1271 | n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
|
1272 | n.elements = this.visitArrayPatternElements(n.elements);
|
1273 | return n;
|
1274 | }
|
1275 | visitArrayPatternElements(nodes) {
|
1276 | return nodes.map(this.visitArrayPatternElement.bind(this));
|
1277 | }
|
1278 | visitArrayPatternElement(n) {
|
1279 | if (n) {
|
1280 | n = this.visitPattern(n);
|
1281 | }
|
1282 | return n;
|
1283 | }
|
1284 | }
|
1285 | exports.default = Visitor;
|