From b766b594c13a9437f96c2dd398f667175685d102 Mon Sep 17 00:00:00 2001 From: crypt0lith <118923461+crypt0lith@users.noreply.github.com> Date: Tue, 20 Oct 2026 07:35:28 -0500 Subject: [PATCH 1/2] Fix match value patterns of Never and NoReturn treated as unreachable A value pattern of Never or NoReturn evaluates to the Never type, so narrowing always produces Never and pyright treats the case as unreachable, though at runtime it compares the subject against the special form object. Narrow against the special form instead. --- .../src/analyzer/patternMatching.ts | 7 ++++++- .../src/tests/samples/matchValue1.py | 14 ++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/analyzer/patternMatching.ts b/packages/pyright-internal/src/analyzer/patternMatching.ts index 912dc2120843..dc498e1a863d 100644 --- a/packages/pyright-internal/src/analyzer/patternMatching.ts +++ b/packages/pyright-internal/src/analyzer/patternMatching.ts @@ -1423,9 +1423,14 @@ function narrowTypeBasedOnValuePattern( pattern: PatternValueNode, isPositiveTest: boolean ): 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, diff --git a/packages/pyright-internal/src/tests/samples/matchValue1.py b/packages/pyright-internal/src/tests/samples/matchValue1.py index d2f5889a5cbd..49142768e687 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,15 @@ 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") From 947a03e88ffcf292e3f21e918171434dc7efc19f Mon Sep 17 00:00:00 2001 From: crypt0lith <118923461+crypt0lith@users.noreply.github.com> Date: Tue, 20 Oct 2026 12:41:41 -0500 Subject: [PATCH 2/2] Keep unrelated non-final subjects of value patterns --- .../src/analyzer/patternMatching.ts | 25 ++++++++++++++++--- .../src/tests/samples/matchValue1.py | 20 +++++++++++++++ 2 files changed, 42 insertions(+), 3 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/patternMatching.ts b/packages/pyright-internal/src/analyzer/patternMatching.ts index dc498e1a863d..10a5bfc5cbe3 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'; @@ -169,7 +170,7 @@ export function narrowTypeBasedOnPattern( } case ParseNodeType.PatternValue: { - return narrowTypeBasedOnValuePattern(evaluator, type, pattern, isPositiveTest); + return narrowTypeBasedOnValuePattern(evaluator, type, pattern, isPositiveTest, nodeInfo); } case ParseNodeType.PatternCapture: { @@ -1421,7 +1422,8 @@ function narrowTypeBasedOnValuePattern( evaluator: TypeEvaluator, subjectType: Type, pattern: PatternValueNode, - isPositiveTest: boolean + isPositiveTest: boolean, + nodeInfo: AnalyzerNodeInfoAccessor ): Type { let valueType = evaluator.getTypeOfExpression(pattern.d.expr).type; const narrowedSubtypes: Type[] = []; @@ -1518,7 +1520,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 49142768e687..062abdc25e05 100644 --- a/packages/pyright-internal/src/tests/samples/matchValue1.py +++ b/packages/pyright-internal/src/tests/samples/matchValue1.py @@ -425,3 +425,23 @@ def test_never_value_pattern(subj: object): 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")