Added support for evaluating the slice class type arguments for sli…

…ce expressions. This addresses #9533. (#9534)
microsoft · Dec 2, 2024 · b0cd5f1 · b0cd5f1
1 parent 099c43f
commit b0cd5f1
Show file tree

Hide file tree

Showing 3 changed files with 46 additions and 9 deletions.
diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -15015,23 +15015,45 @@ export function createTypeEvaluator(
     }
 
     function getTypeOfSlice(node: SliceNode): TypeResult {
+        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 (!isClassInstance(sliceType)) {
+            return { type: sliceType };
+        }
+
+        return { type: ClassType.specialize(sliceType, [startType, endType, stepType]), isIncomplete };
     }
 
     // Verifies that a type argument's type is not disallowed.

diff --git a/packages/pyright-internal/src/tests/samples/slice1.py b/packages/pyright-internal/src/tests/samples/slice1.py
@@ -0,0 +1,10 @@
+# This sample tests the evaluation of slice types.
+
+class ClassA:
+    def __getitem__[T](self, item: T) -> T:
+        return item
+a1 = ClassA()
+
+reveal_type(a1[::], expected_text="slice[None, None, None]")
+reveal_type(a1[1:'a':False], expected_text="slice[Literal[1], Literal['a'], Literal[False]]")
+reveal_type(a1[:3:5.0], expected_text="slice[None, Literal[3], float]")
diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts
@@ -851,3 +851,8 @@ test('ParamSpec53', () => {
     const results = TestUtils.typeAnalyzeSampleFiles(['paramSpec53.py']);
     TestUtils.validateResults(results, 0);
 });
+
+test('Slice1', () => {
+    const results = TestUtils.typeAnalyzeSampleFiles(['slice1.py']);
+    TestUtils.validateResults(results, 0);
+});