@zzzen/pyright-internal 1.2.0-dev.20241201 → 1.2.0-dev.20241215

package/dist/analyzer/typeEvaluator.js

@@ -2914,7 +2914,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 let annotationType = getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
                     allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
-                    allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
+                    allowClassVar: isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
                 if (annotationType) {
                     const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(target);
@@ -2964,6 +2964,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
+    function isClassVarAllowedForAssignmentTarget(targetNode) {
+        var _a;
+        const classNode = ParseTreeUtils.getEnclosingClass(targetNode, /* stopAtFunction */ true);
+        if (!classNode) {
+            return false;
+        }
+        // ClassVar is not allowed in a TypedDict or a NamedTuple class.
+        const classType = (_a = getTypeOfClass(classNode)) === null || _a === void 0 ? void 0 : _a.classType;
+        if (!classType) {
+            return false;
+        }
+        return !types_1.ClassType.isTypedDictClass(classType) && !classType.shared.namedTupleEntries;
+    }
     function verifyRaiseExceptionType(node, allowNone) {
         const baseExceptionType = getBuiltInType(node, 'BaseException');
         const exceptionType = getTypeOfExpression(node).type;
@@ -10538,20 +10551,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return { type, isIncomplete, typeErrors };
     }
     function getTypeOfSlice(node) {
+        const noneType = getNoneType();
+        let startType = noneType;
+        let endType = noneType;
+        let stepType = noneType;
+        let isIncomplete = false;
         // Evaluate the expressions to report errors and record symbol
-        // references. We can skip this if we're executing speculatively.
-        if (!isSpeculativeModeInUse(node)) {
-            if (node.d.startValue) {
-                getTypeOfExpression(node.d.startValue);
+        // references.
+        if (node.d.startValue) {
+            const startTypeResult = getTypeOfExpression(node.d.startValue);
+            startType = startTypeResult.type;
+            if (startTypeResult.isIncomplete) {
+                isIncomplete = true;
             }
-            if (node.d.endValue) {
-                getTypeOfExpression(node.d.endValue);
+        }
+        if (node.d.endValue) {
+            const endTypeResult = getTypeOfExpression(node.d.endValue);
+            endType = endTypeResult.type;
+            if (endTypeResult.isIncomplete) {
+                isIncomplete = true;
             }
-            if (node.d.stepValue) {
-                getTypeOfExpression(node.d.stepValue);
+        }
+        if (node.d.stepValue) {
+            const stepTypeResult = getTypeOfExpression(node.d.stepValue);
+            stepType = stepTypeResult.type;
+            if (stepTypeResult.isIncomplete) {
+                isIncomplete = true;
             }
         }
-        return { type: getBuiltInObject(node, 'slice') };
+        const sliceType = getBuiltInObject(node, 'slice');
+        if (!(0, types_1.isClassInstance)(sliceType)) {
+            return { type: sliceType };
+        }
+        return { type: types_1.ClassType.specialize(sliceType, [startType, endType, stepType]), isIncomplete };
     }
     // Verifies that a type argument's type is not disallowed.
     function validateTypeArg(argResult, options) {
@@ -10964,7 +10996,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function createSelfType(classType, errorNode, typeArgs, flags) {
         var _a;
         // Self doesn't support any type arguments.
-        if (typeArgs) {
+        if (typeArgs && typeArgs.length > 0) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeArguments, localize_1.LocMessage.typeArgsExpectingNone().format({
                 name: classType.shared.name,
             }), (_a = typeArgs[0].node) !== null && _a !== void 0 ? _a : errorNode);
@@ -13805,7 +13837,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = getTypeOfIterator({ type: exceptionType, isIncomplete: exceptionTypeResult.isIncomplete }, 
-                /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
+                /* isAsync */ false, errorNode, 
+                /* emitNotIterableError */ false)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 return (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
                     if ((0, types_1.isAnyOrUnknown)(subtype)) {
                         return subtype;
@@ -14113,7 +14146,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             const annotationType = getTypeOfAnnotation(node.d.annotation, {
                 varTypeAnnotation: true,
                 allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.d.valueExpr),
-                allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(node.d.valueExpr),
+                allowClassVar: isClassVarAllowedForAssignmentTarget(node.d.valueExpr),
             });
             writeTypeCache(node.d.valueExpr, { type: annotationType }, 0 /* EvalFlags.None */);
         }
@@ -14226,7 +14259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     getTypeOfAnnotation(annotationNode, {
                         varTypeAnnotation: true,
                         allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(annotationParent.d.leftExpr),
-                        allowClassVar: ParseTreeUtils.isClassVarAllowedForAssignmentTarget(annotationParent.d.leftExpr),
+                        allowClassVar: isClassVarAllowedForAssignmentTarget(annotationParent.d.leftExpr),
                     });
                 }
                 else {
@@ -15774,7 +15807,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             ((_c = declaration.node.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 35 /* ParseNodeType.MemberAccess */
                             ? declaration.node.parent
                             : declaration.node;
-                        const allowClassVar = ParseTreeUtils.isClassVarAllowedForAssignmentTarget(declNode);
+                        const allowClassVar = isClassVarAllowedForAssignmentTarget(declNode);
                         const allowFinal = ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode);
                         const allowRequired = ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode) ||
                             !!declaration.isInInlinedTypedDict;