@zzzen/pyright-internal 1.2.0-dev.20241103 → 1.2.0-dev.20241110

package/dist/analyzer/binder.d.ts

@@ -17,6 +17,7 @@ export declare class Binder extends ParseTreeWalker {
     private _finallyTargets;
     private _currentReturnTarget;
     private _currentScopeCodeFlowExpressions;
+    private _currentMatchSubjExpr;
     private _typingImportAliases;
     private _sysImportAliases;
     private _dataclassesImportAliases;

package/dist/analyzer/binder.js

@@ -1169,19 +1169,23 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitAwait(node) {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g;
         // Make sure this is within an async lambda or function.
-        const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
-        if (enclosingFunction === undefined || !enclosingFunction.d.isAsync) {
-            if (this._fileInfo.ipythonMode && enclosingFunction === undefined) {
+        const execScopeNode = ParseTreeUtils.getExecutionScopeNode(node);
+        if ((execScopeNode === null || execScopeNode === void 0 ? void 0 : execScopeNode.nodeType) !== 31 /* ParseNodeType.Function */ || !execScopeNode.d.isAsync) {
+            if (this._fileInfo.ipythonMode && (execScopeNode === null || execScopeNode === void 0 ? void 0 : execScopeNode.nodeType) === 36 /* ParseNodeType.Module */) {
                 // Top level await is allowed in ipython mode.
                 return true;
             }
+            const isInGenerator = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 11 /* ParseNodeType.Comprehension */ &&
+                ((_c = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.nodeType) !== 34 /* ParseNodeType.List */ &&
+                ((_e = (_d = node.parent) === null || _d === void 0 ? void 0 : _d.parent) === null || _e === void 0 ? void 0 : _e.nodeType) !== 45 /* ParseNodeType.Set */ &&
+                ((_g = (_f = node.parent) === null || _f === void 0 ? void 0 : _f.parent) === null || _g === void 0 ? void 0 : _g.nodeType) !== 18 /* ParseNodeType.Dictionary */;
             // 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) !== 11 /* ParseNodeType.Comprehension */) {
-                this._addSyntaxError(localize_1.LocMessage.awaitNotInAsync(), node);
+            if (!isInGenerator) {
+                this._addSyntaxError(localize_1.LocMessage.awaitNotInAsync(), node.d.awaitToken);
             }
         }
         return true;
@@ -1642,7 +1646,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         this._createNewScope(1 /* ScopeType.Comprehension */, this._getNonClassParentScope(), 
         /* proxyScope */ undefined, () => {
-            var _a;
+            var _a, _b, _c;
             AnalyzerNodeInfo.setScope(node, this._currentScope);
             const falseLabel = this._createBranchLabel();
             // We'll walk the forIfNodes list twice. The first time we'll
@@ -1661,7 +1665,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                             // 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) === 34 /* ParseNodeType.List */) {
+                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 34 /* ParseNodeType.List */ ||
+                                ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 45 /* ParseNodeType.Set */ ||
+                                ((_c = node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 18 /* ParseNodeType.Dictionary */) {
                                 this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), compr.d.asyncToken);
                             }
                         }
@@ -1730,9 +1736,18 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 foundIrrefutableCase = true;
             }
             this._currentFlowNode = this._finishFlowLabel(preGuardLabel);
+            // Note the active match subject expression prior to binding
+            // the pattern. If the pattern involves any targets that overwrite
+            // the subject expression, this will be set to undefined.
+            this._currentMatchSubjExpr = node.d.expr;
             // Bind the pattern.
             this.walk(caseStatement.d.pattern);
-            this._createFlowNarrowForPattern(node.d.expr, caseStatement);
+            // If the pattern involves targets that overwrite the subject
+            // expression, skip creating a flow node for narrowing the subject.
+            if (this._currentMatchSubjExpr) {
+                this._createFlowNarrowForPattern(node.d.expr, caseStatement);
+                this._currentMatchSubjExpr = undefined;
+            }
             // Apply the guard expression.
             if (caseStatement.d.guardExpr) {
                 this._bindConditional(caseStatement.d.guardExpr, preSuiteLabel, postCaseLabel);
@@ -1884,6 +1899,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _addPatternCaptureTarget(target) {
         const symbol = this._bindNameToScope(this._currentScope, target);
         this._createAssignmentTargetFlowNodes(target, /* walkTargets */ false, /* unbound */ false);
+        // See if the target overwrites all or a portion of the subject expression.
+        if (this._currentMatchSubjExpr) {
+            if (ParseTreeUtils.isMatchingExpression(target, this._currentMatchSubjExpr) ||
+                ParseTreeUtils.isPartialMatchingExpression(target, this._currentMatchSubjExpr)) {
+                this._currentMatchSubjExpr = undefined;
+            }
+        }
         if (symbol) {
             const declaration = {
                 type: 1 /* DeclarationType.Variable */,
@@ -3169,9 +3191,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // To determine whether the first parameter of the method
             // refers to the class or the instance, we need to apply
             // some heuristics.
-            if (methodNode.d.name.d.value === '__new__') {
-                // The __new__ method is special. It acts as a classmethod even
-                // though it doesn't have a @classmethod decorator.
+            const implicitClassMethods = ['__new__', '__init_subclass__', '__class_getitem__'];
+            if (implicitClassMethods.includes(methodNode.d.name.d.value)) {
+                // Several methods are special. They act as class methods even
+                // though they don't have a @classmethod decorator.
                 isInstanceMember = false;
             }
             else {