@zzzen/pyright-internal 1.2.0-dev.20230423 → 1.2.0-dev.20230507

package/dist/analyzer/checker.js

@@ -510,16 +510,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitListComprehensionIf(node) {
+        this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
     }
     visitIf(node) {
-        this._evaluator.getType(node.testExpression);
+        this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
     }
     visitWhile(node) {
-        this._evaluator.getType(node.testExpression);
+        this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
     }
@@ -694,6 +695,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.exceptionExpression) {
             this._evaluator.getType(node.exceptionExpression);
         }
+        this._validateConditionalIsBool(node.testExpression);
         // Specifically look for a common programming error where the two arguments
         // to an assert are enclosed in parens and interpreted as a two-element tuple.
         //   assert (x > 3, "bad value x")
@@ -776,6 +778,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitBinaryOperation(node) {
+        if (node.operator === 36 /* And */ || node.operator === 37 /* Or */) {
+            this._validateConditionalIsBool(node.leftExpression);
+            this._validateConditionalIsBool(node.rightExpression);
+        }
         if (node.operator === 12 /* Equals */ || node.operator === 28 /* NotEquals */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
@@ -810,11 +816,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitUnaryOperation(node) {
+        if (node.operator === 38 /* Not */) {
+            this._validateConditionalIsBool(node.expression);
+        }
         this._evaluator.getType(node);
         return true;
     }
     visitTernary(node) {
         this._evaluator.getType(node);
+        this._validateConditionalIsBool(node.testExpression);
         this._reportUnnecessaryConditionExpression(node.testExpression);
         return true;
     }
@@ -989,7 +999,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitCase(node) {
         if (node.guardExpression) {
-            this._evaluator.getType(node.guardExpression);
+            this._validateConditionalIsBool(node.guardExpression);
         }
         this._evaluator.evaluateTypesForStatement(node.pattern);
         return true;
@@ -1036,6 +1046,44 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             importName: importResult.importName,
         }), node);
     }
+    _validateConditionalIsBool(node) {
+        const operandType = this._evaluator.getType(node);
+        if (!operandType) {
+            return;
+        }
+        let isTypeBool = true;
+        const diag = new diagnostic_1.DiagnosticAddendum();
+        this._evaluator.mapSubtypesExpandTypeVars(operandType, /* conditionFilter */ undefined, (expandedSubtype) => {
+            if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
+                return undefined;
+            }
+            // If it's a bool (the common case), we're good.
+            if ((0, types_1.isClassInstance)(expandedSubtype) && types_1.ClassType.isBuiltIn(expandedSubtype, 'bool')) {
+                return undefined;
+            }
+            // Invoke the __bool__ method on the type.
+            const boolReturnType = this._evaluator.getTypeOfMagicMethodReturn(expandedSubtype, [], '__bool__', node, 
+            /* inferenceContext */ undefined);
+            if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
+                return undefined;
+            }
+            if ((0, types_1.isClassInstance)(boolReturnType) && types_1.ClassType.isBuiltIn(boolReturnType, 'bool')) {
+                return undefined;
+            }
+            // All other types are problematic.
+            isTypeBool = false;
+            diag.addMessage(localize_1.Localizer.DiagnosticAddendum.conditionalRequiresBool().format({
+                operandType: this._evaluator.printType(expandedSubtype),
+                boolReturnType: this._evaluator.printType(boolReturnType),
+            }));
+            return undefined;
+        });
+        if (!isTypeBool) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.conditionalOperandInvalid().format({
+                type: this._evaluator.printType(operandType),
+            }) + diag.getString(), node);
+        }
+    }
     _reportUnnecessaryConditionExpression(expression) {
         if (expression.nodeType === 7 /* BinaryOperation */) {
             if (expression.operator === 36 /* And */ || expression.operator === 37 /* Or */) {
@@ -1385,7 +1433,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             ``;
             if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.details.isSynthesizedSelf) {
                 // Does this name refer to a TypeVar that is scoped to this function?
-                if (nameType.scopeId === this._evaluator.getScopeIdForNode(node)) {
+                if (nameType.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
                     // We exempt constrained TypeVars, bound TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
@@ -2511,6 +2559,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isSupported = true;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            subtype = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
             switch (subtype.category) {
                 case 2 /* Any */:
                 case 1 /* Unknown */:
@@ -2741,7 +2790,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const stdlibPath = this._importResolver.getTypeshedStdLibPath(this._fileInfo.executionEnvironment);
         if (stdlibPath && this._importResolver.isStdlibModule(module, this._fileInfo.executionEnvironment)) {
             // If the definition for this name is in 'user' module, it is overwriting the stdlib module.
-            const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, namePartNodes[namePartNodes.length - 1], definitionProvider_1.DefinitionFilter.All, this._evaluator, vscode_languageserver_1.CancellationToken.None);
+            const definitions = definitionProvider_1.DefinitionProvider.getDefinitionsForNode(this._sourceMapper, this._evaluator, namePartNodes[namePartNodes.length - 1], namePartNodes[namePartNodes.length - 1].start, vscode_languageserver_1.CancellationToken.None);
             const paths = definitions ? definitions.map((d) => d.path) : [];
             paths.forEach((p) => {
                 if (!p.startsWith(stdlibPath) && !(0, sourceMapper_1.isStubFile)(p) && this._sourceMapper.isUserCode(p)) {
@@ -3258,8 +3307,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (this._fileInfo.diagnosticRuleSet.reportUninitializedInstanceVariable === 'none') {
             return;
         }
-        // Protocol classes are exempted from this check.
-        if (types_1.ClassType.isProtocolClass(classType)) {
+        // Protocol classes and ABCs are exempted from this check unless they are
+        // marked @final.
+        if (types_1.ClassType.isProtocolClass(classType) ||
+            (types_1.ClassType.supportsAbstractMethods(classType) && !types_1.ClassType.isFinal(classType))) {
             return;
         }
         classType.details.fields.forEach((localSymbol, name) => {