@zzzen/pyright-internal 1.2.0-dev.20221016 → 1.2.0-dev.20221204

package/dist/analyzer/parseTreeWalker.js

@@ -7,448 +7,631 @@
  *
  * Class that traverses a parse tree.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseTreeWalker = void 0;
+exports.ParseTreeWalker = exports.ParseTreeVisitor = exports.getChildNodes = void 0;
+const debug = __importStar(require("../common/debug"));
+// Get child nodes of the given node.
+function getChildNodes(node) {
+    var _a;
+    switch (node.nodeType) {
+        case 0 /* Error */:
+            return [node.child, ...((_a = node.decorators) !== null && _a !== void 0 ? _a : [])];
+        case 1 /* Argument */:
+            return [node.name, node.valueExpression];
+        case 2 /* Assert */:
+            return [node.testExpression, node.exceptionExpression];
+        case 4 /* AssignmentExpression */:
+            return [node.name, node.rightExpression];
+        case 3 /* Assignment */:
+            return [node.leftExpression, node.rightExpression, node.typeAnnotationComment];
+        case 5 /* AugmentedAssignment */:
+            return [node.leftExpression, node.rightExpression];
+        case 6 /* Await */:
+            return [node.expression];
+        case 7 /* BinaryOperation */:
+            return [node.leftExpression, node.rightExpression];
+        case 8 /* Break */:
+            return [];
+        case 9 /* Call */:
+            return [node.leftExpression, ...node.arguments];
+        case 64 /* Case */:
+            return [node.pattern, node.guardExpression, node.suite];
+        case 10 /* Class */:
+            return [...node.decorators, node.name, node.typeParameters, ...node.arguments, node.suite];
+        case 11 /* Constant */:
+            return [];
+        case 12 /* Continue */:
+            return [];
+        case 13 /* Decorator */:
+            return [node.expression];
+        case 14 /* Del */:
+            return node.expressions;
+        case 15 /* Dictionary */:
+            return node.entries;
+        case 16 /* DictionaryExpandEntry */:
+            return [node.expandExpression];
+        case 17 /* DictionaryKeyEntry */:
+            return [node.keyExpression, node.valueExpression];
+        case 18 /* Ellipsis */:
+            return [];
+        case 19 /* If */:
+            return [node.testExpression, node.ifSuite, node.elseSuite];
+        case 20 /* Import */:
+            return node.list;
+        case 21 /* ImportAs */:
+            return [node.module, node.alias];
+        case 22 /* ImportFrom */:
+            return [node.module, ...node.imports];
+        case 23 /* ImportFromAs */:
+            return [node.name, node.alias];
+        case 24 /* Index */:
+            return [node.baseExpression, ...node.items];
+        case 25 /* Except */:
+            return [node.typeExpression, node.name, node.exceptSuite];
+        case 26 /* For */:
+            return [node.targetExpression, node.iterableExpression, node.forSuite, node.elseSuite];
+        case 27 /* FormatString */:
+            return node.expressions;
+        case 28 /* Function */:
+            return [
+                ...node.decorators,
+                node.name,
+                node.typeParameters,
+                ...node.parameters,
+                node.returnTypeAnnotation,
+                node.functionAnnotationComment,
+                node.suite,
+            ];
+        case 62 /* FunctionAnnotation */:
+            return [...node.paramTypeAnnotations, node.returnTypeAnnotation];
+        case 29 /* Global */:
+            return node.nameList;
+        case 30 /* Lambda */:
+            return [...node.parameters, node.expression];
+        case 31 /* List */:
+            return node.entries;
+        case 32 /* ListComprehension */:
+            return [node.expression, ...node.forIfNodes];
+        case 33 /* ListComprehensionFor */:
+            return [node.targetExpression, node.iterableExpression];
+        case 34 /* ListComprehensionIf */:
+            return [node.testExpression];
+        case 63 /* Match */:
+            return [node.subjectExpression, ...node.cases];
+        case 35 /* MemberAccess */:
+            return [node.leftExpression, node.memberName];
+        case 37 /* ModuleName */:
+            return node.nameParts;
+        case 36 /* Module */:
+            return [...node.statements];
+        case 38 /* Name */:
+            return [];
+        case 39 /* Nonlocal */:
+            return node.nameList;
+        case 40 /* Number */:
+            return [];
+        case 41 /* Parameter */:
+            return [node.name, node.typeAnnotation, node.typeAnnotationComment, node.defaultValue];
+        case 42 /* Pass */:
+            return [];
+        case 66 /* PatternAs */:
+            return [...node.orPatterns, node.target];
+        case 68 /* PatternClass */:
+            return [node.className, ...node.arguments];
+        case 74 /* PatternClassArgument */:
+            return [node.name, node.pattern];
+        case 69 /* PatternCapture */:
+            return [node.target];
+        case 67 /* PatternLiteral */:
+            return [node.expression];
+        case 72 /* PatternMappingExpandEntry */:
+            return [node.target];
+        case 71 /* PatternMappingKeyEntry */:
+            return [node.keyPattern, node.valuePattern];
+        case 70 /* PatternMapping */:
+            return [...node.entries];
+        case 65 /* PatternSequence */:
+            return [...node.entries];
+        case 73 /* PatternValue */:
+            return [node.expression];
+        case 43 /* Raise */:
+            return [node.typeExpression, node.valueExpression, node.tracebackExpression];
+        case 44 /* Return */:
+            return [node.returnExpression];
+        case 45 /* Set */:
+            return node.entries;
+        case 46 /* Slice */:
+            return [node.startValue, node.endValue, node.stepValue];
+        case 47 /* StatementList */:
+            return node.statements;
+        case 48 /* StringList */:
+            return [node.typeAnnotation, ...node.strings];
+        case 49 /* String */:
+            return [];
+        case 50 /* Suite */:
+            return [...node.statements];
+        case 51 /* Ternary */:
+            return [node.ifExpression, node.testExpression, node.elseExpression];
+        case 52 /* Tuple */:
+            return node.expressions;
+        case 53 /* Try */:
+            return [node.trySuite, ...node.exceptClauses, node.elseSuite, node.finallySuite];
+        case 77 /* TypeAlias */:
+            return [node.name, node.typeParameters, node.expression];
+        case 54 /* TypeAnnotation */:
+            return [node.valueExpression, node.typeAnnotation];
+        case 75 /* TypeParameter */:
+            return [node.name, node.boundExpression, node.defaultExpression];
+        case 76 /* TypeParameterList */:
+            return [...node.parameters];
+        case 55 /* UnaryOperation */:
+            return [node.expression];
+        case 56 /* Unpack */:
+            return [node.expression];
+        case 57 /* While */:
+            return [node.testExpression, node.whileSuite, node.elseSuite];
+        case 58 /* With */:
+            return [...node.withItems, node.suite];
+        case 59 /* WithItem */:
+            return [node.expression, node.target];
+        case 60 /* Yield */:
+            return [node.expression];
+        case 61 /* YieldFrom */:
+            return [node.expression];
+        default:
+            debug.assertNever(node, `Unknown node type ${node}`);
+    }
+}
+exports.getChildNodes = getChildNodes;
 // To use this class, create a subclass and override the
 // visitXXX methods that you want to handle.
