@zzzen/pyright-internal 1.2.0-dev.20240526 → 1.2.0-dev.20240602

package/dist/analyzer/analyzerNodeInfo.d.ts

@@ -1,4 +1,4 @@
-import { ClassNode, ExecutionScopeNode, FunctionNode, LambdaNode, ListComprehensionNode, ModuleNode, ParseNode, StringNode } from '../parser/parseNodes';
+import { ClassNode, ComprehensionNode, ExecutionScopeNode, FunctionNode, LambdaNode, ModuleNode, ParseNode, StringNode } from '../parser/parseNodes';
 import { AnalyzerFileInfo } from './analyzerFileInfo';
 import { FlowNode } from './codeFlowTypes';
 import { Declaration } from './declaration';
@@ -9,7 +9,7 @@ export interface DunderAllInfo {
     stringNodes: StringNode[];
     usesUnsupportedDunderAllForm: boolean;
 }
-export type ScopedNode = ModuleNode | ClassNode | FunctionNode | LambdaNode | ListComprehensionNode;
+export type ScopedNode = ModuleNode | ClassNode | FunctionNode | LambdaNode | ComprehensionNode;
 export declare function cleanNodeAnalysisInfo(node: ParseNode): void;
 export declare function getImportInfo(node: ParseNode): ImportResult | undefined;
 export declare function setImportInfo(node: ParseNode, importInfo: ImportResult): void;

package/dist/analyzer/binder.d.ts

