diff --git a/packages/pyright-internal/src/analyzer/patternMatching.ts b/packages/pyright-internal/src/analyzer/patternMatching.ts index a9aab8675cbc..bdc5dfdff849 100644 --- a/packages/pyright-internal/src/analyzer/patternMatching.ts +++ b/packages/pyright-internal/src/analyzer/patternMatching.ts @@ -32,6 +32,7 @@ import { AnalyzerNodeInfoAccessor } from './analyzerNodeInfo'; import { CodeFlowReferenceExpressionNode } from './codeFlowTypes'; import { addConstraintsForExpectedType } from './constraintSolver'; import { ConstraintTracker } from './constraintTracker'; +import { isEnumClassWithMembers } from './enums'; import { getTypeVarScopesForNode, isMatchingExpression } from './parseTreeUtils'; import { validateProtocolUnsafeOverlap } from './protocols'; import { getTypedDictMembersForClass } from './typedDicts'; @@ -170,7 +171,7 @@ export function narrowTypeBasedOnPattern( } case ParseNodeType.PatternValue: { - return narrowTypeBasedOnValuePattern(evaluator, type, pattern, isPositiveTest); + return narrowTypeBasedOnValuePattern(evaluator, type, pattern, isPositiveTest, nodeInfo); } case ParseNodeType.PatternCapture: { @@ -1437,11 +1438,17 @@ function narrowTypeBasedOnValuePattern( evaluator: TypeEvaluator, subjectType: Type, pattern: PatternValueNode, - isPositiveTest: boolean + isPositiveTest: boolean, + nodeInfo: AnalyzerNodeInfoAccessor ): Type { - const valueType = evaluator.getTypeOfExpression(pattern.d.expr).type; + let valueType = evaluator.getTypeOfExpression(pattern.d.expr).type; const narrowedSubtypes: Type[] = []; + // A Never or NoReturn value pattern compares against its special form at runtime. + if (isNever(valueType) && valueType.props?.specialForm) { + valueType = valueType.props.specialForm; + } + evaluator.mapSubtypesExpandTypeVars( valueType, /* options */ undefined, @@ -1529,7 +1536,24 @@ function narrowTypeBasedOnValuePattern( // override __eq__. If neither does, equality implies identity, so // narrow to the value type. if (!hasCustomEq(valueSubtypeExpanded) && !hasCustomEq(subjectSubtypeExpanded)) { - return valueSubtypeUnexpanded; + if ( + evaluator.assignType(subjectSubtypeExpanded, valueSubtypeExpanded) || + evaluator.assignType(valueSubtypeExpanded, subjectSubtypeExpanded) + ) { + return valueSubtypeUnexpanded; + } + + // A special form's class does not model its runtime object. + if (isClass(valueSubtypeExpanded) && ClassType.isSpecialFormClass(valueSubtypeExpanded)) { + return subjectSubtypeUnexpanded; + } + + // An unrelated subject can match only through a subclass that overrides __eq__. + return isClass(subjectSubtypeExpanded) && + (ClassType.isFinal(subjectSubtypeExpanded) || + isEnumClassWithMembers(evaluator, subjectSubtypeExpanded, nodeInfo)) + ? undefined + : subjectSubtypeUnexpanded; } // Literal (including enum) values are handled specially: narrow to diff --git a/packages/pyright-internal/src/tests/samples/matchValue1.py b/packages/pyright-internal/src/tests/samples/matchValue1.py index d2f5889a5cbd..062abdc25e05 100644 --- a/packages/pyright-internal/src/tests/samples/matchValue1.py +++ b/packages/pyright-internal/src/tests/samples/matchValue1.py @@ -1,6 +1,8 @@ # This sample tests type checking for match statements (as # described in PEP 634) that contain value patterns. +import typing +import typing_extensions # pyright: ignore[reportMissingModuleSource] from dataclasses import dataclass from enum import Enum, auto from http import HTTPStatus @@ -411,3 +413,35 @@ def test_bool_expansion(subj: bool): case x: reveal_type(subj, expected_text="Literal[True]") + + +def test_never_value_pattern(subj: object): + result = None + match subj: + case typing_extensions.Never as a1: + reveal_type(a1, expected_text="type[Never]") + result = a1 + case typing.NoReturn as a2: + reveal_type(a2, expected_text="type[NoReturn]") + result = a2 + reveal_type(result, expected_text="type[Never] | type[NoReturn] | None") + + +def test_never_value_pattern_unrelated(subj: PlainToken, form: typing._SpecialForm): + match subj: + case typing.NoReturn as a1: + reveal_type(a1, expected_text="PlainToken") + match form: + case typing_extensions.Never as a2: + reveal_type(a2, expected_text="_SpecialForm") + + +def test_unrelated_identity_eq_value_pattern(subj: PlainBase, final_subj: IdentityClassB): + result = None + match subj: + case PlainTokens.value as a1: + reveal_type(a1, expected_text="PlainBase") + match final_subj: + case PlainTokens.value: + result = final_subj + reveal_type(result, expected_text="None")