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

package/dist/analyzer/binder.d.ts

@@ -1,10 +1,8 @@
-import { DocStringService } from '../common/docStringService';
 import { AssertNode, AssignmentExpressionNode, AssignmentNode, AugmentedAssignmentNode, AwaitNode, BinaryOperationNode, BreakNode, CallNode, ClassNode, ComprehensionNode, ContinueNode, DelNode, ExceptNode, ForNode, FunctionNode, GlobalNode, IfNode, ImportAsNode, ImportFromNode, IndexNode, LambdaNode, MatchNode, MemberAccessNode, ModuleNameNode, ModuleNode, NameNode, NonlocalNode, ParseNode, PatternAsNode, PatternCaptureNode, PatternMappingExpandEntryNode, RaiseNode, ReturnNode, SuiteNode, TernaryNode, TryNode, TypeAliasNode, TypeAnnotationNode, TypeParameterListNode, UnaryOperationNode, WhileNode, WithNode, YieldFromNode, YieldNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import { ParseTreeWalker } from './parseTreeWalker';
 import { Scope } from './scope';
 export declare class Binder extends ParseTreeWalker {
-    private _docStringService;
     private _moduleSymbolOnly;
     private readonly _fileInfo;
     private _deferredBindingTasks;
@@ -19,6 +17,7 @@ export declare class Binder extends ParseTreeWalker {
     private _finallyTargets;
     private _currentReturnTarget;
     private _currentScopeCodeFlowExpressions;
+    private _currentMatchSubjExpr;
     private _typingImportAliases;
     private _sysImportAliases;
     private _dataclassesImportAliases;
@@ -34,7 +33,7 @@ export declare class Binder extends ParseTreeWalker {
     private _potentialHiddenSymbols;
     private _potentialPrivateSymbols;
     private _codeFlowComplexity;
-    constructor(fileInfo: AnalyzerFileInfo, _docStringService: DocStringService, _moduleSymbolOnly?: boolean);
+    constructor(fileInfo: AnalyzerFileInfo, _moduleSymbolOnly?: boolean);
     bindModule(node: ModuleNode): void;
     visitModule(node: ModuleNode): boolean;
     visitSuite(node: SuiteNode): boolean;

package/dist/analyzer/binder.js

@@ -64,9 +64,8 @@ const symbolNameUtils_1 = require("./symbolNameUtils");
 // flow nodes. This number is somewhat arbitrary and is tuned empirically.
 const flowNodeComplexityContribution = 0.05;
 class Binder extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(fileInfo, _docStringService, _moduleSymbolOnly = false) {
+    constructor(fileInfo, _moduleSymbolOnly = false) {
         super();
-        this._docStringService = _docStringService;
         this._moduleSymbolOnly = _moduleSymbolOnly;
         // A queue of deferred analysis operations.
         this._deferredBindingTasks = [];
@@ -317,14 +316,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._currentFlowNode = this._createStartFlowNode();
                 this._codeFlowComplexity = 0;
                 node.d.params.forEach((paramNode) => {
-                    var _a, _b;
                     if (paramNode.d.name) {
                         const symbol = this._bindNameToScope(this._currentScope, paramNode.d.name);
-                        // Extract the parameter docString from the function docString
-                        let docString = ParseTreeUtils.getDocString((_b = (_a = node === null || node === void 0 ? void 0 : node.d.suite) === null || _a === void 0 ? void 0 : _a.d.statements) !== null && _b !== void 0 ? _b : []);
-                        if (docString !== undefined) {
-                            docString = this._docStringService.extractParameterDocumentation(docString, paramNode.d.name.d.value);
-                        }
                         if (symbol) {
                             const paramDeclaration = {
                                 type: 2 /* DeclarationType.Param */,
@@ -333,7 +326,6 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                 range: (0, positionUtils_1.convertTextRangeToRange)(paramNode, this._fileInfo.lines),
                                 moduleName: this._fileInfo.moduleName,
                                 isInExceptSuite: this._isInExceptSuite,
-                                docString: docString,
                             };
                             symbol.addDeclaration(paramDeclaration);
                             AnalyzerNodeInfo.setDeclaration(paramNode.d.name, paramDeclaration);
@@ -1177,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;
@@ -1650,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
@@ -1669,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);
                             }
                         }
@@ -1738,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);
@@ -1892,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 */,
@@ -3177,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 {