@zzzen/pyright-internal 1.2.0-dev.20230903 → 1.2.0-dev.20230917

package/dist/analyzer/checker.js

@@ -1105,15 +1105,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const exprTypeResult = this._evaluator.getTypeOfExpression(expression);
         let isExprFunction = true;
+        let isCoroutine = false;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
             if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
                 isExprFunction = false;
             }
+            if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
+                isCoroutine = true;
+            }
         });
         if (isExprFunction) {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.functionInConditionalExpression(), expression);
         }
+        if (isCoroutine) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnnecessaryComparison, diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, localize_1.Localizer.Diagnostic.coroutineInConditionalExpression(), expression);
+        }
     }
     _reportUnusedExpression(node) {
         var _a, _b;
@@ -1890,14 +1897,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // 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);
                 }
-                overloadedFunctions.forEach((overload) => {
-                    if (overload.details.declaration &&
-                        !ParseTreeUtils.isFunctionSuiteEmpty(overload.details.declaration.node)) {
-                        const diag = new diagnostic_1.DiagnosticAddendum();
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overloadWithImplementation());
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithImplementation().format({ name }) + diag.getString(), overload.details.declaration.node.name);
-                    }
-                });
                 // If the file is not a stub and this is the first overload,
                 // verify that there is an implementation.
                 if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
@@ -1990,18 +1989,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // is implicitly initialized by the synthesized `__init__` method and
                 // therefore has an implied assignment.
                 let isImplicitlyAssigned = false;
