@zzzen/pyright-internal 1.2.0-dev.20231029 → 1.2.0-dev.20231105

package/dist/analyzer/analyzerFileInfo.d.ts

@@ -37,6 +37,7 @@ export interface AnalyzerFileInfo {
     isStubFile: boolean;
     isTypingStubFile: boolean;
     isTypingExtensionsStubFile: boolean;
+    isTypeshedStubFile: boolean;
     isBuiltInStubFile: boolean;
     isInPyTypedPackage: boolean;
     ipythonMode: IPythonMode;

package/dist/analyzer/analyzerFileInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAAwD;AAqDxD,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,IAAI,6BAAa,CAAC,KAAK,EAAE;QACpE,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}
+{"version":3,"file":"analyzerFileInfo.js","sourceRoot":"","sources":["../../../src/analyzer/analyzerFileInfo.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAIH,2DAAwD;AAsDxD,SAAgB,+BAA+B,CAAC,QAA0B;IACtE,IAAI,QAAQ,CAAC,UAAU,EAAE;QACrB,OAAO,IAAI,CAAC;KACf;IAED,IAAI,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE;QAC3C,OAAO,IAAI,CAAC;KACf;IAED,oFAAoF;IACpF,iFAAiF;IACjF,8BAA8B;IAC9B,qGAAqG;IACrG,IAAI,QAAQ,CAAC,oBAAoB,CAAC,aAAa,IAAI,6BAAa,CAAC,KAAK,EAAE;QACpE,OAAO,IAAI,CAAC;KACf;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,0EAkBC"}

package/dist/analyzer/checker.js

@@ -195,7 +195,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     visitFunction(node) {
-        var _a;
+        var _a, _b;
         if (node.typeParameters) {
             this.walk(node.typeParameters);
         }
@@ -210,9 +210,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Track whether we have seen a *args: P.args parameter. Named
             // parameters after this need to be flagged as an error.
             let sawParamSpecArgs = false;
+            const keywordNames = new Set();
+            const paramDetails = (0, parameterUtils_1.getParameterListDetails)(functionTypeResult.functionType);
             // Report any unknown or missing parameter types.
             node.parameters.forEach((param, index) => {
                 if (param.name) {
+                    if (param.category === 0 /* Simple */ && index >= paramDetails.positionOnlyParamCount) {
+                        keywordNames.add(param.name.value);
+                    }
                     // Determine whether this is a P.args parameter.
                     if (param.category === 1 /* ArgsList */) {
                         const annotationExpr = param.typeAnnotation || param.typeAnnotationComment;
@@ -270,6 +275,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             });
+            // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
+            if (paramDetails.hasUnpackedTypedDict) {
+                const kwargsIndex = functionTypeResult.functionType.details.parameters.length - 1;
+                const kwargsType = types_1.FunctionType.getEffectiveParameterType(functionTypeResult.functionType, kwargsIndex);
+                if ((0, types_1.isClass)(kwargsType) && kwargsType.details.typedDictEntries) {
+                    const overlappingEntries = new Set();
+                    kwargsType.details.typedDictEntries.forEach((_, name) => {
+                        if (keywordNames.has(name)) {
+                            overlappingEntries.add(name);
+                        }
+                    });
+                    if (overlappingEntries.size > 0) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overlappingKeywordArgs().format({
+                            names: [...overlappingEntries.values()].join(', '),
+                        }), (_a = node.parameters[kwargsIndex].typeAnnotation) !== null && _a !== void 0 ? _a : node.parameters[kwargsIndex]);
+                    }
+                }
+            }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
             const paramSpecParams = functionTypeResult.functionType.details.parameters.filter((param) => {
                 if (param.typeAnnotation && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
@@ -284,7 +307,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // If this is a stub, ensure that the return type is specified.
             if (this._fileInfo.isStubFile) {
-                const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
+                const returnAnnotation = node.returnTypeAnnotation || ((_b = node.functionAnnotationComment) === null || _b === void 0 ? void 0 : _b.returnTypeAnnotation);
                 if (!returnAnnotation) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportUnknownParameterType, diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.Localizer.Diagnostic.returnTypeUnknown(), node.name);
                 }
@@ -514,7 +537,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         else {
             // There is no return expression, so "None" is assumed.
-            returnTypeResult = { type: types_1.NoneType.createInstance() };
+            returnTypeResult = { type: this._evaluator.getNoneType() };
         }
         // If the enclosing function is async and a generator, the return
         // statement is not allowed to have an argument. A syntax error occurs
@@ -591,7 +614,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a;
         const yieldTypeResult = node.expression
             ? this._evaluator.getTypeResult(node.expression)
-            : { type: types_1.NoneType.createInstance() };
+            : { type: this._evaluator.getNoneType() };
         this._validateYieldType(node, (_a = yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.expectedTypeDiagAddendum);
         return true;
     }
@@ -633,7 +656,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 (0, typeUtils_1.doForEachSubtype)(exceptionType, (subtype) => {
                     subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, types_1.isNoneInstance)(subtype)) {
+                    if (!(0, types_1.isAnyOrUnknown)(subtype) && !(0, typeUtils_1.isNoneInstance)(subtype)) {
                         if ((0, types_1.isClass)(subtype)) {
                             if (!(0, typeUtils_1.derivesFromClassRecursive)(subtype, baseExceptionType, /* ignoreUnknown */ false)) {
                                 diagAddendum.addMessage(localize_1.Localizer.Diagnostic.exceptionTypeIncorrect().format({
@@ -1077,7 +1100,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = this._evaluator.getTypeOfMagicMethodReturn(expandedSubtype, [], '__bool__', node, 
+            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
             /* inferenceContext */ undefined);
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
@@ -1252,7 +1275,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // operation have overlapping types.
     _validateComparisonTypesForIsOperator(node) {
         const rightType = this._evaluator.getType(node.rightExpression);
-        if (!rightType || !(0, types_1.isNoneInstance)(rightType)) {
+        if (!rightType || !(0, typeUtils_1.isNoneInstance)(rightType)) {
             return;
         }
         const leftType = this._evaluator.getType(node.leftExpression);
@@ -1262,7 +1285,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let foundMatchForNone = false;
         (0, typeUtils_1.doForEachSubtype)(leftType, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-            if (this._evaluator.assignType(subtype, types_1.NoneType.createInstance())) {
+            if (this._evaluator.assignType(subtype, this._evaluator.getNoneType())) {
                 foundMatchForNone = true;
             }
         });
@@ -1359,7 +1382,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType);
         }
-        if ((0, types_1.isNoneInstance)(leftType) || (0, types_1.isNoneInstance)(rightType)) {
+        if ((0, typeUtils_1.isNoneInstance)(leftType) || (0, typeUtils_1.isNoneInstance)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType);
         }
         const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloadedFunction)(leftType);
@@ -1468,7 +1491,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Determines whether the specified type is one that should trigger
     // an "unused" value diagnostic.
     _isTypeValidForUnusedValueTest(type) {
-        return !(0, types_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
+        return !(0, typeUtils_1.isNoneInstance)(type) && !(0, types_1.isNever)(type) && !(0, types_1.isAnyOrUnknown)(type);
     }
     // Verifies that each local type variable is used more than once.
     _validateFunctionTypeVarUsage(node, functionTypeResult) {
@@ -2638,22 +2661,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 case 1 /* Unknown */:
                 case 0 /* Unbound */:
                     break;
-                case 7 /* Class */:
-                    // If it's a class, make sure that it has not been given explicit
-                    // type arguments. This will result in a TypeError exception.
-                    if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
+                case 6 /* Class */:
+                    if ((0, typeUtils_1.isNoneInstance)(subtype)) {
+                        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.
                         isSupported = false;
                     }
                     break;
-                case 3 /* None */:
-                    isSupported = types_1.TypeBase.isInstantiable(subtype);
-                    break;
-                case 5 /* Function */:
+                case 4 /* Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
                         isSupported = false;
                     }
                     break;
-                case 9 /* Union */:
+                case 8 /* Union */:
                     isSupported = this._isTypeSupportedTypeForIsInstance(subtype, isInstanceCheck);
                     break;
                 default:
@@ -3105,14 +3128,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const returnAnnotation = node.returnTypeAnnotation || ((_a = node.functionAnnotationComment) === null || _a === void 0 ? void 0 : _a.returnTypeAnnotation);
             const declaredReturnType = functionType.details.declaredReturnType;
             if (returnAnnotation && declaredReturnType) {
-                if (!(0, types_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
+                if (!(0, typeUtils_1.isNoneInstance)(declaredReturnType) && !(0, types_1.isNever)(declaredReturnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), returnAnnotation);
                 }
             }
             else {
                 const inferredReturnType = this._evaluator.getFunctionInferredReturnType(functionType);
                 if (!(0, types_1.isNever)(inferredReturnType) &&
-                    !(0, types_1.isNoneInstance)(inferredReturnType) &&
+                    !(0, typeUtils_1.isNoneInstance)(inferredReturnType) &&
                     !(0, types_1.isAnyOrUnknown)(inferredReturnType)) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.initMustReturnNone(), node.name);
                 }
@@ -3161,7 +3184,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // type doesn't allow it. Skip this check for abstract methods.
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     // If the declared type isn't compatible with 'None', flag an error.
-                    if (!this._evaluator.assignType(declaredReturnType, types_1.NoneType.createInstance(), diagAddendum)) {
+                    if (!this._evaluator.assignType(declaredReturnType, this._evaluator.getNoneType(), diagAddendum)) {
                         // If the function consists entirely of "...", assume that it's
                         // an abstract method or a protocol method and don't require that
                         // the return type matches. This check can also be skipped for an overload.
@@ -3289,7 +3312,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 */ | 32 /* DeclaredTypesOnly */);
+        const postInitMember = (0, typeUtils_1.lookUpClassMember)(classType, '__post_init__', 2 /* SkipBaseClasses */ | 64 /* DeclaredTypesOnly */);
         // If there's no __post_init__ method, there's nothing to check.
         if (!postInitMember) {
             return;
@@ -3604,8 +3627,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Validates that the __init__ and __new__ method signatures are consistent.
     _validateConstructorConsistency(classType) {
-        const initMember = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
-        const newMember = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 4 /* SkipObjectBaseClass */ | 8 /* SkipInstanceVariables */);
+        const initMember = (0, typeUtils_1.lookUpClassMember)(classType, '__init__', 4 /* SkipObjectBaseClass */ | 16 /* SkipInstanceMembers */);
+        const newMember = (0, typeUtils_1.lookUpClassMember)(classType, '__new__', 4 /* SkipObjectBaseClass */ | 16 /* SkipInstanceMembers */);
         if (!initMember || !newMember || !(0, types_1.isClass)(initMember.classType) || !(0, types_1.isClass)(newMember.classType)) {
             return;
         }
@@ -3619,7 +3642,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__', 64 /* SkipTypeBaseClass */ | 8 /* SkipInstanceVariables */);
+            const callMethod = (0, typeUtils_1.lookUpClassMember)(metaclass, '__call__', 8 /* SkipTypeBaseClass */ | 16 /* SkipInstanceMembers */);
             if (callMethod) {
                 return;
             }
@@ -4064,8 +4087,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const baseClass = baseClassAndSymbol.classType;
-        const childClassSelf = (0, typeUtils_1.selfSpecializeClass)(childClassType);
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, types_1.ClassType.cloneAsInstance(childClassSelf));
+        const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, childClassSelf);
+        overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
         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)) {
@@ -4290,7 +4314,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Performs checks on a function that is located within a class
     // and has been determined not to be a property accessor.
     _validateMethod(node, functionType, classNode) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
         const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
         if (node.name && classType) {
@@ -4314,25 +4338,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
             }
         }
-        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '__init_subclass__') {
-            // __init_subclass__ overrides should have a "cls" parameter.
-            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.initSubclassClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
-            }
-            if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
-            }
-        }
-        else if (((_c = node.name) === null || _c === void 0 ? void 0 : _c.value) === '__class_getitem__') {
-            // __class_getitem__ overrides should have a "cls" parameter.
-            if (node.parameters.length === 0 || !node.parameters[0].name || node.parameters[0].name.value !== 'cls') {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportSelfClsParameterName, diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.Localizer.Diagnostic.classGetItemClsParam(), node.parameters.length > 0 ? node.parameters[0] : node.name);
-            }
-            if (classType) {
-                this._validateClsSelfParameterType(functionType, classType, /* isCls */ true);
-            }
-        }
-        else if (((_d = node.name) === null || _d === void 0 ? void 0 : _d.value) === '_generate_next_value_') {
+        else if (((_b = node.name) === null || _b === void 0 ? void 0 : _b.value) === '_generate_next_value_') {
             // Skip this check for _generate_next_value_.
         }
         else if (types_1.FunctionType.isStaticMethod(functionType)) {
@@ -4420,7 +4426,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // it could be combined with other classes in a multi-inheritance
         // situation that effectively adds new superclasses that we don't know
         // about statically.
-        let effectiveFlags = 8 /* SkipInstanceVariables */ | 1 /* SkipOriginalClass */;
+        let effectiveFlags = 16 /* SkipInstanceMembers */ | 1 /* SkipOriginalClass */;
         if (types_1.ClassType.isFinal(classType)) {
             effectiveFlags |= 4 /* SkipObjectBaseClass */;
         }
@@ -4593,7 +4599,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, 
                 /* isAsync */ false, 
-                /* errorNode */ undefined)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                /* errorNode */ except.typeExpression, 
+                /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 (0, typeUtils_1.doForEachSubtype)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         sawUnknownExceptionType = true;