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

package/dist/analyzer/binder.js

@@ -2242,7 +2242,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Limit only to expressions that contain a narrowable subexpression
             // that is a name. This avoids complexities with composite expressions like
             // member access or index expressions.
-            if (this._isNarrowingExpression(node, expressionList, /* neverNarrowingExpressions */ true)) {
+            if (this._isNarrowingExpression(node, expressionList, { filterForNeverNarrowing: true })) {
                 const filteredExprList = expressionList.filter((expr) => expr.nodeType === 38 /* ParseNodeType.Name */);
                 if (filteredExprList.length > 0) {
                     this._currentFlowNode = this._createFlowConditional(isPositiveTest ? codeFlowTypes_1.FlowFlags.TrueNeverCondition : codeFlowTypes_1.FlowFlags.FalseNeverCondition, this._currentFlowNode, node);
@@ -2282,10 +2282,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             return Binder._unreachableFlowNode;
         }
         const expressionList = [];
-        if (!this._isNarrowingExpression(expression, expressionList, 
-        /* filterForNeverNarrowing */ (flags &
-            (codeFlowTypes_1.FlowFlags.TrueNeverCondition | codeFlowTypes_1.FlowFlags.FalseNeverCondition)) !==
-            0)) {
+        if (!this._isNarrowingExpression(expression, expressionList, {
+            filterForNeverNarrowing: (flags & (codeFlowTypes_1.FlowFlags.TrueNeverCondition | codeFlowTypes_1.FlowFlags.FalseNeverCondition)) !== 0,
+        })) {
             return antecedent;
         }
         expressionList.forEach((expr) => {
@@ -2324,12 +2323,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     // The isComplexExpression parameter is used internally to determine whether
     // the call is an atom (name, member access, index - plus a "not" form of
     // these) or something more complex (binary operator, call, etc.).
-    _isNarrowingExpression(expression, expressionList, filterForNeverNarrowing = false, isComplexExpression = false) {
+    _isNarrowingExpression(expression, expressionList, options = {}) {
         switch (expression.nodeType) {
             case 38 /* ParseNodeType.Name */:
             case 35 /* ParseNodeType.MemberAccess */:
             case 27 /* ParseNodeType.Index */: {
-                if (filterForNeverNarrowing) {
+                if (options.filterForNeverNarrowing) {
                     // Never narrowing doesn't support member access or index
                     // expressions.
                     if (expression.nodeType !== 38 /* ParseNodeType.Name */) {
@@ -2338,17 +2337,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // Never narrowing doesn't support simple names (falsy
                     // or truthy narrowing) because it's too expensive and
                     // provides relatively little utility.
-                    if (!isComplexExpression) {
+                    if (!options.isComplexExpression) {
                         return false;
                     }
                 }
                 if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression)) {
                     expressionList.push(expression);
-                    if (!filterForNeverNarrowing) {
+                    if (!options.filterForNeverNarrowing) {
                         // If the expression is a member access expression, add its
                         // leftExpression to the expression list because that expression
                         // can be narrowed based on the attribute type.
-                        if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */) {
+                        if (expression.nodeType === 35 /* ParseNodeType.MemberAccess */ && options.allowDiscriminatedNarrowing) {
                             if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(expression.d.leftExpr)) {
                                 expressionList.push(expression.d.leftExpr);
                             }
@@ -2371,8 +2370,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
             case 4 /* ParseNodeType.AssignmentExpression */: {
                 expressionList.push(expression.d.name);
-                this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
-                /* isComplexExpression */ true);
+                this._isNarrowingExpression(expression.d.rightExpr, expressionList, {
+                    ...options,
+                    isComplexExpression: true,
+                });
                 return true;
             }
             case 7 /* ParseNodeType.BinaryOperation */: {
@@ -2383,8 +2384,11 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // These are commonly-used patterns used in control flow.
                     if (expression.d.rightExpr.nodeType === 14 /* ParseNodeType.Constant */ &&
                         expression.d.rightExpr.d.constType === 26 /* KeywordType.None */) {
-                        return this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
-                        /* isComplexExpression */ true);
+                        return this._isNarrowingExpression(expression.d.leftExpr, expressionList, {
+                            ...options,
+                            isComplexExpression: true,
+                            allowDiscriminatedNarrowing: true,
+                        });
                     }
                     // Look for "type(X) is Y" or "type(X) is not Y".
                     if (isOrIsNotOperator &&
@@ -2393,11 +2397,13 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         expression.d.leftExpr.d.leftExpr.d.value === 'type' &&
                         expression.d.leftExpr.d.args.length === 1 &&
                         expression.d.leftExpr.d.args[0].d.argCategory === 0 /* ArgCategory.Simple */) {
-                        return this._isNarrowingExpression(expression.d.leftExpr.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
-                        /* isComplexExpression */ true);
+                        return this._isNarrowingExpression(expression.d.leftExpr.d.args[0].d.valueExpr, expressionList, { ...options, isComplexExpression: true });
                     }
-                    const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
+                    const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                        allowDiscriminatedNarrowing: true,
+                    });
                     // Look for "X is Y" or "X is not Y".
                     // Look for X == <literal> or X != <literal>
                     // Look for len(X) == <literal> or len(X) != <literal>
@@ -2409,61 +2415,79 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         expression.d.operator === 21 /* OperatorType.LessThanOrEqual */ ||
                         expression.d.operator === 15 /* OperatorType.GreaterThan */ ||
                         expression.d.operator === 16 /* OperatorType.GreaterThanOrEqual */) {
-                        const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
-                        /* isComplexExpression */ true);
+                        const isLeftNarrowing = this._isNarrowingExpression(expression.d.leftExpr, expressionList, {
+                            ...options,
+                            isComplexExpression: true,
+                        });
                         return isLeftNarrowing;
                     }
                 }
                 // Look for "<string> in Y" or "<string> not in Y".
                 if (expression.d.operator === 41 /* OperatorType.In */ || expression.d.operator === 42 /* OperatorType.NotIn */) {
                     if (expression.d.leftExpr.nodeType === 48 /* ParseNodeType.StringList */ &&
-                        this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
-                        /* isComplexExpression */ true)) {
+                        this._isNarrowingExpression(expression.d.rightExpr, expressionList, {
+                            ...options,
+                            isComplexExpression: true,
+                        })) {
                         return true;
                     }
                 }
                 // Look for "X in Y" or "X not in Y".
                 if (expression.d.operator === 41 /* OperatorType.In */ || expression.d.operator === 42 /* OperatorType.NotIn */) {
-                    const isLeftNarrowable = this._isNarrowingExpression(expression.d.leftExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
-                    const isRightNarrowable = this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
+                    const isLeftNarrowable = this._isNarrowingExpression(expression.d.leftExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                    });
+                    const isRightNarrowable = this._isNarrowingExpression(expression.d.rightExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                    });
                     return isLeftNarrowable || isRightNarrowable;
                 }
                 return false;
             }
             case 55 /* ParseNodeType.UnaryOperation */: {
                 return (expression.d.operator === 38 /* OperatorType.Not */ &&
-                    this._isNarrowingExpression(expression.d.expr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ false));
+                    this._isNarrowingExpression(expression.d.expr, expressionList, {
+                        ...options,
+                        isComplexExpression: false,
+                    }));
             }
             case 5 /* ParseNodeType.AugmentedAssignment */: {
-                return this._isNarrowingExpression(expression.d.rightExpr, expressionList, filterForNeverNarrowing, 
-                /* isComplexExpression */ true);
+                return this._isNarrowingExpression(expression.d.rightExpr, expressionList, {
+                    ...options,
+                    isComplexExpression: true,
+                });
             }
             case 9 /* ParseNodeType.Call */: {
                 if (expression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
                     (expression.d.leftExpr.d.value === 'isinstance' ||
                         expression.d.leftExpr.d.value === 'issubclass') &&
                     expression.d.args.length === 2) {
-                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                    });
                 }
                 if (expression.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
                     expression.d.leftExpr.d.value === 'callable' &&
                     expression.d.args.length === 1) {
-                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                    });
                 }
                 // Is this potentially a call to a user-defined type guard function?
                 if (expression.d.args.length >= 1) {
                     // Never narrowing doesn't support type guards because they do not
                     // offer negative narrowing.
-                    if (filterForNeverNarrowing) {
+                    if (options.filterForNeverNarrowing) {
                         return false;
                     }
-                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, filterForNeverNarrowing, 
-                    /* isComplexExpression */ true);
+                    return this._isNarrowingExpression(expression.d.args[0].d.valueExpr, expressionList, {
+                        ...options,
+                        isComplexExpression: true,
+                    });
                 }
             }
         }