@@ -1,4 +1,4 @@
-import { AssertNode, AssignmentExpressionNode, AssignmentNode, AugmentedAssignmentNode, AwaitNode, BinaryOperationNode, BreakNode, CallNode, ClassNode, ContinueNode, DelNode, ExceptNode, ForNode, FunctionNode, GlobalNode, IfNode, ImportAsNode, ImportFromNode, IndexNode, LambdaNode, ListComprehensionNode, 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 { 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';
@@ -72,7 +72,7 @@ export declare class Binder extends ParseTreeWalker {
     visitTernary(node: TernaryNode): boolean;
     visitUnaryOperation(node: UnaryOperationNode): boolean;
     visitBinaryOperation(node: BinaryOperationNode): boolean;
-    visitListComprehension(node: ListComprehensionNode): boolean;
+    visitComprehension(node: ComprehensionNode): boolean;
     visitMatch(node: MatchNode): boolean;
     visitPatternAs(node: PatternAsNode): boolean;
     visitPatternCapture(node: PatternCaptureNode): boolean;
@@ -80,7 +80,7 @@ export declare class Binder extends ParseTreeWalker {
     private _formatModuleName;
     private _getNonClassParentScope;
     private _addSlotsToCurrentScope;
-    private _isInListComprehension;
+    private _isInComprehension;
     private _addPatternCaptureTarget;
     private _useExceptTargets;
     private _getDunderAllNamesFromImport;

package/dist/analyzer/binder.js

@@ -426,7 +426,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // 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 /* ParseNodeType.Decorator */)) {
+        if (!ParseTreeUtils.isNodeContainedWithinNodeType(node, 16 /* ParseNodeType.Decorator */)) {
             // Skip if we're in an 'Annotated' annotation because this creates
             // problems for "No Return" return type analysis when annotation
             // evaluation is deferred.
@@ -444,7 +444,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             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 /* ParseNodeType.List */) {
+                if (argExpr.nodeType === 34 /* ParseNodeType.List */) {
                     argExpr.entries.forEach((listEntryNode) => {
                         var _a, _b;
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
@@ -581,7 +581,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // If the assignment target base expression is potentially a
         // TypedDict, add the base expression to the flow expressions set
         // to accommodate TypedDict type narrowing.
-        if (node.leftExpression.nodeType === 24 /* ParseNodeType.Index */) {
+        if (node.leftExpression.nodeType === 27 /* ParseNodeType.Index */) {
             const target = node.leftExpression;
             if (target.items.length === 1 &&
                 !target.trailingComma &&
@@ -621,7 +621,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 const expr = node.rightExpression;
                 this._dunderAllNames = [];
                 let emitDunderAllWarning = false;
-                if (expr.nodeType === 31 /* ParseNodeType.List */) {
+                if (expr.nodeType === 34 /* ParseNodeType.List */) {
                     expr.entries.forEach((listEntryNode) => {
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             listEntryNode.strings.length === 1 &&
@@ -668,7 +668,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 if (expr.nodeType === 48 /* ParseNodeType.StringList */) {
                     this._dunderSlotsEntries.push(expr);
                 }
-                else if (expr.nodeType === 31 /* ParseNodeType.List */) {
+                else if (expr.nodeType === 34 /* ParseNodeType.List */) {
                     expr.entries.forEach((listEntryNode) => {
                         if (listEntryNode.nodeType === 48 /* ParseNodeType.StringList */ &&
                             listEntryNode.strings.length === 1 &&
@@ -751,7 +751,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             node.leftExpression.value === '__all__') {
             const expr = node.rightExpression;
             let emitDunderAllWarning = true;
-            if (expr.nodeType === 31 /* ParseNodeType.List */) {
+            if (expr.nodeType === 34 /* ParseNodeType.List */) {
                 // Is this the form __all__ += ["a", "b"]?
                 expr.entries.forEach((listEntryNode) => {
                     var _a;
@@ -899,15 +899,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitYield(node) {
-        if (this._isInListComprehension(node, /* ignoreOutermostIterable */ true)) {
-            this._addSyntaxError(localize_1.LocMessage.yieldWithinListCompr(), node);
+        if (this._isInComprehension(node, /* ignoreOutermostIterable */ true)) {
+            this._addSyntaxError(localize_1.LocMessage.yieldWithinComprehension(), node);
         }
         this._bindYield(node);
         return false;
     }
     visitYieldFrom(node) {
-        if (this._isInListComprehension(node, /* ignoreOutermostIterable */ true)) {
-            this._addSyntaxError(localize_1.LocMessage.yieldWithinListCompr(), node);
+        if (this._isInComprehension(node, /* ignoreOutermostIterable */ true)) {
+            this._addSyntaxError(localize_1.LocMessage.yieldWithinComprehension(), node);
         }
         this._bindYield(node);
         return false;
@@ -1191,7 +1191,7 @@ 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) !== 32 /* ParseNodeType.ListComprehension */) {
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 11 /* ParseNodeType.Comprehension */) {
                 this._addSyntaxError(localize_1.LocMessage.awaitNotInAsync(), node);
             }
         }
@@ -1639,13 +1639,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
-    visitListComprehension(node) {
+    visitComprehension(node) {
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
         // The first iterable is executed outside of the comprehension scope.
-        if (node.forIfNodes.length > 0 && node.forIfNodes[0].nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+        if (node.forIfNodes.length > 0 && node.forIfNodes[0].nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
             this.walk(node.forIfNodes[0].iterableExpression);
         }
-        this._createNewScope(1 /* ScopeType.ListComprehension */, this._getNonClassParentScope(), 
+        this._createNewScope(1 /* ScopeType.Comprehension */, this._getNonClassParentScope(), 
         /* proxyScope */ undefined, () => {
             var _a;
             AnalyzerNodeInfo.setScope(node, this._currentScope);
@@ -1656,7 +1656,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             for (let i = 0; i < node.forIfNodes.length; i++) {
                 const compr = node.forIfNodes[i];
                 const addedSymbols = new Map();
-                if (compr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+                if (compr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
                     this._bindPossibleTupleNamedTarget(compr.targetExpression, addedSymbols);
                     this._addInferredTypeAssignmentForVariable(compr.targetExpression, compr);
                     // Async for is not allowed outside of an async function
@@ -1666,7 +1666,7 @@ 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) === 31 /* ParseNodeType.List */) {
+                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 34 /* ParseNodeType.List */) {
                                 this._addSyntaxError(localize_1.LocMessage.asyncNotInAsyncFunction(), compr.asyncToken);
                             }
                         }
@@ -1675,7 +1675,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             for (let i = 0; i < node.forIfNodes.length; i++) {
                 const compr = node.forIfNodes[i];
-                if (compr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+                if (compr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
                     // We already walked the first iterable expression above,
                     // so skip it here.
                     if (i !== 0) {
@@ -1843,15 +1843,15 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._currentScope.setSlotsNames(slotNameNodes.map((node) => node.strings[0].value));
         }
     }
-    _isInListComprehension(node, ignoreOutermostIterable = false) {
+    _isInComprehension(node, ignoreOutermostIterable = false) {
         let curNode = node;
         let prevNode;
         let prevPrevNode;
         while (curNode) {
-            if (curNode.nodeType === 32 /* ParseNodeType.ListComprehension */) {
+            if (curNode.nodeType === 11 /* ParseNodeType.Comprehension */) {
                 if (ignoreOutermostIterable && curNode.forIfNodes.length > 0) {
                     const outermostCompr = curNode.forIfNodes[0];
-                    if (prevNode === outermostCompr && outermostCompr.nodeType === 33 /* ParseNodeType.ListComprehensionFor */) {
+                    if (prevNode === outermostCompr && outermostCompr.nodeType === 12 /* ParseNodeType.ComprehensionFor */) {
                         if (prevPrevNode === outermostCompr.iterableExpression) {
                             return false;
                         }
@@ -2304,7 +2304,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         switch (expression.nodeType) {
             case 38 /* ParseNodeType.Name */:
             case 35 /* ParseNodeType.MemberAccess */:
-            case 24 /* ParseNodeType.Index */: {
+            case 27 /* ParseNodeType.Index */: {
                 if (filterForNeverNarrowing) {
                     // Never narrowing doesn't support member access or index
                     // expressions.
@@ -2332,7 +2332,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         // If the expression is an index expression with a supported
                         // subscript, add its baseExpression to the expression list because
                         // that expression can be narrowed.
-                        if (expression.nodeType === 24 /* ParseNodeType.Index */ &&
+                        if (expression.nodeType === 27 /* ParseNodeType.Index */ &&
                             expression.items.length === 1 &&
                             !expression.trailingComma &&
                             expression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */) {
@@ -2357,7 +2357,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 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 /* ParseNodeType.Constant */ &&
+                    if (expression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
                         expression.rightExpression.constType === 26 /* KeywordType.None */) {
                         return this._isNarrowingExpression(expression.leftExpression, expressionList, filterForNeverNarrowing, 
                         /* isComplexExpression */ true);
@@ -2456,7 +2456,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 break;
             }
-            case 24 /* ParseNodeType.Index */: {
+            case 27 /* ParseNodeType.Index */: {
                 this._createFlowAssignment(target, unbound);
                 if (walkTargets) {
                     this.walk(target);
@@ -2483,7 +2483,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 break;
             }
-            case 31 /* ParseNodeType.List */: {
+            case 34 /* ParseNodeType.List */: {
                 target.entries.forEach((entry) => {
                     this._createAssignmentTargetFlowNodes(entry, walkTargets, unbound);
                 });
@@ -2684,7 +2684,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 });
                 break;
             }
-            case 31 /* ParseNodeType.List */: {
+            case 34 /* ParseNodeType.List */: {
                 target.entries.forEach((expr) => {
                     this._bindPossibleTupleNamedTarget(expr, addedSymbols);
                 });
@@ -2831,7 +2831,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._addInferredTypeAssignmentForVariable(target.expression, source);
                 break;
             }
-            case 31 /* ParseNodeType.List */: {
+            case 34 /* ParseNodeType.List */: {
                 target.entries.forEach((entry) => {
                     this._addInferredTypeAssignmentForVariable(entry, source);
                 });
@@ -2905,14 +2905,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         symbolWithScope.symbol.setIsInstanceMember();
                     }
                     // Look for an 'InitVar' either by itself or wrapped in an 'Annotated'.
-                    if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */) {
+                    if (typeAnnotation.nodeType === 27 /* ParseNodeType.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 /* ParseNodeType.Index */ &&
+                            if (item0Expr.nodeType === 27 /* ParseNodeType.Index */ &&
                                 this._isDataclassesAnnotation(item0Expr.baseExpression, 'InitVar')) {
                                 symbolWithScope.symbol.setIsInitVar();
                             }
@@ -3031,7 +3031,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (this._isTypingAnnotation(typeAnnotation, 'Final')) {
                 isFinal = true;
             }
-            else if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
                 // Recursively call to see if the base expression is "Final".
                 const finalInfo = this._isAnnotationFinal(typeAnnotation.baseExpression);
                 if (finalInfo.isFinal &&
@@ -3056,7 +3056,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             if (typeAnnotation.nodeType === 48 /* ParseNodeType.StringList */ && typeAnnotation.typeAnnotation) {
                 typeAnnotation = typeAnnotation.typeAnnotation;
             }
-            if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ &&
+            if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ &&
                 typeAnnotation.items.length > 0 &&
                 this._isTypingAnnotation(typeAnnotation.baseExpression, 'Annotated')) {
                 typeAnnotation = typeAnnotation.items[0].valueExpression;
@@ -3065,7 +3065,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isClassVar = true;
                 break;
             }
-            else if (typeAnnotation.nodeType === 24 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
+            else if (typeAnnotation.nodeType === 27 /* ParseNodeType.Index */ && typeAnnotation.items.length === 1) {
                 // Recursively call to see if the base expression is "ClassVar".
                 const finalInfo = this._isAnnotationClassVar(typeAnnotation.baseExpression);
                 if (finalInfo.isClassVar &&