@zzzen/pyright-internal 1.2.0-dev.20231126 → 1.2.0-dev.20231203

package/dist/analyzer/checker.js

@@ -385,6 +385,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
             this._validateGeneratorReturnType(node, functionTypeResult.functionType);
+            this._reportDeprecatedClassProperty(node, functionTypeResult);
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
@@ -412,6 +413,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
+            this._validateOverloadAttributeConsistency(node, functionTypeResult.decoratedType);
         }
         return false;
     }
@@ -531,7 +533,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitReturn(node) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         let returnTypeResult;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         const declaredReturnType = enclosingFunctionNode
@@ -600,17 +602,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.returnTypeMismatch().format({
                             exprType: this._evaluator.printType(returnTypeResult.type),
                             returnType: this._evaluator.printType(declaredReturnType),
-                        }) + diagAddendum.getString(), node.returnExpression ? node.returnExpression : node, (_b = returnTypeResult.expectedTypeDiagAddendum) === null || _b === void 0 ? void 0 : _b.getEffectiveTextRange());
+                        }) + diagAddendum.getString(), (_b = node.returnExpression) !== null && _b !== void 0 ? _b : node, (_c = returnTypeResult.expectedTypeDiagAddendum) === null || _c === void 0 ? void 0 : _c.getEffectiveTextRange());
                     }
                 }
             }
             if ((0, types_1.isUnknown)(returnTypeResult.type)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.returnExpression);
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), (_d = node.returnExpression) !== null && _d !== void 0 ? _d : node);
             }
             else if ((0, typeUtils_1.isPartlyUnknown)(returnTypeResult.type)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownVariableType, diagnosticRules_1.DiagnosticRule.reportUnknownVariableType, localize_1.Localizer.Diagnostic.returnTypePartiallyUnknown().format({
                     returnType: this._evaluator.printType(returnTypeResult.type, { expandTypeAlias: true }),
-                }), node.returnExpression);
+                }), (_e = node.returnExpression) !== null && _e !== void 0 ? _e : node);
             }
         }
         return true;
@@ -1030,6 +1032,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     visitTypeParameter(node) {
         return false;
     }
+    visitTypeAlias(node) {
+        const scope = (0, scopeUtils_1.getScopeForNode)(node);
+        if (scope) {
+            if (scope.type !== 2 /* ScopeType.Class */ && scope.type !== 3 /* ScopeType.Module */ && scope.type !== 4 /* ScopeType.Builtin */) {
+                this._evaluator.addError(localize_1.Localizer.Diagnostic.typeAliasStatementBadScope(), node.name);
+            }
+        }
+        return true;
+    }
     visitTypeAnnotation(node) {
         this._evaluator.getType(node.typeAnnotation);
         return true;
@@ -1691,6 +1702,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
+    // Validates that overloads use @staticmethod and @classmethod consistently.
+    _validateOverloadAttributeConsistency(node, functionType) {
+        var _a, _b, _c, _d, _e, _f;
+        let staticMethodCount = 0;
+        let classMethodCount = 0;
+        functionType.overloads.forEach((overload) => {
+            if (types_1.FunctionType.isStaticMethod(overload)) {
+                staticMethodCount++;
+            }
+            if (types_1.FunctionType.isClassMethod(overload)) {
+                classMethodCount++;
+            }
+        });
+        if (staticMethodCount > 0 && staticMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadStaticMethodInconsistent().format({
+                name: node.name.value,
+            }), (_c = (_b = (_a = functionType.overloads[0]) === null || _a === void 0 ? void 0 : _a.details.declaration) === null || _b === void 0 ? void 0 : _b.node.name) !== null && _c !== void 0 ? _c : node.name);
+        }
+        if (classMethodCount > 0 && classMethodCount < functionType.overloads.length) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadClassMethodInconsistent().format({
+                name: node.name.value,
+            }), (_f = (_e = (_d = functionType.overloads[0]) === null || _d === void 0 ? void 0 : _d.details.declaration) === null || _e === void 0 ? void 0 : _e.node.name) !== null && _f !== void 0 ? _f : node.name);
+        }
+    }
+    // Validates that overloads do not overlap with inconsistent return results.
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
@@ -2725,6 +2761,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
+    _reportDeprecatedClassProperty(node, functionTypeResult) {
+        if (!(0, types_1.isClassInstance)(functionTypeResult.decoratedType) ||
+            !types_1.ClassType.isClassProperty(functionTypeResult.decoratedType)) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node.name, localize_1.Localizer.Diagnostic.classPropertyDeprecated());
+    }
     _reportDeprecatedUseForMemberAccess(node, info) {
         let errorMessage;
         if (info.accessType === 'property') {
@@ -3281,14 +3324,21 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         });
     }
