4 * Copyright 2013 Palantir Technologies, Inc.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 Object.defineProperty(exports, "__esModule", { value: true });
19 var ts = require("typescript");
20 var SyntaxWalker = /** @class */ (function () {
21 function SyntaxWalker() {
23 SyntaxWalker.prototype.walk = function (node) {
26 SyntaxWalker.prototype.visitAnyKeyword = function (node) {
27 this.walkChildren(node);
29 SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) {
30 this.walkChildren(node);
32 SyntaxWalker.prototype.visitArrayType = function (node) {
33 this.walkChildren(node);
35 SyntaxWalker.prototype.visitArrowFunction = function (node) {
36 this.walkChildren(node);
38 SyntaxWalker.prototype.visitBinaryExpression = function (node) {
39 this.walkChildren(node);
41 SyntaxWalker.prototype.visitBindingElement = function (node) {
42 this.walkChildren(node);
44 SyntaxWalker.prototype.visitBindingPattern = function (node) {
45 this.walkChildren(node);
47 SyntaxWalker.prototype.visitBlock = function (node) {
48 this.walkChildren(node);
50 SyntaxWalker.prototype.visitBreakStatement = function (node) {
51 this.walkChildren(node);
53 SyntaxWalker.prototype.visitCallExpression = function (node) {
54 this.walkChildren(node);
56 SyntaxWalker.prototype.visitCallSignature = function (node) {
57 this.walkChildren(node);
59 SyntaxWalker.prototype.visitCaseClause = function (node) {
60 this.walkChildren(node);
62 SyntaxWalker.prototype.visitClassDeclaration = function (node) {
63 this.walkChildren(node);
65 SyntaxWalker.prototype.visitClassExpression = function (node) {
66 this.walkChildren(node);
68 SyntaxWalker.prototype.visitCatchClause = function (node) {
69 this.walkChildren(node);
71 SyntaxWalker.prototype.visitConditionalExpression = function (node) {
72 this.walkChildren(node);
74 SyntaxWalker.prototype.visitConstructSignature = function (node) {
75 this.walkChildren(node);
77 SyntaxWalker.prototype.visitConstructorDeclaration = function (node) {
78 this.walkChildren(node);
80 SyntaxWalker.prototype.visitConstructorType = function (node) {
81 this.walkChildren(node);
83 SyntaxWalker.prototype.visitContinueStatement = function (node) {
84 this.walkChildren(node);
86 SyntaxWalker.prototype.visitDebuggerStatement = function (node) {
87 this.walkChildren(node);
89 SyntaxWalker.prototype.visitDefaultClause = function (node) {
90 this.walkChildren(node);
92 SyntaxWalker.prototype.visitDoStatement = function (node) {
93 this.walkChildren(node);
95 SyntaxWalker.prototype.visitElementAccessExpression = function (node) {
96 this.walkChildren(node);
98 SyntaxWalker.prototype.visitEndOfFileToken = function (node) {
99 this.walkChildren(node);
101 SyntaxWalker.prototype.visitEnumDeclaration = function (node) {
102 this.walkChildren(node);
104 SyntaxWalker.prototype.visitEnumMember = function (node) {
105 this.walkChildren(node);
107 SyntaxWalker.prototype.visitExportAssignment = function (node) {
108 this.walkChildren(node);
110 SyntaxWalker.prototype.visitExpressionStatement = function (node) {
111 this.walkChildren(node);
113 SyntaxWalker.prototype.visitForStatement = function (node) {
114 this.walkChildren(node);
116 SyntaxWalker.prototype.visitForInStatement = function (node) {
117 this.walkChildren(node);
119 SyntaxWalker.prototype.visitForOfStatement = function (node) {
120 this.walkChildren(node);
122 SyntaxWalker.prototype.visitFunctionDeclaration = function (node) {
123 this.walkChildren(node);
125 SyntaxWalker.prototype.visitFunctionExpression = function (node) {
126 this.walkChildren(node);
128 SyntaxWalker.prototype.visitFunctionType = function (node) {
129 this.walkChildren(node);
131 SyntaxWalker.prototype.visitGetAccessor = function (node) {
132 this.walkChildren(node);
134 SyntaxWalker.prototype.visitIdentifier = function (node) {
135 this.walkChildren(node);
137 SyntaxWalker.prototype.visitIfStatement = function (node) {
138 this.walkChildren(node);
140 SyntaxWalker.prototype.visitImportDeclaration = function (node) {
141 this.walkChildren(node);
143 SyntaxWalker.prototype.visitImportEqualsDeclaration = function (node) {
144 this.walkChildren(node);
146 SyntaxWalker.prototype.visitIndexSignatureDeclaration = function (node) {
147 this.walkChildren(node);
149 SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) {
150 this.walkChildren(node);
152 SyntaxWalker.prototype.visitJsxAttribute = function (node) {
153 this.walkChildren(node);
155 SyntaxWalker.prototype.visitJsxElement = function (node) {
156 this.walkChildren(node);
158 SyntaxWalker.prototype.visitJsxExpression = function (node) {
159 this.walkChildren(node);
161 SyntaxWalker.prototype.visitJsxSelfClosingElement = function (node) {
162 this.walkChildren(node);
164 SyntaxWalker.prototype.visitJsxSpreadAttribute = function (node) {
165 this.walkChildren(node);
167 SyntaxWalker.prototype.visitLabeledStatement = function (node) {
168 this.walkChildren(node);
170 SyntaxWalker.prototype.visitMethodDeclaration = function (node) {
171 this.walkChildren(node);
173 SyntaxWalker.prototype.visitMethodSignature = function (node) {
174 this.walkChildren(node);
176 SyntaxWalker.prototype.visitModuleDeclaration = function (node) {
177 this.walkChildren(node);
179 SyntaxWalker.prototype.visitNamedImports = function (node) {
180 this.walkChildren(node);
182 SyntaxWalker.prototype.visitNamespaceImport = function (node) {
183 this.walkChildren(node);
185 SyntaxWalker.prototype.visitNewExpression = function (node) {
186 this.walkChildren(node);
188 SyntaxWalker.prototype.visitNonNullExpression = function (node) {
189 this.walkChildren(node);
191 SyntaxWalker.prototype.visitNumericLiteral = function (node) {
192 this.walkChildren(node);
194 SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) {
195 this.walkChildren(node);
197 SyntaxWalker.prototype.visitParameterDeclaration = function (node) {
198 this.walkChildren(node);
200 SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) {
201 this.walkChildren(node);
203 SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) {
204 this.walkChildren(node);
206 SyntaxWalker.prototype.visitPropertyAccessExpression = function (node) {
207 this.walkChildren(node);
209 SyntaxWalker.prototype.visitPropertyAssignment = function (node) {
210 this.walkChildren(node);
212 SyntaxWalker.prototype.visitPropertyDeclaration = function (node) {
213 this.walkChildren(node);
215 SyntaxWalker.prototype.visitPropertySignature = function (node) {
216 this.walkChildren(node);
218 SyntaxWalker.prototype.visitRegularExpressionLiteral = function (node) {
219 this.walkChildren(node);
221 SyntaxWalker.prototype.visitReturnStatement = function (node) {
222 this.walkChildren(node);
224 SyntaxWalker.prototype.visitSetAccessor = function (node) {
225 this.walkChildren(node);
227 SyntaxWalker.prototype.visitSourceFile = function (node) {
228 this.walkChildren(node);
230 SyntaxWalker.prototype.visitStringLiteral = function (node) {
231 this.walkChildren(node);
233 SyntaxWalker.prototype.visitSwitchStatement = function (node) {
234 this.walkChildren(node);
236 SyntaxWalker.prototype.visitTemplateExpression = function (node) {
237 this.walkChildren(node);
239 SyntaxWalker.prototype.visitThrowStatement = function (node) {
240 this.walkChildren(node);
242 SyntaxWalker.prototype.visitTryStatement = function (node) {
243 this.walkChildren(node);
245 SyntaxWalker.prototype.visitTupleType = function (node) {
246 this.walkChildren(node);
248 SyntaxWalker.prototype.visitTypeAliasDeclaration = function (node) {
249 this.walkChildren(node);
251 SyntaxWalker.prototype.visitTypeAssertionExpression = function (node) {
252 this.walkChildren(node);
254 SyntaxWalker.prototype.visitTypeLiteral = function (node) {
255 this.walkChildren(node);
257 SyntaxWalker.prototype.visitTypeReference = function (node) {
258 this.walkChildren(node);
260 SyntaxWalker.prototype.visitVariableDeclaration = function (node) {
261 this.walkChildren(node);
263 SyntaxWalker.prototype.visitVariableDeclarationList = function (node) {
264 this.walkChildren(node);
266 SyntaxWalker.prototype.visitVariableStatement = function (node) {
267 this.walkChildren(node);
269 SyntaxWalker.prototype.visitWhileStatement = function (node) {
270 this.walkChildren(node);
272 SyntaxWalker.prototype.visitWithStatement = function (node) {
273 this.walkChildren(node);
275 SyntaxWalker.prototype.visitNode = function (node) {
277 case ts.SyntaxKind.AnyKeyword:
278 this.visitAnyKeyword(node);
280 case ts.SyntaxKind.ArrayBindingPattern:
281 this.visitBindingPattern(node);
283 case ts.SyntaxKind.ArrayLiteralExpression:
284 this.visitArrayLiteralExpression(node);
286 case ts.SyntaxKind.ArrayType:
287 this.visitArrayType(node);
289 case ts.SyntaxKind.ArrowFunction:
290 this.visitArrowFunction(node);
292 case ts.SyntaxKind.BinaryExpression:
293 this.visitBinaryExpression(node);
295 case ts.SyntaxKind.BindingElement:
296 this.visitBindingElement(node);
298 case ts.SyntaxKind.Block:
299 this.visitBlock(node);
301 case ts.SyntaxKind.BreakStatement:
302 this.visitBreakStatement(node);
304 case ts.SyntaxKind.CallExpression:
305 this.visitCallExpression(node);
307 case ts.SyntaxKind.CallSignature:
308 this.visitCallSignature(node);
310 case ts.SyntaxKind.CaseClause:
311 this.visitCaseClause(node);
313 case ts.SyntaxKind.ClassDeclaration:
314 this.visitClassDeclaration(node);
316 case ts.SyntaxKind.ClassExpression:
317 this.visitClassExpression(node);
319 case ts.SyntaxKind.CatchClause:
320 this.visitCatchClause(node);
322 case ts.SyntaxKind.ConditionalExpression:
323 this.visitConditionalExpression(node);
325 case ts.SyntaxKind.ConstructSignature:
326 this.visitConstructSignature(node);
328 case ts.SyntaxKind.Constructor:
329 this.visitConstructorDeclaration(node);
331 case ts.SyntaxKind.ConstructorType:
332 this.visitConstructorType(node);
334 case ts.SyntaxKind.ContinueStatement:
335 this.visitContinueStatement(node);
337 case ts.SyntaxKind.DebuggerStatement:
338 this.visitDebuggerStatement(node);
340 case ts.SyntaxKind.DefaultClause:
341 this.visitDefaultClause(node);
343 case ts.SyntaxKind.DoStatement:
344 this.visitDoStatement(node);
346 case ts.SyntaxKind.ElementAccessExpression:
347 this.visitElementAccessExpression(node);
349 case ts.SyntaxKind.EndOfFileToken:
350 this.visitEndOfFileToken(node);
352 case ts.SyntaxKind.EnumDeclaration:
353 this.visitEnumDeclaration(node);
355 case ts.SyntaxKind.EnumMember:
356 this.visitEnumMember(node);
358 case ts.SyntaxKind.ExportAssignment:
359 this.visitExportAssignment(node);
361 case ts.SyntaxKind.ExpressionStatement:
362 this.visitExpressionStatement(node);
364 case ts.SyntaxKind.ForStatement:
365 this.visitForStatement(node);
367 case ts.SyntaxKind.ForInStatement:
368 this.visitForInStatement(node);
370 case ts.SyntaxKind.ForOfStatement:
371 this.visitForOfStatement(node);
373 case ts.SyntaxKind.FunctionDeclaration:
374 this.visitFunctionDeclaration(node);
376 case ts.SyntaxKind.FunctionExpression:
377 this.visitFunctionExpression(node);
379 case ts.SyntaxKind.FunctionType:
380 this.visitFunctionType(node);
382 case ts.SyntaxKind.GetAccessor:
383 this.visitGetAccessor(node);
385 case ts.SyntaxKind.Identifier:
386 this.visitIdentifier(node);
388 case ts.SyntaxKind.IfStatement:
389 this.visitIfStatement(node);
391 case ts.SyntaxKind.ImportDeclaration:
392 this.visitImportDeclaration(node);
394 case ts.SyntaxKind.ImportEqualsDeclaration:
395 this.visitImportEqualsDeclaration(node);
397 case ts.SyntaxKind.IndexSignature:
398 this.visitIndexSignatureDeclaration(node);
400 case ts.SyntaxKind.InterfaceDeclaration:
401 this.visitInterfaceDeclaration(node);
403 case ts.SyntaxKind.JsxAttribute:
404 this.visitJsxAttribute(node);
406 case ts.SyntaxKind.JsxElement:
407 this.visitJsxElement(node);
409 case ts.SyntaxKind.JsxExpression:
410 this.visitJsxExpression(node);
412 case ts.SyntaxKind.JsxSelfClosingElement:
413 this.visitJsxSelfClosingElement(node);
415 case ts.SyntaxKind.JsxSpreadAttribute:
416 this.visitJsxSpreadAttribute(node);
418 case ts.SyntaxKind.LabeledStatement:
419 this.visitLabeledStatement(node);
421 case ts.SyntaxKind.MethodDeclaration:
422 this.visitMethodDeclaration(node);
424 case ts.SyntaxKind.MethodSignature:
425 this.visitMethodSignature(node);
427 case ts.SyntaxKind.ModuleDeclaration:
428 this.visitModuleDeclaration(node);
430 case ts.SyntaxKind.NamedImports:
431 this.visitNamedImports(node);
433 case ts.SyntaxKind.NamespaceImport:
434 this.visitNamespaceImport(node);
436 case ts.SyntaxKind.NewExpression:
437 this.visitNewExpression(node);
439 case ts.SyntaxKind.NonNullExpression:
440 this.visitNonNullExpression(node);
442 case ts.SyntaxKind.NumericLiteral:
443 this.visitNumericLiteral(node);
445 case ts.SyntaxKind.ObjectBindingPattern:
446 this.visitBindingPattern(node);
448 case ts.SyntaxKind.ObjectLiteralExpression:
449 this.visitObjectLiteralExpression(node);
451 case ts.SyntaxKind.Parameter:
452 this.visitParameterDeclaration(node);
454 case ts.SyntaxKind.PostfixUnaryExpression:
455 this.visitPostfixUnaryExpression(node);
457 case ts.SyntaxKind.PrefixUnaryExpression:
458 this.visitPrefixUnaryExpression(node);
460 case ts.SyntaxKind.PropertyAccessExpression:
461 this.visitPropertyAccessExpression(node);
463 case ts.SyntaxKind.PropertyAssignment:
464 this.visitPropertyAssignment(node);
466 case ts.SyntaxKind.PropertyDeclaration:
467 this.visitPropertyDeclaration(node);
469 case ts.SyntaxKind.PropertySignature:
470 this.visitPropertySignature(node);
472 case ts.SyntaxKind.RegularExpressionLiteral:
473 this.visitRegularExpressionLiteral(node);
475 case ts.SyntaxKind.ReturnStatement:
476 this.visitReturnStatement(node);
478 case ts.SyntaxKind.SetAccessor:
479 this.visitSetAccessor(node);
481 case ts.SyntaxKind.SourceFile:
482 this.visitSourceFile(node);
484 case ts.SyntaxKind.StringLiteral:
485 this.visitStringLiteral(node);
487 case ts.SyntaxKind.SwitchStatement:
488 this.visitSwitchStatement(node);
490 case ts.SyntaxKind.TemplateExpression:
491 this.visitTemplateExpression(node);
493 case ts.SyntaxKind.ThrowStatement:
494 this.visitThrowStatement(node);
496 case ts.SyntaxKind.TryStatement:
497 this.visitTryStatement(node);
499 case ts.SyntaxKind.TupleType:
500 this.visitTupleType(node);
502 case ts.SyntaxKind.TypeAliasDeclaration:
503 this.visitTypeAliasDeclaration(node);
505 case ts.SyntaxKind.TypeAssertionExpression:
506 this.visitTypeAssertionExpression(node);
508 case ts.SyntaxKind.TypeLiteral:
509 this.visitTypeLiteral(node);
511 case ts.SyntaxKind.TypeReference:
512 this.visitTypeReference(node);
514 case ts.SyntaxKind.VariableDeclaration:
515 this.visitVariableDeclaration(node);
517 case ts.SyntaxKind.VariableDeclarationList:
518 this.visitVariableDeclarationList(node);
520 case ts.SyntaxKind.VariableStatement:
521 this.visitVariableStatement(node);
523 case ts.SyntaxKind.WhileStatement:
524 this.visitWhileStatement(node);
526 case ts.SyntaxKind.WithStatement:
527 this.visitWithStatement(node);
530 this.walkChildren(node);
533 SyntaxWalker.prototype.walkChildren = function (node) {
535 ts.forEachChild(node, function (child) { return _this.visitNode(child); });
539 exports.SyntaxWalker = SyntaxWalker;