@zzzen/pyright-internal 1.2.0-dev.20220710 → 1.2.0-dev.20220731

package/dist/analyzer/checker.js

@@ -386,14 +386,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         this._scopedNodes.push(node);
         if (functionTypeResult && (0, types_1.isOverloadedFunction)(functionTypeResult.decoratedType)) {
-            const overloads = functionTypeResult.decoratedType.overloads;
-            if (overloads.length > 1) {
-                const maxOverloadConsistencyCheckLength = 100;
-                // The check is n^2 in time, so if the number of overloads
-                // is very large (which can happen for some generated code),
-                // skip this check to avoid quadratic analysis time.
-                if (overloads.length < maxOverloadConsistencyCheckLength) {
-                    this._validateOverloadConsistency(node, overloads[overloads.length - 1], overloads.slice(0, overloads.length - 1));
+            // If this is the implementation for the overloaded function, skip
+            // overload consistency checks.
+            if (types_1.OverloadedFunctionType.getImplementation(functionTypeResult.decoratedType) !==
+                functionTypeResult.functionType) {
+                const overloads = types_1.OverloadedFunctionType.getOverloads(functionTypeResult.decoratedType);
+                if (overloads.length > 1) {
+                    const maxOverloadConsistencyCheckLength = 100;
+                    // The check is n^2 in time, so if the number of overloads
+                    // is very large (which can happen for some generated code),
+                    // skip this check to avoid quadratic analysis time.
+                    if (overloads.length < maxOverloadConsistencyCheckLength) {
+                        this._validateOverloadConsistency(node, overloads[overloads.length - 1], overloads.slice(0, overloads.length - 1));
+                    }
                 }
             }
         }
@@ -732,6 +737,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateComparisonTypes(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)) {
+                this._validateContainmentTypes(node);
+            }
+        }
         this._evaluator.getType(node);
         return true;
     }