-    // 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
-    // empty functions declared in the protocol are implemented in the subclass.
+    // If a non-protocol class explicitly inherits from a protocol class and does
+    // not explicit derive from ABC, 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 empty functions declared in the protocol
+    // are implemented in the subclass.
     _validateProtocolCompatibility(classType, errorNode) {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
+        // If a class derives from ABC, exempt it from this check. This is used for
+        // mixins that derive from a protocol but do not directly implement all
+        // of the protocol's methods.
+        if (classType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'ABC'))) {
+            return;
+        }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         const isSymbolImplemented = (name) => {
             return classType.details.mro.some((mroClass) => {
@@ -3947,12 +3997,63 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // If the child class overrides this symbol with its own type, make sure
                     // the override is compatible with the overridden symbol. Otherwise use the
                     // override type.
-                    if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType)) {
+                    // Verify that the override type is assignable to (same or narrower than)
+                    // the declared type of the base symbol.
+                    const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
+                    let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
+                    // If the entry is a member of a frozen dataclass, it is immutable,
+                    // so it does not need to be invariant.
+                    if (types_1.ClassType.isFrozenDataClass(overriddenClassAndSymbol.classType) &&
+                        overriddenClassAndSymbol.classType.details.dataClassEntries) {
+                        const dataclassEntry = overriddenClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                        if (dataclassEntry) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overriddenTDEntry;
+                    if (overriddenClassAndSymbol.classType.details.typedDictEntries) {
+                        overriddenTDEntry = overriddenClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (overrideClassAndSymbol.classType.details.typedDictEntries) {
+                        overrideTDEntry = overrideClassAndSymbol.classType.details.typedDictEntries.get(memberName);
+                    }
+                    if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
+                    /* diag */ undefined, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
                         diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.baseClassVariableTypeIncompatible().format({
                             classType: childClassType.details.name,
                             name: memberName,
                         }), errorNode);
                     }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        let isRequiredCompatible;
+                        let isReadOnlyCompatible = true;
+                        // If both classes are TypedDicts and they both define this field,
+                        // make sure the attributes are compatible.
+                        if (overriddenTDEntry.isReadOnly) {
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isReadOnlyCompatible = !overrideTDEntry.isReadOnly;
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            const message = overrideTDEntry.isRequired
+                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
+                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, message().format({ name: memberName }), errorNode);
+                        }
+                        else if (!isReadOnlyCompatible) {
+                            diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                                name: memberName,
+                            }), errorNode);
+                        }
+                    }
                 }
             }
         }
@@ -4261,6 +4362,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             isInvariant = false;
                         }
                     }
+                    let overriddenTDEntry;
+                    if (baseClass.details.typedDictEntries) {
+                        overriddenTDEntry = baseClass.details.typedDictEntries.get(memberName);
+                        if (overriddenTDEntry === null || overriddenTDEntry === void 0 ? void 0 : overriddenTDEntry.isReadOnly) {
+                            isInvariant = false;
+                        }
+                    }
+                    let overrideTDEntry;
+                    if (childClassType.details.typedDictEntries) {
+                        overrideTDEntry = childClassType.details.typedDictEntries.get(memberName);
+                    }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
                     /* destTypeVarContext */ undefined, 
@@ -4282,6 +4394,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
                         }
                     }
+                    else if (overriddenTDEntry && overrideTDEntry) {
+                        // Make sure the required/not-required attribute is compatible.
+                        let isRequiredCompatible = true;
+                        if (overriddenTDEntry.isReadOnly) {
+                            // If the read-only flag is set, a not-required field can be overridden
+                            // by a required field, but not vice versa.
+                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                        }
+                        else {
+                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                        }
+                        if (!isRequiredCompatible) {
+                            const message = overrideTDEntry.isRequired
+                                ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
+                                : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
+                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), lastDecl.node);
+                        }
+                        // Make sure that the derived class isn't marking a previously writable
+                        // entry as read-only.
+                        if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
+                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
+                                name: memberName,
+                            }), lastDecl.node);
+                        }
+                    }
                     // Verify that there is not a Final mismatch.
                     const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
                     const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));