@zzzen/pyright-internal 1.2.0-dev.20221204 → 1.2.0-dev.20221218

package/dist/analyzer/checker.js

@@ -232,6 +232,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.typeParameters) {
             this.walk(node.typeParameters);
         }
+        if (!this._fileInfo.diagnosticRuleSet.analyzeUnannotatedFunctions && !this._fileInfo.isStubFile) {
+            if (ParseTreeUtils.isUnannotatedFunction(node)) {
+                this._evaluator.addInformation(localize_1.Localizer.Diagnostic.unannotatedFunctionSkipped().format({ name: node.name.value }), node.name);
+            }
+        }
         const functionTypeResult = this._evaluator.getTypeOfFunction(node);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         if (functionTypeResult) {
@@ -295,13 +300,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                // If it's a stub file, report an issue of the default value expression is not "...".
-                if (param.defaultValue && this._fileInfo.isStubFile) {
-                    const defaultValueType = this._evaluator.getType(param.defaultValue);
-                    if (!defaultValueType || !(0, typeUtils_1.isEllipsisType)(defaultValueType)) {
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportInvalidStubStatement, diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement, localize_1.Localizer.Diagnostic.defaultValueNotEllipsis(), param.defaultValue);
-                    }
-                }
             });
             // Check for invalid use of ParamSpec P.args and P.kwargs.
             const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