-class ParseTreeWalker {
-    walk(node) {
-        const childrenToWalk = this.visitNode(node);
-        if (childrenToWalk.length > 0) {
-            this.walkMultiple(childrenToWalk);
-        }
+class ParseTreeVisitor {
+    constructor(_default) {
+        this._default = _default;
+        // empty
     }
-    walkMultiple(nodes) {
-        nodes.forEach((node) => {
-            if (node) {
-                this.walk(node);
-            }
-        });
-    }
-    // Calls the node-specific method (visitXXXX). If the method
-    // returns true, all child nodes for the node are returned.
-    // If the method returns false, we assume that the handler
-    // has already handled the child nodes, so an empty list is
-    // returned.
-    visitNode(node) {
-        var _a;
+    visit(node) {
         switch (node.nodeType) {
             case 0 /* Error */:
-                return this.visitError(node) ? [node.child, ...((_a = node.decorators) !== null && _a !== void 0 ? _a : [])] : [];
+                return this.visitError(node);
             case 1 /* Argument */:
-                return this.visitArgument(node) ? [node.name, node.valueExpression] : [];
+                return this.visitArgument(node);
             case 2 /* Assert */:
-                return this.visitAssert(node) ? [node.testExpression, node.exceptionExpression] : [];
+                return this.visitAssert(node);
             case 4 /* AssignmentExpression */:
-                return this.visitAssignmentExpression(node) ? [node.name, node.rightExpression] : [];
+                return this.visitAssignmentExpression(node);
             case 3 /* Assignment */:
-                return this.visitAssignment(node)
-                    ? [node.leftExpression, node.rightExpression, node.typeAnnotationComment]
-                    : [];
+                return this.visitAssignment(node);
             case 5 /* AugmentedAssignment */:
-                return this.visitAugmentedAssignment(node) ? [node.leftExpression, node.rightExpression] : [];
+                return this.visitAugmentedAssignment(node);
             case 6 /* Await */:
-                return this.visitAwait(node) ? [node.expression] : [];
+                return this.visitAwait(node);
             case 7 /* BinaryOperation */:
-                return this.visitBinaryOperation(node) ? [node.leftExpression, node.rightExpression] : [];
+                return this.visitBinaryOperation(node);
             case 8 /* Break */:
-                return this.visitBreak(node) ? [] : [];
+                return this.visitBreak(node);
             case 9 /* Call */:
-                return this.visitCall(node) ? [node.leftExpression, ...node.arguments] : [];
+                return this.visitCall(node);
             case 64 /* Case */:
-                return this.visitCase(node) ? [node.pattern, node.guardExpression, node.suite] : [];
+                return this.visitCase(node);
             case 10 /* Class */:
-                return this.visitClass(node)
-                    ? [...node.decorators, node.name, node.typeParameters, ...node.arguments, node.suite]
-                    : [];
+                return this.visitClass(node);
             case 11 /* Constant */:
-                return this.visitConstant(node) ? [] : [];
+                return this.visitConstant(node);
             case 12 /* Continue */:
-                return this.visitContinue(node) ? [] : [];
+                return this.visitContinue(node);
             case 13 /* Decorator */:
-                return this.visitDecorator(node) ? [node.expression] : [];
+                return this.visitDecorator(node);
             case 14 /* Del */:
-                return this.visitDel(node) ? node.expressions : [];
+                return this.visitDel(node);
             case 15 /* Dictionary */:
-                return this.visitDictionary(node) ? node.entries : [];
+                return this.visitDictionary(node);
             case 16 /* DictionaryExpandEntry */:
-                return this.visitDictionaryExpandEntry(node) ? [node.expandExpression] : [];
+                return this.visitDictionaryExpandEntry(node);
             case 17 /* DictionaryKeyEntry */:
-                return this.visitDictionaryKeyEntry(node) ? [node.keyExpression, node.valueExpression] : [];
+                return this.visitDictionaryKeyEntry(node);
             case 18 /* Ellipsis */:
-                return this.visitEllipsis(node) ? [] : [];
+                return this.visitEllipsis(node);
             case 19 /* If */:
-                return this.visitIf(node) ? [node.testExpression, node.ifSuite, node.elseSuite] : [];
+                return this.visitIf(node);
             case 20 /* Import */:
-                return this.visitImport(node) ? node.list : [];
+                return this.visitImport(node);
             case 21 /* ImportAs */:
-                return this.visitImportAs(node) ? [node.module, node.alias] : [];
+                return this.visitImportAs(node);
             case 22 /* ImportFrom */:
-                return this.visitImportFrom(node) ? [node.module, ...node.imports] : [];
+                return this.visitImportFrom(node);
             case 23 /* ImportFromAs */:
-                return this.visitImportFromAs(node) ? [node.name, node.alias] : [];
+                return this.visitImportFromAs(node);
             case 24 /* Index */:
-                return this.visitIndex(node) ? [node.baseExpression, ...node.items] : [];
+                return this.visitIndex(node);
             case 25 /* Except */:
-                return this.visitExcept(node) ? [node.typeExpression, node.name, node.exceptSuite] : [];
+                return this.visitExcept(node);
             case 26 /* For */:
-                return this.visitFor(node)
-                    ? [node.targetExpression, node.iterableExpression, node.forSuite, node.elseSuite]
-                    : [];
+                return this.visitFor(node);
             case 27 /* FormatString */:
-                return this.visitFormatString(node) ? node.expressions : [];
+                return this.visitFormatString(node);
             case 28 /* Function */:
-                return this.visitFunction(node)
-                    ? [
-                        ...node.decorators,
-                        node.name,
-                        node.typeParameters,
-                        ...node.parameters,
-                        node.returnTypeAnnotation,
-                        node.functionAnnotationComment,
-                        node.suite,
-                    ]
-                    : [];
+                return this.visitFunction(node);
             case 62 /* FunctionAnnotation */:
-                return this.visitFunctionAnnotation(node)
-                    ? [...node.paramTypeAnnotations, node.returnTypeAnnotation]
-                    : [];
+                return this.visitFunctionAnnotation(node);
             case 29 /* Global */:
-                return this.visitGlobal(node) ? node.nameList : [];
+                return this.visitGlobal(node);
             case 30 /* Lambda */:
-                return this.visitLambda(node) ? [...node.parameters, node.expression] : [];
+                return this.visitLambda(node);
             case 31 /* List */:
-                return this.visitList(node) ? node.entries : [];
+                return this.visitList(node);
             case 32 /* ListComprehension */:
-                return this.visitListComprehension(node) ? [node.expression, ...node.forIfNodes] : [];
+                return this.visitListComprehension(node);
             case 33 /* ListComprehensionFor */:
-                return this.visitListComprehensionFor(node) ? [node.targetExpression, node.iterableExpression] : [];
+                return this.visitListComprehensionFor(node);
             case 34 /* ListComprehensionIf */:
-                return this.visitListComprehensionIf(node) ? [node.testExpression] : [];
+                return this.visitListComprehensionIf(node);
             case 63 /* Match */:
-                return this.visitMatch(node) ? [node.subjectExpression, ...node.cases] : [];
+                return this.visitMatch(node);
             case 35 /* MemberAccess */:
-                return this.visitMemberAccess(node) ? [node.leftExpression, node.memberName] : [];
+                return this.visitMemberAccess(node);
             case 37 /* ModuleName */:
-                return this.visitModuleName(node) ? node.nameParts : [];
+                return this.visitModuleName(node);
             case 36 /* Module */:
-                return this.visitModule(node) ? [...node.statements] : [];
+                return this.visitModule(node);
             case 38 /* Name */:
-                return this.visitName(node) ? [] : [];
+                return this.visitName(node);
             case 39 /* Nonlocal */:
-                return this.visitNonlocal(node) ? node.nameList : [];
+                return this.visitNonlocal(node);
             case 40 /* Number */:
-                return this.visitNumber(node) ? [] : [];
+                return this.visitNumber(node);
             case 41 /* Parameter */:
-                return this.visitParameter(node)
-                    ? [node.name, node.typeAnnotation, node.typeAnnotationComment, node.defaultValue]
-                    : [];
+                return this.visitParameter(node);
             case 42 /* Pass */:
-                return this.visitPass(node) ? [] : [];
+                return this.visitPass(node);
             case 66 /* PatternAs */:
-                return this.visitPatternAs(node) ? [...node.orPatterns, node.target] : [];
+                return this.visitPatternAs(node);
             case 68 /* PatternClass */:
-                return this.visitPatternClass(node) ? [node.className, ...node.arguments] : [];
+                return this.visitPatternClass(node);
             case 74 /* PatternClassArgument */:
-                return this.visitPatternClassArgument(node) ? [node.name, node.pattern] : [];
+                return this.visitPatternClassArgument(node);
             case 69 /* PatternCapture */:
-                return this.visitPatternCapture(node) ? [node.target] : [];
+                return this.visitPatternCapture(node);
             case 67 /* PatternLiteral */:
-                return this.visitPatternLiteral(node) ? [node.expression] : [];
+                return this.visitPatternLiteral(node);
             case 72 /* PatternMappingExpandEntry */:
-                return this.visitPatternMappingExpandEntry(node) ? [node.target] : [];
+                return this.visitPatternMappingExpandEntry(node);
             case 71 /* PatternMappingKeyEntry */:
-                return this.visitPatternMappingKeyEntry(node) ? [node.keyPattern, node.valuePattern] : [];
+                return this.visitPatternMappingKeyEntry(node);
             case 70 /* PatternMapping */:
-                return this.visitPatternMapping(node) ? [...node.entries] : [];
+                return this.visitPatternMapping(node);
             case 65 /* PatternSequence */:
-                return this.visitPatternSequence(node) ? [...node.entries] : [];
+                return this.visitPatternSequence(node);
             case 73 /* PatternValue */:
-                return this.visitPatternValue(node) ? [node.expression] : [];
+                return this.visitPatternValue(node);
             case 43 /* Raise */:
-                return this.visitRaise(node)
-                    ? [node.typeExpression, node.valueExpression, node.tracebackExpression]
-                    : [];
+                return this.visitRaise(node);
             case 44 /* Return */:
-                return this.visitReturn(node) ? [node.returnExpression] : [];
+                return this.visitReturn(node);
             case 45 /* Set */:
-                return this.visitSet(node) ? node.entries : [];
+                return this.visitSet(node);
             case 46 /* Slice */:
-                return this.visitSlice(node) ? [node.startValue, node.endValue, node.stepValue] : [];
+                return this.visitSlice(node);
             case 47 /* StatementList */:
-                return this.visitStatementList(node) ? node.statements : [];
+                return this.visitStatementList(node);
             case 48 /* StringList */:
-                return this.visitStringList(node) ? [node.typeAnnotation, ...node.strings] : [];
+                return this.visitStringList(node);
             case 49 /* String */:
-                return this.visitString(node) ? [] : [];
+                return this.visitString(node);
             case 50 /* Suite */:
-                return this.visitSuite(node) ? [...node.statements] : [];
+                return this.visitSuite(node);
             case 51 /* Ternary */:
-                return this.visitTernary(node) ? [node.ifExpression, node.testExpression, node.elseExpression] : [];
+                return this.visitTernary(node);
             case 52 /* Tuple */:
-                return this.visitTuple(node) ? node.expressions : [];
+                return this.visitTuple(node);
             case 53 /* Try */:
-                return this.visitTry(node)
-                    ? [node.trySuite, ...node.exceptClauses, node.elseSuite, node.finallySuite]
-                    : [];
+                return this.visitTry(node);
             case 77 /* TypeAlias */:
-                return this.visitTypeAlias(node) ? [node.name, node.typeParameters, node.expression] : [];
+                return this.visitTypeAlias(node);
             case 54 /* TypeAnnotation */:
-                return this.visitTypeAnnotation(node) ? [node.valueExpression, node.typeAnnotation] : [];
+                return this.visitTypeAnnotation(node);
             case 75 /* TypeParameter */:
-                return this.visitTypeParameter(node) ? [node.name, node.boundExpression] : [];
+                return this.visitTypeParameter(node);
             case 76 /* TypeParameterList */:
-                return this.visitTypeParameterList(node) ? [...node.parameters] : [];
+                return this.visitTypeParameterList(node);
             case 55 /* UnaryOperation */:
-                return this.visitUnaryOperation(node) ? [node.expression] : [];
+                return this.visitUnaryOperation(node);
             case 56 /* Unpack */:
-                return this.visitUnpack(node) ? [node.expression] : [];
+                return this.visitUnpack(node);
             case 57 /* While */:
-                return this.visitWhile(node) ? [node.testExpression, node.whileSuite, node.elseSuite] : [];
+                return this.visitWhile(node);
             case 58 /* With */:
-                return this.visitWith(node) ? [...node.withItems, node.suite] : [];
+                return this.visitWith(node);
             case 59 /* WithItem */:
-                return this.visitWithItem(node) ? [node.expression, node.target] : [];
+                return this.visitWithItem(node);
             case 60 /* Yield */:
-                return this.visitYield(node) ? [node.expression] : [];
+                return this.visitYield(node);
             case 61 /* YieldFrom */:
-                return this.visitYieldFrom(node) ? [node.expression] : [];
+                return this.visitYieldFrom(node);
+            default:
+                debug.assertNever(node, `Unknown node type ${node}`);
         }
     }
     // Override these methods as necessary.
     visitArgument(node) {
-        return true;
+        return this._default;
     }
     visitAssert(node) {
-        return true;
+        return this._default;
     }
     visitAssignment(node) {
-        return true;
+        return this._default;
     }
     visitAssignmentExpression(node) {
-        return true;
+        return this._default;
     }
     visitAugmentedAssignment(node) {
-        return true;
+        return this._default;
     }
     visitAwait(node) {
-        return true;
+        return this._default;
     }
     visitBinaryOperation(node) {
-        return true;
+        return this._default;
     }
     visitBreak(node) {
-        return true;
+        return this._default;
     }
     visitCall(node) {
-        return true;
+        return this._default;
     }
     visitCase(node) {
-        return true;
+        return this._default;
     }
     visitClass(node) {
-        return true;
+        return this._default;
     }
     visitTernary(node) {
-        return true;
+        return this._default;
     }
     visitContinue(node) {
-        return true;
+        return this._default;
     }
     visitConstant(node) {
-        return true;
+        return this._default;
     }
     visitDecorator(node) {
-        return true;
+        return this._default;
     }
     visitDel(node) {
-        return true;
+        return this._default;
     }
     visitDictionary(node) {
-        return true;
+        return this._default;
     }
     visitDictionaryKeyEntry(node) {
-        return true;
+        return this._default;
     }
     visitDictionaryExpandEntry(node) {
-        return true;
+        return this._default;
     }
     visitError(node) {
-        return true;
+        return this._default;
     }
     visitEllipsis(node) {
-        return true;
+        return this._default;
     }
     visitIf(node) {
-        return true;
+        return this._default;
     }
     visitImport(node) {
-        return true;
+        return this._default;
     }
     visitImportAs(node) {
-        return true;
+        return this._default;
     }
     visitImportFrom(node) {
-        return true;
+        return this._default;
     }
     visitImportFromAs(node) {
-        return true;
+        return this._default;
     }
     visitIndex(node) {
-        return true;
+        return this._default;
     }
     visitExcept(node) {
-        return true;
+        return this._default;
     }
     visitFor(node) {
-        return true;
+        return this._default;
     }
     visitFormatString(node) {
-        return true;
+        return this._default;
     }
     visitFunction(node) {
-        return true;
+        return this._default;
     }
     visitFunctionAnnotation(node) {
-        return true;
+        return this._default;
     }
     visitGlobal(node) {
-        return true;
+        return this._default;
     }
     visitLambda(node) {
-        return true;
+        return this._default;
     }
     visitList(node) {
-        return true;
+        return this._default;
     }
     visitListComprehension(node) {
-        return true;
+        return this._default;
     }
     visitListComprehensionFor(node) {
-        return true;
+        return this._default;
     }
     visitListComprehensionIf(node) {
-        return true;
+        return this._default;
     }
     visitMatch(node) {
-        return true;
+        return this._default;
     }
     visitMemberAccess(node) {
-        return true;
+        return this._default;
     }
     visitModule(node) {
-        return true;
+        return this._default;
     }
     visitModuleName(node) {
-        return true;
+        return this._default;
     }
     visitName(node) {
-        return true;
+        return this._default;
     }
     visitNonlocal(node) {
-        return true;
+        return this._default;
     }
     visitNumber(node) {
-        return true;
+        return this._default;
     }
     visitParameter(node) {
-        return true;
+        return this._default;
     }
     visitPass(node) {
-        return true;
+        return this._default;
     }
     visitPatternCapture(node) {
-        return true;
+        return this._default;
     }
     visitPatternClass(node) {
-        return true;
+        return this._default;
     }
     visitPatternClassArgument(node) {
-        return true;
+        return this._default;
     }
     visitPatternAs(node) {
-        return true;
+        return this._default;
     }
     visitPatternLiteral(node) {
-        return true;
+        return this._default;
     }
     visitPatternMappingExpandEntry(node) {
-        return true;
+        return this._default;
     }
     visitPatternSequence(node) {
-        return true;
+        return this._default;
     }
     visitPatternValue(node) {
-        return true;
+        return this._default;
     }
     visitPatternMappingKeyEntry(node) {
-        return true;
+        return this._default;
     }
     visitPatternMapping(node) {
-        return true;
+        return this._default;
     }
     visitRaise(node) {
-        return true;
+        return this._default;
     }
     visitReturn(node) {
-        return true;
+        return this._default;
     }
     visitSet(node) {
-        return true;
+        return this._default;
     }
     visitSlice(node) {
-        return true;
+        return this._default;
     }
     visitStatementList(node) {
-        return true;
+        return this._default;
     }
     visitString(node) {
-        return true;
+        return this._default;
     }
     visitStringList(node) {
-        return true;
+        return this._default;
     }
     visitSuite(node) {
-        return true;
+        return this._default;
     }
     visitTuple(node) {
-        return true;
+        return this._default;
     }
     visitTry(node) {
-        return true;
+        return this._default;
     }
     visitTypeAlias(node) {
-        return true;
+        return this._default;
     }
     visitTypeAnnotation(node) {
-        return true;
+        return this._default;
     }
     visitTypeParameter(node) {
-        return true;
+        return this._default;
     }
     visitTypeParameterList(node) {
-        return true;
+        return this._default;
     }
     visitUnaryOperation(node) {
-        return true;
+        return this._default;
     }
     visitUnpack(node) {
-        return true;
+        return this._default;
     }
     visitWhile(node) {
-        return true;
+        return this._default;
     }
     visitWith(node) {
-        return true;
+        return this._default;
     }
     visitWithItem(node) {
-        return true;
+        return this._default;
     }
     visitYield(node) {
-        return true;
+        return this._default;
     }
     visitYieldFrom(node) {
-        return true;
+        return this._default;
+    }
+}
+exports.ParseTreeVisitor = ParseTreeVisitor;
+// To use this class, create a subclass and override the
+// visitXXX methods that you want to handle.
+class ParseTreeWalker extends ParseTreeVisitor {
+    constructor() {
+        super(/* default */ true);
+    }
+    walk(node) {
+        const childrenToWalk = this.visitNode(node);
+        if (childrenToWalk.length > 0) {
+            this.walkMultiple(childrenToWalk);
+        }
+    }
+    walkMultiple(nodes) {
+        nodes.forEach((node) => {
+            if (node) {
+                this.walk(node);
+            }
+        });
+    }
+    // If this.visit(node) returns true, all child nodes for the node are returned.
+    // If the method returns false, we assume that the handler has already handled the
+    // child nodes, so an empty list is returned.
+    visitNode(node) {
+        return this.visit(node) ? getChildNodes(node) : [];
     }
 }
 exports.ParseTreeWalker = ParseTreeWalker;