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

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;
@@ -34,7 +32,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);
@@ -2242,7 +2234,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 +2274,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 +2315,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 +2329,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 +2362,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 +2376,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 +2389,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 +2407,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,
+                    });
                 }
             }
         }