@zzzen/pyright-internal 1.2.0-dev.20231224 → 1.2.0-dev.20231231

package/dist/analyzer/checker.js

@@ -386,6 +386,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
             this._validateGeneratorReturnType(node, functionTypeResult.functionType);
             this._reportDeprecatedClassProperty(node, functionTypeResult);
+            // If this is not a method, @final is disallowed.
+            if (!containingClassNode && types_1.FunctionType.isFinal(functionTypeResult.functionType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalNonMethod().format({ name: node.name.value }), node.name);
+            }
         }
         // 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.
@@ -564,7 +568,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnTypeResult.type, diagAddendum, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                    /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
                     else {
@@ -587,7 +591,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
                                 if (this._evaluator.assignType(adjustedReturnType, returnTypeResult.type, diagAddendum, 
                                 /* destTypeVarContext */ undefined, 
-                                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                                /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -1731,7 +1735,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(functionType, prevOverload)) {
+            if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
                 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,
@@ -1742,14 +1746,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(prevOverload, functionType)) {
+            if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
                 const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
                 const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
                     /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 512 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overloadReturnTypeMismatch().format({
                         name: node.name.value,
@@ -1779,7 +1783,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return undefined;
     }
-    _isOverlappingOverload(functionType, prevOverload) {
+    _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -1788,18 +1792,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.details.name === '__get__') {
             return false;
         }
+        let flags = 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */;
+        if (partialOverlap) {
+            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */;
+        }
         return this._evaluator.assignType(functionType, prevOverload, 
         /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
-        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */);
+        /* srcTypeVarContext */ undefined, flags);
     }
     _isLegalOverloadImplementation(overload, implementation, diag) {
         var _a;
         const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
         const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
-            256 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
+            512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
         const overloadReturnType = (_a = overload.details.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
         const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.details.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
@@ -2715,6 +2723,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noneNotAllowed());
                         isSupported = false;
                     }
+                    else if (types_1.ClassType.isTypedDictClass(subtype)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictClassNotAllowed());
+                        isSupported = false;
+                    }
                     else if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
                         // If it's a class, make sure that it has not been given explicit
                         // type arguments. This will result in a TypeError exception.
@@ -2730,6 +2742,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolRequiresRuntimeCheckable());
                         isSupported = false;
                     }
+                    else if (types_1.ClassType.isNewTypeClass(subtype)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.newTypeClassNotAllowed());
+                        isSupported = false;
+                    }
                     break;
                 case 4 /* TypeCategory.Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
@@ -3782,11 +3798,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.details.declaration;
             const newDecl = newMemberType.details.declaration;
@@ -4150,7 +4166,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Constructors are exempt.
-        if (overrideFunction.details.name === '__init__' || overrideFunction.details.name === '__new__') {
+        if (this._isMethodExemptFromLsp(overrideFunction.details.name)) {
             return;
         }
         // If the declaration for the override function is not the same as the
@@ -4164,6 +4180,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             className: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseMember.classType)),
         }), funcNode.name);
     }
+    // Determines whether the name is exempt from Liskov Substitution Principle rules.
+    _isMethodExemptFromLsp(name) {
+        const exemptMethods = ['__init__', '__new__', '__init_subclass__', '__post_init__'];
+        return exemptMethods.some((n) => n === name);
+    }
     // Determines whether the type is a function or overloaded function with an @override
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
@@ -4217,7 +4238,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             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
                 // false positives.
@@ -4226,7 +4246,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Also, skip this check if the class is a TypedDict. The methods for a TypedDict
                 // are synthesized, and they can result in many overloads. We assume they
                 // are correct and will not produce any errors.
-                if (!exemptMethods.some((exempt) => exempt === memberName) &&
+                if (!this._isMethodExemptFromLsp(memberName) &&
                     !SymbolNameUtils.isPrivateName(memberName) &&
                     !types_1.ClassType.isTypedDictClass(childClassType)) {
                     if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {