UNPKG

20.5 kBJavaScriptView Raw
1"use strict";
2/**
3 * @license
4 * Copyright 2013 Palantir Technologies, Inc.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18Object.defineProperty(exports, "__esModule", { value: true });
19exports.SyntaxWalker = void 0;
20var ts = require("typescript");
21var SyntaxWalker = /** @class */ (function () {
22 function SyntaxWalker() {
23 }
24 SyntaxWalker.prototype.walk = function (node) {
25 this.visitNode(node);
26 };
27 SyntaxWalker.prototype.visitAnyKeyword = function (node) {
28 this.walkChildren(node);
29 };
30 SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) {
31 this.walkChildren(node);
32 };
33 SyntaxWalker.prototype.visitArrayType = function (node) {
34 this.walkChildren(node);
35 };
36 SyntaxWalker.prototype.visitArrowFunction = function (node) {
37 this.walkChildren(node);
38 };
39 SyntaxWalker.prototype.visitBinaryExpression = function (node) {
40 this.walkChildren(node);
41 };
42 SyntaxWalker.prototype.visitBindingElement = function (node) {
43 this.walkChildren(node);
44 };
45 SyntaxWalker.prototype.visitBindingPattern = function (node) {
46 this.walkChildren(node);
47 };
48 SyntaxWalker.prototype.visitBlock = function (node) {
49 this.walkChildren(node);
50 };
51 SyntaxWalker.prototype.visitBreakStatement = function (node) {
52 this.walkChildren(node);
53 };
54 SyntaxWalker.prototype.visitCallExpression = function (node) {
55 this.walkChildren(node);
56 };
57 SyntaxWalker.prototype.visitCallSignature = function (node) {
58 this.walkChildren(node);
59 };
60 SyntaxWalker.prototype.visitCaseClause = function (node) {
61 this.walkChildren(node);
62 };
63 SyntaxWalker.prototype.visitClassDeclaration = function (node) {
64 this.walkChildren(node);
65 };
66 SyntaxWalker.prototype.visitClassExpression = function (node) {
67 this.walkChildren(node);
68 };
69 SyntaxWalker.prototype.visitCatchClause = function (node) {
70 this.walkChildren(node);
71 };
72 SyntaxWalker.prototype.visitConditionalExpression = function (node) {
73 this.walkChildren(node);
74 };
75 SyntaxWalker.prototype.visitConstructSignature = function (node) {
76 this.walkChildren(node);
77 };
78 SyntaxWalker.prototype.visitConstructorDeclaration = function (node) {
79 this.walkChildren(node);
80 };
81 SyntaxWalker.prototype.visitConstructorType = function (node) {
82 this.walkChildren(node);
83 };
84 SyntaxWalker.prototype.visitContinueStatement = function (node) {
85 this.walkChildren(node);
86 };
87 SyntaxWalker.prototype.visitDebuggerStatement = function (node) {
88 this.walkChildren(node);
89 };
90 SyntaxWalker.prototype.visitDefaultClause = function (node) {
91 this.walkChildren(node);
92 };
93 SyntaxWalker.prototype.visitDoStatement = function (node) {
94 this.walkChildren(node);
95 };
96 SyntaxWalker.prototype.visitElementAccessExpression = function (node) {
97 this.walkChildren(node);
98 };
99 SyntaxWalker.prototype.visitEndOfFileToken = function (node) {
100 this.walkChildren(node);
101 };
102 SyntaxWalker.prototype.visitEnumDeclaration = function (node) {
103 this.walkChildren(node);
104 };
105 SyntaxWalker.prototype.visitEnumMember = function (node) {
106 this.walkChildren(node);
107 };
108 SyntaxWalker.prototype.visitExportAssignment = function (node) {
109 this.walkChildren(node);
110 };
111 SyntaxWalker.prototype.visitExpressionStatement = function (node) {
112 this.walkChildren(node);
113 };
114 SyntaxWalker.prototype.visitForStatement = function (node) {
115 this.walkChildren(node);
116 };
117 SyntaxWalker.prototype.visitForInStatement = function (node) {
118 this.walkChildren(node);
119 };
120 SyntaxWalker.prototype.visitForOfStatement = function (node) {
121 this.walkChildren(node);
122 };
123 SyntaxWalker.prototype.visitFunctionDeclaration = function (node) {
124 this.walkChildren(node);
125 };
126 SyntaxWalker.prototype.visitFunctionExpression = function (node) {
127 this.walkChildren(node);
128 };
129 SyntaxWalker.prototype.visitFunctionType = function (node) {
130 this.walkChildren(node);
131 };
132 SyntaxWalker.prototype.visitGetAccessor = function (node) {
133 this.walkChildren(node);
134 };
135 SyntaxWalker.prototype.visitIdentifier = function (node) {
136 this.walkChildren(node);
137 };
138 SyntaxWalker.prototype.visitIfStatement = function (node) {
139 this.walkChildren(node);
140 };
141 SyntaxWalker.prototype.visitImportDeclaration = function (node) {
142 this.walkChildren(node);
143 };
144 SyntaxWalker.prototype.visitImportEqualsDeclaration = function (node) {
145 this.walkChildren(node);
146 };
147 SyntaxWalker.prototype.visitIndexSignatureDeclaration = function (node) {
148 this.walkChildren(node);
149 };
150 SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) {
151 this.walkChildren(node);
152 };
153 SyntaxWalker.prototype.visitJsxAttribute = function (node) {
154 this.walkChildren(node);
155 };
156 SyntaxWalker.prototype.visitJsxElement = function (node) {
157 this.walkChildren(node);
158 };
159 SyntaxWalker.prototype.visitJsxExpression = function (node) {
160 this.walkChildren(node);
161 };
162 SyntaxWalker.prototype.visitJsxSelfClosingElement = function (node) {
163 this.walkChildren(node);
164 };
165 SyntaxWalker.prototype.visitJsxSpreadAttribute = function (node) {
166 this.walkChildren(node);
167 };
168 SyntaxWalker.prototype.visitLabeledStatement = function (node) {
169 this.walkChildren(node);
170 };
171 SyntaxWalker.prototype.visitMethodDeclaration = function (node) {
172 this.walkChildren(node);
173 };
174 SyntaxWalker.prototype.visitMethodSignature = function (node) {
175 this.walkChildren(node);
176 };
177 SyntaxWalker.prototype.visitModuleDeclaration = function (node) {
178 this.walkChildren(node);
179 };
180 SyntaxWalker.prototype.visitNamedImports = function (node) {
181 this.walkChildren(node);
182 };
183 SyntaxWalker.prototype.visitNamespaceImport = function (node) {
184 this.walkChildren(node);
185 };
186 SyntaxWalker.prototype.visitNewExpression = function (node) {
187 this.walkChildren(node);
188 };
189 SyntaxWalker.prototype.visitNonNullExpression = function (node) {
190 this.walkChildren(node);
191 };
192 SyntaxWalker.prototype.visitNumericLiteral = function (node) {
193 this.walkChildren(node);
194 };
195 SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) {
196 this.walkChildren(node);
197 };
198 SyntaxWalker.prototype.visitParameterDeclaration = function (node) {
199 this.walkChildren(node);
200 };
201 SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) {
202 this.walkChildren(node);
203 };
204 SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) {
205 this.walkChildren(node);
206 };
207 SyntaxWalker.prototype.visitPropertyAccessExpression = function (node) {
208 this.walkChildren(node);
209 };
210 SyntaxWalker.prototype.visitPropertyAssignment = function (node) {
211 this.walkChildren(node);
212 };
213 SyntaxWalker.prototype.visitPropertyDeclaration = function (node) {
214 this.walkChildren(node);
215 };
216 SyntaxWalker.prototype.visitPropertySignature = function (node) {
217 this.walkChildren(node);
218 };
219 SyntaxWalker.prototype.visitRegularExpressionLiteral = function (node) {
220 this.walkChildren(node);
221 };
222 SyntaxWalker.prototype.visitReturnStatement = function (node) {
223 this.walkChildren(node);
224 };
225 SyntaxWalker.prototype.visitSetAccessor = function (node) {
226 this.walkChildren(node);
227 };
228 SyntaxWalker.prototype.visitSourceFile = function (node) {
229 this.walkChildren(node);
230 };
231 SyntaxWalker.prototype.visitStringLiteral = function (node) {
232 this.walkChildren(node);
233 };
234 SyntaxWalker.prototype.visitSwitchStatement = function (node) {
235 this.walkChildren(node);
236 };
237 SyntaxWalker.prototype.visitTemplateExpression = function (node) {
238 this.walkChildren(node);
239 };
240 SyntaxWalker.prototype.visitThrowStatement = function (node) {
241 this.walkChildren(node);
242 };
243 SyntaxWalker.prototype.visitTryStatement = function (node) {
244 this.walkChildren(node);
245 };
246 SyntaxWalker.prototype.visitTupleType = function (node) {
247 this.walkChildren(node);
248 };
249 SyntaxWalker.prototype.visitTypeAliasDeclaration = function (node) {
250 this.walkChildren(node);
251 };
252 SyntaxWalker.prototype.visitTypeAssertionExpression = function (node) {
253 this.walkChildren(node);
254 };
255 SyntaxWalker.prototype.visitTypeLiteral = function (node) {
256 this.walkChildren(node);
257 };
258 SyntaxWalker.prototype.visitTypeReference = function (node) {
259 this.walkChildren(node);
260 };
261 SyntaxWalker.prototype.visitVariableDeclaration = function (node) {
262 this.walkChildren(node);
263 };
264 SyntaxWalker.prototype.visitVariableDeclarationList = function (node) {
265 this.walkChildren(node);
266 };
267 SyntaxWalker.prototype.visitVariableStatement = function (node) {
268 this.walkChildren(node);
269 };
270 SyntaxWalker.prototype.visitWhileStatement = function (node) {
271 this.walkChildren(node);
272 };
273 SyntaxWalker.prototype.visitWithStatement = function (node) {
274 this.walkChildren(node);
275 };
276 SyntaxWalker.prototype.visitNode = function (node) {
277 switch (node.kind) {
278 case ts.SyntaxKind.AnyKeyword:
279 this.visitAnyKeyword(node);
280 break;
281 case ts.SyntaxKind.ArrayBindingPattern:
282 this.visitBindingPattern(node);
283 break;
284 case ts.SyntaxKind.ArrayLiteralExpression:
285 this.visitArrayLiteralExpression(node);
286 break;
287 case ts.SyntaxKind.ArrayType:
288 this.visitArrayType(node);
289 break;
290 case ts.SyntaxKind.ArrowFunction:
291 this.visitArrowFunction(node);
292 break;
293 case ts.SyntaxKind.BinaryExpression:
294 this.visitBinaryExpression(node);
295 break;
296 case ts.SyntaxKind.BindingElement:
297 this.visitBindingElement(node);
298 break;
299 case ts.SyntaxKind.Block:
300 this.visitBlock(node);
301 break;
302 case ts.SyntaxKind.BreakStatement:
303 this.visitBreakStatement(node);
304 break;
305 case ts.SyntaxKind.CallExpression:
306 this.visitCallExpression(node);
307 break;
308 case ts.SyntaxKind.CallSignature:
309 this.visitCallSignature(node);
310 break;
311 case ts.SyntaxKind.CaseClause:
312 this.visitCaseClause(node);
313 break;
314 case ts.SyntaxKind.ClassDeclaration:
315 this.visitClassDeclaration(node);
316 break;
317 case ts.SyntaxKind.ClassExpression:
318 this.visitClassExpression(node);
319 break;
320 case ts.SyntaxKind.CatchClause:
321 this.visitCatchClause(node);
322 break;
323 case ts.SyntaxKind.ConditionalExpression:
324 this.visitConditionalExpression(node);
325 break;
326 case ts.SyntaxKind.ConstructSignature:
327 this.visitConstructSignature(node);
328 break;
329 case ts.SyntaxKind.Constructor:
330 this.visitConstructorDeclaration(node);
331 break;
332 case ts.SyntaxKind.ConstructorType:
333 this.visitConstructorType(node);
334 break;
335 case ts.SyntaxKind.ContinueStatement:
336 this.visitContinueStatement(node);
337 break;
338 case ts.SyntaxKind.DebuggerStatement:
339 this.visitDebuggerStatement(node);
340 break;
341 case ts.SyntaxKind.DefaultClause:
342 this.visitDefaultClause(node);
343 break;
344 case ts.SyntaxKind.DoStatement:
345 this.visitDoStatement(node);
346 break;
347 case ts.SyntaxKind.ElementAccessExpression:
348 this.visitElementAccessExpression(node);
349 break;
350 case ts.SyntaxKind.EndOfFileToken:
351 this.visitEndOfFileToken(node);
352 break;
353 case ts.SyntaxKind.EnumDeclaration:
354 this.visitEnumDeclaration(node);
355 break;
356 case ts.SyntaxKind.EnumMember:
357 this.visitEnumMember(node);
358 break;
359 case ts.SyntaxKind.ExportAssignment:
360 this.visitExportAssignment(node);
361 break;
362 case ts.SyntaxKind.ExpressionStatement:
363 this.visitExpressionStatement(node);
364 break;
365 case ts.SyntaxKind.ForStatement:
366 this.visitForStatement(node);
367 break;
368 case ts.SyntaxKind.ForInStatement:
369 this.visitForInStatement(node);
370 break;
371 case ts.SyntaxKind.ForOfStatement:
372 this.visitForOfStatement(node);
373 break;
374 case ts.SyntaxKind.FunctionDeclaration:
375 this.visitFunctionDeclaration(node);
376 break;
377 case ts.SyntaxKind.FunctionExpression:
378 this.visitFunctionExpression(node);
379 break;
380 case ts.SyntaxKind.FunctionType:
381 this.visitFunctionType(node);
382 break;
383 case ts.SyntaxKind.GetAccessor:
384 this.visitGetAccessor(node);
385 break;
386 case ts.SyntaxKind.Identifier:
387 this.visitIdentifier(node);
388 break;
389 case ts.SyntaxKind.IfStatement:
390 this.visitIfStatement(node);
391 break;
392 case ts.SyntaxKind.ImportDeclaration:
393 this.visitImportDeclaration(node);
394 break;
395 case ts.SyntaxKind.ImportEqualsDeclaration:
396 this.visitImportEqualsDeclaration(node);
397 break;
398 case ts.SyntaxKind.IndexSignature:
399 this.visitIndexSignatureDeclaration(node);
400 break;
401 case ts.SyntaxKind.InterfaceDeclaration:
402 this.visitInterfaceDeclaration(node);
403 break;
404 case ts.SyntaxKind.JsxAttribute:
405 this.visitJsxAttribute(node);
406 break;
407 case ts.SyntaxKind.JsxElement:
408 this.visitJsxElement(node);
409 break;
410 case ts.SyntaxKind.JsxExpression:
411 this.visitJsxExpression(node);
412 break;
413 case ts.SyntaxKind.JsxSelfClosingElement:
414 this.visitJsxSelfClosingElement(node);
415 break;
416 case ts.SyntaxKind.JsxSpreadAttribute:
417 this.visitJsxSpreadAttribute(node);
418 break;
419 case ts.SyntaxKind.LabeledStatement:
420 this.visitLabeledStatement(node);
421 break;
422 case ts.SyntaxKind.MethodDeclaration:
423 this.visitMethodDeclaration(node);
424 break;
425 case ts.SyntaxKind.MethodSignature:
426 this.visitMethodSignature(node);
427 break;
428 case ts.SyntaxKind.ModuleDeclaration:
429 this.visitModuleDeclaration(node);
430 break;
431 case ts.SyntaxKind.NamedImports:
432 this.visitNamedImports(node);
433 break;
434 case ts.SyntaxKind.NamespaceImport:
435 this.visitNamespaceImport(node);
436 break;
437 case ts.SyntaxKind.NewExpression:
438 this.visitNewExpression(node);
439 break;
440 case ts.SyntaxKind.NonNullExpression:
441 this.visitNonNullExpression(node);
442 break;
443 case ts.SyntaxKind.NumericLiteral:
444 this.visitNumericLiteral(node);
445 break;
446 case ts.SyntaxKind.ObjectBindingPattern:
447 this.visitBindingPattern(node);
448 break;
449 case ts.SyntaxKind.ObjectLiteralExpression:
450 this.visitObjectLiteralExpression(node);
451 break;
452 case ts.SyntaxKind.Parameter:
453 this.visitParameterDeclaration(node);
454 break;
455 case ts.SyntaxKind.PostfixUnaryExpression:
456 this.visitPostfixUnaryExpression(node);
457 break;
458 case ts.SyntaxKind.PrefixUnaryExpression:
459 this.visitPrefixUnaryExpression(node);
460 break;
461 case ts.SyntaxKind.PropertyAccessExpression:
462 this.visitPropertyAccessExpression(node);
463 break;
464 case ts.SyntaxKind.PropertyAssignment:
465 this.visitPropertyAssignment(node);
466 break;
467 case ts.SyntaxKind.PropertyDeclaration:
468 this.visitPropertyDeclaration(node);
469 break;
470 case ts.SyntaxKind.PropertySignature:
471 this.visitPropertySignature(node);
472 break;
473 case ts.SyntaxKind.RegularExpressionLiteral:
474 this.visitRegularExpressionLiteral(node);
475 break;
476 case ts.SyntaxKind.ReturnStatement:
477 this.visitReturnStatement(node);
478 break;
479 case ts.SyntaxKind.SetAccessor:
480 this.visitSetAccessor(node);
481 break;
482 case ts.SyntaxKind.SourceFile:
483 this.visitSourceFile(node);
484 break;
485 case ts.SyntaxKind.StringLiteral:
486 this.visitStringLiteral(node);
487 break;
488 case ts.SyntaxKind.SwitchStatement:
489 this.visitSwitchStatement(node);
490 break;
491 case ts.SyntaxKind.TemplateExpression:
492 this.visitTemplateExpression(node);
493 break;
494 case ts.SyntaxKind.ThrowStatement:
495 this.visitThrowStatement(node);
496 break;
497 case ts.SyntaxKind.TryStatement:
498 this.visitTryStatement(node);
499 break;
500 case ts.SyntaxKind.TupleType:
501 this.visitTupleType(node);
502 break;
503 case ts.SyntaxKind.TypeAliasDeclaration:
504 this.visitTypeAliasDeclaration(node);
505 break;
506 case ts.SyntaxKind.TypeAssertionExpression:
507 this.visitTypeAssertionExpression(node);
508 break;
509 case ts.SyntaxKind.TypeLiteral:
510 this.visitTypeLiteral(node);
511 break;
512 case ts.SyntaxKind.TypeReference:
513 this.visitTypeReference(node);
514 break;
515 case ts.SyntaxKind.VariableDeclaration:
516 this.visitVariableDeclaration(node);
517 break;
518 case ts.SyntaxKind.VariableDeclarationList:
519 this.visitVariableDeclarationList(node);
520 break;
521 case ts.SyntaxKind.VariableStatement:
522 this.visitVariableStatement(node);
523 break;
524 case ts.SyntaxKind.WhileStatement:
525 this.visitWhileStatement(node);
526 break;
527 case ts.SyntaxKind.WithStatement:
528 this.visitWithStatement(node);
529 break;
530 default:
531 this.walkChildren(node);
532 }
533 };
534 SyntaxWalker.prototype.walkChildren = function (node) {
535 var _this = this;
536 ts.forEachChild(node, function (child) { return _this.visitNode(child); });
537 };
538 return SyntaxWalker;
539}());
540exports.SyntaxWalker = SyntaxWalker;