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

package/dist/analyzer/checker.js

@@ -1897,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) {
@@ -2662,27 +2654,34 @@ 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;
             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 = 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,
-                                });
-                            }
+                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) => {
@@ -2699,9 +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 = getDeprecatedMessageForFunction(subtype);
+                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)) {
@@ -4122,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,