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

package/dist/analyzer/typeGuards.js

@@ -73,7 +73,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 : !isPositiveTest;
             // Look for "X is None", "X is not None", "X == None", and "X != None".
             // These are commonly-used patterns used in control flow.
-            if (testExpression.rightExpression.nodeType === 11 /* ParseNodeType.Constant */ &&
+            if (testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
                 testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
@@ -86,7 +86,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         return { type: narrowTypeForIsNone(evaluator, type, adjIsPositiveTest), isIncomplete: false };
                     };
                 }
-                if (leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
+                if (leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
                     ParseTreeUtils.isMatchingExpression(reference, leftExpression.baseExpression) &&
                     leftExpression.items.length === 1 &&
                     !leftExpression.trailingComma &&
@@ -107,7 +107,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 }
             }
             // Look for "X is ...", "X is not ...", "X == ...", and "X != ...".
-            if (testExpression.rightExpression.nodeType === 18 /* ParseNodeType.Ellipsis */) {
+            if (testExpression.rightExpression.nodeType === 21 /* ParseNodeType.Ellipsis */) {
                 // Allow the LHS to be either a simple expression or an assignment
                 // expression that assigns to a simple name.
                 let leftExpression = testExpression.leftExpression;
@@ -172,7 +172,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] is <literal> or X[<literal>] is not <literal>.
-                if (testExpression.leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
+                if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
                     testExpression.leftExpression.items.length === 1 &&
                     !testExpression.leftExpression.trailingComma &&
                     testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
@@ -238,7 +238,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     }
                 }
                 // Look for X[<literal>] == <literal> or X[<literal>] != <literal>
-                if (testExpression.leftExpression.nodeType === 24 /* ParseNodeType.Index */ &&
+                if (testExpression.leftExpression.nodeType === 27 /* ParseNodeType.Index */ &&
                     testExpression.leftExpression.items.length === 1 &&
                     !testExpression.leftExpression.trailingComma &&
                     testExpression.leftExpression.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
@@ -308,7 +308,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             // These are commonly-used patterns used in control flow.
             if (testExpression.leftExpression.nodeType === 35 /* ParseNodeType.MemberAccess */ &&
                 ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.leftExpression) &&
-                testExpression.rightExpression.nodeType === 11 /* ParseNodeType.Constant */ &&
+                testExpression.rightExpression.nodeType === 14 /* ParseNodeType.Constant */ &&
                 testExpression.rightExpression.constType === 26 /* KeywordType.None */) {
                 const memberName = testExpression.leftExpression.memberName;
                 return (type) => {

package/dist/analyzer/typeStubWriter.js

@@ -292,7 +292,7 @@ class TypeStubWriter extends parseTreeWalker_1.ParseTreeWalker {
             if (elseSuite) {
                 this._emitLine('else:');
                 this._emitSuite(() => {
-                    if (elseSuite.nodeType === 19 /* ParseNodeType.If */) {
+                    if (elseSuite.nodeType === 22 /* ParseNodeType.If */) {
                         this.walkMultiple([elseSuite.testExpression, elseSuite.ifSuite, elseSuite.elseSuite]);
                     }
                     else {

package/dist/analyzer/typeUtils.d.ts

@@ -166,7 +166,7 @@ export declare function convertToInstance(type: Type, includeSubclasses?: boolea
 export declare function convertToInstantiable(type: Type, includeSubclasses?: boolean): Type;
 export declare function getMembersForClass(classType: ClassType, symbolTable: SymbolTable, includeInstanceVars: boolean): void;
 export declare function getMembersForModule(moduleType: ModuleType, symbolTable: SymbolTable): void;
-export declare function containsAnyRecursive(type: Type): boolean;
+export declare function containsAnyRecursive(type: Type, includeUnknown?: boolean): boolean;
 export declare function containsAnyOrUnknown(type: Type, recurse: boolean): AnyType | UnknownType | undefined;
 export declare function isPartlyUnknown(type: Type, recursionCount?: number): boolean;
 export declare function explodeGenericClass(classType: ClassType): Type;

package/dist/analyzer/typeUtils.js

@@ -2009,18 +2009,25 @@ function getMembersForModule(moduleType, symbolTable) {
 }
 exports.getMembersForModule = getMembersForModule;
 // Determines if the type contains an Any recursively.
-function containsAnyRecursive(type) {
+function containsAnyRecursive(type, includeUnknown = true) {
     class AnyWalker extends typeWalker_1.TypeWalker {
-        constructor() {
-            super(...arguments);
+        constructor(_includeUnknown) {
+            super();
+            this._includeUnknown = _includeUnknown;
             this.foundAny = false;
         }
         visitAny(type) {
             this.foundAny = true;
             this.cancelWalk();
         }
+        visitUnknown(type) {
+            if (this._includeUnknown) {
+                this.foundAny = true;
+                this.cancelWalk();
+            }
+        }
     }
-    const walker = new AnyWalker();
+    const walker = new AnyWalker(includeUnknown);
     walker.walk(type);
     return walker.foundAny;
 }