@@ -2554,9 +2552,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
     }
     _conditionallyReportShadowedImport(node) {
+        var _a, _b;
         if (this._fileInfo.diagnosticRuleSet.reportShadowedImports === 'none') {
             return;
         }
+        // Skip this check for relative imports.
+        const nodeModule = node.nodeType === 23 /* ImportFromAs */
+            ? ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 22 /* ImportFrom */
+                ? (_b = node.parent) === null || _b === void 0 ? void 0 : _b.module
+                : undefined
+            : node.module;
+        if (nodeModule === null || nodeModule === void 0 ? void 0 : nodeModule.leadingDots) {
+            return;
+        }
+        // Otherwise use the name to determine if a match for a stdlib module.
         const namePartNodes = node.nodeType === 21 /* ImportAs */
             ? node.module.nameParts
             : node.nodeType === 23 /* ImportFromAs */
@@ -3389,7 +3398,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Build maps of symbols for each of the base classes.
-        const symbolMaps = baseClasses.map((baseClass) => {
+        const baseClassSymbolMaps = baseClasses.map((baseClass) => {
             const specializedBaseClass = classType.details.mro.find((c) => (0, types_1.isClass)(c) && types_1.ClassType.isSameGenericClass(c, baseClass));
             if (!specializedBaseClass || !(0, types_1.isClass)(specializedBaseClass)) {
                 return new Map();
@@ -3397,30 +3406,37 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Retrieve all of the specialized symbols from the base class and its ancestors.
             return (0, typeUtils_1.getClassFieldsRecursive)(specializedBaseClass);
         });
-        for (let symbolMapBaseIndex = 1; symbolMapBaseIndex < symbolMaps.length; symbolMapBaseIndex++) {
-            const baseSymbolMap = symbolMaps[symbolMapBaseIndex];
-            for (const [name, baseClassAndSymbol] of baseSymbolMap) {
+        const childClassSymbolMap = (0, typeUtils_1.getClassFieldsRecursive)(classType);
+        for (let symbolMapBaseIndex = 1; symbolMapBaseIndex < baseClassSymbolMaps.length; symbolMapBaseIndex++) {
+            const baseSymbolMap = baseClassSymbolMaps[symbolMapBaseIndex];
+            for (const [name, overriddenClassAndSymbol] of baseSymbolMap) {
                 // Special-case dundered methods, which can differ in signature. Also
                 // exempt private symbols.
                 if (SymbolNameUtils.isDunderName(name) || SymbolNameUtils.isPrivateName(name)) {
                     continue;
                 }
-                const baseClassType = baseClassAndSymbol.classType;
-                if (!(0, types_1.isClass)(baseClassType)) {
+                const overriddenClassType = overriddenClassAndSymbol.classType;
+                if (!(0, types_1.isClass)(overriddenClassType)) {
                     continue;
                 }
-                for (let overrideIndex = 0; overrideIndex < symbolMapBaseIndex; overrideIndex++) {
-                    const overrideSymbolMap = symbolMaps[overrideIndex];
-                    const overrideClassAndSymbol = overrideSymbolMap.get(name);
-                    if (overrideClassAndSymbol) {
-                        this._validateMultipleInheritanceOverride(baseClassAndSymbol, overrideClassAndSymbol, classType, name, baseClasses[symbolMapBaseIndex], baseClasses[overrideIndex], errorNode);
+                const overrideClassAndSymbol = childClassSymbolMap.get(name);
+                if (overrideClassAndSymbol) {
+                    const overrideClassType = overrideClassAndSymbol.classType;
+                    // If the override is the same as the overridden, then there's nothing
+                    // to check. If the override is the child class, then we can also skip
+                    // the check because the normal override checks will report the error.
+                    if (!(0, types_1.isClass)(overrideClassType) ||
+                        types_1.ClassType.isSameGenericClass(overrideClassType, overriddenClassType) ||
+                        types_1.ClassType.isSameGenericClass(overrideClassType, classType)) {
+                        continue;
                     }
+                    this._validateMultipleInheritanceOverride(overriddenClassAndSymbol, overrideClassAndSymbol, classType, name, errorNode);
                 }
             }
         }
     }
-    _validateMultipleInheritanceOverride(baseClassAndSymbol, overrideClassAndSymbol, childClassType, memberName, baseClass1, baseClass2, errorNode) {
-        if (!(0, types_1.isClass)(baseClassAndSymbol.classType) || !(0, types_1.isClass)(overrideClassAndSymbol.classType)) {
+    _validateMultipleInheritanceOverride(overriddenClassAndSymbol, overrideClassAndSymbol, childClassType, memberName, errorNode) {
+        if (!(0, types_1.isClass)(overriddenClassAndSymbol.classType) || !(0, types_1.isClass)(overrideClassAndSymbol.classType)) {
             return;
         }
         // Special case the '_' symbol, which is used in single dispatch
@@ -3428,15 +3444,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (memberName === '_') {
             return;
         }
-        let baseType = this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol);
-        baseType = (0, typeUtils_1.partiallySpecializeType)(baseType, baseClassAndSymbol.classType);
+        let overriddenType = this._evaluator.getEffectiveTypeOfSymbol(overriddenClassAndSymbol.symbol);
+        overriddenType = (0, typeUtils_1.partiallySpecializeType)(overriddenType, overriddenClassAndSymbol.classType);
         const overrideSymbol = overrideClassAndSymbol.symbol;
         let overrideType = this._evaluator.getEffectiveTypeOfSymbol(overrideSymbol);
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, overrideClassAndSymbol.classType);
+        const childOverrideSymbol = childClassType.details.fields.get(memberName);
+        const childOverrideType = childOverrideSymbol
+            ? this._evaluator.getEffectiveTypeOfSymbol(childOverrideSymbol)
+            : undefined;
         let diag;
         const overrideDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideClassAndSymbol.symbol);
-        const baseDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
-        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
+        const overriddenDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overriddenClassAndSymbol.symbol);
+        if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloadedFunction)(overriddenType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             let overrideFunction;
             if ((0, types_1.isFunction)(overrideType)) {
@@ -3451,7 +3471,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             if (overrideFunction) {
-                if (!this._evaluator.validateOverrideMethod(baseType, overrideFunction, diagAddendum, 
+                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
                     if (decl && decl.type === 5 /* Function */) {
@@ -3463,7 +3483,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
         }
-        else if ((0, typeUtils_1.isProperty)(baseType)) {
+        else if ((0, typeUtils_1.isProperty)(overriddenType)) {
             // Handle properties specially.
             if (!(0, typeUtils_1.isProperty)(overrideType) && !(0, types_1.isAnyOrUnknown)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
@@ -3482,23 +3502,28 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // This check can be expensive, so don't perform it if the corresponding
             // rule is disabled.
             if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
-                if (!(0, types_1.isAnyOrUnknown)(baseType) && !(0, types_1.isAnyOrUnknown)(overrideType) && !(0, types_1.isTypeSame)(baseType, overrideType)) {
-                    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);
+                if (!(0, types_1.isAnyOrUnknown)(overriddenType) && !(0, types_1.isAnyOrUnknown)(overrideType)) {
+                    // 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)) {
+                        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);
+                    }
                 }
             }
         }
-        if (diag && overrideDecl && baseDecl) {
-            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassProvidesType().format({
-                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseClass1)),
+        if (diag && overrideDecl && overriddenDecl) {
+            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverriddenType().format({
+                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overriddenClassAndSymbol.classType)),
+                type: this._evaluator.printType(overriddenType),
+            }), overriddenDecl.path, overriddenDecl.range);
+            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassOverridesType().format({
+                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(overrideClassAndSymbol.classType)),
                 type: this._evaluator.printType(overrideType),
             }), overrideDecl.path, overrideDecl.range);
-            diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.baseClassProvidesType().format({
-                baseClass: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseClass2)),
-                type: this._evaluator.printType(baseType),
-            }), baseDecl.path, baseDecl.range);
         }
     }
     // Validates that any overridden methods or variables contain the same