@zzzen/pyright-internal 1.1.254

package/dist/analyzer/binder.js

@@ -0,0 +1,3195 @@
+"use strict";
+/*
+ * binder.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * A parse tree walker that performs basic name binding (creation of
+ * scopes and associated symbol tables).
+ * The binder walks the parse tree by scopes starting at the module
+ * level. When a new scope is detected, it is pushed onto a list and
+ * walked separately at a later time. (The exception is a class scope,
+ * which is immediately walked.) Walking the tree in this manner
+ * simulates the order in which execution normally occurs in a Python
+ * file. The binder attempts to statically detect runtime errors that
+ * would be reported by the python interpreter when executing the code.
+ * This binder doesn't perform any static type checking.
+ */
+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.ReturnFinder = exports.YieldFinder = exports.Binder = void 0;
+const collectionUtils_1 = require("../common/collectionUtils");
+const debug_1 = require("../common/debug");
+const diagnosticRules_1 = require("../common/diagnosticRules");
+const pathUtils_1 = require("../common/pathUtils");
+const positionUtils_1 = require("../common/positionUtils");
+const textRange_1 = require("../common/textRange");
+const textRange_2 = require("../common/textRange");
+const localize_1 = require("../localization/localize");
+const analyzerFileInfo_1 = require("./analyzerFileInfo");
+const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const codeFlowTypes_1 = require("./codeFlowTypes");
+const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
+const parseTreeWalker_1 = require("./parseTreeWalker");
+const scope_1 = require("./scope");
+const StaticExpressions = __importStar(require("./staticExpressions"));
+const symbol_1 = require("./symbol");
+const symbolNameUtils_1 = require("./symbolNameUtils");
+// For each flow node within an execution context, we'll add a small
+// amount to the complexity factor. Without this, the complexity
+// calculation fails to take into account large numbers of non-cyclical
+// flow nodes. This number is somewhat arbitrary and is tuned empirically.
+const flowNodeComplexityFactor = 0.05;
+class Binder extends parseTreeWalker_1.ParseTreeWalker {
+    constructor(fileInfo, _moduleSymbolOnly = false) {
+        super();
+        this._moduleSymbolOnly = _moduleSymbolOnly;
+        // A queue of deferred analysis operations.
+        this._deferredBindingTasks = [];
+        // Flow nodes used within try blocks.
+        this._currentExceptTargets = [];
+        // Flow nodes used within try/finally flows.
+        this._finallyTargets = [];
+        // Aliases of "typing" and "typing_extensions".
+        this._typingImportAliases = [];
+        // Aliases of "sys".
+        this._sysImportAliases = [];
+        // Aliases of "dataclasses".
+        this._dataclassesImportAliases = [];
+        // Map of imports of specific symbols imported from "typing" and "typing_extensions"
+        // and the names they alias to.
+        this._typingSymbolAliases = new Map();
+        // Map of imports of specific symbols imported from "dataclasses"
+        // and the names they alias to.
+        this._dataclassesSymbolAliases = new Map();
+        // List of string nodes associated with the "__all__" symbol.
+        this._dunderAllStringNodes = [];
+        // One or more statements are manipulating __all__ in a manner that a
+        // static analyzer doesn't understand.
+        this._usesUnsupportedDunderAllForm = false;
+        // Are we currently binding code located within an except block?
+        this._isInExceptSuite = false;
+        // Map of symbols at the module level that may be externally
+        // hidden depending on whether they are listed in the __all__ list.
+        this._potentialHiddenSymbols = new Map();
+        // Map of symbols at the module level that may be private depending
+        // on whether they are listed in the __all__ list.
+        this._potentialPrivateSymbols = new Map();
+        // Estimates the overall complexity of the code flow graph for
+        // the current function.
+        this._codeFlowComplexity = 0;
+        this._fileInfo = fileInfo;
+    }
+    bindModule(node) {
+        var _a;
+        // We'll assume that if there is no builtins scope provided, we must be
+        // binding the builtins module itself.
+        const isBuiltInModule = this._fileInfo.builtinsScope === undefined;
+        this._createNewScope(isBuiltInModule ? 4 /* Builtin */ : 3 /* Module */, this._fileInfo.builtinsScope, () => {
+            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+            // Bind implicit names.
+            // List taken from https://docs.python.org/3/reference/import.html#__name__
+            this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
+            this._addImplicitSymbolToCurrentScope('__name__', node, 'str');
+            this._addImplicitSymbolToCurrentScope('__qualname__', node, 'str');
+            this._addImplicitSymbolToCurrentScope('__loader__', node, 'Any');
+            this._addImplicitSymbolToCurrentScope('__package__', node, 'str');
+            this._addImplicitSymbolToCurrentScope('__spec__', node, 'Any');
+            this._addImplicitSymbolToCurrentScope('__path__', node, 'Iterable[str]');
+            this._addImplicitSymbolToCurrentScope('__file__', node, 'str');
+            this._addImplicitSymbolToCurrentScope('__cached__', node, 'str');
+            this._addImplicitSymbolToCurrentScope('__dict__', node, 'Dict[str, Any]');
+            this._addImplicitSymbolToCurrentScope('__annotations__', node, 'Dict[str, Any]');
+            this._addImplicitSymbolToCurrentScope('__builtins__', node, 'Any');
+            // Create a start node for the module.
+            this._currentFlowNode = this._createStartFlowNode();
+            this._walkStatementsAndReportUnreachable(node.statements);
+            // Associate the code flow node at the end of the module with the module.
+            AnalyzerNodeInfo.setAfterFlowNode(node, this._currentFlowNode);
+            AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+            AnalyzerNodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
+        });
+        // Perform all analysis that was deferred during the first pass.
+        this._bindDeferred();
+        // Use the __all__ list to determine whether any potential private
+        // symbols should be made externally hidden or private.
+        this._potentialHiddenSymbols.forEach((symbol, name) => {
+            var _a;
+            if (!((_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.some((sym) => sym === name))) {
+                if (this._fileInfo.isStubFile) {
+                    symbol.setIsExternallyHidden();
+                }
+                else {
+                    symbol.setPrivatePyTypedImport();
+                }
+            }
+        });
+        this._potentialPrivateSymbols.forEach((symbol, name) => {
+            var _a;
+            if (!((_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.some((sym) => sym === name))) {
+                symbol.setIsPrivateMember();
+            }
+        });
+        if (this._dunderAllNames) {
+            AnalyzerNodeInfo.setDunderAllInfo(node, {
+                names: this._dunderAllNames,
+                stringNodes: this._dunderAllStringNodes,
+                usesUnsupportedDunderAllForm: this._usesUnsupportedDunderAllForm,
+            });
+        }
+        else {
+            AnalyzerNodeInfo.setDunderAllInfo(node, /* names */ undefined);
+        }
+        // Set __all__ flags on the module symbols.
+        const scope = AnalyzerNodeInfo.getScope(node);
+        if (scope && this._dunderAllNames) {
+            for (const name of this._dunderAllNames) {
+                (_a = scope.symbolTable.get(name)) === null || _a === void 0 ? void 0 : _a.setIsInDunderAll();
+            }
+        }
+    }
+    visitModule(node) {
+        // Tree walking should start with the children of
+        // the node, so we should never get here.
+        (0, debug_1.fail)('We should never get here');
+        return false;
+    }
+    visitSuite(node) {
+        this._walkStatementsAndReportUnreachable(node.statements);
+        return false;
+    }
+    visitModuleName(node) {
+        const importResult = AnalyzerNodeInfo.getImportInfo(node);
+        (0, debug_1.assert)(importResult !== undefined);
+        if (importResult.isNativeLib) {
+            return true;
+        }
+        if (!importResult.isImportFound) {
+            this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingImports, diagnosticRules_1.DiagnosticRule.reportMissingImports, localize_1.Localizer.Diagnostic.importResolveFailure().format({ importName: importResult.importName }), node);
+            return true;
+        }
+        // Source found, but type stub is missing
+        if (!importResult.isStubFile &&
+            importResult.importType === 1 /* ThirdParty */ &&
+            !importResult.pyTypedInfo) {
+            const diagnostic = this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportMissingTypeStubs, diagnosticRules_1.DiagnosticRule.reportMissingTypeStubs, localize_1.Localizer.Diagnostic.stubFileMissing().format({ importName: importResult.importName }), node);
+            if (diagnostic) {
+                // Add a diagnostic action for resolving this diagnostic.
+                const createTypeStubAction = {
+                    action: "pyright.createtypestub" /* createTypeStub */,
+                    moduleName: importResult.importName,
+                };
+                diagnostic.addAction(createTypeStubAction);
+            }
+        }
+        return true;
+    }
+    visitClass(node) {
+        this.walkMultiple(node.decorators);
+        const classDeclaration = {
+            type: 4 /* Class */,
+            node,
+            path: this._fileInfo.filePath,
+            range: (0, positionUtils_1.convertOffsetsToRange)(node.name.start, textRange_2.TextRange.getEnd(node.name), this._fileInfo.lines),
+            moduleName: this._fileInfo.moduleName,
+            isInExceptSuite: this._isInExceptSuite,
+        };
+        const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+        if (symbol) {
+            symbol.addDeclaration(classDeclaration);
+        }
+        // Stash the declaration in the parse node for later access.
+        AnalyzerNodeInfo.setDeclaration(node, classDeclaration);
+        this.walkMultiple(node.arguments);
+        this._createNewScope(2 /* Class */, this._getNonClassParentScope(), () => {
+            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._addImplicitSymbolToCurrentScope('__doc__', node, 'str | None');
+            this._addImplicitSymbolToCurrentScope('__module__', node, 'str');
+            this._dunderSlotsEntries = undefined;
+            if (!this._moduleSymbolOnly) {
+                // Analyze the suite.
+                this.walk(node.suite);
+            }
+            if (this._dunderSlotsEntries) {
+                this._addSlotsToCurrentScope(this._dunderSlotsEntries);
+            }
+            this._dunderSlotsEntries = undefined;
+        });
+        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        return false;
+    }
+    visitFunction(node) {
+        this._createVariableAnnotationFlowNode();
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+        const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
+        const functionDeclaration = {
+            type: 3 /* Function */,
+            node,
+            isMethod: !!containingClassNode,
+            isGenerator: false,
+            path: this._fileInfo.filePath,
+            range: (0, positionUtils_1.convertOffsetsToRange)(node.name.start, textRange_2.TextRange.getEnd(node.name), this._fileInfo.lines),
+            moduleName: this._fileInfo.moduleName,
+            isInExceptSuite: this._isInExceptSuite,
+        };
+        if (symbol) {
+            symbol.addDeclaration(functionDeclaration);
+        }
+        // Stash the declaration in the parse node for later access.
+        AnalyzerNodeInfo.setDeclaration(node, functionDeclaration);
+        this.walkMultiple(node.decorators);
+        node.parameters.forEach((param) => {
+            if (param.defaultValue) {
+                this.walk(param.defaultValue);
+            }
+            if (param.typeAnnotation) {
+                this.walk(param.typeAnnotation);
+            }
+            if (param.typeAnnotationComment) {
+                this.walk(param.typeAnnotationComment);
+            }
+        });
+        if (node.returnTypeAnnotation) {
+            this.walk(node.returnTypeAnnotation);
+        }
+        if (node.functionAnnotationComment) {
+            this.walk(node.functionAnnotationComment);
+        }
+        // Don't walk the body of the function until we're done analyzing
+        // the current scope.
+        this._createNewScope(1 /* Function */, this._getNonClassParentScope(), () => {
+            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
+            if (enclosingClass) {
+                // Add the implicit "__class__" symbol described in PEP 3135.
+                this._addImplicitSymbolToCurrentScope('__class__', node, 'class');
+            }
+            this._deferBinding(() => {
+                // Create a start node for the function.
+                this._currentFlowNode = this._createStartFlowNode();
+                this._codeFlowComplexity = 0;
+                node.parameters.forEach((paramNode) => {
+                    if (paramNode.name) {
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name.value);
+                        if (symbol) {
+                            const paramDeclaration = {
+                                type: 2 /* Parameter */,
+                                node: paramNode,
+                                path: this._fileInfo.filePath,
+                                range: (0, positionUtils_1.convertOffsetsToRange)(paramNode.start, textRange_2.TextRange.getEnd(paramNode), this._fileInfo.lines),
+                                moduleName: this._fileInfo.moduleName,
+                                isInExceptSuite: this._isInExceptSuite,
+                            };
+                            symbol.addDeclaration(paramDeclaration);
+                            AnalyzerNodeInfo.setDeclaration(paramNode.name, paramDeclaration);
+                        }
+                        this._createFlowAssignment(paramNode.name);
+                    }
+                });
+                this._targetFunctionDeclaration = functionDeclaration;
+                this._currentReturnTarget = this._createBranchLabel();
+                // Walk the statements that make up the function.
+                this.walk(node.suite);
+                // Associate the code flow node at the end of the suite with
+                // the suite.
+                AnalyzerNodeInfo.setAfterFlowNode(node.suite, this._currentFlowNode);
+                // Compute the final return flow node and associate it with
+                // the function's parse node. If this node is unreachable, then
+                // the function never returns.
+                this._addAntecedent(this._currentReturnTarget, this._currentFlowNode);
+                const returnFlowNode = this._finishFlowLabel(this._currentReturnTarget);
+                AnalyzerNodeInfo.setAfterFlowNode(node, returnFlowNode);
+                AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+                AnalyzerNodeInfo.setCodeFlowComplexity(node, this._codeFlowComplexity);
+            });
+        });
+        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        // We'll walk the child nodes in a deferred manner, so don't walk them now.
+        return false;
+    }
+    visitLambda(node) {
+        this._createVariableAnnotationFlowNode();
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        // Analyze the parameter defaults in the context of the parent's scope
+        // before we add any names from the function's scope.
+        node.parameters.forEach((param) => {
+            if (param.defaultValue) {
+                this.walk(param.defaultValue);
+            }
+        });
+        this._createNewScope(1 /* Function */, this._getNonClassParentScope(), () => {
+            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            this._deferBinding(() => {
+                // Create a start node for the lambda.
+                this._currentFlowNode = this._createStartFlowNode();
+                node.parameters.forEach((paramNode) => {
+                    if (paramNode.name) {
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name.value);
+                        if (symbol) {
+                            const paramDeclaration = {
+                                type: 2 /* Parameter */,
+                                node: paramNode,
+                                path: this._fileInfo.filePath,
+                                range: (0, positionUtils_1.convertOffsetsToRange)(paramNode.start, textRange_2.TextRange.getEnd(paramNode), this._fileInfo.lines),
+                                moduleName: this._fileInfo.moduleName,
+                                isInExceptSuite: this._isInExceptSuite,
+                            };
+                            symbol.addDeclaration(paramDeclaration);
+                            AnalyzerNodeInfo.setDeclaration(paramNode.name, paramDeclaration);
+                        }
+                        this._createFlowAssignment(paramNode.name);
+                        this.walk(paramNode.name);
+                    }
+                });
+                // Walk the expression that make up the lambda body.
+                this.walk(node.expression);
+                AnalyzerNodeInfo.setCodeFlowExpressions(node, this._currentScopeCodeFlowExpressions);
+            });
+        });
+        // We'll walk the child nodes in a deferred manner.
+        return false;
+    }
+    visitCall(node) {
+        var _a, _b;
+        this._disableTrueFalseTargets(() => {
+            this.walk(node.leftExpression);
+            node.arguments.forEach((argNode) => {
+                if (this._currentFlowNode) {
+                    AnalyzerNodeInfo.setFlowNode(argNode, this._currentFlowNode);
+                }
+                this.walk(argNode);
+            });
+        });
+        // Create a call flow node. We'll skip this if the call is part of
+        // a decorator. We assume that decorators are not NoReturn functions.
+        // There are libraries that make extensive use of unannotated decorators,
+        // and this can lead to a performance issue when walking the control
+        // flow graph if we need to evaluate every decorator.
+        if (!ParseTreeUtils.isNodeContainedWithinNodeType(node, 13 /* Decorator */)) {
+            this._createCallFlowNode(node);
+        }
+        // Is this an manipulation of dunder all?
+        if (this._currentScope.type === 3 /* Module */ &&
+            node.leftExpression.nodeType === 35 /* MemberAccess */ &&
+            node.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+            node.leftExpression.leftExpression.value === '__all__') {
+            let emitDunderAllWarning = true;
+            // Is this a call to "__all__.extend()"?
+            if (node.leftExpression.memberName.value === 'extend' && node.arguments.length === 1) {
+                const argExpr = node.arguments[0].valueExpression;
+                // Is this a call to "__all__.extend([<list>])"?
+                if (argExpr.nodeType === 31 /* List */) {
+                    argExpr.entries.forEach((listEntryNode) => {
+                        var _a, _b;
+                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                            listEntryNode.strings.length === 1 &&
+                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
+                            (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(listEntryNode.strings[0]);
+                            emitDunderAllWarning = false;
+                        }
+                    });
+                }
+                else if (argExpr.nodeType === 35 /* MemberAccess */ &&
+                    argExpr.leftExpression.nodeType === 38 /* Name */ &&
+                    argExpr.memberName.value === '__all__') {
+                    // Is this a call to "__all__.extend(<mod>.__all__)"?
+                    const namesToAdd = this._getDunderAllNamesFromImport(argExpr.leftExpression.value);
+                    if (namesToAdd && namesToAdd.length > 0) {
+                        namesToAdd.forEach((name) => {
+                            var _a;
+                            (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(name);
+                        });
+                        emitDunderAllWarning = false;
+                    }
+                }
+            }
+            else if (node.leftExpression.memberName.value === 'remove' && node.arguments.length === 1) {
+                // Is this a call to "__all__.remove()"?
+                const argExpr = node.arguments[0].valueExpression;
+                if (argExpr.nodeType === 48 /* StringList */ &&
+                    argExpr.strings.length === 1 &&
+                    argExpr.strings[0].nodeType === 49 /* String */ &&
+                    this._dunderAllNames) {
+                    this._dunderAllNames = this._dunderAllNames.filter((name) => name !== argExpr.strings[0].value);
+                    this._dunderAllStringNodes = this._dunderAllStringNodes.filter((node) => node.value !== argExpr.strings[0].value);
+                    emitDunderAllWarning = false;
+                }
+            }
+            else if (node.leftExpression.memberName.value === 'append' && node.arguments.length === 1) {
+                // Is this a call to "__all__.append()"?
+                const argExpr = node.arguments[0].valueExpression;
+                if (argExpr.nodeType === 48 /* StringList */ &&
+                    argExpr.strings.length === 1 &&
+                    argExpr.strings[0].nodeType === 49 /* String */) {
+                    (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(argExpr.strings[0].value);
+                    (_b = this._dunderAllStringNodes) === null || _b === void 0 ? void 0 : _b.push(argExpr.strings[0]);
+                    emitDunderAllWarning = false;
+                }
+            }
+            if (emitDunderAllWarning) {
+                this._usesUnsupportedDunderAllForm = true;
+                this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll, diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.Localizer.Diagnostic.unsupportedDunderAllOperation(), node);
+            }
+        }
+        return false;
+    }
+    visitAssignment(node) {
+        if (this._handleTypingStubAssignmentOrAnnotation(node)) {
+            return false;
+        }
+        this._bindPossibleTupleNamedTarget(node.leftExpression);
+        if (node.typeAnnotationComment) {
+            this.walk(node.typeAnnotationComment);
+            this._addTypeDeclarationForVariable(node.leftExpression, node.typeAnnotationComment);
+        }
+        // If there is a type annotation associated with the assignment and annotation evaluations are
+        // not deferred, the Python interpreter creates an entry in the local symbol table (presumably
+        // to store the __annotation__ attribute) before it evaluates the RHS of the assignment. This
+        // can affect the evaluation of the RHS if the name of the symbol is the same as a name that
+        // is defined in an outer scope.
+        let createdAssignmentTargetFlowNodes = false;
+        if (node.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
+            !(0, analyzerFileInfo_1.isAnnotationEvaluationPostponed)(this._fileInfo)) {
+            this._createAssignmentTargetFlowNodes(node.leftExpression, /* walkTargets */ true, /* unbound */ false);
+            createdAssignmentTargetFlowNodes = true;
+        }
+        this.walk(node.rightExpression);
+        let isPossibleTypeAlias = true;
+        if (ParseTreeUtils.getEnclosingFunction(node)) {
+            // We will assume that type aliases are defined only at the module level
+            // or as class variables, not as local variables within a function.
+            isPossibleTypeAlias = false;
+        }
+        else if (node.rightExpression.nodeType === 9 /* Call */ && this._fileInfo.isTypingStubFile) {
+            // Some special built-in types defined in typing.pyi use
+            // assignments of the form List = _Alias(). We don't want to
+            // treat these as type aliases.
+            isPossibleTypeAlias = false;
+        }
+        else if (ParseTreeUtils.isWithinLoop(node)) {
+            // Assume that it's not a type alias if it's within a loop.
+            isPossibleTypeAlias = false;
+        }
+        this._addInferredTypeAssignmentForVariable(node.leftExpression, node.rightExpression, isPossibleTypeAlias);
+        // If we didn't create assignment target flow nodes above, do so now.
+        if (!createdAssignmentTargetFlowNodes) {
+            this._createAssignmentTargetFlowNodes(node.leftExpression, /* walkTargets */ true, /* unbound */ false);
+        }
+        // Is this an assignment to dunder all?
+        if (this._currentScope.type === 3 /* Module */) {
+            if ((node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === '__all__') ||
+                (node.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
+                    node.leftExpression.valueExpression.nodeType === 38 /* Name */ &&
+                    node.leftExpression.valueExpression.value === '__all__')) {
+                const expr = node.rightExpression;
+                this._dunderAllNames = [];
+                let emitDunderAllWarning = false;
+                if (expr.nodeType === 31 /* List */) {
+                    expr.entries.forEach((listEntryNode) => {
+                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                            listEntryNode.strings.length === 1 &&
+                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            this._dunderAllNames.push(listEntryNode.strings[0].value);
+                            this._dunderAllStringNodes.push(listEntryNode.strings[0]);
+                        }
+                        else {
+                            emitDunderAllWarning = true;
+                        }
+                    });
+                }
+                else if (expr.nodeType === 52 /* Tuple */) {
+                    expr.expressions.forEach((tupleEntryNode) => {
+                        if (tupleEntryNode.nodeType === 48 /* StringList */ &&
+                            tupleEntryNode.strings.length === 1 &&
+                            tupleEntryNode.strings[0].nodeType === 49 /* String */) {
+                            this._dunderAllNames.push(tupleEntryNode.strings[0].value);
+                            this._dunderAllStringNodes.push(tupleEntryNode.strings[0]);
+                        }
+                        else {
+                            emitDunderAllWarning = true;
+                        }
+                    });
+                }
+                else {
+                    emitDunderAllWarning = true;
+                }
+                if (emitDunderAllWarning) {
+                    this._usesUnsupportedDunderAllForm = true;
+                    this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll, diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.Localizer.Diagnostic.unsupportedDunderAllOperation(), node);
+                }
+            }
+        }
+        // Is this an assignment to dunder slots?
+        if (this._currentScope.type === 2 /* Class */) {
+            if ((node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === '__slots__') ||
+                (node.leftExpression.nodeType === 54 /* TypeAnnotation */ &&
+                    node.leftExpression.valueExpression.nodeType === 38 /* Name */ &&
+                    node.leftExpression.valueExpression.value === '__slots__')) {
+                const expr = node.rightExpression;
+                this._dunderSlotsEntries = [];
+                let isExpressionUnderstood = true;
+                if (expr.nodeType === 48 /* StringList */) {
+                    this._dunderSlotsEntries.push(expr);
+                }
+                else if (expr.nodeType === 31 /* List */) {
+                    expr.entries.forEach((listEntryNode) => {
+                        if (listEntryNode.nodeType === 48 /* StringList */ &&
+                            listEntryNode.strings.length === 1 &&
+                            listEntryNode.strings[0].nodeType === 49 /* String */) {
+                            this._dunderSlotsEntries.push(listEntryNode);
+                        }
+                        else {
+                            isExpressionUnderstood = false;
+                        }
+                    });
+                }
+                else if (expr.nodeType === 52 /* Tuple */) {
+                    expr.expressions.forEach((tupleEntryNode) => {
+                        if (tupleEntryNode.nodeType === 48 /* StringList */ &&
+                            tupleEntryNode.strings.length === 1 &&
+                            tupleEntryNode.strings[0].nodeType === 49 /* String */) {
+                            this._dunderSlotsEntries.push(tupleEntryNode);
+                        }
+                        else {
+                            isExpressionUnderstood = false;
+                        }
+                    });
+                }
+                else {
+                    isExpressionUnderstood = false;
+                }
+                if (!isExpressionUnderstood) {
+                    this._dunderSlotsEntries = undefined;
+                }
+            }
+        }
+        return false;
+    }
+    visitAssignmentExpression(node) {
+        // Temporarily disable true/false targets in case this assignment
+        // expression is located within an if/else conditional.
+        this._disableTrueFalseTargets(() => {
+            // Evaluate the operand expression.
+            this.walk(node.rightExpression);
+        });
+        const evaluationNode = ParseTreeUtils.getEvaluationNodeForAssignmentExpression(node);
+        if (!evaluationNode) {
+            this._addError(localize_1.Localizer.Diagnostic.assignmentExprContext(), node);
+            this.walk(node.name);
+        }
+        else {
+            // Bind the name to the containing scope. This special logic is required
+            // because of the behavior defined in PEP 572. Targets of assignment
+            // expressions don't bind to a list comprehension's scope but instead
+            // bind to its containing scope.
+            const containerScope = AnalyzerNodeInfo.getScope(evaluationNode);
+            // If we're in a list comprehension (possibly nested), make sure that
+            // local for targets don't collide with the target of the assignment
+            // expression.
+            let curScope = this._currentScope;
+            while (curScope && curScope !== containerScope) {
+                const localSymbol = curScope.lookUpSymbol(node.name.value);
+                if (localSymbol) {
+                    this._addError(localize_1.Localizer.Diagnostic.assignmentExprComprehension().format({ name: node.name.value }), node.name);
+                    break;
+                }
+                curScope = curScope.parent;
+            }
+            this._bindNameToScope(containerScope, node.name.value);
+            this._addInferredTypeAssignmentForVariable(node.name, node.rightExpression);
+            this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+        }
+        return false;
+    }
+    visitAugmentedAssignment(node) {
+        this.walk(node.leftExpression);
+        this.walk(node.rightExpression);
+        this._bindPossibleTupleNamedTarget(node.destExpression);
+        this._createAssignmentTargetFlowNodes(node.destExpression, /* walkTargets */ false, /* unbound */ false);
+        // Is this an assignment to dunder all of the form
+        // __all__ += <expression>?
+        if (node.operator === 1 /* AddEqual */ &&
+            this._currentScope.type === 3 /* Module */ &&
+            node.leftExpression.nodeType === 38 /* Name */ &&
+            node.leftExpression.value === '__all__') {
+            const expr = node.rightExpression;
+            let emitDunderAllWarning = true;
+            if (expr.nodeType === 31 /* List */) {
+                // Is this the form __all__ += ["a", "b"]?
+                expr.entries.forEach((listEntryNode) => {
+                    var _a;
+                    if (listEntryNode.nodeType === 48 /* StringList */ &&
+                        listEntryNode.strings.length === 1 &&
+                        listEntryNode.strings[0].nodeType === 49 /* String */) {
+                        (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(listEntryNode.strings[0].value);
+                        this._dunderAllStringNodes.push(listEntryNode.strings[0]);
+                    }
+                });
+                emitDunderAllWarning = false;
+            }
+            else if (expr.nodeType === 35 /* MemberAccess */ &&
+                expr.leftExpression.nodeType === 38 /* Name */ &&
+                expr.memberName.value === '__all__') {
+                // Is this using the form "__all__ += <mod>.__all__"?
+                const namesToAdd = this._getDunderAllNamesFromImport(expr.leftExpression.value);
+                if (namesToAdd) {
+                    namesToAdd.forEach((name) => {
+                        var _a;
+                        (_a = this._dunderAllNames) === null || _a === void 0 ? void 0 : _a.push(name);
+                    });
+                    emitDunderAllWarning = false;
+                }
+            }
+            if (emitDunderAllWarning) {
+                this._usesUnsupportedDunderAllForm = true;
+                this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnsupportedDunderAll, diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll, localize_1.Localizer.Diagnostic.unsupportedDunderAllOperation(), node);
+            }
+        }
+        return false;
+    }
+    visitDel(node) {
+        node.expressions.forEach((expr) => {
+            this._bindPossibleTupleNamedTarget(expr);
+            this.walk(expr);
+            this._createAssignmentTargetFlowNodes(expr, /* walkTargets */ false, /* unbound */ true);
+        });
+        return false;
+    }
+    visitTypeAnnotation(node) {
+        if (this._handleTypingStubAssignmentOrAnnotation(node)) {
+            return false;
+        }
+        // Walk the type annotation first so it is "before" the target
+        // in the code flow graph.
+        this.walk(node.typeAnnotation);
+        this._createVariableAnnotationFlowNode();
+        this._bindPossibleTupleNamedTarget(node.valueExpression);
+        this._addTypeDeclarationForVariable(node.valueExpression, node.typeAnnotation);
+        // For type annotations that are not part of assignments (e.g. simple variable
+        // annotations), we need to populate the reference map. Otherwise the type
+        // analyzer's code flow engine won't run and detect cases where the variable
+        // is unbound.
+        const expressionList = [];
+        if (this._isNarrowingExpression(node.valueExpression, expressionList)) {
+            expressionList.forEach((expr) => {
+                const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(expr);
+                this._currentScopeCodeFlowExpressions.add(referenceKey);
+            });
+        }
+        this.walk(node.valueExpression);
+        return false;
+    }
+    visitFor(node) {
+        this._bindPossibleTupleNamedTarget(node.targetExpression);
+        this._addInferredTypeAssignmentForVariable(node.targetExpression, node);
+        this.walk(node.iterableExpression);
+        const preForLabel = this._createLoopLabel();
+        const preElseLabel = this._createBranchLabel();
+        const postForLabel = this._createBranchLabel();
+        this._addAntecedent(preForLabel, this._currentFlowNode);
+        this._currentFlowNode = preForLabel;
+        this._addAntecedent(preElseLabel, this._currentFlowNode);
+        this._createAssignmentTargetFlowNodes(node.targetExpression, /* walkTargets */ true, /* unbound */ false);
+        this._bindLoopStatement(preForLabel, postForLabel, () => {
+            this.walk(node.forSuite);
+            this._addAntecedent(preForLabel, this._currentFlowNode);
+        });
+        this._currentFlowNode = this._finishFlowLabel(preElseLabel);
+        if (node.elseSuite) {
+            this.walk(node.elseSuite);
+        }
+        this._addAntecedent(postForLabel, this._currentFlowNode);
+        this._currentFlowNode = this._finishFlowLabel(postForLabel);
+        if (node.asyncToken) {
+            const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+            if (!enclosingFunction || !enclosingFunction.isAsync) {
+                this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), node.asyncToken);
+            }
+        }
+        return false;
+    }
+    visitContinue(node) {
+        if (this._currentContinueTarget) {
+            this._addAntecedent(this._currentContinueTarget, this._currentFlowNode);
+        }
+        this._currentFlowNode = Binder._unreachableFlowNode;
+        // Continue nodes don't have any children.
+        return false;
+    }
+    visitBreak(node) {
+        if (this._currentBreakTarget) {
+            this._addAntecedent(this._currentBreakTarget, this._currentFlowNode);
+        }
+        this._currentFlowNode = Binder._unreachableFlowNode;
+        // Break nodes don't have any children.
+        return false;
+    }
+    visitReturn(node) {
+        if (this._targetFunctionDeclaration) {
+            if (!this._targetFunctionDeclaration.returnStatements) {
+                this._targetFunctionDeclaration.returnStatements = [];
+            }
+            this._targetFunctionDeclaration.returnStatements.push(node);
+        }
+        if (node.returnExpression) {
+            this.walk(node.returnExpression);
+        }
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        if (this._currentReturnTarget) {
+            this._addAntecedent(this._currentReturnTarget, this._currentFlowNode);
+        }
+        this._finallyTargets.forEach((target) => {
+            this._addAntecedent(target, this._currentFlowNode);
+        });
+        this._currentFlowNode = Binder._unreachableFlowNode;
+        return false;
+    }
+    visitYield(node) {
+        if (this._isInListComprehension(node, /* ignoreOutermostIterable */ true)) {
+            this._addError(localize_1.Localizer.Diagnostic.yieldWithinListCompr(), node);
+        }
+        this._bindYield(node);
+        return false;
+    }
+    visitYieldFrom(node) {
+        if (this._isInListComprehension(node, /* ignoreOutermostIterable */ true)) {
+            this._addError(localize_1.Localizer.Diagnostic.yieldWithinListCompr(), node);
+        }
+        this._bindYield(node);
+        return false;
+    }
+    visitMemberAccess(node) {
+        this.walk(node.leftExpression);
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        return false;
+    }
+    visitName(node) {
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        // Name nodes have no children.
+        return false;
+    }
+    visitIndex(node) {
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        return true;
+    }
+    visitIf(node) {
+        const preIfFlowNode = this._currentFlowNode;
+        const thenLabel = this._createBranchLabel();
+        const elseLabel = this._createBranchLabel();
+        const postIfLabel = this._createBranchLabel(preIfFlowNode);
+        postIfLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
+            // Determine if the test condition is always true or always false. If so,
+            // we can treat either the then or the else clause as unconditional.
+            const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.testExpression, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
+            this._bindConditional(node.testExpression, thenLabel, elseLabel);
+            // Handle the if clause.
+            this._currentFlowNode =
+                constExprValue === false ? Binder._unreachableFlowNode : this._finishFlowLabel(thenLabel);
+            this.walk(node.ifSuite);
+            this._addAntecedent(postIfLabel, this._currentFlowNode);
+            // Now handle the else clause if it's present. If there
+            // are chained "else if" statements, they'll be handled
+            // recursively here.
+            this._currentFlowNode =
+                constExprValue === true ? Binder._unreachableFlowNode : this._finishFlowLabel(elseLabel);
+            if (node.elseSuite) {
+                this.walk(node.elseSuite);
+            }
+            else {
+                this._bindNeverCondition(node.testExpression, postIfLabel, /* isPositiveTest */ false);
+            }
+            this._addAntecedent(postIfLabel, this._currentFlowNode);
+            this._currentFlowNode = this._finishFlowLabel(postIfLabel);
+        });
+        return false;
+    }
+    visitWhile(node) {
+        const thenLabel = this._createBranchLabel();
+        const elseLabel = this._createBranchLabel();
+        const postWhileLabel = this._createBranchLabel();
+        // Determine if the test condition is always true or always false. If so,
+        // we can treat either the while or the else clause as unconditional.
+        const constExprValue = StaticExpressions.evaluateStaticBoolLikeExpression(node.testExpression, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
+        const preLoopLabel = this._createLoopLabel();
+        this._addAntecedent(preLoopLabel, this._currentFlowNode);
+        this._currentFlowNode = preLoopLabel;
+        this._bindConditional(node.testExpression, thenLabel, elseLabel);
+        // Handle the while clause.
+        this._currentFlowNode =
+            constExprValue === false ? Binder._unreachableFlowNode : this._finishFlowLabel(thenLabel);
+        this._bindLoopStatement(preLoopLabel, postWhileLabel, () => {
+            this.walk(node.whileSuite);
+        });
+        this._addAntecedent(preLoopLabel, this._currentFlowNode);
+        this._currentFlowNode =
+            constExprValue === true ? Binder._unreachableFlowNode : this._finishFlowLabel(elseLabel);
+        if (node.elseSuite) {
+            this.walk(node.elseSuite);
+        }
+        this._addAntecedent(postWhileLabel, this._currentFlowNode);
+        this._currentFlowNode = this._finishFlowLabel(postWhileLabel);
+        return false;
+    }
+    visitAssert(node) {
+        const assertTrueLabel = this._createBranchLabel();
+        const assertFalseLabel = this._createBranchLabel();
+        this._bindConditional(node.testExpression, assertTrueLabel, assertFalseLabel);
+        if (node.exceptionExpression) {
+            this._currentFlowNode = this._finishFlowLabel(assertFalseLabel);
+            this.walk(node.exceptionExpression);
+        }
+        this._currentFlowNode = this._finishFlowLabel(assertTrueLabel);
+        return false;
+    }
+    visitExcept(node) {
+        if (node.typeExpression) {
+            this.walk(node.typeExpression);
+        }
+        if (node.name) {
+            this.walk(node.name);
+            const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+            this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+            if (symbol) {
+                const declaration = {
+                    type: 1 /* Variable */,
+                    node: node.name,
+                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.name.value),
+                    inferredTypeSource: node,
+                    path: this._fileInfo.filePath,
+                    range: (0, positionUtils_1.convertOffsetsToRange)(node.name.start, textRange_2.TextRange.getEnd(node.name), this._fileInfo.lines),
+                    moduleName: this._fileInfo.moduleName,
+                    isInExceptSuite: this._isInExceptSuite,
+                };
+                symbol.addDeclaration(declaration);
+            }
+        }
+        const wasInExceptSuite = this._isInExceptSuite;
+        this._isInExceptSuite = true;
+        this.walk(node.exceptSuite);
+        this._isInExceptSuite = wasInExceptSuite;
+        if (node.name) {
+            // The exception name is implicitly unbound at the end of
+            // the except block.
+            this._createFlowAssignment(node.name, /* unbound */ true);
+        }
+        return false;
+    }
+    visitRaise(node) {
+        if (this._targetFunctionDeclaration) {
+            if (!this._targetFunctionDeclaration.raiseStatements) {
+                this._targetFunctionDeclaration.raiseStatements = [];
+            }
+            this._targetFunctionDeclaration.raiseStatements.push(node);
+        }
+        if (node.typeExpression) {
+            this.walk(node.typeExpression);
+        }
+        if (node.valueExpression) {
+            this.walk(node.valueExpression);
+        }
+        if (node.tracebackExpression) {
+            this.walk(node.tracebackExpression);
+        }
+        this._finallyTargets.forEach((target) => {
+            this._addAntecedent(target, this._currentFlowNode);
+        });
+        this._currentFlowNode = Binder._unreachableFlowNode;
+        return false;
+    }
+    visitTry(node) {
+        // The try/except/else/finally statement is tricky to model using static code
+        // flow rules because the finally clause is executed regardless of whether an
+        // exception is raised or a return statement is executed. Code within the finally
+        // clause needs to be reachable always, and we conservatively assume that any
+        // statement within the try block can generate an exception, so we assume that its
+        // antecedent is the pre-try flow. We implement this with a "gate" node in the
+        // control flow graph. If analysis starts within the finally clause, the gate is
+        // opened, and all raise/return statements within try/except/else blocks are
+        // considered antecedents. If analysis starts outside (after) the finally clause,
+        // the gate is closed, and only paths that don't hit a raise/return statement
+        // in try/except/else blocks are considered.
+        //
+        //
+        //                               1. PostElse
+        //                                    ^
+        //                                    |
+        // 3. TryExceptElseReturnOrExcept     |
+        //       ^                            |
+        //       |                            |     2. PostExcept (for each except)
+        //       |                            |            ^
+        // 4. ReturnOrRaiseLabel              |            |
+        //       ^                            |            |
+        //       |                            |   |---------
+        // 5. PreFinallyGate                  |   |
+        //       ^                            |   |
+        //       |------------------          |   |
+        //                         |          |   |
+        //                        6. PreFinallyLabel
+        //                                ^
+        //                         (finally block)
+        //                                ^
+        //                        7. PostFinally
+        //                                ^    (only if isAfterElseAndExceptsReachable)
+        //                         (after finally)
+        // Create one flow label for every except clause.
+        const preTryFlowNode = this._currentFlowNode;
+        const curExceptTargets = node.exceptClauses.map(() => this._createBranchLabel());
+        const preFinallyLabel = this._createBranchLabel(preTryFlowNode);
+        let isAfterElseAndExceptsReachable = false;
+        // Create a label for all of the return or raise labels that are
+        // encountered within the try/except/else blocks. This conditionally
+        // connects the return/raise statement to the finally clause.
+        const preFinallyReturnOrRaiseLabel = this._createBranchLabel(preTryFlowNode);
+        const preFinallyGate = {
+            flags: codeFlowTypes_1.FlowFlags.PreFinallyGate,
+            id: this._getUniqueFlowNodeId(),
+            antecedent: preFinallyReturnOrRaiseLabel,
+            isGateClosed: false,
+        };
+        preFinallyLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
+            if (node.finallySuite) {
+                this._addAntecedent(preFinallyLabel, preFinallyGate);
+            }
+            // Add the finally target as an exception target unless there is
+            // a "bare" except clause that accepts all exception types.
+            const hasBareExceptClause = node.exceptClauses.some((except) => !except.typeExpression);
+            if (!hasBareExceptClause) {
+                curExceptTargets.push(preFinallyReturnOrRaiseLabel);
+            }
+            // An exception may be generated before the first flow node
+            // added by the try block, so all of the exception targets
+            // must have the pre-try flow node as an antecedent.
+            curExceptTargets.forEach((exceptLabel) => {
+                this._addAntecedent(exceptLabel, this._currentFlowNode);
+            });
+            // We don't perfectly handle nested finally clauses, which are not
+            // possible to model fully within a static analyzer, but we do handle
+            // a single level of finally statements, and we handle most cases
+            // involving nesting. Returns or raises within the try/except/raise
+            // block will execute the finally target(s).
+            if (node.finallySuite) {
+                this._finallyTargets.push(preFinallyReturnOrRaiseLabel);
+            }
+            // Handle the try block.
+            this._useExceptTargets(curExceptTargets, () => {
+                this.walk(node.trySuite);
+            });
+            // Handle the else block, which is executed only if
+            // execution falls through the try block.
+            if (node.elseSuite) {
+                this.walk(node.elseSuite);
+            }
+            this._addAntecedent(preFinallyLabel, this._currentFlowNode);
+            if (!this._isCodeUnreachable()) {
+                isAfterElseAndExceptsReachable = true;
+            }
+            // Handle the except blocks.
+            node.exceptClauses.forEach((exceptNode, index) => {
+                this._currentFlowNode = this._finishFlowLabel(curExceptTargets[index]);
+                this.walk(exceptNode);
+                this._addAntecedent(preFinallyLabel, this._currentFlowNode);
+                if (!this._isCodeUnreachable()) {
+                    isAfterElseAndExceptsReachable = true;
+                }
+            });
+            if (node.finallySuite) {
+                this._finallyTargets.pop();
+            }
+            // Handle the finally block.
+            this._currentFlowNode = this._finishFlowLabel(preFinallyLabel);
+        });
+        if (node.finallySuite) {
+            this.walk(node.finallySuite);
+            // Add a post-finally node at the end. If we traverse this node,
+            // we'll set the "ignore" flag in the pre-finally node.
+            const postFinallyNode = {
+                flags: codeFlowTypes_1.FlowFlags.PostFinally,
+                id: this._getUniqueFlowNodeId(),
+                finallyNode: node.finallySuite,
+                antecedent: this._currentFlowNode,
+                preFinallyGate,
+            };
+            this._currentFlowNode = isAfterElseAndExceptsReachable ? postFinallyNode : Binder._unreachableFlowNode;
+        }
+        return false;
+    }
+    visitAwait(node) {
+        var _a;
+        // Make sure this is within an async lambda or function.
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        if (enclosingFunction === undefined || !enclosingFunction.isAsync) {
+            if (this._fileInfo.isIPythonMode && enclosingFunction === undefined) {
+                // Top level await is allowed in ipython mode.
+                return true;
+            }
+            // Allow if it's within a generator expression. Execution of
+            // generator expressions is deferred and therefore can be
+            // run within the context of an async function later.
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 32 /* ListComprehension */) {
+                this._addError(localize_1.Localizer.Diagnostic.awaitNotInAsync(), node);
+            }
+        }
+        return true;
+    }
+    visitGlobal(node) {
+        const globalScope = this._currentScope.getGlobalScope().scope;
+        node.nameList.forEach((name) => {
+            const nameValue = name.value;
+            // Is the binding inconsistent?
+            if (this._currentScope.getBindingType(nameValue) === 0 /* Nonlocal */) {
+                this._addError(localize_1.Localizer.Diagnostic.nonLocalRedefinition().format({ name: nameValue }), name);
+            }
+            const valueWithScope = this._currentScope.lookUpSymbolRecursive(nameValue);
+            // Was the name already assigned within this scope before it was declared global?
+            if (valueWithScope && valueWithScope.scope === this._currentScope) {
+                this._addError(localize_1.Localizer.Diagnostic.globalReassignment().format({ name: nameValue }), name);
+            }
+            // Add it to the global scope if it's not already added.
+            this._bindNameToScope(globalScope, nameValue);
+            if (this._currentScope !== globalScope) {
+                this._currentScope.setBindingType(nameValue, 1 /* Global */);
+            }
+        });
+        return true;
+    }
+    visitNonlocal(node) {
+        const globalScope = this._currentScope.getGlobalScope().scope;
+        if (this._currentScope === globalScope) {
+            this._addError(localize_1.Localizer.Diagnostic.nonLocalInModule(), node);
+        }
+        else {
+            node.nameList.forEach((name) => {
+                const nameValue = name.value;
+                // Is the binding inconsistent?
+                if (this._currentScope.getBindingType(nameValue) === 1 /* Global */) {
+                    this._addError(localize_1.Localizer.Diagnostic.globalRedefinition().format({ name: nameValue }), name);
+                }
+                const valueWithScope = this._currentScope.lookUpSymbolRecursive(nameValue);
+                // Was the name already assigned within this scope before it was declared nonlocal?
+                if (valueWithScope && valueWithScope.scope === this._currentScope) {
+                    this._addError(localize_1.Localizer.Diagnostic.nonLocalReassignment().format({ name: nameValue }), name);
+                }
+                else if (!valueWithScope || valueWithScope.scope === globalScope) {
+                    this._addError(localize_1.Localizer.Diagnostic.nonLocalNoBinding().format({ name: nameValue }), name);
+                }
+                if (valueWithScope) {
+                    this._currentScope.setBindingType(nameValue, 0 /* Nonlocal */);
+                }
+            });
+        }
+        return true;
+    }
+    visitImportAs(node) {
+        var _a, _b, _c, _d, _e, _f;
+        if (node.module.nameParts.length > 0) {
+            const firstNamePartValue = node.module.nameParts[0].value;
+            let symbolName;
+            if (node.alias) {
+                // The symbol name is defined by the alias.
+                symbolName = node.alias.value;
+            }
+            else {
+                // There was no alias, so we need to use the first element of
+                // the name parts as the symbol.
+                symbolName = firstNamePartValue;
+            }
+            const symbol = this._bindNameToScope(this._currentScope, symbolName);
+            if (symbol &&
+                (this._currentScope.type === 3 /* Module */ || this._currentScope.type === 4 /* Builtin */) &&
+                (!node.alias ||
+                    node.module.nameParts.length !== 1 ||
+                    node.module.nameParts[0].value !== node.alias.value)) {
+                if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
+                    // PEP 484 indicates that imported symbols should not be
+                    // considered "reexported" from a type stub file unless
+                    // they are imported using the "as" form and the aliased
+                    // name is entirely redundant.
+                    this._potentialHiddenSymbols.set(symbolName, symbol);
+                }
+            }
+            const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+            (0, debug_1.assert)(importInfo !== undefined);
+            if (symbol) {
+                this._createAliasDeclarationForMultipartImportName(node, node.alias, importInfo, symbol);
+            }
+            this._createFlowAssignment(node.alias ? node.alias : node.module.nameParts[0]);
+            if (node.module.nameParts.length === 1) {
+                if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
+                    this._typingImportAliases.push((_b = (_a = node.alias) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : firstNamePartValue);
+                }
+                else if (firstNamePartValue === 'sys') {
+                    this._sysImportAliases.push((_d = (_c = node.alias) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : firstNamePartValue);
+                }
+                else if (firstNamePartValue === 'dataclasses') {
+                    this._dataclassesImportAliases.push((_f = (_e = node.alias) === null || _e === void 0 ? void 0 : _e.value) !== null && _f !== void 0 ? _f : firstNamePartValue);
+                }
+            }
+        }
+        return true;
+    }
+    visitImportFrom(node) {
+        const typingSymbolsOfInterest = ['Final', 'TypeAlias', 'ClassVar', 'Required', 'NotRequired', 'Annotated'];
+        const dataclassesSymbolsOfInterest = ['InitVar'];
+        const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
+        let resolvedPath = '';
+        if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib) {
+            resolvedPath = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
+        }
+        // If this file is a module __init__.py(i), relative imports of submodules
+        // using the syntax "from .x import y" introduce a symbol x into the
+        // module namespace. We do this first (before adding the individual imported
+        // symbols below) in case one of the imported symbols is the same name as the
+        // submodule. In that case, we want to the symbol to appear later in the
+        // declaration list because it should "win" when resolving the alias.
+        const fileName = (0, pathUtils_1.stripFileExtension)((0, pathUtils_1.getFileName)(this._fileInfo.filePath));
+        const isModuleInitFile = fileName === '__init__' && node.module.leadingDots === 1 && node.module.nameParts.length === 1;
+        let isTypingImport = false;
+        let isDataclassesImport = false;
+        if (node.module.nameParts.length === 1) {
+            const firstNamePartValue = node.module.nameParts[0].value;
+            if (firstNamePartValue === 'typing' || firstNamePartValue === 'typing_extensions') {
+                isTypingImport = true;
+            }
+            if (firstNamePartValue === 'dataclasses') {
+                isDataclassesImport = true;
+            }
+        }
+        if (node.isWildcardImport) {
+            if (ParseTreeUtils.getEnclosingClass(node) || ParseTreeUtils.getEnclosingFunction(node)) {
+                this._addError(localize_1.Localizer.Diagnostic.wildcardInFunction(), node);
+            }
+            if (importInfo) {
+                const names = [];
+                const lookupInfo = this._fileInfo.importLookup(resolvedPath);
+                if (lookupInfo) {
+                    const wildcardNames = this._getWildcardImportNames(lookupInfo);
+                    if (isModuleInitFile) {
+                        // If the symbol is going to be immediately replaced with a same-named
+                        // imported symbol, skip this.
+                        const isImmediatelyReplaced = wildcardNames.some((name) => {
+                            return name === node.module.nameParts[0].value;
+                        });
+                        if (!isImmediatelyReplaced) {
+                            this._addImplicitFromImport(node, importInfo);
+                        }
+                    }
+                    wildcardNames.forEach((name) => {
+                        const localSymbol = this._bindNameToScope(this._currentScope, name);
+                        if (localSymbol) {
+                            const importedSymbol = lookupInfo.symbolTable.get(name);
+                            // Is the symbol in the target module's symbol table? If so,
+                            // alias it.
+                            if (importedSymbol) {
+                                const aliasDecl = {
+                                    type: 6 /* Alias */,
+                                    node,
+                                    path: resolvedPath,
+                                    loadSymbolsFromPath: true,
+                                    range: (0, textRange_1.getEmptyRange)(),
+                                    usesLocalName: false,
+                                    symbolName: name,
+                                    moduleName: this._fileInfo.moduleName,
+                                    isInExceptSuite: this._isInExceptSuite,
+                                };
+                                localSymbol.addDeclaration(aliasDecl);
+                                names.push(name);
+                            }
+                            else {
+                                // The symbol wasn't in the target module's symbol table. It's probably
+                                // an implicitly-imported submodule referenced by __all__.
+                                if (importInfo && importInfo.filteredImplicitImports) {
+                                    const implicitImport = importInfo.filteredImplicitImports.find((imp) => imp.name === name);
+                                    if (implicitImport) {
+                                        const submoduleFallback = {
+                                            type: 6 /* Alias */,
+                                            node,
+                                            path: implicitImport.path,
+                                            loadSymbolsFromPath: true,
+                                            range: (0, textRange_1.getEmptyRange)(),
+                                            usesLocalName: false,
+                                            moduleName: this._fileInfo.moduleName,
+                                            isInExceptSuite: this._isInExceptSuite,
+                                        };
+                                        const aliasDecl = {
+                                            type: 6 /* Alias */,
+                                            node,
+                                            path: resolvedPath,
+                                            loadSymbolsFromPath: true,
+                                            usesLocalName: false,
+                                            symbolName: name,
+                                            submoduleFallback,
+                                            range: (0, textRange_1.getEmptyRange)(),
+                                            moduleName: this._fileInfo.moduleName,
+                                            isInExceptSuite: this._isInExceptSuite,
+                                        };
+                                        localSymbol.addDeclaration(aliasDecl);
+                                    }
+                                }
+                            }
+                        }
+                    });
+                }
+                this._createFlowWildcardImport(node, names);
+                if (isTypingImport) {
+                    typingSymbolsOfInterest.forEach((s) => {
+                        this._typingSymbolAliases.set(s, s);
+                    });
+                }
+                if (isDataclassesImport) {
+                    dataclassesSymbolsOfInterest.forEach((s) => {
+                        this._dataclassesSymbolAliases.set(s, s);
+                    });
+                }
+            }
+        }
+        else {
+            if (isModuleInitFile) {
+                this._addImplicitFromImport(node, importInfo);
+            }
+            node.imports.forEach((importSymbolNode) => {
+                const importedName = importSymbolNode.name.value;
+                const nameNode = importSymbolNode.alias || importSymbolNode.name;
+                const symbol = this._bindNameToScope(this._currentScope, nameNode.value);
+                if (symbol) {
+                    // All import statements of the form `from . import x` treat x
+                    // as an externally-visible (not hidden) symbol.
+                    if (node.module.nameParts.length > 0) {
+                        if (this._currentScope.type === 3 /* Module */ ||
+                            this._currentScope.type === 4 /* Builtin */) {
+                            if (!importSymbolNode.alias ||
+                                importSymbolNode.alias.value !== importSymbolNode.name.value) {
+                                if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
+                                    // PEP 484 indicates that imported symbols should not be
+                                    // considered "reexported" from a type stub file unless
+                                    // they are imported using the "as" form using a redundant form.
+                                    // Py.typed packages follow the same rule as PEP 484.
+                                    this._potentialHiddenSymbols.set(nameNode.value, symbol);
+                                }
+                            }
+                        }
+                    }
+                    // Is the import referring to an implicitly-imported module?
+                    let implicitImport;
+                    if (importInfo && importInfo.filteredImplicitImports) {
+                        implicitImport = importInfo.filteredImplicitImports.find((imp) => imp.name === importedName);
+                    }
+                    let submoduleFallback;
+                    let loadSymbolsFromPath = true;
+                    if (implicitImport) {
+                        submoduleFallback = {
+                            type: 6 /* Alias */,
+                            node: importSymbolNode,
+                            path: implicitImport.path,
+                            loadSymbolsFromPath: true,
+                            range: (0, textRange_1.getEmptyRange)(),
+                            usesLocalName: false,
+                            moduleName: this._fileInfo.moduleName,
+                            isInExceptSuite: this._isInExceptSuite,
+                        };
+                        // Handle the case of "from . import X" within an __init__ file.
+                        // In this case, we want to always resolve to the submodule rather
+                        // than the resolved path.
+                        if (fileName === '__init__' &&
+                            node.module.leadingDots === 1 &&
+                            node.module.nameParts.length === 0) {
+                            loadSymbolsFromPath = false;
+                        }
+                    }
+                    const aliasDecl = {
+                        type: 6 /* Alias */,
+                        node: importSymbolNode,
+                        path: resolvedPath,
+                        loadSymbolsFromPath,
+                        usesLocalName: !!importSymbolNode.alias,
+                        symbolName: importedName,
+                        submoduleFallback,
+                        range: (0, textRange_1.getEmptyRange)(),
+                        moduleName: this._fileInfo.moduleName,
+                        isInExceptSuite: this._isInExceptSuite,
+                        isNativeLib: importInfo === null || importInfo === void 0 ? void 0 : importInfo.isNativeLib,
+                    };
+                    symbol.addDeclaration(aliasDecl);
+                    this._createFlowAssignment(importSymbolNode.alias || importSymbolNode.name);
+                    if (isTypingImport) {
+                        if (typingSymbolsOfInterest.some((s) => s === importSymbolNode.name.value)) {
+                            this._typingSymbolAliases.set(nameNode.value, importSymbolNode.name.value);
+                        }
+                    }
+                    if (isDataclassesImport) {
+                        if (dataclassesSymbolsOfInterest.some((s) => s === importSymbolNode.name.value)) {
+                            this._dataclassesSymbolAliases.set(nameNode.value, importSymbolNode.name.value);
+                        }
+                    }
+                }
+            });
+        }
+        return true;
+    }
+    visitWith(node) {
+        node.withItems.forEach((item) => {
+            this.walk(item.expression);
+            if (item.target) {
+                this._bindPossibleTupleNamedTarget(item.target);
+                this._addInferredTypeAssignmentForVariable(item.target, item);
+                this._createAssignmentTargetFlowNodes(item.target, /* walkTargets */ true, /* unbound */ false);
+            }
+        });
+        // We need to treat the "with" body as though it is wrapped in a try/except
+        // block because some context managers catch and suppress exceptions.
+        // We'll make use of a special "context manager label" which acts like
+        // a regular branch label in most respects except that it is disabled
+        // if none of the context managers support exception suppression. We won't
+        // be able to determine whether any context managers support exception
+        // processing until the type evaluation phase.
+        //
+        //  (pre with suite)
+        //         ^
+        //         |<--------------------|
+        //    (with suite)<--------------|
+        //         ^                     |
+        //         |    ContextManagerSwallowExceptionTarget
+        //         |                     ^
+        //         |          PostContextManagerLabel
+        //         |                     ^
+        //         |---------------------|
+        //         |
+        //   (after with)
+        //
+        // In addition to the ContextManagerSwallowExceptionTarget, we'll create
+        // a second target called ContextManagerForwardExceptionTarget that forwards
+        // exceptions to existing exception targets if they exist.
+        const contextManagerSwallowExceptionTarget = this._createContextManagerLabel(node.withItems.map((item) => item.expression), !!node.isAsync, 
+        /* blockIfSwallowsExceptions */ false);
+        this._addAntecedent(contextManagerSwallowExceptionTarget, this._currentFlowNode);
+        const contextManagerForwardExceptionTarget = this._createContextManagerLabel(node.withItems.map((item) => item.expression), !!node.isAsync, 
+        /* blockIfSwallowsExceptions */ true);
+        this._currentExceptTargets.forEach((exceptionTarget) => {
+            this._addAntecedent(exceptionTarget, contextManagerForwardExceptionTarget);
+        });
+        const preWithSuiteNode = this._currentFlowNode;
+        const postContextManagerLabel = this._createBranchLabel(preWithSuiteNode);
+        this._addAntecedent(postContextManagerLabel, contextManagerSwallowExceptionTarget);
+        postContextManagerLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
+            this._useExceptTargets([contextManagerSwallowExceptionTarget, contextManagerForwardExceptionTarget], () => {
+                this.walk(node.suite);
+            });
+            this._addAntecedent(postContextManagerLabel, this._currentFlowNode);
+            this._currentFlowNode = postContextManagerLabel;
+            // Model the call to `__exit__` as a potential exception generator.
+            if (!this._isCodeUnreachable()) {
+                this._addExceptTargets(this._currentFlowNode);
+            }
+            if (node.asyncToken) {
+                const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+                if (!enclosingFunction || !enclosingFunction.isAsync) {
+                    this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), node.asyncToken);
+                }
+            }
+        });
+        return false;
+    }
+    visitTernary(node) {
+        const preTernaryFlowNode = this._currentFlowNode;
+        const trueLabel = this._createBranchLabel();
+        const falseLabel = this._createBranchLabel();
+        const postExpressionLabel = this._createBranchLabel(preTernaryFlowNode);
+        postExpressionLabel.affectedExpressions = this._trackCodeFlowExpressions(() => {
+            // Handle the test expression.
+            this._bindConditional(node.testExpression, trueLabel, falseLabel);
+            // Handle the "true" portion (the "if" expression).
+            this._currentFlowNode = this._finishFlowLabel(trueLabel);
+            this.walk(node.ifExpression);
+            this._addAntecedent(postExpressionLabel, this._currentFlowNode);
+            // Handle the "false" portion (the "else" expression).
+            this._currentFlowNode = this._finishFlowLabel(falseLabel);
+            this.walk(node.elseExpression);
+            this._addAntecedent(postExpressionLabel, this._currentFlowNode);
+            this._currentFlowNode = this._finishFlowLabel(postExpressionLabel);
+        });
+        return false;
+    }
+    visitUnaryOperation(node) {
+        if (node.operator === 38 /* Not */ && this._currentFalseTarget && this._currentTrueTarget) {
+            // Swap the existing true/false targets.
+            this._bindConditional(node.expression, this._currentFalseTarget, this._currentTrueTarget);
+        }
+        else {
+            // Temporarily set the true/false targets to undefined because
+            // this unary operation is not part of a chain of logical expressions
+            // (AND/OR/NOT subexpressions).
+            this._disableTrueFalseTargets(() => {
+                // Evaluate the operand expression.
+                this.walk(node.expression);
+            });
+        }
+        return false;
+    }
+    visitBinaryOperation(node) {
+        if (node.operator === 36 /* And */ || node.operator === 37 /* Or */) {
+            let trueTarget = this._currentTrueTarget;
+            let falseTarget = this._currentFalseTarget;
+            let postRightLabel;
+            if (!trueTarget || !falseTarget) {
+                postRightLabel = this._createBranchLabel();
+                trueTarget = falseTarget = postRightLabel;
+            }
+            const preRightLabel = this._createBranchLabel();
+            if (node.operator === 36 /* And */) {
+                this._bindConditional(node.leftExpression, preRightLabel, falseTarget);
+            }
+            else {
+                this._bindConditional(node.leftExpression, trueTarget, preRightLabel);
+            }
+            this._currentFlowNode = this._finishFlowLabel(preRightLabel);
+            this._bindConditional(node.rightExpression, trueTarget, falseTarget);
+            if (postRightLabel) {
+                this._currentFlowNode = this._finishFlowLabel(postRightLabel);
+            }
+        }
+        else {
+            // Temporarily set the true/false targets to undefined because
+            // this binary operation is not part of a chain of logical expressions
+            // (AND/OR/NOT subexpressions).
+            this._disableTrueFalseTargets(() => {
+                this.walk(node.leftExpression);
+                this.walk(node.rightExpression);
+            });
+        }
+        return false;
+    }
+    visitListComprehension(node) {
+        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
+        this._createNewScope(0 /* ListComprehension */, this._getNonClassParentScope(), () => {
+            var _a;
+            AnalyzerNodeInfo.setScope(node, this._currentScope);
+            const falseLabel = this._createBranchLabel();
+            // We'll walk the forIfNodes list twice. The first time we'll
+            // bind targets of for statements. The second time we'll walk
+            // expressions and create the control flow graph.
+            for (let i = 0; i < node.forIfNodes.length; i++) {
+                const compr = node.forIfNodes[i];
+                const addedSymbols = new Map();
+                if (compr.nodeType === 33 /* ListComprehensionFor */) {
+                    this._bindPossibleTupleNamedTarget(compr.targetExpression, addedSymbols);
+                    this._addInferredTypeAssignmentForVariable(compr.targetExpression, compr);
+                    // Async for is not allowed outside of an async function.
+                    if (compr.asyncToken) {
+                        if (!enclosingFunction || !enclosingFunction.isAsync) {
+                            // Allow if it's within a generator expression. Execution of
+                            // generator expressions is deferred and therefore can be
+                            // run within the context of an async function later.
+                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 31 /* List */) {
+                                this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), compr.asyncToken);
+                            }
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < node.forIfNodes.length; i++) {
+                const compr = node.forIfNodes[i];
+                if (compr.nodeType === 33 /* ListComprehensionFor */) {
+                    this.walk(compr.iterableExpression);
+                    this._createAssignmentTargetFlowNodes(compr.targetExpression, 
+                    /* walkTargets */ true, 
+                    /* unbound */ false);
+                }
+                else {
+                    const trueLabel = this._createBranchLabel();
+                    this._bindConditional(compr.testExpression, trueLabel, falseLabel);
+                    this._currentFlowNode = this._finishFlowLabel(trueLabel);
+                }
+            }
+            this.walk(node.expression);
+            this._addAntecedent(falseLabel, this._currentFlowNode);
+            this._currentFlowNode = this._finishFlowLabel(falseLabel);
+        });
+        return false;
+    }
+    visitMatch(node) {
+        // Evaluate the subject expression.
+        this.walk(node.subjectExpression);
+        const expressionList = [];
+        const isSubjectNarrowable = this._isNarrowingExpression(node.subjectExpression, expressionList);
+        if (isSubjectNarrowable) {
+            expressionList.forEach((expr) => {
+                const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(expr);
+                this._currentScopeCodeFlowExpressions.add(referenceKey);
+            });
+        }
+        const postMatchLabel = this._createBranchLabel();
+        let foundIrrefutableCase = false;
+        // Model the match statement as a series of if/elif clauses
+        // each of which tests for the specified pattern (and optionally
+        // for the guard condition).
+        node.cases.forEach((caseStatement) => {
+            const postCaseLabel = this._createBranchLabel();
+            const preGuardLabel = this._createBranchLabel();
+            const preSuiteLabel = this._createBranchLabel();
+            // Evaluate the pattern.
+            this._addAntecedent(preGuardLabel, this._currentFlowNode);
+            if (!caseStatement.isIrrefutable) {
+                this._addAntecedent(postCaseLabel, this._currentFlowNode);
+            }
+            else if (!caseStatement.guardExpression) {
+                foundIrrefutableCase = true;
+            }
+            this._currentFlowNode = this._finishFlowLabel(preGuardLabel);
+            // Bind the pattern.
+            this.walk(caseStatement.pattern);
+            if (isSubjectNarrowable) {
+                this._createFlowNarrowForPattern(node.subjectExpression, caseStatement);
+            }
+            // Apply the guard expression.
+            if (caseStatement.guardExpression) {
+                this._bindConditional(caseStatement.guardExpression, preSuiteLabel, postCaseLabel);
+            }
+            else {
+                this._addAntecedent(preSuiteLabel, this._currentFlowNode);
+            }
+            this._currentFlowNode = this._finishFlowLabel(preSuiteLabel);
+            // Bind the body of the case statement.
+            this.walk(caseStatement.suite);
+            this._addAntecedent(postMatchLabel, this._currentFlowNode);
+            this._currentFlowNode = this._finishFlowLabel(postCaseLabel);
+        });
+        // Add a final narrowing step for the subject expression for the entire
+        // match statement. This will compute the narrowed type if no case
+        // statements are matched.
+        if (isSubjectNarrowable) {
+            this._createFlowNarrowForPattern(node.subjectExpression, node);
+        }
+        // Create an "implied else" to conditionally gate code flow based on
+        // whether the narrowed type of the subject expression is Never at this point.
+        if (!foundIrrefutableCase) {
+            this._createFlowExhaustedMatch(node);
+        }
+        this._addAntecedent(postMatchLabel, this._currentFlowNode);
+        this._currentFlowNode = this._finishFlowLabel(postMatchLabel);
+        return false;
+    }
+    visitPatternAs(node) {
+        const postOrLabel = this._createBranchLabel();
+        node.orPatterns.forEach((orPattern) => {
+            this.walk(orPattern);
+            this._addAntecedent(postOrLabel, this._currentFlowNode);
+        });
+        this._currentFlowNode = this._finishFlowLabel(postOrLabel);
+        if (node.target) {
+            this.walk(node.target);
+            const symbol = this._bindNameToScope(this._currentScope, node.target.value);
+            this._createAssignmentTargetFlowNodes(node.target, /* walkTargets */ false, /* unbound */ false);
+            if (symbol) {
+                const declaration = {
+                    type: 1 /* Variable */,
+                    node: node.target,
+                    isConstant: (0, symbolNameUtils_1.isConstantName)(node.target.value),
+                    inferredTypeSource: node,
+                    path: this._fileInfo.filePath,
+                    range: (0, positionUtils_1.convertOffsetsToRange)(node.target.start, textRange_2.TextRange.getEnd(node.target), this._fileInfo.lines),
+                    moduleName: this._fileInfo.moduleName,
+                    isInExceptSuite: this._isInExceptSuite,
+                };
+                symbol.addDeclaration(declaration);
+            }
+        }
+        return false;
+    }
+    visitPatternCapture(node) {
+        if (!node.isWildcard) {
+            this._addPatternCaptureTarget(node.target);
+        }
+        return true;
+    }
+    visitPatternMappingExpandEntry(node) {
+        if (node.target.value !== '_') {
+            this._addPatternCaptureTarget(node.target);
+        }
+        return true;
+    }
+    _getNonClassParentScope() {
+        // We may not be able to use the current scope if it's a class scope.
+        // Walk up until we find a non-class scope instead.
+        let parentScope = this._currentScope;
+        while (parentScope.type === 2 /* Class */) {
+            parentScope = parentScope.parent;
+        }
+        return parentScope;
+    }
+    _addSlotsToCurrentScope(slotNameNodes) {
+        (0, debug_1.assert)(this._currentScope.type === 2 /* Class */);
+        let slotsContainsDict = false;
+        for (const slotNameNode of slotNameNodes) {
+            const slotName = slotNameNode.strings[0].value;
+            if (slotName === '__dict__') {
+                slotsContainsDict = true;
+                continue;
+            }
+            let symbol = this._currentScope.lookUpSymbol(slotName);
+            if (!symbol) {
+                symbol = this._currentScope.addSymbol(slotName, 1 /* InitiallyUnbound */ | 4 /* ClassMember */);
+                const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
+                if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(slotName) && honorPrivateNaming) {
+                    symbol.setIsPrivateMember();
+                }
+            }
+            const declaration = {
+                type: 1 /* Variable */,
+                node: slotNameNode,
+                isConstant: (0, symbolNameUtils_1.isConstantName)(slotName),
+                isDefinedBySlots: true,
+                path: this._fileInfo.filePath,
+                range: (0, positionUtils_1.convertOffsetsToRange)(slotNameNode.start, slotNameNode.start + slotNameNode.length, this._fileInfo.lines),
+                moduleName: this._fileInfo.moduleName,
+                isInExceptSuite: this._isInExceptSuite,
+            };
+            symbol.addDeclaration(declaration);
+        }
+        if (!slotsContainsDict) {
+            this._currentScope.setSlotsNames(slotNameNodes.map((node) => node.strings[0].value));
+        }
+    }
+    _isInListComprehension(node, ignoreOutermostIterable = false) {
+        let curNode = node;
+        let prevNode;
+        let prevPrevNode;
+        while (curNode) {
+            if (curNode.nodeType === 32 /* ListComprehension */) {
+                if (ignoreOutermostIterable && curNode.forIfNodes.length > 0) {
+                    const outermostCompr = curNode.forIfNodes[0];
+                    if (prevNode === outermostCompr && outermostCompr.nodeType === 33 /* ListComprehensionFor */) {
+                        if (prevPrevNode === outermostCompr.iterableExpression) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            prevPrevNode = prevNode;
+            prevNode = curNode;
+            curNode = curNode.parent;
+        }
+        return false;
+    }
+    _addPatternCaptureTarget(target) {
+        const symbol = this._bindNameToScope(this._currentScope, target.value);
+        this._createAssignmentTargetFlowNodes(target, /* walkTargets */ false, /* unbound */ false);
+        if (symbol) {
+            const declaration = {
+                type: 1 /* Variable */,
+                node: target,
+                isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
+                inferredTypeSource: target.parent,
+                path: this._fileInfo.filePath,
+                range: (0, positionUtils_1.convertOffsetsToRange)(target.start, textRange_2.TextRange.getEnd(target), this._fileInfo.lines),
+                moduleName: this._fileInfo.moduleName,
+                isInExceptSuite: this._isInExceptSuite,
+            };
+            symbol.addDeclaration(declaration);
+        }
+    }
+    _useExceptTargets(targets, callback) {
+        const prevExceptTargets = this._currentExceptTargets;
+        this._currentExceptTargets = targets;
+        callback();
+        this._currentExceptTargets = prevExceptTargets;
+    }
+    // Attempts to resolve the module name, import it, and return
+    // its __all__ symbols.
+    _getDunderAllNamesFromImport(varName) {
+        var _a;
+        const varSymbol = this._currentScope.lookUpSymbol(varName);
+        if (!varSymbol) {
+            return undefined;
+        }
+        // There should be only one declaration for the variable.
+        const aliasDecl = varSymbol.getDeclarations().find((decl) => decl.type === 6 /* Alias */);
+        const resolvedPath = (aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.path) && aliasDecl.loadSymbolsFromPath
+            ? aliasDecl.path
+            : ((_a = aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.submoduleFallback) === null || _a === void 0 ? void 0 : _a.path) && aliasDecl.submoduleFallback.loadSymbolsFromPath
+                ? aliasDecl.submoduleFallback.path
+                : undefined;
+        if (!resolvedPath) {
+            return undefined;
+        }
+        const lookupInfo = this._fileInfo.importLookup(resolvedPath);
+        if (!lookupInfo) {
+            return undefined;
+        }
+        return lookupInfo.dunderAllNames;
+    }
+    _addImplicitFromImport(node, importInfo) {
+        const symbolName = node.module.nameParts[0].value;
+        const symbol = this._bindNameToScope(this._currentScope, symbolName);
+        if (symbol) {
+            this._createAliasDeclarationForMultipartImportName(node, /* importAlias */ undefined, importInfo, symbol);
+        }
+        this._createFlowAssignment(node.module.nameParts[0]);
+    }
+    _createAliasDeclarationForMultipartImportName(node, importAlias, importInfo, symbol) {
+        var _a;
+        const firstNamePartValue = node.module.nameParts[0].value;
+        // See if there's already a matching alias declaration for this import.
+        // if so, we'll update it rather than creating a new one. This is required
+        // to handle cases where multiple import statements target the same
+        // starting symbol such as "import a.b.c" and "import a.d". In this case,
+        // we'll build a single declaration that describes the combined actions
+        // of both import statements, thus reflecting the behavior of the
+        // python module loader.
+        const existingDecl = symbol
+            .getDeclarations()
+            .find((decl) => decl.type === 6 /* Alias */ && decl.firstNamePart === firstNamePartValue);
+        let newDecl;
+        let pathOfLastSubmodule;
+        if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedPaths.length > 0) {
+            pathOfLastSubmodule = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
+        }
+        else {
+            pathOfLastSubmodule = '*** unresolved ***';
+        }
+        const isResolved = importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedPaths.length > 0;
+        if (existingDecl) {
+            newDecl = existingDecl;
+        }
+        else if (isResolved) {
+            newDecl = {
+                type: 6 /* Alias */,
+                node,
+                path: pathOfLastSubmodule,
+                loadSymbolsFromPath: false,
+                range: (0, textRange_1.getEmptyRange)(),
+                usesLocalName: !!importAlias,
+                moduleName: importInfo.importName,
+                firstNamePart: firstNamePartValue,
+                isInExceptSuite: this._isInExceptSuite,
+            };
+        }
+        else {
+            // If we couldn't resolve the import, create a dummy declaration with a
+            // bogus path so it gets an unknown type (rather than an unbound type) at
+            // analysis time.
+            newDecl = {
+                type: 6 /* Alias */,
+                node,
+                path: pathOfLastSubmodule,
+                loadSymbolsFromPath: true,
+                range: (0, textRange_1.getEmptyRange)(),
+                usesLocalName: !!importAlias,
+                moduleName: (_a = importInfo === null || importInfo === void 0 ? void 0 : importInfo.importName) !== null && _a !== void 0 ? _a : '',
+                firstNamePart: firstNamePartValue,
+                isUnresolved: true,
+                isInExceptSuite: this._isInExceptSuite,
+            };
+        }
+        // Add the implicit imports for this module if it's the last
+        // name part we're resolving.
+        if (importAlias || node.module.nameParts.length === 1) {
+            newDecl.path = pathOfLastSubmodule;
+            newDecl.loadSymbolsFromPath = true;
+            newDecl.isUnresolved = false;
+            if (importInfo) {
+                this._addImplicitImportsToLoaderActions(importInfo, newDecl);
+            }
+        }
+        else {
+            // Fill in the remaining name parts.
+            let curLoaderActions = newDecl;
+            for (let i = 1; i < node.module.nameParts.length; i++) {
+                const namePartValue = node.module.nameParts[i].value;
+                // Is there an existing loader action for this name?
+                let loaderActions = curLoaderActions.implicitImports
+                    ? curLoaderActions.implicitImports.get(namePartValue)
+                    : undefined;
+                if (!loaderActions) {
+                    const loaderActionPath = importInfo && i < importInfo.resolvedPaths.length
+                        ? importInfo.resolvedPaths[i]
+                        : '*** unresolved ***';
+                    // Allocate a new loader action.
+                    loaderActions = {
+                        path: loaderActionPath,
+                        loadSymbolsFromPath: false,
+                        implicitImports: new Map(),
+                        isUnresolved: !isResolved,
+                    };
+                    if (!curLoaderActions.implicitImports) {
+                        curLoaderActions.implicitImports = new Map();
+                    }
+                    curLoaderActions.implicitImports.set(namePartValue, loaderActions);
+                }
+                // If this is the last name part we're resolving, add in the
+                // implicit imports as well.
+                if (i === node.module.nameParts.length - 1) {
+                    if (importInfo && i < importInfo.resolvedPaths.length) {
+                        loaderActions.path = importInfo.resolvedPaths[i];
+                        loaderActions.loadSymbolsFromPath = true;
+                        this._addImplicitImportsToLoaderActions(importInfo, loaderActions);
+                    }
+                }
+                curLoaderActions = loaderActions;
+            }
+        }
+        if (!existingDecl) {
+            symbol.addDeclaration(newDecl);
+        }
+    }
+    _getWildcardImportNames(lookupInfo) {
+        const namesToImport = [];
+        // If a dunder all symbol is defined, it takes precedence.
+        if (lookupInfo.dunderAllNames) {
+            if (!lookupInfo.usesUnsupportedDunderAllForm) {
+                return lookupInfo.dunderAllNames;
+            }
+            (0, collectionUtils_1.appendArray)(namesToImport, lookupInfo.dunderAllNames);
+        }
+        lookupInfo.symbolTable.forEach((symbol, name) => {
+            if (!symbol.isExternallyHidden() && !(0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
+                namesToImport.push(name);
+            }
+        });
+        return namesToImport;
+    }
+    _walkStatementsAndReportUnreachable(statements) {
+        let foundUnreachableStatement = false;
+        for (const statement of statements) {
+            AnalyzerNodeInfo.setFlowNode(statement, this._currentFlowNode);
+            if (!foundUnreachableStatement) {
+                foundUnreachableStatement = this._isCodeUnreachable();
+            }
+            if (!foundUnreachableStatement) {
+                this.walk(statement);
+            }
+            else {
+                // If we're within a function, we need to look for unreachable yield
+                // statements because they affect the behavior of the function (making
+                // it a generator) even if they're never executed.
+                if (this._targetFunctionDeclaration && !this._targetFunctionDeclaration.isGenerator) {
+                    const yieldFinder = new YieldFinder();
+                    if (yieldFinder.checkContainsYield(statement)) {
+                        this._targetFunctionDeclaration.isGenerator = true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    _createStartFlowNode() {
+        const flowNode = {
+            flags: codeFlowTypes_1.FlowFlags.Start,
+            id: this._getUniqueFlowNodeId(),
+        };
+        return flowNode;
+    }
+    _createBranchLabel(preBranchAntecedent) {
+        const flowNode = {
+            flags: codeFlowTypes_1.FlowFlags.BranchLabel,
+            id: this._getUniqueFlowNodeId(),
+            antecedents: [],
+            preBranchAntecedent,
+            affectedExpressions: undefined,
+        };
+        return flowNode;
+    }
+    // Create a flow node that narrows the type of the subject expression for
+    // a specified case statement or the entire match statement (if the flow
+    // falls through the bottom of all cases).
+    _createFlowNarrowForPattern(subjectExpression, statement) {
+        const flowNode = {
+            flags: codeFlowTypes_1.FlowFlags.NarrowForPattern,
+            id: this._getUniqueFlowNodeId(),
+            subjectExpression,
+            statement,
+            antecedent: this._currentFlowNode,
+        };
+        this._currentFlowNode = flowNode;
+    }
+    _createContextManagerLabel(expressions, isAsync, blockIfSwallowsExceptions) {
+        const flowNode = {
+            flags: codeFlowTypes_1.FlowFlags.PostContextManager | codeFlowTypes_1.FlowFlags.BranchLabel,
+            id: this._getUniqueFlowNodeId(),
+            antecedents: [],
+            expressions,
+            affectedExpressions: undefined,
+            isAsync,
+            blockIfSwallowsExceptions,
+        };
+        return flowNode;
+    }
+    _createLoopLabel() {
+        const flowNode = {
+            flags: codeFlowTypes_1.FlowFlags.LoopLabel,
+            id: this._getUniqueFlowNodeId(),
+            antecedents: [],
+            affectedExpressions: undefined,
+        };
+        return flowNode;
+    }
+    _finishFlowLabel(node) {
+        // If there were no antecedents, this is unreachable.
+        if (node.antecedents.length === 0) {
+            return Binder._unreachableFlowNode;
+        }
+        // If there was only one antecedent and this is a simple
+        // branch label, there's no need for a label to exist.
+        if (node.antecedents.length === 1 && node.flags === codeFlowTypes_1.FlowFlags.BranchLabel) {
+            return node.antecedents[0];
+        }
+        // The cyclomatic complexity is the number of edges minus the
+        // number of nodes in the graph. Add n-1 where n is the number
+        // of antecedents (edges) and 1 represents the label node.
+        this._codeFlowComplexity += node.antecedents.length - 1;
+        return node;
+    }
+    // Creates a node that creates a "gate" that is closed (doesn't allow for code
+    // flow) if the specified expression is never once it is narrowed (in either the
+    // positive or negative case).
+    _bindNeverCondition(node, target, isPositiveTest) {
+        const expressionList = [];
+        if (node.nodeType === 55 /* UnaryOperation */ && node.operator === 38 /* Not */) {
+            this._bindNeverCondition(node.expression, target, !isPositiveTest);
+        }
+        else if (node.nodeType === 7 /* BinaryOperation */ &&
+            (node.operator === 36 /* And */ || node.operator === 37 /* Or */)) {
+            let isAnd = node.operator === 36 /* And */;
+            if (isPositiveTest) {
+                isAnd = !isAnd;
+            }
+            if (isAnd) {
+                // In the And case, we need to gate the synthesized else clause if both
+                // of the operands evaluate to never once they are narrowed.
+                const savedCurrentFlowNode = this._currentFlowNode;
+                this._bindNeverCondition(node.leftExpression, target, isPositiveTest);
+                this._currentFlowNode = savedCurrentFlowNode;
+                this._bindNeverCondition(node.rightExpression, target, isPositiveTest);
+            }
+            else {
+                const initialCurrentFlowNode = this._currentFlowNode;
+                // In the Or case, we need to gate the synthesized else clause if either
+                // of the operands evaluate to never.
+                const afterLabel = this._createBranchLabel();
+                this._bindNeverCondition(node.leftExpression, afterLabel, isPositiveTest);
+                // If the condition didn't result in any new flow nodes, we can skip
+                // checking the other condition.
+                if (initialCurrentFlowNode !== this._currentFlowNode) {
+                    this._currentFlowNode = this._finishFlowLabel(afterLabel);
+                    const prevCurrentNode = this._currentFlowNode;
+                    this._bindNeverCondition(node.rightExpression, target, isPositiveTest);
+                    // If the second condition resulted in no new control flow node, we can
+                    // eliminate this entire subgraph.
+                    if (prevCurrentNode === this._currentFlowNode) {
+                        this._currentFlowNode = initialCurrentFlowNode;
+                    }
+                }
+            }
+        }
+        else {
+            // Limit only to expressions that contain a narrowable subexpression
+            // that is a name. This avoids complexities with composite expressions like
+            // member access or index expressions.
+            if (this._isNarrowingExpression(node, expressionList, /* neverNarrowingExpressions */ true)) {
+                const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* Name */);
+                if (filteredExprList.length > 0) {
+                    this._currentFlowNode = this._createFlowConditional(isPositiveTest ? codeFlowTypes_1.FlowFlags.TrueNeverCondition : codeFlowTypes_1.FlowFlags.FalseNeverCondition, this._currentFlowNode, node);
+                }
+            }
+            this._addAntecedent(target, this._currentFlowNode);
+        }
+    }
+    _bindConditional(node, trueTarget, falseTarget) {
+        this._setTrueFalseTargets(trueTarget, falseTarget, () => {
+            this.walk(node);
+        });
+        if (!this._isLogicalExpression(node)) {
+            this._addAntecedent(trueTarget, this._createFlowConditional(codeFlowTypes_1.FlowFlags.TrueCondition, this._currentFlowNode, node));
+            this._addAntecedent(falseTarget, this._createFlowConditional(codeFlowTypes_1.FlowFlags.FalseCondition, this._currentFlowNode, node));
+        }
+    }
+    _disableTrueFalseTargets(callback) {
+        this._setTrueFalseTargets(/* trueTarget */ undefined, /* falseTarget */ undefined, callback);
+    }
+    _setTrueFalseTargets(trueTarget, falseTarget, callback) {
+        const savedTrueTarget = this._currentTrueTarget;
+        const savedFalseTarget = this._currentFalseTarget;
+        this._currentTrueTarget = trueTarget;
+        this._currentFalseTarget = falseTarget;
+        callback();
+        this._currentTrueTarget = savedTrueTarget;
+        this._currentFalseTarget = savedFalseTarget;
+    }
+    _createFlowConditional(flags, antecedent, expression) {
+        if (antecedent.flags & codeFlowTypes_1.FlowFlags.Unreachable) {
+            return antecedent;
+        }
+        const staticValue = StaticExpressions.evaluateStaticBoolLikeExpression(expression, this._fileInfo.executionEnvironment, this._fileInfo.definedConstants, this._typingImportAliases, this._sysImportAliases);
+        if ((staticValue === true && flags & codeFlowTypes_1.FlowFlags.FalseCondition) ||
+            (staticValue === false && flags & codeFlowTypes_1.FlowFlags.TrueCondition)) {
+            return Binder._unreachableFlowNode;
+        }
+        const expressionList = [];
+        if (!this._isNarrowingExpression(expression, expressionList)) {
+            return antecedent;
+        }
+        expressionList.forEach((expr) => {
+            const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(expr);
+            this._currentScopeCodeFlowExpressions.add(referenceKey);
+        });
+        // Select the first name expression.
+        const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* Name */);
+        const conditionalFlowNode = {
+            flags,
+            id: this._getUniqueFlowNodeId(),
+            reference: filteredExprList.length > 0 ? filteredExprList[0] : undefined,
+            expression,
+            antecedent,
+        };
+        this._addExceptTargets(conditionalFlowNode);
+        return conditionalFlowNode;
+    }
+    // Indicates whether the expression is a NOT, AND or OR expression.
+    _isLogicalExpression(expression) {
+        switch (expression.nodeType) {
+            case 55 /* UnaryOperation */: {
+                return expression.operator === 38 /* Not */;
+            }
+            case 7 /* BinaryOperation */: {
+                return expression.operator === 36 /* And */ || expression.operator === 37 /* Or */;
+            }
+        }
+        return false;
+    }
+    // Determines whether the specified expression can be used for conditional
+    // type narrowing. The expression atoms (names, member accesses and index)
+    // are provided as an output in the expressionList.
+    // If filterForNeverNarrowing is true, we limit some types of narrowing
+    // expressions for performance reasons.
+    // The isComplexExpression parameter is used internally to determine whether
+    // the call is an atom (name, member access, index - plus a "not" form of
+    // these) or something more complex (binary operator, call, etc.).
+    _isNarrowingExpression(expression, expressionList, filterForNeverNarrowing = false, isComplexExpression = false) {
+        switch (expression.nodeType) {
+            case 38 /* Name */:
+            case 35 /* MemberAccess */:
+            case 24 /* Index */: {
+                if (filterForNeverNarrowing) {
+                    // Never narrowing doesn't support member access or index
+                    // expressions.
+                    if (expression.nodeType !== 38 /* Name */) {
+                        return false;
+                    }
+                    // Never narrowing doesn't support simple names (falsy
+                    // or truthy narrowing) because it's too expensive and
+                    // provides relatively little utility.
+                    if (!isComplexExpression) {
+                        return false;
+                    }
+                }
+                if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression)) {
+                    expressionList.push(expression);
+                    return true;
+                }
+                return false;
+            }
+            case 4 /* AssignmentExpression */: {
+                expressionList.push(expression.name);
+                this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                /* isComplexExpression */ true);
+                return true;
+            }
+            case 7 /* BinaryOperation */: {
+                const isOrIsNotOperator = expression.operator === 39 /* Is */ || expression.operator === 40 /* IsNot */;
+                const equalsOrNotEqualsOperator = expression.operator === 12 /* Equals */ || expression.operator === 28 /* NotEquals */;
+                if (isOrIsNotOperator || equalsOrNotEqualsOperator) {
+                    // Look for "X is None", "X is not None", "X == None", "X != None".
+                    // These are commonly-used patterns used in control flow.
+                    if (expression.rightExpression.nodeType === 11 /* Constant */ &&
+                        expression.rightExpression.constType === 26 /* None */) {
+                        return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                        /* isComplexExpression */ true);
+                    }
+                    // Look for "type(X) is Y" or "type(X) is not Y".
+                    if (isOrIsNotOperator &&
+                        expression.leftExpression.nodeType === 9 /* Call */ &&
+                        expression.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
+                        expression.leftExpression.leftExpression.value === 'type' &&
+                        expression.leftExpression.arguments.length === 1 &&
+                        expression.leftExpression.arguments[0].argumentCategory === 0 /* Simple */) {
+                        return this._isNarrowingExpression(expression.leftExpression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                        /* isComplexExpression */ true);
+                    }
+                    const isLeftNarrowing = this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ true);
+                    // Look for "X is Y" or "X is not Y".
+                    if (isOrIsNotOperator) {
+                        return isLeftNarrowing;
+                    }
+                    // Look for X == <literal>, X != <literal> or <literal> == X, <literal> != X
+                    if (equalsOrNotEqualsOperator) {
+                        const isRightNarrowing = this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                        /* isComplexExpression */ true);
+                        return isLeftNarrowing || isRightNarrowing;
+                    }
+                }
+                // Look for "<string> in Y" or "<string> not in Y".
+                if (expression.operator === 41 /* In */ || expression.operator === 42 /* NotIn */) {
+                    if (expression.leftExpression.nodeType === 48 /* StringList */ &&
+                        this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                        /* isComplexExpression */ true)) {
+                        return true;
+                    }
+                }
+                // Look for "X in Y" or "X not in Y".
+                if (expression.operator === 41 /* In */ || expression.operator === 42 /* NotIn */) {
+                    return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ true);
+                }
+                return false;
+            }
+            case 55 /* UnaryOperation */: {
+                return (expression.operator === 38 /* Not */ &&
+                    this._isNarrowingExpression(expression.expression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ false));
+            }
+            case 5 /* AugmentedAssignment */: {
+                return this._isNarrowingExpression(expression.rightExpression, expressionList, filterForNeverNarrowing, 
+                /* isComplexExpression */ true);
+            }
+            case 9 /* Call */: {
+                if (expression.leftExpression.nodeType === 38 /* Name */ &&
+                    (expression.leftExpression.value === 'isinstance' ||
+                        expression.leftExpression.value === 'issubclass') &&
+                    expression.arguments.length === 2) {
+                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ true);
+                }
+                if (expression.leftExpression.nodeType === 38 /* Name */ &&
+                    expression.leftExpression.value === 'callable' &&
+                    expression.arguments.length === 1) {
+                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ true);
+                }
+                // Is this potentially a call to a user-defined type guard function?
+                if (expression.arguments.length >= 1) {
+                    // Never narrowing doesn't support type guards because they do not
+                    // offer negative narrowing.
+                    if (filterForNeverNarrowing) {
+                        return false;
+                    }
+                    return this._isNarrowingExpression(expression.arguments[0].valueExpression, expressionList, filterForNeverNarrowing, 
+                    /* isComplexExpression */ true);
+                }
+            }
+        }
+        return false;
+    }
+    _createAssignmentTargetFlowNodes(target, walkTargets, unbound) {
+        switch (target.nodeType) {
+            case 38 /* Name */:
+            case 35 /* MemberAccess */: {
+                this._createFlowAssignment(target, unbound);
+                if (walkTargets) {
+                    this.walk(target);
+                }
+                break;
+            }
+            case 24 /* Index */: {
+                this._createFlowAssignment(target, unbound);
+                if (walkTargets) {
+                    this.walk(target);
+                }
+                break;
+            }
+            case 52 /* Tuple */: {
+                target.expressions.forEach((expr) => {
+                    this._createAssignmentTargetFlowNodes(expr, walkTargets, unbound);
+                });
+                break;
+            }
+            case 54 /* TypeAnnotation */: {
+                this._createAssignmentTargetFlowNodes(target.valueExpression, /* walkTargets */ false, unbound);
+                if (walkTargets) {
+                    this.walk(target);
+                }
+                break;
+            }
+            case 56 /* Unpack */: {
+                this._createAssignmentTargetFlowNodes(target.expression, /* walkTargets */ false, unbound);
+                if (walkTargets) {
+                    this.walk(target);
+                }
+                break;
+            }
+            case 31 /* List */: {
+                target.entries.forEach((entry) => {
+                    this._createAssignmentTargetFlowNodes(entry, walkTargets, unbound);
+                });
+                break;
+            }
+            default: {
+                if (walkTargets) {
+                    this.walk(target);
+                }
+            }
+        }
+    }
+    _createCallFlowNode(node) {
+        if (!this._isCodeUnreachable()) {
+            const flowNode = {
+                flags: codeFlowTypes_1.FlowFlags.Call,
+                id: this._getUniqueFlowNodeId(),
+                node,
+                antecedent: this._currentFlowNode,
+            };
+            this._currentFlowNode = flowNode;
+        }
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        if (!this._isCodeUnreachable()) {
+            this._addExceptTargets(this._currentFlowNode);
+        }
+    }
+    _createVariableAnnotationFlowNode() {
+        if (!this._isCodeUnreachable()) {
+            const flowNode = {
+                flags: codeFlowTypes_1.FlowFlags.VariableAnnotation,
+                id: this._getUniqueFlowNodeId(),
+                antecedent: this._currentFlowNode,
+            };
+            this._currentFlowNode = flowNode;
+        }
+    }
+    _createFlowAssignment(node, unbound = false) {
+        let targetSymbolId = symbol_1.indeterminateSymbolId;
+        if (node.nodeType === 38 /* Name */) {
+            const symbolWithScope = this._currentScope.lookUpSymbolRecursive(node.value);
+            (0, debug_1.assert)(symbolWithScope !== undefined);
+            targetSymbolId = symbolWithScope.symbol.id;
+        }
+        const prevFlowNode = this._currentFlowNode;
+        if (!this._isCodeUnreachable() && (0, codeFlowTypes_1.isCodeFlowSupportedForReference)(node)) {
+            const flowNode = {
+                flags: codeFlowTypes_1.FlowFlags.Assignment,
+                id: this._getUniqueFlowNodeId(),
+                node,
+                antecedent: this._currentFlowNode,
+                targetSymbolId,
+            };
+            const referenceKey = (0, codeFlowTypes_1.createKeyForReference)(node);
+            this._currentScopeCodeFlowExpressions.add(referenceKey);
+            if (unbound) {
+                flowNode.flags |= codeFlowTypes_1.FlowFlags.Unbind;
+            }
+            // Assume that an assignment to a member access expression
+            // can potentially generate an exception.
+            if (node.nodeType === 35 /* MemberAccess */) {
+                this._addExceptTargets(flowNode);
+            }
+            this._currentFlowNode = flowNode;
+        }
+        // If we're marking the node as unbound and there is already a flow node
+        // associated with the node, don't replace it. This case applies for symbols
+        // introduced in except clauses. If there is no use the previous flow node
+        // associated, use the previous flow node (applies in the del case).
+        // Otherwise, the node will be evaluated as unbound at this point in the flow.
+        if (!unbound || AnalyzerNodeInfo.getFlowNode(node) === undefined) {
+            AnalyzerNodeInfo.setFlowNode(node, unbound ? prevFlowNode : this._currentFlowNode);
+        }
+    }
+    _createFlowWildcardImport(node, names) {
+        if (!this._isCodeUnreachable()) {
+            const flowNode = {
+                flags: codeFlowTypes_1.FlowFlags.WildcardImport,
+                id: this._getUniqueFlowNodeId(),
+                node,
+                names,
+                antecedent: this._currentFlowNode,
+            };
+            this._addExceptTargets(flowNode);
+            this._currentFlowNode = flowNode;
+        }
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+    }
+    _createFlowExhaustedMatch(node) {
+        if (!this._isCodeUnreachable()) {
+            const flowNode = {
+                flags: codeFlowTypes_1.FlowFlags.ExhaustedMatch,
+                id: this._getUniqueFlowNodeId(),
+                node,
+                antecedent: this._currentFlowNode,
+            };
+            this._currentFlowNode = flowNode;
+        }
+        AnalyzerNodeInfo.setAfterFlowNode(node, this._currentFlowNode);
+    }
+    _isCodeUnreachable() {
+        return !!(this._currentFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable);
+    }
+    _addExceptTargets(flowNode) {
+        // If there are any except targets, then we're in a try block, and we
+        // have to assume that an exception can be raised after every assignment.
+        if (this._currentExceptTargets) {
+            this._currentExceptTargets.forEach((label) => {
+                this._addAntecedent(label, flowNode);
+            });
+        }
+    }
+    _trackCodeFlowExpressions(callback) {
+        const savedExpressions = this._currentScopeCodeFlowExpressions;
+        this._currentScopeCodeFlowExpressions = new Set();
+        callback();
+        const scopedExpressions = this._currentScopeCodeFlowExpressions;
+        if (savedExpressions) {
+            this._currentScopeCodeFlowExpressions.forEach((value) => {
+                savedExpressions.add(value);
+            });
+        }
+        this._currentScopeCodeFlowExpressions = savedExpressions;
+        return scopedExpressions;
+    }
+    _bindLoopStatement(preLoopLabel, postLoopLabel, callback) {
+        const savedContinueTarget = this._currentContinueTarget;
+        const savedBreakTarget = this._currentBreakTarget;
+        this._currentContinueTarget = preLoopLabel;
+        this._currentBreakTarget = postLoopLabel;
+        preLoopLabel.affectedExpressions = this._trackCodeFlowExpressions(callback);
+        this._currentContinueTarget = savedContinueTarget;
+        this._currentBreakTarget = savedBreakTarget;
+    }
+    _addAntecedent(label, antecedent) {
+        if (!(this._currentFlowNode.flags & codeFlowTypes_1.FlowFlags.Unreachable)) {
+            // Don't add the same antecedent twice.
+            if (!label.antecedents.some((existing) => existing.id === antecedent.id)) {
+                label.antecedents.push(antecedent);
+            }
+        }
+    }
+    _bindNameToScope(scope, name, addedSymbols) {
+        // Is this name already bound to a scope other than the local one?
+        const bindingType = this._currentScope.getBindingType(name);
+        if (bindingType !== undefined) {
+            const scopeToUse = bindingType === 0 /* Nonlocal */
+                ? this._currentScope.parent
+                : this._currentScope.getGlobalScope().scope;
+            const symbolWithScope = scopeToUse.lookUpSymbolRecursive(name);
+            if (symbolWithScope) {
+                return symbolWithScope.symbol;
+            }
+        }
+        else {
+            // Don't overwrite an existing symbol.
+            let symbol = scope.lookUpSymbol(name);
+            if (!symbol) {
+                symbol = scope.addSymbol(name, 1 /* InitiallyUnbound */ | 4 /* ClassMember */);
+                if (this._currentScope.type === 3 /* Module */ || this._currentScope.type === 4 /* Builtin */) {
+                    if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name)) {
+                        if ((0, symbolNameUtils_1.isPrivateName)(name)) {
+                            // Private names are obscured, so they are always externally hidden.
+                            symbol.setIsExternallyHidden();
+                        }
+                        else if (this._fileInfo.isStubFile || this._fileInfo.isInPyTypedPackage) {
+                            if (this._currentScope.type === 4 /* Builtin */) {
+                                // Don't include private-named symbols in the builtin scope.
+                                symbol.setIsExternallyHidden();
+                            }
+                            else {
+                                this._potentialPrivateSymbols.set(name, symbol);
+                            }
+                        }
+                        else {
+                            symbol.setIsPrivateMember();
+                        }
+                    }
+                }
+                if (addedSymbols) {
+                    addedSymbols.set(name, symbol);
+                }
+            }
+            return symbol;
+        }
+        return undefined;
+    }
+    _bindPossibleTupleNamedTarget(target, addedSymbols) {
+        switch (target.nodeType) {
+            case 38 /* Name */: {
+                this._bindNameToScope(this._currentScope, target.value, addedSymbols);
+                break;
+            }
+            case 52 /* Tuple */: {
+                target.expressions.forEach((expr) => {
+                    this._bindPossibleTupleNamedTarget(expr, addedSymbols);
+                });
+                break;
+            }
+            case 31 /* List */: {
+                target.entries.forEach((expr) => {
+                    this._bindPossibleTupleNamedTarget(expr, addedSymbols);
+                });
+                break;
+            }
+            case 54 /* TypeAnnotation */: {
+                this._bindPossibleTupleNamedTarget(target.valueExpression, addedSymbols);
+                break;
+            }
+            case 56 /* Unpack */: {
+                this._bindPossibleTupleNamedTarget(target.expression, addedSymbols);
+                break;
+            }
+        }
+    }
+    _addImplicitSymbolToCurrentScope(nameValue, node, type) {
+        const symbol = this._addSymbolToCurrentScope(nameValue, /* isInitiallyUnbound */ false);
+        if (symbol) {
+            symbol.addDeclaration({
+                type: 0 /* Intrinsic */,
+                node,
+                intrinsicType: type,
+                path: this._fileInfo.filePath,
+                range: (0, textRange_1.getEmptyRange)(),
+                moduleName: this._fileInfo.moduleName,
+                isInExceptSuite: this._isInExceptSuite,
+            });
+            symbol.setIsIgnoredForProtocolMatch();
+        }
+    }
+    // Adds a new symbol with the specified name if it doesn't already exist.
+    _addSymbolToCurrentScope(nameValue, isInitiallyUnbound) {
+        let symbol = this._currentScope.lookUpSymbol(nameValue);
+        if (!symbol) {
+            let symbolFlags = 0 /* None */;
+            if (isInitiallyUnbound) {
+                symbolFlags |= 1 /* InitiallyUnbound */;
+            }
+            if (this._currentScope.type === 2 /* Class */) {
+                symbolFlags |= 4 /* ClassMember */;
+            }
+            if (this._fileInfo.isStubFile && (0, symbolNameUtils_1.isPrivateOrProtectedName)(nameValue)) {
+                symbolFlags |= 2 /* ExternallyHidden */;
+            }
+            // Add the symbol. Assume that symbols with a default type source ID
+            // are "implicit" symbols added to the scope. These are not initially unbound.
+            symbol = this._currentScope.addSymbol(nameValue, symbolFlags);
+        }
+        return symbol;
+    }
+    _createNewScope(scopeType, parentScope, callback) {
+        const prevScope = this._currentScope;
+        const newScope = new scope_1.Scope(scopeType, parentScope);
+        this._currentScope = newScope;
+        // If this scope is an execution scope, allocate a new reference map.
+        const isExecutionScope = scopeType === 4 /* Builtin */ || scopeType === 3 /* Module */ || scopeType === 1 /* Function */;
+        const prevExpressions = this._currentScopeCodeFlowExpressions;
+        if (isExecutionScope) {
+            this._currentScopeCodeFlowExpressions = new Set();
+        }
+        callback();
+        this._currentScopeCodeFlowExpressions = prevExpressions;
+        this._currentScope = prevScope;
+        return newScope;
+    }
+    _addInferredTypeAssignmentForVariable(target, source, isPossibleTypeAlias = false) {
+        switch (target.nodeType) {
+            case 38 /* Name */: {
+                const name = target;
+                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
+                if (symbolWithScope && symbolWithScope.symbol) {
+                    const declaration = {
+                        type: 1 /* Variable */,
+                        node: target,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(target.value),
+                        inferredTypeSource: source,
+                        isInferenceAllowedInPyTyped: this._isInferenceAllowedInPyTyped(name.value),
+                        typeAliasName: isPossibleTypeAlias ? target : undefined,
+                        path: this._fileInfo.filePath,
+                        range: (0, positionUtils_1.convertOffsetsToRange)(name.start, textRange_2.TextRange.getEnd(name), this._fileInfo.lines),
+                        moduleName: this._fileInfo.moduleName,
+                        isInExceptSuite: this._isInExceptSuite,
+                        docString: this._getVariableDocString(target),
+                    };
+                    symbolWithScope.symbol.addDeclaration(declaration);
+                }
+                break;
+            }
+            case 35 /* MemberAccess */: {
+                const memberAccessInfo = this._getMemberAccessInfo(target);
+                if (memberAccessInfo) {
+                    const name = target.memberName;
+                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
+                    if (!symbol) {
+                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* InitiallyUnbound */);
+                        const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
+                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
+                            symbol.setIsPrivateMember();
+                        }
+                    }
+                    if (memberAccessInfo.isInstanceMember) {
+                        // If a method (which has a declared type) is being overwritten
+                        // by an expression with no declared type, don't mark it as
+                        // an instance member because the type evaluator will think
+                        // that it doesn't need to perform object binding.
+                        if (!symbol.isClassMember() ||
+                            !symbol
+                                .getDeclarations()
+                                .some((decl) => decl.type === 3 /* Function */ && decl.isMethod)) {
+                            symbol.setIsInstanceMember();
+                        }
+                    }
+                    else {
+                        symbol.setIsClassMember();
+                    }
+                    const declaration = {
+                        type: 1 /* Variable */,
+                        node: target.memberName,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        inferredTypeSource: source,
+                        isDefinedByMemberAccess: true,
+                        path: this._fileInfo.filePath,
+                        range: (0, positionUtils_1.convertOffsetsToRange)(target.memberName.start, target.memberName.start + target.memberName.length, this._fileInfo.lines),
+                        moduleName: this._fileInfo.moduleName,
+                        isInExceptSuite: this._isInExceptSuite,
+                        docString: this._getVariableDocString(target),
+                    };
+                    symbol.addDeclaration(declaration);
+                }
+                break;
+            }
+            case 52 /* Tuple */: {
+                target.expressions.forEach((expr) => {
+                    this._addInferredTypeAssignmentForVariable(expr, source);
+                });
+                break;
+            }
+            case 54 /* TypeAnnotation */: {
+                this._addInferredTypeAssignmentForVariable(target.valueExpression, source);
+                break;
+            }
+            case 56 /* Unpack */: {
+                this._addInferredTypeAssignmentForVariable(target.expression, source);
+                break;
+            }
+            case 31 /* List */: {
+                target.entries.forEach((entry) => {
+                    this._addInferredTypeAssignmentForVariable(entry, source);
+                });
+                break;
+            }
+        }
+    }
+    _isInferenceAllowedInPyTyped(symbolName) {
+        const exemptSymbols = ['__match_args__', '__slots__', '__all__'];
+        return exemptSymbols.some((name) => name === symbolName);
+    }
+    _addTypeDeclarationForVariable(target, typeAnnotation) {
+        var _a, _b, _c;
+        let declarationHandled = false;
+        switch (target.nodeType) {
+            case 38 /* Name */: {
+                const name = target;
+                const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
+                if (symbolWithScope && symbolWithScope.symbol) {
+                    const finalInfo = this._isAnnotationFinal(typeAnnotation);
+                    const isExplicitTypeAlias = this._isAnnotationTypeAlias(typeAnnotation);
+                    let typeAnnotationNode = typeAnnotation;
+                    let innerTypeAnnotationNode = typeAnnotation;
+                    if (isExplicitTypeAlias) {
+                        typeAnnotationNode = undefined;
+                        innerTypeAnnotationNode = undefined;
+                        // Type aliases are allowed only in the global or class scope.
+                        if (this._currentScope.type !== 2 /* Class */ &&
+                            this._currentScope.type !== 3 /* Module */ &&
+                            this._currentScope.type !== 4 /* Builtin */) {
+                            this._addError(localize_1.Localizer.Diagnostic.typeAliasNotInModuleOrClass(), typeAnnotation);
+                        }
+                    }
+                    else if (finalInfo.isFinal) {
+                        innerTypeAnnotationNode = finalInfo.finalTypeNode;
+                        if (!finalInfo.finalTypeNode) {
+                            typeAnnotationNode = undefined;
+                        }
+                    }
+                    // Is this annotation indicating that the variable is a "ClassVar"?
+                    let classVarInfo = this._isAnnotationClassVar(typeAnnotation);
+                    if (classVarInfo.isClassVar) {
+                        innerTypeAnnotationNode = classVarInfo.classVarTypeNode;
+                        if (!classVarInfo.classVarTypeNode) {
+                            typeAnnotationNode = undefined;
+                        }
+                    }
+                    // PEP 591 indicates that a Final variable initialized within a class
+                    // body should also be considered a ClassVar.
+                    if (finalInfo.isFinal) {
+                        const containingClass = ParseTreeUtils.getEnclosingClassOrFunction(target);
+                        if (containingClass && containingClass.nodeType === 10 /* Class */) {
+                            // Make sure it's part of an assignment.
+                            if (((_a = target.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 3 /* Assignment */ ||
+                                ((_c = (_b = target.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 3 /* Assignment */) {
+                                classVarInfo = {
+                                    isClassVar: true,
+                                    classVarTypeNode: undefined,
+                                };
+                            }
+                        }
+                    }
+                    const declaration = {
+                        type: 1 /* Variable */,
+                        node: target,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        isFinal: finalInfo.isFinal,
+                        isClassVar: classVarInfo.isClassVar,
+                        isRequired: this._isRequiredAnnotation(innerTypeAnnotationNode),
+                        isNotRequired: this._isNotRequiredAnnotation(innerTypeAnnotationNode),
+                        typeAliasAnnotation: isExplicitTypeAlias ? typeAnnotation : undefined,
+                        typeAliasName: isExplicitTypeAlias ? target : undefined,
+                        path: this._fileInfo.filePath,
+                        typeAnnotationNode,
+                        range: (0, positionUtils_1.convertOffsetsToRange)(name.start, textRange_2.TextRange.getEnd(name), this._fileInfo.lines),
+                        moduleName: this._fileInfo.moduleName,
+                        isInExceptSuite: this._isInExceptSuite,
+                        docString: this._getVariableDocString(target),
+                    };
+                    symbolWithScope.symbol.addDeclaration(declaration);
+                    if (classVarInfo.isClassVar) {
+                        symbolWithScope.symbol.setIsClassVar();
+                    }
+                    else {
+                        symbolWithScope.symbol.setIsInstanceMember();
+                    }
+                    // Look for an 'InitVar' either by itself or wrapped in an 'Annotated'.
+                    if (typeAnnotation.nodeType === 24 /* Index */) {
+                        if (this._isDataclassesAnnotation(typeAnnotation.baseExpression, 'InitVar')) {
+                            symbolWithScope.symbol.setIsInitVar();
+                        }
+                        else if (this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated') &&
+                            typeAnnotation.items.length > 0) {
+                            const item0Expr = typeAnnotation.items[0].valueExpression;
+                            if (item0Expr.nodeType === 24 /* Index */ &&
+                                this._isDataclassesAnnotation(item0Expr.baseExpression, 'InitVar')) {
+                                symbolWithScope.symbol.setIsInitVar();
+                            }
+                        }
+                    }
+                }
+                declarationHandled = true;
+                break;
+            }
+            case 35 /* MemberAccess */: {
+                // We need to determine whether this expression is declaring a class or
+                // instance variable. This is difficult because python doesn't provide
+                // a keyword for accessing "this". Instead, it uses naming conventions
+                // of "cls" and "self", but we don't want to rely on these naming
+                // conventions here. Instead, we'll apply some heuristics to determine
+                // whether the symbol on the LHS is a reference to the current class
+                // or an instance of the current class.
+                const memberAccessInfo = this._getMemberAccessInfo(target);
+                if (memberAccessInfo) {
+                    const name = target.memberName;
+                    let symbol = memberAccessInfo.classScope.lookUpSymbol(name.value);
+                    if (!symbol) {
+                        symbol = memberAccessInfo.classScope.addSymbol(name.value, 1 /* InitiallyUnbound */);
+                        const honorPrivateNaming = this._fileInfo.diagnosticRuleSet.reportPrivateUsage !== 'none';
+                        if ((0, symbolNameUtils_1.isPrivateOrProtectedName)(name.value) && honorPrivateNaming) {
+                            symbol.setIsPrivateMember();
+                        }
+                    }
+                    if (memberAccessInfo.isInstanceMember) {
+                        symbol.setIsInstanceMember();
+                    }
+                    else {
+                        symbol.setIsClassMember();
+                    }
+                    const finalInfo = this._isAnnotationFinal(typeAnnotation);
+                    const declaration = {
+                        type: 1 /* Variable */,
+                        node: target.memberName,
+                        isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
+                        isDefinedByMemberAccess: true,
+                        isFinal: finalInfo.isFinal,
+                        path: this._fileInfo.filePath,
+                        typeAnnotationNode: finalInfo.isFinal && !finalInfo.finalTypeNode ? undefined : typeAnnotation,
+                        range: (0, positionUtils_1.convertOffsetsToRange)(target.memberName.start, target.memberName.start + target.memberName.length, this._fileInfo.lines),
+                        moduleName: this._fileInfo.moduleName,
+                        isInExceptSuite: this._isInExceptSuite,
+                        docString: this._getVariableDocString(target),
+                    };
+                    symbol.addDeclaration(declaration);
+                    declarationHandled = true;
+                }
+                break;
+            }
+        }
+        if (!declarationHandled) {
+            this._addError(localize_1.Localizer.Diagnostic.annotationNotSupported(), typeAnnotation);
+        }
+    }
+    // Determines whether the expression refers to a type exported by the typing
+    // or typing_extensions modules. We can directly evaluate the types at binding
+    // time. We assume here that the code isn't making use of some custom type alias
+    // to refer to the typing types.
+    _isTypingAnnotation(typeAnnotation, name) {
+        return this._isKnownAnnotation(typeAnnotation, name, this._typingImportAliases, this._typingSymbolAliases);
+    }
+    _isDataclassesAnnotation(typeAnnotation, name) {
+        return this._isKnownAnnotation(typeAnnotation, name, this._dataclassesImportAliases, this._dataclassesSymbolAliases);
+    }
+    _isKnownAnnotation(typeAnnotation, name, importAliases, symbolAliases) {
+        if (typeAnnotation.nodeType === 38 /* Name */) {
+            const alias = symbolAliases.get(typeAnnotation.value);
+            if (alias === name) {
+                return true;
+            }
+        }
+        else if (typeAnnotation.nodeType === 35 /* MemberAccess */) {
+            if (typeAnnotation.leftExpression.nodeType === 38 /* Name */ &&
+                typeAnnotation.memberName.value === name) {
+                const baseName = typeAnnotation.leftExpression.value;
+                return importAliases.some((alias) => alias === baseName);
+            }
+        }
+        return false;
+    }
+    _getVariableDocString(node) {
+        var _a, _b, _c, _d;
+        // Walk up the parse tree to find an assignment expression.
+        let curNode = node;
+        let annotationNode;
+        while (curNode) {
+            if (curNode.nodeType === 3 /* Assignment */) {
+                break;
+            }
+            if (curNode.nodeType === 54 /* TypeAnnotation */ && !annotationNode) {
+                annotationNode = curNode;
+            }
+            curNode = curNode.parent;
+        }
+        if ((curNode === null || curNode === void 0 ? void 0 : curNode.nodeType) !== 3 /* Assignment */) {
+            // Allow a simple annotation statement to have a docstring even
+            // though PEP 258 doesn't mention this case. This PEP pre-dated
+            // PEP 526, so it didn't contemplate this situation.
+            if (annotationNode) {
+                curNode = annotationNode;
+            }
+            else {
+                return undefined;
+            }
+        }
+        const parentNode = curNode.parent;
+        if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) !== 47 /* StatementList */) {
+            return undefined;
+        }
+        const suiteOrModule = parentNode.parent;
+        if (!suiteOrModule ||
+            (suiteOrModule.nodeType !== 36 /* Module */ && suiteOrModule.nodeType !== 50 /* Suite */)) {
+            return undefined;
+        }
+        const assignmentIndex = suiteOrModule.statements.findIndex((node) => node === parentNode);
+        if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.statements.length - 1) {
+            return undefined;
+        }
+        const nextStatement = suiteOrModule.statements[assignmentIndex + 1];
+        if (nextStatement.nodeType !== 47 /* StatementList */ || !ParseTreeUtils.isDocString(nextStatement)) {
+            return undefined;
+        }
+        // See if the assignment is within one of the contexts specified in PEP 258.
+        let isValidContext = false;
+        if (((_a = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 36 /* Module */) {
+            // If we're at the top level of a module, the attribute docstring is valid.
+            isValidContext = true;
+        }
+        else if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* Suite */ &&
+            ((_d = (_c = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* Class */) {
+            // If we're at the top level of a class, the attribute docstring is valid.
+            isValidContext = true;
+        }
+        else {
+            const func = ParseTreeUtils.getEnclosingFunction(parentNode);
+            // If we're within an __init__ method, the attribute docstring is valid.
+            if (func &&
+                func.name.value === '__init__' &&
+                ParseTreeUtils.getEnclosingClass(func, /* stopAtFunction */ true)) {
+                isValidContext = true;
+            }
+        }
+        if (!isValidContext) {
+            return undefined;
+        }
+        // A docstring can consist of multiple joined strings in a single expression.
+        const strings = nextStatement.statements[0].strings;
+        if (strings.length === 1) {
+            // Common case.
+            return strings[0].value;
+        }
+        return strings.map((s) => s.value).join('');
+    }
+    // Determines if the specified type annotation expression is a "Final".
+    // It returns a value indicating whether the expression is a "Final"
+    // expression and whether it's a "raw" Final with no type arguments.
+    _isAnnotationFinal(typeAnnotation) {
+        let isFinal = false;
+        let finalTypeNode;
+        if (typeAnnotation) {
+            if (this._isTypingAnnotation(typeAnnotation, 'Final')) {
+                isFinal = true;
+            }
+            else if (typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+                // Recursively call to see if the base expression is "Final".
+                const finalInfo = this._isAnnotationFinal(typeAnnotation.baseExpression);
+                if (finalInfo.isFinal &&
+                    typeAnnotation.items[0].argumentCategory === 0 /* Simple */ &&
+                    !typeAnnotation.items[0].name &&
+                    !typeAnnotation.trailingComma) {
+                    isFinal = true;
+                    finalTypeNode = typeAnnotation.items[0].valueExpression;
+                }
+            }
+        }
+        return { isFinal, finalTypeNode };
+    }
+    // Determines if the specified type annotation expression is a "ClassVar".
+    // It returns a value indicating whether the expression is a "ClassVar"
+    // expression and whether it's a "raw" ClassVar with no type arguments.
+    _isAnnotationClassVar(typeAnnotation) {
+        let isClassVar = false;
+        let classVarTypeNode;
+        while (typeAnnotation) {
+            if (typeAnnotation.nodeType === 24 /* Index */ &&
+                typeAnnotation.items.length > 0 &&
+                this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated')) {
+                typeAnnotation = typeAnnotation.items[0].valueExpression;
+            }
+            else if (this._isTypingAnnotation(typeAnnotation, 'ClassVar')) {
+                isClassVar = true;
+                break;
+            }
+            else if (typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+                // Recursively call to see if the base expression is "ClassVar".
+                const finalInfo = this._isAnnotationClassVar(typeAnnotation.baseExpression);
+                if (finalInfo.isClassVar &&
+                    typeAnnotation.items[0].argumentCategory === 0 /* Simple */ &&
+                    !typeAnnotation.items[0].name &&
+                    !typeAnnotation.trailingComma) {
+                    isClassVar = true;
+                    classVarTypeNode = typeAnnotation.items[0].valueExpression;
+                }
+                break;
+            }
+            else {
+                break;
+            }
+        }
+        return { isClassVar, classVarTypeNode };
+    }
+    // Determines if the specified type annotation is wrapped in a "Required".
+    _isRequiredAnnotation(typeAnnotation) {
+        if (typeAnnotation && typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+            if (this._isTypingAnnotation(typeAnnotation.baseExpression, 'Required')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Determines if the specified type annotation is wrapped in a "NotRequired".
+    _isNotRequiredAnnotation(typeAnnotation) {
+        if (typeAnnotation && typeAnnotation.nodeType === 24 /* Index */ && typeAnnotation.items.length === 1) {
+            if (this._isTypingAnnotation(typeAnnotation.baseExpression, 'NotRequired')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _isAnnotationTypeAlias(typeAnnotation) {
+        if (!typeAnnotation) {
+            return false;
+        }
+        return this._isTypingAnnotation(typeAnnotation, 'TypeAlias');
+    }
+    // Determines whether a member access expression is referring to a
+    // member of a class (either a class or instance member). This will
+    // typically take the form "self.x" or "cls.x".
+    _getMemberAccessInfo(node) {
+        // We handle only simple names on the left-hand side of the expression,
+        // not calls, nested member accesses, index expressions, etc.
+        if (node.leftExpression.nodeType !== 38 /* Name */) {
+            return undefined;
+        }
+        const leftSymbolName = node.leftExpression.value;
+        // Make sure the expression is within a function (i.e. a method) that's
+        // within a class definition.
+        const methodNode = ParseTreeUtils.getEnclosingFunction(node);
+        if (!methodNode) {
+            return undefined;
+        }
+        const classNode = ParseTreeUtils.getEnclosingClass(methodNode, /* stopAtFunction */ true);
+        if (!classNode) {
+            return undefined;
+        }
+        // Determine whether the left-hand side indicates a class or
+        // instance member.
+        let isInstanceMember = false;
+        if (methodNode.parameters.length < 1 || !methodNode.parameters[0].name) {
+            return undefined;
+        }
+        const className = classNode.name.value;
+        const firstParamName = methodNode.parameters[0].name.value;
+        if (leftSymbolName === className) {
+            isInstanceMember = false;
+        }
+        else {
+            if (leftSymbolName !== firstParamName) {
+                return undefined;
+            }
+            // To determine whether the first parameter of the method
+            // refers to the class or the instance, we need to apply
+            // some heuristics.
+            if (methodNode.name.value === '__new__') {
+                // The __new__ method is special. It acts as a classmethod even
+                // though it doesn't have a @classmethod decorator.
+                isInstanceMember = false;
+            }
+            else {
+                // Assume that it's an instance member unless we find
+                // a decorator that tells us otherwise.
+                isInstanceMember = true;
+                for (const decorator of methodNode.decorators) {
+                    if (decorator.expression.nodeType === 38 /* Name */) {
+                        const decoratorName = decorator.expression.value;
+                        if (decoratorName === 'staticmethod') {
+                            // A static method doesn't have a "self" or "cls" parameter.
+                            return undefined;
+                        }
+                        else if (decoratorName === 'classmethod') {
+                            // A classmethod implies that the first parameter is "cls".
+                            isInstanceMember = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        const classScope = AnalyzerNodeInfo.getScope(classNode);
+        (0, debug_1.assert)(classScope !== undefined);
+        return {
+            classNode,
+            methodNode,
+            classScope,
+            isInstanceMember,
+        };
+    }
+    _addImplicitImportsToLoaderActions(importResult, loaderActions) {
+        importResult.filteredImplicitImports.forEach((implicitImport) => {
+            const existingLoaderAction = loaderActions.implicitImports
+                ? loaderActions.implicitImports.get(implicitImport.name)
+                : undefined;
+            if (existingLoaderAction) {
+                existingLoaderAction.path = implicitImport.path;
+                existingLoaderAction.loadSymbolsFromPath = true;
+            }
+            else {
+                if (!loaderActions.implicitImports) {
+                    loaderActions.implicitImports = new Map();
+                }
+                loaderActions.implicitImports.set(implicitImport.name, {
+                    path: implicitImport.path,
+                    loadSymbolsFromPath: true,
+                    implicitImports: new Map(),
+                });
+            }
+        });
+    }
+    // Handles some special-case assignment statements that are found
+    // within the typings.pyi file.
+    _handleTypingStubAssignmentOrAnnotation(node) {
+        if (!this._fileInfo.isTypingStubFile) {
+            return false;
+        }
+        let annotationNode;
+        if (node.nodeType === 54 /* TypeAnnotation */) {
+            annotationNode = node;
+        }
+        else {
+            if (node.leftExpression.nodeType !== 54 /* TypeAnnotation */) {
+                return false;
+            }
+            annotationNode = node.leftExpression;
+        }
+        if (annotationNode.valueExpression.nodeType !== 38 /* Name */) {
+            return false;
+        }
+        const assignedNameNode = annotationNode.valueExpression;
+        const specialTypes = new Map([
+            ['Tuple', true],
+            ['Generic', true],
+            ['Protocol', true],
+            ['Callable', true],
+            ['Type', true],
+            ['ClassVar', true],
+            ['Final', true],
+            ['Literal', true],
+            ['TypedDict', true],
+            ['Union', true],
+            ['Optional', true],
+            ['Annotated', true],
+            ['TypeAlias', true],
+            ['OrderedDict', true],
+            ['Concatenate', true],
+            ['TypeGuard', true],
+            ['StrictTypeGuard', true],
+            ['Unpack', true],
+            ['Self', true],
+            ['NoReturn', true],
+            ['Never', true],
+            ['LiteralString', true],
+        ]);
+        const assignedName = assignedNameNode.value;
+        if (!specialTypes.has(assignedName)) {
+            return false;
+        }
+        const symbol = this._bindNameToScope(this._currentScope, assignedName);
+        if (symbol) {
+            symbol.addDeclaration({
+                type: 5 /* SpecialBuiltInClass */,
+                node: annotationNode,
+                path: this._fileInfo.filePath,
+                range: (0, positionUtils_1.convertOffsetsToRange)(annotationNode.start, textRange_2.TextRange.getEnd(annotationNode), this._fileInfo.lines),
+                moduleName: this._fileInfo.moduleName,
+                isInExceptSuite: this._isInExceptSuite,
+            });
+        }
+        return true;
+    }
+    _deferBinding(callback) {
+        if (this._moduleSymbolOnly) {
+            return;
+        }
+        this._deferredBindingTasks.push({
+            scope: this._currentScope,
+            codeFlowExpressions: this._currentScopeCodeFlowExpressions,
+            callback,
+        });
+    }
+    _bindDeferred() {
+        while (this._deferredBindingTasks.length > 0) {
+            const nextItem = this._deferredBindingTasks.shift();
+            // Reset the state
+            this._currentScope = nextItem.scope;
+            this._currentScopeCodeFlowExpressions = nextItem.codeFlowExpressions;
+            nextItem.callback();
+        }
+    }
+    _bindYield(node) {
+        const functionNode = ParseTreeUtils.getEnclosingFunction(node);
+        if (!functionNode) {
+            if (!ParseTreeUtils.getEnclosingLambda(node)) {
+                this._addError(localize_1.Localizer.Diagnostic.yieldOutsideFunction(), node);
+            }
+        }
+        else if (functionNode.isAsync && node.nodeType === 61 /* YieldFrom */) {
+            // PEP 525 indicates that 'yield from' is not allowed in an
+            // async function.
+            this._addError(localize_1.Localizer.Diagnostic.yieldFromOutsideAsync(), node);
+        }
+        if (this._targetFunctionDeclaration) {
+            if (!this._targetFunctionDeclaration.yieldStatements) {
+                this._targetFunctionDeclaration.yieldStatements = [];
+            }
+            this._targetFunctionDeclaration.yieldStatements.push(node);
+            this._targetFunctionDeclaration.isGenerator = true;
+        }
+        if (node.expression) {
+            this.walk(node.expression);
+        }
+        AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+    }
+    _getUniqueFlowNodeId() {
+        this._codeFlowComplexity += flowNodeComplexityFactor;
+        return (0, codeFlowTypes_1.getUniqueFlowNodeId)();
+    }
+    _addDiagnostic(diagLevel, rule, message, textRange) {
+        let diagnostic;
+        switch (diagLevel) {
+            case 'error':
+                diagnostic = this._addError(message, textRange);
+                break;
+            case 'warning':
+                diagnostic = this._addWarning(message, textRange);
+                break;
+            case 'information':
+                diagnostic = this._addInformation(message, textRange);
+                break;
+            case 'none':
+                break;
+            default:
+                return (0, debug_1.assertNever)(diagLevel, `${diagLevel} is not expected`);
+        }
+        if (diagnostic) {
+            diagnostic.setRule(rule);
+        }
+        return diagnostic;
+    }
+    _addError(message, textRange) {
+        return this._fileInfo.diagnosticSink.addDiagnosticWithTextRange('error', message, textRange);
+    }
+    _addWarning(message, textRange) {
+        return this._fileInfo.diagnosticSink.addDiagnosticWithTextRange('warning', message, textRange);
+    }
+    _addInformation(message, textRange) {
+        return this._fileInfo.diagnosticSink.addDiagnosticWithTextRange('information', message, textRange);
+    }
+}
+exports.Binder = Binder;
+// Flow node that is used for unreachable code.
+Binder._unreachableFlowNode = {
+    flags: codeFlowTypes_1.FlowFlags.Unreachable,
+    id: (0, codeFlowTypes_1.getUniqueFlowNodeId)(),
+};
+class YieldFinder extends parseTreeWalker_1.ParseTreeWalker {
+    constructor() {
+        super(...arguments);
+        this._containsYield = false;
+    }
+    checkContainsYield(node) {
+        this.walk(node);
+        return this._containsYield;
+    }
+    visitYield(node) {
+        this._containsYield = true;
+        return false;
+    }
+    visitYieldFrom(node) {
+        this._containsYield = true;
+        return false;
+    }
+}
+exports.YieldFinder = YieldFinder;
+class ReturnFinder extends parseTreeWalker_1.ParseTreeWalker {
+    constructor() {
+        super(...arguments);
+        this._containsReturn = false;
+    }
+    checkContainsReturn(node) {
+        this.walk(node);
+        return this._containsReturn;
+    }
+    visitReturn(node) {
+        this._containsReturn = true;
+        return false;
+    }
+}
+exports.ReturnFinder = ReturnFinder;
+//# sourceMappingURL=binder.js.map