@zzzen/pyright-internal 1.2.0-dev.20220814 → 1.2.0-dev.20220904

package/dist/analyzer/binder.js

@@ -45,7 +45,6 @@ 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"));
@@ -539,17 +538,6 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             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;
-        }
         // If the assignment target base expression is potentially a
         // TypedDict, add the base expression to the flow expressions set
         // to accommodate TypedDict type narrowing.
@@ -583,9 +571,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         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);
-        }
+        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__') ||
@@ -770,9 +756,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         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);
+        // We normally want to walk the type annotation first so it is "before"
+        // the target in the code flow graph, but this is reversed for class variables
+        // declared within a class body.
+        const evaluateAnnotationAfterAssignment = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
+        if (!evaluateAnnotationAfterAssignment) {
+            this.walk(node.typeAnnotation);
+        }
         this._createVariableAnnotationFlowNode();
         this._bindPossibleTupleNamedTarget(node.valueExpression);
         this._addTypeDeclarationForVariable(node.valueExpression, node.typeAnnotation);
@@ -788,6 +778,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             });
         }
         this.walk(node.valueExpression);
+        if (evaluateAnnotationAfterAssignment) {
+            this.walk(node.typeAnnotation);
+        }
         return false;
     }
     visitFor(node) {
@@ -818,7 +811,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         this._addAntecedent(postForLabel, this._currentFlowNode);
         this._currentFlowNode = this._finishFlowLabel(postForLabel);
-        if (node.asyncToken) {
+        // Async for is not allowed outside of an async function
+        // unless we're in ipython mode.
+        if (node.asyncToken && !this._fileInfo.ipythonMode) {
             const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
             if (!enclosingFunction || !enclosingFunction.isAsync) {
                 this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), node.asyncToken);
@@ -1504,7 +1499,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (!this._isCodeUnreachable()) {
                 this._addExceptTargets(this._currentFlowNode);
             }
-            if (node.asyncToken) {
+            if (node.asyncToken && !this._fileInfo.ipythonMode) {
+                // Top level async with is allowed in ipython mode.
                 const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
                 if (!enclosingFunction || !enclosingFunction.isAsync) {
                     this._addError(localize_1.Localizer.Diagnostic.asyncNotInAsyncFunction(), node.asyncToken);
@@ -1597,8 +1593,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 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) {
+                    // Async for is not allowed outside of an async function
+                    // unless we're in ipython mode.
+                    if (compr.asyncToken && !this._fileInfo.ipythonMode) {
                         if (!enclosingFunction || !enclosingFunction.isAsync) {
                             // Allow if it's within a generator expression. Execution of
                             // generator expressions is deferred and therefore can be
@@ -1833,7 +1830,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // Attempts to resolve the module name, import it, and return
     // its __all__ symbols.
     _getDunderAllNamesFromImport(varName) {
-        var _a;
+        var _a, _b;
         const varSymbol = this._currentScope.lookUpSymbol(varName);
         if (!varSymbol) {
             return undefined;
@@ -1848,11 +1845,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (!resolvedPath) {
             return undefined;
         }
-        const lookupInfo = this._fileInfo.importLookup(resolvedPath);
-        if (!lookupInfo) {
-            return undefined;
+        let lookupInfo = this._fileInfo.importLookup(resolvedPath);
+        if (lookupInfo === null || lookupInfo === void 0 ? void 0 : lookupInfo.dunderAllNames) {
+            return lookupInfo.dunderAllNames;
         }
-        return lookupInfo.dunderAllNames;
+        if ((_b = aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.submoduleFallback) === null || _b === void 0 ? void 0 : _b.path) {
+            lookupInfo = this._fileInfo.importLookup(aliasDecl.submoduleFallback.path);
+            return lookupInfo === null || lookupInfo === void 0 ? void 0 : lookupInfo.dunderAllNames;
+        }
+        return undefined;
     }
     _addImplicitFromImport(node, importInfo) {
         const symbolName = node.module.nameParts[0].value;