+                // Is this a class variable within a protocol class? If so, it can
+                // be marked final without providing a value.
+                let isProtocolClass = false;
                 if (symbol.isClassMember() && !symbol.isClassVar()) {
                     const containingClass = ParseTreeUtils.getEnclosingClass(firstDecl.node, /* stopAtFunction */ true);
                     if (containingClass) {
                         const classType = this._evaluator.getTypeOfClass(containingClass);
-                        if (classType &&
-                            (0, types_1.isClass)(classType.decoratedType) &&
-                            types_1.ClassType.isDataClass(classType.decoratedType)) {
-                            isImplicitlyAssigned = true;
+                        if (classType && (0, types_1.isClass)(classType.decoratedType)) {
+                            if (types_1.ClassType.isDataClass(classType.decoratedType)) {
+                                isImplicitlyAssigned = true;
+                            }
+                            if (types_1.ClassType.isProtocolClass(classType.decoratedType)) {
+                                isProtocolClass = true;
+                            }
                         }
                     }
                 }
-                if (!isImplicitlyAssigned) {
+                if (!isImplicitlyAssigned && !isProtocolClass) {
                     this._evaluator.addError(localize_1.Localizer.Diagnostic.finalUnassigned().format({ name }), firstDecl.node);
                 }
             }
@@ -2492,7 +2497,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // derives from an unknown type. In this case, we'll add an
                 // unknown type into the filtered type list to avoid any
                 // false positives.
-                const isClassRelationshipIndeterminate = filterIsSubclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
+                const isClassRelationshipIndeterminate = filterIsSuperclass && filterIsSubclass && !types_1.ClassType.isSameGenericClass(varType, filterType);
                 if (isClassRelationshipIndeterminate) {
                     filteredTypes.push(types_1.UnknownType.create());
                 }
@@ -2628,34 +2633,55 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         let errorMessage;
         let deprecatedMessage;
+        function getDeprecatedMessageForFunction(functionType) {
+            if (functionType.details.declaration &&
+                functionType.details.declaration.node.nodeType === 28 /* Function */) {
+                const containingClass = ParseTreeUtils.getEnclosingClass(functionType.details.declaration.node, 
+                /* stopAtFunction */ true);
+                if (containingClass) {
+                    return localize_1.Localizer.Diagnostic.deprecatedMethod().format({
+                        name: functionType.details.name || '<anonymous>',
+                        className: containingClass.name.value,
+                    });
+                }
+            }
+            return localize_1.Localizer.Diagnostic.deprecatedFunction().format({
+                name: functionType.details.name,
+            });
+        }
         function getDeprecatedMessageForOverloadedCall(evaluator, type) {
             // Determine if the node is part of a call expression. If so,
             // we can determine which overload(s) were used to satisfy
             // the call expression and determine whether any of them
             // are deprecated.
+            let callTypeResult;
             const callNode = ParseTreeUtils.getCallForName(node);
             if (callNode) {
-                const callTypeResult = evaluator.getTypeResult(callNode);
-                if (callTypeResult &&
-                    callTypeResult.overloadsUsedForCall &&
-                    callTypeResult.overloadsUsedForCall.length > 0) {
-                    callTypeResult.overloadsUsedForCall.forEach((overload) => {
-                        if (overload.details.deprecatedMessage !== undefined) {
-                            if (node.value === overload.details.name) {
-                                deprecatedMessage = overload.details.deprecatedMessage;
-                                errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction().format({
-                                    name: overload.details.name,
-                                });
-                            }
-                            else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
-                                deprecatedMessage = overload.details.deprecatedMessage;
-                                errorMessage = localize_1.Localizer.Diagnostic.deprecatedConstructor().format({
-                                    name: type.details.name,
-                                });
-                            }
+                callTypeResult = evaluator.getTypeResult(callNode);
+            }
+            else {
+                const decoratorNode = ParseTreeUtils.getDecoratorForName(node);
+                if (decoratorNode) {
+                    callTypeResult = evaluator.getTypeResultForDecorator(decoratorNode);
+                }
+            }
+            if (callTypeResult &&
+                callTypeResult.overloadsUsedForCall &&
+                callTypeResult.overloadsUsedForCall.length > 0) {
+                callTypeResult.overloadsUsedForCall.forEach((overload) => {
+                    if (overload.details.deprecatedMessage !== undefined) {
+                        if (node.value === overload.details.name) {
+                            deprecatedMessage = overload.details.deprecatedMessage;
+                            errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                    });
-                }
+                        else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
+                            deprecatedMessage = overload.details.deprecatedMessage;
+                            errorMessage = localize_1.Localizer.Diagnostic.deprecatedConstructor().format({
+                                name: type.details.name,
+                            });
+                        }
+                    }
+                });
             }
         }
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
@@ -2672,11 +2698,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if ((0, types_1.isFunction)(subtype)) {
-                if (subtype.details.deprecatedMessage !== undefined && node.value === subtype.details.name) {
-                    deprecatedMessage = subtype.details.deprecatedMessage;
-                    errorMessage = localize_1.Localizer.Diagnostic.deprecatedFunction().format({
-                        name: subtype.details.name || '<anonymous>',
-                    });
+                if (subtype.details.deprecatedMessage !== undefined) {
+                    if (!subtype.details.name || node.value === subtype.details.name) {
+                        deprecatedMessage = subtype.details.deprecatedMessage;
+                        errorMessage = getDeprecatedMessageForFunction(subtype);
+                    }
                 }
             }
             else if ((0, types_1.isOverloadedFunction)(subtype)) {
@@ -3178,7 +3204,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!types_1.ClassType.isDataClass(classType)) {
             return;
         }
-        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 16 /* DeclaredTypesOnly */);
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 32 /* DeclaredTypesOnly */);
         // If there's no __post_init__ method, there's nothing to check.
         if (!postInitMember) {
             return;
@@ -3508,7 +3534,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // __call__ method, skip this check.
         const metaclass = newMember.classType.details.effectiveMetaclass;
         if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
-            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 32 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
+            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 64 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
             if (callMethod) {
                 return;
             }
@@ -4097,10 +4123,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
                     const lastDecl = decls[decls.length - 1];
+                    const primaryDecl = decls[0];
                     // Verify that the override type is assignable to (same or narrower than)
                     // the declared type of the base symbol.
-                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum)) {
+                    const isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !primaryDecl.isFinal;
+                    let diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* EnforceInvariance */ : 0 /* Default */)) {
+                        if (isInvariant) {
+                            diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideIsInvariant());
+                            diagAddendum.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.overrideInvariantMismatch().format({
+                                overrideType: this._evaluator.printType(overrideType),
+                                baseType: this._evaluator.printType(baseType),
+                            }));
+                        }
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
                             name: memberName,
                             className: baseClassAndSymbol.classType.details.name,