UNPKG

43.1 kBJavaScriptView Raw
1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3class 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 "UnaryExpression":
763 return this.visitUnaryExpression(n);
764 case "UpdateExpression":
765 return this.visitUpdateExpression(n);
766 case "YieldExpression":
767 return this.visitYieldExpression(n);
768 case "OptionalChainingExpression":
769 return this.visitOptionalChainingExpression(n);
770 case "Invalid":
771 return n;
772 }
773 }
774 visitOptionalChainingExpression(n) {
775 n.expr = this.visitExpression(n.expr);
776 return n;
777 }
778 visitAssignmentExpression(n) {
779 n.left = this.visitPatternOrExpressison(n.left);
780 n.right = this.visitExpression(n.right);
781 return n;
782 }
783 visitPatternOrExpressison(n) {
784 switch (n.type) {
785 case "ObjectPattern":
786 case "ArrayPattern":
787 case "Identifier":
788 case "AssignmentPattern":
789 case "RestElement":
790 return this.visitPattern(n);
791 default:
792 return this.visitExpression(n);
793 }
794 }
795 visitYieldExpression(n) {
796 n.argument = this.visitOptionalExpression(n.argument);
797 return n;
798 }
799 visitUpdateExpression(n) {
800 n.argument = this.visitExpression(n.argument);
801 return n;
802 }
803 visitUnaryExpression(n) {
804 n.argument = this.visitExpression(n.argument);
805 return n;
806 }
807 visitTsTypeAssertion(n) {
808 n.expression = this.visitExpression(n.expression);
809 n.typeAnnotation = this.visitTsType(n.typeAnnotation);
810 return n;
811 }
812 visitTsNonNullExpression(n) {
813 n.expression = this.visitExpression(n.expression);
814 return n;
815 }
816 visitTsAsExpression(n) {
817 n.expression = this.visitExpression(n.expression);
818 n.typeAnnotation = this.visitTsType(n.typeAnnotation);
819 return n;
820 }
821 visitThisExpression(n) {
822 return n;
823 }
824 visitTemplateLiteral(n) {
825 n.expressions = n.expressions.map(this.visitExpression.bind(this));
826 return n;
827 }
828 visitParameters(n) {
829 return n.map(this.visitParameter.bind(this));
830 }
831 visitParameter(n) {
832 n.pat = this.visitPattern(n.pat);
833 return n;
834 }
835 visitTaggedTemplateExpression(n) {
836 n.tag = this.visitExpression(n.tag);
837 n.expressions = n.expressions.map(this.visitExpression.bind(this));
838 return n;
839 }
840 visitSequenceExpression(n) {
841 n.expressions = n.expressions.map(this.visitExpression.bind(this));
842 return n;
843 }
844 visitRegExpLiteral(n) {
845 return n;
846 }
847 visitParenthesisExpression(n) {
848 n.expression = this.visitExpression(n.expression);
849 return n;
850 }
851 visitObjectExpression(n) {
852 if (n.properties) {
853 n.properties = this.visitObjectProperties(n.properties);
854 }
855 return n;
856 }
857 visitObjectProperties(nodes) {
858 return nodes.map(this.visitObjectProperty.bind(this));
859 }
860 visitObjectProperty(n) {
861 switch (n.type) {
862 case "SpreadElement":
863 return this.visitSpreadElement(n);
864 default:
865 return this.visitProperty(n);
866 }
867 }
868 visitProperty(n) {
869 switch (n.type) {
870 case "Identifier":
871 return this.visitIdentifier(n);
872 case "AssignmentProperty":
873 return this.visitAssignmentProperty(n);
874 case "GetterProperty":
875 return this.visitGetterProperty(n);
876 case "KeyValueProperty":
877 return this.visitKeyValueProperty(n);
878 case "MethodProperty":
879 return this.visitMethodProperty(n);
880 case "SetterProperty":
881 return this.visitSetterProperty(n);
882 }
883 }
884 visitSetterProperty(n) {
885 n.key = this.visitPropertyName(n.key);
886 n.param = this.visitPattern(n.param);
887 if (n.body) {
888 n.body = this.visitBlockStatement(n.body);
889 }
890 return n;
891 }
892 visitMethodProperty(n) {
893 n.key = this.visitPropertyName(n.key);
894 if (n.body) {
895 n.body = this.visitBlockStatement(n.body);
896 }
897 n.decorators = this.visitDecorators(n.decorators);
898 n.params = this.visitParameters(n.params);
899 n.returnType = this.visitTsTypeAnnotation(n.returnType);
900 n.typeParameters = this.visitTsTypeParameterDeclaration(n.typeParameters);
901 return n;
902 }
903 visitKeyValueProperty(n) {
904 n.key = this.visitPropertyName(n.key);
905 n.value = this.visitExpression(n.value);
906 return n;
907 }
908 visitGetterProperty(n) {
909 n.key = this.visitPropertyName(n.key);
910 if (n.body) {
911 n.body = this.visitBlockStatement(n.body);
912 }
913 n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
914 return n;
915 }
916 visitAssignmentProperty(n) {
917 n.key = this.visitIdentifier(n.key);
918 n.value = this.visitExpression(n.value);
919 return n;
920 }
921 visitNullLiteral(n) {
922 return n;
923 }
924 visitNewExpression(n) {
925 n.callee = this.visitExpression(n.callee);
926 if (n.arguments) {
927 n.arguments = this.visitArguments(n.arguments);
928 }
929 n.typeArguments = this.visitTsTypeArguments(n.typeArguments);
930 return n;
931 }
932 visitTsTypeArguments(n) {
933 if (n) {
934 n.params = this.visitTsTypes(n.params);
935 }
936 return n;
937 }
938 visitArguments(nodes) {
939 return nodes.map(this.visitArgument.bind(this));
940 }
941 visitArgument(n) {
942 n.expression = this.visitExpression(n.expression);
943 return n;
944 }
945 visitMetaProperty(n) {
946 n.meta = this.visitIdentifierReference(n.meta);
947 n.property = this.visitIdentifier(n.property);
948 return n;
949 }
950 visitMemberExpression(n) {
951 n.object = this.visitExpressionOrSuper(n.object);
952 n.property = this.visitExpression(n.property);
953 return n;
954 }
955 visitExpressionOrSuper(n) {
956 if (n.type === "Super") {
957 return n;
958 }
959 return this.visitExpression(n);
960 }
961 visitJSXText(n) {
962 return n;
963 }
964 visitJSXNamespacedName(n) {
965 n.namespace = this.visitIdentifierReference(n.namespace);
966 n.name = this.visitIdentifierReference(n.name);
967 return n;
968 }
969 visitJSXMemberExpression(n) {
970 n.object = this.visitJSXObject(n.object);
971 n.property = this.visitIdentifierReference(n.property);
972 return n;
973 }
974 visitJSXObject(n) {
975 switch (n.type) {
976 case "Identifier":
977 return this.visitIdentifierReference(n);
978 case "JSXMemberExpression":
979 return this.visitJSXMemberExpression(n);
980 }
981 }
982 visitJSXFragment(n) {
983 n.opening = this.visitJSXOpeningFragment(n.opening);
984 if (n.children) {
985 n.children = this.visitJSXElementChildren(n.children);
986 }
987 n.closing = this.visitJSXClosingFragment(n.closing);
988 return n;
989 }
990 visitJSXClosingFragment(n) {
991 return n;
992 }
993 visitJSXElementChildren(nodes) {
994 return nodes.map(this.visitJSXElementChild.bind(this));
995 }
996 visitJSXElementChild(n) {
997 switch (n.type) {
998 case "JSXElement":
999 return this.visitJSXElement(n);
1000 case "JSXExpressionContainer":
1001 return this.visitJSXExpressionContainer(n);
1002 case "JSXFragment":
1003 return this.visitJSXFragment(n);
1004 case "JSXSpreadChild":
1005 return this.visitJSXSpreadChild(n);
1006 case "JSXText":
1007 return this.visitJSXText(n);
1008 }
1009 }
1010 visitJSXExpressionContainer(n) {
1011 n.expression = this.visitExpression(n.expression);
1012 return n;
1013 }
1014 visitJSXSpreadChild(n) {
1015 n.expression = this.visitExpression(n.expression);
1016 return n;
1017 }
1018 visitJSXOpeningFragment(n) {
1019 return n;
1020 }
1021 visitJSXEmptyExpression(n) {
1022 return n;
1023 }
1024 visitJSXElement(n) {
1025 n.opening = this.visitJSXOpeningElement(n.opening);
1026 n.children = this.visitJSXElementChildren(n.children);
1027 n.closing = this.visitJSXClosingElement(n.closing);
1028 return n;
1029 }
1030 visitJSXClosingElement(n) {
1031 if (n) {
1032 n.name = this.visitJSXElementName(n.name);
1033 }
1034 return n;
1035 }
1036 visitJSXElementName(n) {
1037 switch (n.type) {
1038 case "Identifier":
1039 return this.visitIdentifierReference(n);
1040 case "JSXMemberExpression":
1041 return this.visitJSXMemberExpression(n);
1042 case "JSXNamespacedName":
1043 return this.visitJSXNamespacedName(n);
1044 }
1045 }
1046 visitJSXOpeningElement(n) {
1047 n.name = this.visitJSXElementName(n.name);
1048 n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
1049 n.attrs = this.visitJSXAttributes(n.attrs);
1050 return n;
1051 }
1052 visitJSXAttributes(attrs) {
1053 if (attrs)
1054 return attrs.map(this.visitJSXAttributeOrSpread.bind(this));
1055 }
1056 visitJSXAttributeOrSpread(n) {
1057 switch (n.type) {
1058 case "JSXAttribute":
1059 return this.visitJSXAttribute(n);
1060 case "SpreadElement":
1061 return this.visitSpreadElement(n);
1062 }
1063 }
1064 visitJSXAttribute(n) {
1065 n.name = this.visitJSXAttributeName(n.name);
1066 n.value = this.visitJSXAttributeValue(n.value);
1067 return n;
1068 }
1069 visitJSXAttributeValue(n) {
1070 if (!n)
1071 return n;
1072 switch (n.type) {
1073 case "BooleanLiteral":
1074 return this.visitBooleanLiteral(n);
1075 case "NullLiteral":
1076 return this.visitNullLiteral(n);
1077 case "NumericLiteral":
1078 return this.visitNumericLiteral(n);
1079 case "JSXText":
1080 return this.visitJSXText(n);
1081 case "StringLiteral":
1082 return this.visitStringLiteral(n);
1083 case "JSXElement":
1084 return this.visitJSXElement(n);
1085 case "JSXExpressionContainer":
1086 return this.visitJSXExpressionContainer(n);
1087 case "JSXFragment":
1088 return this.visitJSXFragment(n);
1089 }
1090 return n;
1091 }
1092 visitJSXAttributeName(n) {
1093 switch (n.type) {
1094 case "Identifier":
1095 return this.visitIdentifierReference(n);
1096 case "JSXNamespacedName":
1097 return this.visitJSXNamespacedName(n);
1098 }
1099 }
1100 visitConditionalExpression(n) {
1101 n.test = this.visitExpression(n.test);
1102 n.consequent = this.visitExpression(n.consequent);
1103 n.alternate = this.visitExpression(n.alternate);
1104 return n;
1105 }
1106 visitCallExpression(n) {
1107 n.callee = this.visitExpressionOrSuper(n.callee);
1108 n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
1109 if (n.arguments) {
1110 n.arguments = this.visitArguments(n.arguments);
1111 }
1112 return n;
1113 }
1114 visitBooleanLiteral(n) {
1115 return n;
1116 }
1117 visitBinaryExpression(n) {
1118 n.left = this.visitExpression(n.left);
1119 n.right = this.visitExpression(n.right);
1120 return n;
1121 }
1122 visitAwaitExpression(n) {
1123 n.argument = this.visitExpression(n.argument);
1124 return n;
1125 }
1126 visitTsTypeParameterDeclaration(n) {
1127 if (n) {
1128 n.parameters = this.visitTsTypeParameters(n.parameters);
1129 }
1130 return n;
1131 }
1132 visitTsTypeParameters(nodes) {
1133 return nodes.map(this.visitTsTypeParameter.bind(this));
1134 }
1135 visitTsTypeParameter(n) {
1136 if (n.constraint) {
1137 n.constraint = this.visitTsType(n.constraint);
1138 }
1139 if (n.default) {
1140 n.default = this.visitTsType(n.default);
1141 }
1142 n.name = this.visitIdentifierReference(n.name);
1143 return n;
1144 }
1145 visitTsTypeAnnotation(a) {
1146 if (a) {
1147 a.typeAnnotation = this.visitTsType(a.typeAnnotation);
1148 }
1149 return a;
1150 }
1151 visitTsType(n) {
1152 throw new Error("Method visitTsType not implemented.");
1153 }
1154 visitPatterns(nodes) {
1155 return nodes.map(this.visitPattern.bind(this));
1156 }
1157 visitImportDeclaration(n) {
1158 n.source = this.visitStringLiteral(n.source);
1159 n.specifiers = this.visitImportSpecifiers(n.specifiers || []);
1160 return n;
1161 }
1162 visitImportSpecifiers(nodes) {
1163 return nodes.map(this.visitImportSpecifier.bind(this));
1164 }
1165 visitImportSpecifier(node) {
1166 switch (node.type) {
1167 case "ImportDefaultSpecifier":
1168 return this.visitImportDefaultSpecifier(node);
1169 case "ImportNamespaceSpecifier":
1170 return this.visitImportNamespaceSpecifier(node);
1171 case "ImportSpecifier":
1172 return this.visitNamedImportSpecifier(node);
1173 }
1174 }
1175 visitNamedImportSpecifier(node) {
1176 node.local = this.visitBindingIdentifier(node.local);
1177 if (node.imported) {
1178 node.imported = this.visitIdentifierReference(node.imported);
1179 }
1180 return node;
1181 }
1182 visitImportNamespaceSpecifier(node) {
1183 node.local = this.visitBindingIdentifier(node.local);
1184 return node;
1185 }
1186 visitImportDefaultSpecifier(node) {
1187 node.local = this.visitBindingIdentifier(node.local);
1188 return node;
1189 }
1190 visitBindingIdentifier(i) {
1191 return this.visitIdentifier(i);
1192 }
1193 visitIdentifierReference(i) {
1194 return this.visitIdentifier(i);
1195 }
1196 visitLabelIdentifier(label) {
1197 return this.visitIdentifier(label);
1198 }
1199 visitIdentifier(n) {
1200 return n;
1201 }
1202 visitStringLiteral(n) {
1203 return n;
1204 }
1205 visitNumericLiteral(n) {
1206 return n;
1207 }
1208 visitPattern(n) {
1209 switch (n.type) {
1210 case "Identifier":
1211 return this.visitBindingIdentifier(n);
1212 case "ArrayPattern":
1213 return this.visitArrayPattern(n);
1214 case "ObjectPattern":
1215 return this.visitObjectPattern(n);
1216 case "AssignmentPattern":
1217 return this.visitAssignmentPattern(n);
1218 case "RestElement":
1219 return this.visitRestElement(n);
1220 default:
1221 return this.visitExpression(n);
1222 }
1223 }
1224 visitRestElement(n) {
1225 n.argument = this.visitPattern(n.argument);
1226 n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
1227 return n;
1228 }
1229 visitAssignmentPattern(n) {
1230 n.left = this.visitPattern(n.left);
1231 n.right = this.visitExpression(n.right);
1232 n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
1233 return n;
1234 }
1235 visitObjectPattern(n) {
1236 n.props = this.visitObjectPatternProperties(n.props || []);
1237 n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
1238 return n;
1239 }
1240 visitObjectPatternProperties(nodes) {
1241 return nodes.map(this.visitObjectPatternProperty.bind(this));
1242 }
1243 visitObjectPatternProperty(n) {
1244 switch (n.type) {
1245 case "AssignmentPatternProperty":
1246 return this.visitAssignmentPatternProperty(n);
1247 case "KeyValuePatternProperty":
1248 return this.visitKeyValuePatternProperty(n);
1249 case "RestElement":
1250 return this.visitRestElement(n);
1251 }
1252 }
1253 visitKeyValuePatternProperty(n) {
1254 n.key = this.visitPropertyName(n.key);
1255 n.value = this.visitPattern(n.value);
1256 return n;
1257 }
1258 visitAssignmentPatternProperty(n) {
1259 n.key = this.visitBindingIdentifier(n.key);
1260 n.value = this.visitOptionalExpression(n.value);
1261 return n;
1262 }
1263 visitArrayPattern(n) {
1264 n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
1265 n.elements = this.visitArrayPatternElements(n.elements);
1266 return n;
1267 }
1268 visitArrayPatternElements(nodes) {
1269 return nodes.map(this.visitArrayPatternElement.bind(this));
1270 }
1271 visitArrayPatternElement(n) {
1272 if (n) {
1273 n = this.visitPattern(n);
1274 }
1275 return n;
1276 }
1277}
1278exports.default = Visitor;