@zzzen/pyright-internal 1.2.0-dev.20230115 → 1.2.0-dev.20230129

package/dist/analyzer/checker.js

@@ -215,7 +215,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateFinalClassNotAbstract(classTypeResult.classType, node);
             this._validateDataClassPostInit(classTypeResult.classType, node);
             this._validateProtocolCompatibility(classTypeResult.classType, node);
-            this._validateInitSubclassArgs(classTypeResult.classType, node);
             this._reportDuplicateEnumMembers(classTypeResult.classType);
             if (types_1.ClassType.isTypedDictClass(classTypeResult.classType)) {
                 this._validateTypedDictClassSuite(node.suite);
@@ -765,6 +764,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateComparisonTypes(node);
             }
         }
+        else if (node.operator === 39 /* Is */ || node.operator === 40 /* IsNot */) {
+            // Don't apply this rule if it's within an assert.
+            if (!ParseTreeUtils.isWithinAssertExpression(node)) {
+                this._validateComparisonTypesForIsOperator(node);
+            }
+        }
         else if (node.operator === 41 /* In */ || node.operator === 42 /* NotIn */) {
             // Don't apply this rule if it's within an assert.
             if (!ParseTreeUtils.isWithinAssertExpression(node)) {
@@ -989,7 +994,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     _getImportResult(node, filePath) {
-        const execEnv = this._importResolver.getConfigOption().findExecEnvironment(filePath);
+        const execEnv = this._importResolver.getConfigOptions().findExecEnvironment(filePath);
         const moduleNameNode = node.parent.module;
         // Handle both absolute and relative imports.
         const moduleName = moduleNameNode.leadingDots === 0
@@ -1155,6 +1160,36 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }), node);
         }
     }
+    // Determines whether the types of the two operands for an "is" or "is not"
+    // operation have overlapping types.
+    _validateComparisonTypesForIsOperator(node) {
+        const rightType = this._evaluator.getType(node.rightExpression);
+        if (!rightType || !(0, types_1.isNoneInstance)(rightType)) {
+            return;
+        }
+        const leftType = this._evaluator.getType(node.leftExpression);
+        if (!leftType) {
+            return;
+        }
+        let foundMatchForNone = false;
+        (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
+            subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
+            if (this._evaluator.assignType(subtype, types_1.NoneType.createInstance())) {
+                foundMatchForNone = true;
+            }
+        });
+        const getMessage = () => {
+            return node.operator === 39 /* Is */
+                ? localize_1.Localizer.Diagnostic.comparisonAlwaysFalse()
+                : localize_1.Localizer.Diagnostic.comparisonAlwaysTrue();
+        };
+        if (!foundMatchForNone) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
+                leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
+                rightType: this._evaluator.printType(rightType),
+            }), node);
+        }
+    }
     // Determines whether the types of the two operands for an == or != operation
     // have overlapping types.
     _validateComparisonTypes(node) {
@@ -2501,7 +2536,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let errorMessage;
         let deprecatedMessage;
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-            var _a, _b, _c;
             if ((0, types_1.isClass)(subtype)) {
                 if (!subtype.includeSubclasses &&
                     subtype.details.deprecatedMessage !== undefined &&
@@ -2521,25 +2555,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // we can determine which overload(s) were used to satisfy
                 // the call expression and determine whether any of them
                 // are deprecated.
-                let callTypeResult;
-                if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */ && node.parent.leftExpression === node) {
-                    callTypeResult = this._evaluator.getTypeResult(node.parent);
-                }
-                else if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 35 /* MemberAccess */ &&
-                    node.parent.memberName === node &&
-                    ((_c = node.parent.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 9 /* Call */ &&
-                    node.parent.parent.leftExpression === node.parent) {
-                    callTypeResult = this._evaluator.getTypeResult(node.parent.parent);
-                }
-                if (callTypeResult &&
-                    callTypeResult.overloadsUsedForCall &&
-                    callTypeResult.overloadsUsedForCall.length > 0) {
-                    callTypeResult.overloadsUsedForCall.forEach((overload) => {
-                        if (overload.details.deprecatedMessage !== undefined && node.value === overload.details.name) {
-                            deprecatedMessage = overload.details.deprecatedMessage;
-                            errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction();
-                        }
-                    });
+                const callNode = ParseTreeUtils.getCallForName(node);
+                if (callNode) {
+                    const callTypeResult = this._evaluator.getTypeResult(callNode);
+                    if (callTypeResult &&
+                        callTypeResult.overloadsUsedForCall &&
+                        callTypeResult.overloadsUsedForCall.length > 0) {
+                        callTypeResult.overloadsUsedForCall.forEach((overload) => {
+                            if (overload.details.deprecatedMessage !== undefined &&
+                                node.value === overload.details.name) {
+                                deprecatedMessage = overload.details.deprecatedMessage;
+                                errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction();
+                            }
+                        });
+                    }
                 }
             }
         });
@@ -2999,22 +3028,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    _validateInitSubclassArgs(classType, node) {
-        const argList = [];
-        // Collect arguments that will be passed to the `__init_subclass__`
-        // method described in PEP 487.
-        node.arguments.forEach((arg) => {
-            if (arg.name && arg.name.value !== 'metaclass') {
-                argList.push({
-                    argumentCategory: 0 /* Simple */,
-                    node: arg,
-                    name: arg.name,
-                    valueExpression: arg.valueExpression,
-                });
-            }
-        });
-        this._evaluator.validateInitSubclassArgs(node, classType, argList);
-    }
     // If a non-protocol class explicitly inherits from a protocol class, this method
     // verifies that any class or instance variables declared but not assigned
     // in the protocol class are implemented in the subclass. It also checks that any