@@ -977,11 +988,46 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    _validateContainmentTypes(node) {
+        const leftType = this._evaluator.getType(node.leftExpression);
+        const containerType = this._evaluator.getType(node.rightExpression);
+        if (!leftType || !containerType) {
+            return;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(containerType)) {
+            return;
+        }
+        // Use the common narrowing logic for containment.
+        const elementType = (0, typeGuards_1.getElementTypeForContainerNarrowing)(containerType);
+        if (!elementType) {
+            return;
+        }
+        const narrowedType = (0, typeGuards_1.narrowTypeForContainerElementType)(this._evaluator, leftType, this._evaluator.makeTopLevelTypeVarsConcrete(elementType));
+        if ((0, types_1.isNever)(narrowedType)) {
+            const getMessage = () => {
+                return node.operator === 41 /* In */
+                    ? localize_1.Localizer.Diagnostic.containmentAlwaysFalse()
+                    : localize_1.Localizer.Diagnostic.containmentAlwaysTrue();
+            };
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryContains, diagnosticRules_1.DiagnosticRule.reportUnnecessaryContains, getMessage().format({
+                leftType: this._evaluator.printType(leftType, /* expandTypeAlias */ true),
+                rightType: this._evaluator.printType(elementType, /* expandTypeAlias */ true),
+            }), node);
+        }
+    }
     // Determines whether the types of the two operands for an == or != operation
     // have overlapping types.
     _validateComparisonTypes(node) {
+        let rightExpression = node.rightExpression;
+        // Check for chained comparisons.
+        if (rightExpression.nodeType === 7 /* BinaryOperation */ &&
+            !rightExpression.parenthesized &&
+            ParseTreeUtils.operatorSupportsChaining(rightExpression.operator)) {
+            // Use the left side of the right expression for comparison purposes.
+            rightExpression = rightExpression.leftExpression;
+        }
         const leftType = this._evaluator.getType(node.leftExpression);
-        const rightType = this._evaluator.getType(node.rightExpression);
+        const rightType = this._evaluator.getType(rightExpression);
         if (!leftType || !rightType) {
             return;
         }
@@ -1285,9 +1331,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (types_1.FunctionType.isOverloaded(functionType) &&
-                types_1.FunctionType.isOverloaded(prevOverload) &&
-                this._isOverlappingOverload(functionType, prevOverload)) {
+            if (this._isOverlappingOverload(functionType, prevOverload)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overlappingOverload().format({
                     name: node.name.value,
                     obscured: prevOverloads.length + 1,
@@ -1298,9 +1342,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (types_1.FunctionType.isOverloaded(functionType) &&
-                types_1.FunctionType.isOverloaded(prevOverload) &&
-                this._isOverlappingOverload(prevOverload, functionType)) {
+            if (this._isOverlappingOverload(prevOverload, functionType)) {
                 const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
                 const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
                 if (prevReturnType &&
@@ -1388,7 +1430,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const start = statement.start;
                     const lastStatement = statements[statements.length - 1];
                     const end = textRange_1.TextRange.getEnd(lastStatement);
-                    this._evaluator.addUnusedCode(statement, { start, length: end - start });
+                    this._evaluator.addUnreachableCode(statement, { start, length: end - start });
                     reportedUnreachable = true;
                 }
             }
@@ -1578,8 +1620,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const primaryDecl = typedDecls[0];
             if (primaryDecl.type === 5 /* Function */) {
                 const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-                const functions = (0, types_1.isOverloadedFunction)(type) ? type.overloads : (0, types_1.isFunction)(type) ? [type] : [];
-                const overloadedFunctions = functions.filter((func) => types_1.FunctionType.isOverloaded(func));
+                const overloadedFunctions = (0, types_1.isOverloadedFunction)(type)
+                    ? types_1.OverloadedFunctionType.getOverloads(type)
+                    : (0, types_1.isFunction)(type) && types_1.FunctionType.isOverloaded(type)
+                        ? [type]
+                        : [];
                 if (overloadedFunctions.length === 1) {
                     // There should never be a single overload.
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.singleOverload().format({ name }), primaryDecl.node.name);
@@ -1596,9 +1641,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // verify that there is an implementation.
                 if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
                     let implementationFunction;
-                    if ((0, types_1.isOverloadedFunction)(type) &&
-                        !types_1.FunctionType.isOverloaded(type.overloads[type.overloads.length - 1])) {
-                        implementationFunction = type.overloads[type.overloads.length - 1];
+                    if ((0, types_1.isOverloadedFunction)(type) && types_1.OverloadedFunctionType.getImplementation(type)) {
+                        implementationFunction = types_1.OverloadedFunctionType.getImplementation(type);
                     }
                     else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
                         implementationFunction = type;
@@ -1622,11 +1666,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     else if ((0, types_1.isOverloadedFunction)(type)) {
                         // Verify that all overload signatures are assignable to implementation signature.
-                        type.overloads.forEach((overload, index) => {
+                        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
                             var _a, _b, _c, _d;
-                            if (overload === implementationFunction || !types_1.FunctionType.isOverloaded(overload)) {
-                                return;
-                            }
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
                                 if (implementationFunction.details.declaration) {
@@ -2814,6 +2855,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)) {
+            return;
+        }
         classType.details.fields.forEach((localSymbol, name) => {
             // This applies only to instance members.
             if (!localSymbol.isInstanceMember()) {
@@ -3012,7 +3057,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if ((0, types_1.isOverloadedFunction)(newMemberType)) {
             // Find the implementation, not the overloaded signatures.
-            newMemberType = newMemberType.overloads.find((func) => !types_1.FunctionType.isOverloaded(func));
+            newMemberType = types_1.OverloadedFunctionType.getImplementation(newMemberType);
             if (!newMemberType) {
                 return;
             }
@@ -3027,7 +3072,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if ((0, types_1.isOverloadedFunction)(initMemberType)) {
             // Find the implementation, not the overloaded signatures.
-            initMemberType = initMemberType.overloads.find((func) => !types_1.FunctionType.isOverloaded(func));
+            initMemberType = types_1.OverloadedFunctionType.getImplementation(initMemberType);
             if (!initMemberType) {
                 return;
             }
@@ -3165,9 +3210,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             else if ((0, types_1.isOverloadedFunction)(overrideType)) {
                 // Use the last overload.
-                overrideFunction = overrideType.overloads[overrideType.overloads.length - 1];
+                overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
                 // If the last overload isn't an implementation, skip the check for this symbol.
-                if (types_1.FunctionType.isOverloaded(overrideFunction)) {
+                if (!overrideFunction) {
                     return;
                 }
             }
@@ -3235,7 +3280,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // If the symbol has no declaration, and the type is inferred,
             // skip this check.
-            if (!symbol.hasTypedDeclarations()) {
+            if (!symbol.hasTypedDeclarations() && !(0, symbolUtils_1.isFinalVariable)(symbol)) {
                 return;
             }
             // Get the symbol type defined in this class.
@@ -3263,7 +3308,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         });
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
-        var _a;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
@@ -3281,15 +3325,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClassAndSymbol.classType);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-            let overrideFunction;
-            if ((0, types_1.isFunction)(overrideType)) {
-                overrideFunction = overrideType;
-            }
-            else if ((0, types_1.isOverloadedFunction)(overrideType)) {
-                // Use the last overload.
-                overrideFunction = overrideType.overloads[overrideType.overloads.length - 1];
-            }
-            if (overrideFunction) {
+            if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
                 const exemptMethods = ['__init__', '__new__', '__init_subclass__'];
                 // Don't enforce parameter names for dundered methods. Many of them
                 // are misnamed in typeshed stubs, so this would result in many
@@ -3298,8 +3334,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Don't check certain magic functions or private symbols.
                 if (!exemptMethods.some((exempt) => exempt === memberName) &&
                     !SymbolNameUtils.isPrivateName(memberName)) {
-                    if (!this._evaluator.validateOverrideMethod(baseType, overrideFunction, diagAddendum, enforceParamNameMatch)) {
-                        const decl = (_a = overrideFunction.details.declaration) !== null && _a !== void 0 ? _a : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
+                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, diagAddendum, enforceParamNameMatch)) {
+                        const decl = (0, types_1.isFunction)(overrideType) && overrideType.details.declaration
+                            ? overrideType.details.declaration
+                            : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
                         if (decl) {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
@@ -3436,6 +3474,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
                         }
                     }
+                    // Verify that there is not a Final mismatch.
+                    const isBaseVarFinal = (0, symbolUtils_1.isFinalVariable)(baseClassAndSymbol.symbol);
+                    const overrideFinalVarDecl = decls.find((d) => (0, declarationUtils_1.isFinalVariableDeclaration)(d));
+                    if (!isBaseVarFinal && overrideFinalVarDecl) {
+                        const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
+                            name: memberName,
+                            className: baseClassAndSymbol.classType.details.name,
+                        }), lastDecl.node);
+                        if (diag) {
+                            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.path, overrideFinalVarDecl.range);
+                        }
+                    }
                     // Verify that a class variable isn't overriding an instance
                     // variable or vice versa.
                     const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
@@ -3473,6 +3523,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Performs checks on a function that is located within a class
     // and has been determined not to be a property accessor.
     _validateMethod(node, functionType, classNode) {
+        var _a, _b, _c, _d;
         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
         const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
         if (node.name && classType) {
@@ -3485,7 +3536,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         }
-        if (node.name && node.name.value === '__new__') {
+        if (((_a = node.name) === null || _a === void 0 ? void 0 : _a.value) === '__new__') {
             // __new__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 ||
                 !node.parameters[0].name ||
@@ -3496,7 +3547,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
             }
         }
-        else if (node.name && node.name.value === '__init_subclass__') {
+        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '__init_subclass__') {
             // __init_subclass__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.initSubclassClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
@@ -3505,7 +3556,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
             }
         }
-        else if (node.name && node.name.value === '__class_getitem__') {
+        else if (((_c = node.name) === null || _c === void 0 ? void 0 : _c.value) === '__class_getitem__') {
             // __class_getitem__ overrides should have a "cls" parameter.
             if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classGetItemClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
@@ -3514,6 +3565,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
             }
         }
+        else if (((_d = node.name) === null || _d === void 0 ? void 0 : _d.value) === '_generate_next_value_') {
+            // Skip this check for _generate_next_value_.
+        }
         else if (types_1.FunctionType.isStaticMethod(functionType)) {
             // Static methods should not have "self" or "cls" parameters.
             if (node.parameters.length > 0 && node.parameters[0].name) {
@@ -3770,7 +3824,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Were all of the exception types overridden?
                 if (typesOfThisExcept.length === overriddenExceptionCount) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
-                    this._evaluator.addUnusedCode(except, except.exceptSuite);
+                    this._evaluator.addUnreachableCode(except, except.exceptSuite);
                 }
             }
             exceptionTypesSoFar.push(...typesOfThisExcept);