From 992986da90f49aa3310dbc5c59a214a1e0943a4f Mon Sep 17 00:00:00 2001 From: Rich Chiodo false Date: Fri, 30 Oct 2026 16:16:07 -0700 Subject: [PATCH 1/6] Preserve bound receivers during contextual return inference Keep contextual speculative caches isolated, preserve return specialization without freezing inferred Unknown, and recover unsolved constructor type variables. Add receiver, forwarding, cache-isolation, and freshness regressions. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/constructors.ts | 8 +- .../src/analyzer/overloadResult.ts | 3 + .../src/analyzer/typeCacheUtils.ts | 18 +- .../src/analyzer/typeEvaluator.ts | 44 ++++- .../src/analyzer/typeUtils.ts | 15 +- .../pyright-internal/src/analyzer/types.ts | 5 + .../src/tests/overloadResult.test.ts | 4 +- .../src/tests/samples/callSite5.py | 176 ++++++++++++++++++ .../src/tests/samples/callSite6.py | 64 +++++++ .../src/tests/samples/callSite7.py | 75 ++++++++ .../src/tests/samples/callSite8.py | 72 +++++++ .../src/tests/typeCacheUtils.test.ts | 26 +++ .../src/tests/typeEvaluator4.test.ts | 20 ++ .../src/tests/typeUtils.test.ts | 94 +++++++++- 14 files changed, 607 insertions(+), 17 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/callSite5.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite6.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite7.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite8.py diff --git a/packages/pyright-internal/src/analyzer/constructors.ts b/packages/pyright-internal/src/analyzer/constructors.ts index fee55fb8a034..e42d3155df49 100644 --- a/packages/pyright-internal/src/analyzer/constructors.ts +++ b/packages/pyright-internal/src/analyzer/constructors.ts @@ -635,7 +635,13 @@ function applyExpectedSubtypeForConstructor( return expectedSubtype; } - return specializedType; + // The expected type must not let unsolved constructor TypeVars escape. + return applySolvedTypeVars(specializedType, new ConstraintSolution(), { + replaceUnsolved: { + scopeIds: getTypeVarScopeIds(type), + tupleClassType: evaluator.getTupleClassType(), + }, + }); } // Handles the case where a constructor is a generic type and the type diff --git a/packages/pyright-internal/src/analyzer/overloadResult.ts b/packages/pyright-internal/src/analyzer/overloadResult.ts index 15aac4c34046..96a3ff66b93b 100644 --- a/packages/pyright-internal/src/analyzer/overloadResult.ts +++ b/packages/pyright-internal/src/analyzer/overloadResult.ts @@ -148,6 +148,7 @@ export function projectOverloadResultBaseline( const inferredReturnType = optional(value.shared.inferredReturnType?.type, depth); const strippedFirstParamType = optional(value.priv.strippedFirstParamType, depth); const boundToType = optional(value.priv.boundToType, depth); + const boundSelfType = optional(value.priv.boundSelfType, depth); if (boundToType && !isClass(boundToType)) { throw new ProjectionBlocked('category'); } @@ -159,11 +160,13 @@ export function projectOverloadResultBaseline( returnType !== FunctionType.getEffectiveReturnType(value) || inferredReturnType !== value.shared.inferredReturnType?.type || strippedFirstParamType !== value.priv.strippedFirstParamType || + boundSelfType !== value.priv.boundSelfType || boundToType !== value.priv.boundToType ) { const clone = FunctionType.specialize(value, { parameterTypes, parameterDefaultTypes, returnType }); clone.priv.strippedFirstParamType = strippedFirstParamType; clone.priv.boundToType = boundToType; + clone.priv.boundSelfType = boundSelfType; clone.priv.callSiteReturnTypeCache = undefined; if (value.shared.inferredReturnType && inferredReturnType) { clone.shared = { diff --git a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts index 50a043875d0f..78f29f590d07 100644 --- a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts @@ -44,6 +44,8 @@ export interface SpeculativeTypeEntry extends ContextualTypeCacheEntry { typeResult: TypeResult; incompleteGenerationCount: number; dependentTypes?: DependentType[]; + // Call-site inference can evaluate the same node with different parameter types. + typeContext?: object; } export interface SpeculativeModeOptions { @@ -265,7 +267,8 @@ export class SpeculativeTypeTracker { node: ParseNode, typeResult: TypeResult, incompleteGenerationCount: number, - expectedType: Type | undefined + expectedType: Type | undefined, + typeContext?: object ) { assert(this._speculativeContextStack.length > 0); @@ -273,6 +276,7 @@ export class SpeculativeTypeTracker { typeResult, expectedType, incompleteGenerationCount, + typeContext, }; if (this._activeDependentTypes.length > 0) { @@ -287,7 +291,11 @@ export class SpeculativeTypeTracker { this._speculativeTypeCache.set(node.id, cacheEntries); } - getSpeculativeType(node: ParseNode, expectedType: Type | undefined): SpeculativeTypeEntry | undefined { + getSpeculativeType( + node: ParseNode, + expectedType: Type | undefined, + typeContext?: object + ): SpeculativeTypeEntry | undefined { if ( this._speculativeContextStack.some((context) => ParseTreeUtils.isNodeContainedWithin(node, context.speculativeRootNode) @@ -296,7 +304,11 @@ export class SpeculativeTypeTracker { const entries = this._speculativeTypeCache.get(node.id); if (entries) { for (const entry of entries) { - if (contextualTypeCacheEntryMatches(entry, expectedType) && this._dependentTypesMatch(entry)) { + if ( + entry.typeContext === typeContext && + contextualTypeCacheEntryMatches(entry, expectedType) && + this._dependentTypesMatch(entry) + ) { return entry; } } diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 0c4038c17086..622c6703dae3 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -539,6 +539,7 @@ interface SymbolResolutionStackEntry { interface ReturnTypeInferenceContext { functionNode: FunctionNode; codeFlowAnalyzer: CodeFlowAnalyzer; + speculativeCacheContext: object; } interface ParamSpecArgResult { @@ -950,7 +951,8 @@ export function createTypeEvaluator( node, typeResult, incompleteGenCount, - inferenceContext?.expectedType + inferenceContext?.expectedType, + getSpeculativeTypeCacheContext(node) ); } } @@ -1069,6 +1071,12 @@ export function createTypeEvaluator( return contextNode.codeFlowAnalyzer; } + function getSpeculativeTypeCacheContext(node: ParseNode) { + return isNodeInReturnTypeInferenceContext(node) + ? returnTypeInferenceContextStack[returnTypeInferenceContextStack.length - 1].speculativeCacheContext + : undefined; + } + function getIndexOfSymbolResolution(symbol: Symbol, declaration: Declaration) { return symbolResolutionStack.findIndex( (entry) => entry.symbolId === symbol.id && entry.declaration === declaration @@ -1452,7 +1460,11 @@ export function createTypeEvaluator( // Is it cached in the speculative type cache? const specCacheEntry = useTypeFormCache ? undefined - : speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType); + : speculativeTypeTracker.getSpeculativeType( + node, + inferenceContext?.expectedType, + getSpeculativeTypeCacheContext(node) + ); if (specCacheEntry) { if ( !specCacheEntry.typeResult.isIncomplete || @@ -25834,7 +25846,7 @@ export function createTypeEvaluator( // If the return type has already been lazily evaluated, // don't bother computing it again. if (type.shared.inferredReturnType && !type.shared.inferredReturnType.isIncomplete) { - returnType = type.shared.inferredReturnType.type; + returnType = type.priv.specializedTypes?.returnType ?? type.shared.inferredReturnType.type; } else if (evalCount > maxReturnTypeInferenceAttempts) { // Detect a case where a return type won't converge because of recursion. returnType = UnknownType.create(); @@ -26003,6 +26015,7 @@ export function createTypeEvaluator( returnTypeInferenceContextStack.push({ functionNode, codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(), + speculativeCacheContext: {}, }); try { @@ -26034,7 +26047,11 @@ export function createTypeEvaluator( ) { if (functionTypeResult.functionType.shared.parameters.length > 0) { if (functionNode.d.params[0].d.name) { - paramType = FunctionType.getParamType(functionTypeResult.functionType, 0); + // Include the bound receiver in both contextual evaluation + // and its cache key, rather than reverting to the declaration. + paramType = + type.priv.boundSelfType ?? + FunctionType.getParamType(functionTypeResult.functionType, 0); } } } @@ -30964,17 +30981,24 @@ export function createTypeEvaluator( getEffectiveReturnType(memberType); const specializedFunction = solveAndApplyConstraints(memberType, constraints); + let boundFunction: FunctionType | undefined; if (isFunction(specializedFunction)) { - return FunctionType.clone(specializedFunction, stripFirstParam, baseType); - } - - if (isOverloaded(specializedFunction)) { + boundFunction = FunctionType.clone(specializedFunction, stripFirstParam, baseType); + } else if (isOverloaded(specializedFunction)) { // For overloaded functions, use the first overload. This isn't // strictly correct, but this is an extreme edge case. - return FunctionType.clone(OverloadedType.getOverloads(specializedFunction)[0], stripFirstParam, baseType); + boundFunction = FunctionType.clone( + OverloadedType.getOverloads(specializedFunction)[0], + stripFirstParam, + baseType + ); } - return undefined; + if (boundFunction && stripFirstParam) { + boundFunction.priv.boundSelfType = firstParamType; + } + + return boundFunction; } function isFinalVariable(symbol: Symbol): boolean { diff --git a/packages/pyright-internal/src/analyzer/typeUtils.ts b/packages/pyright-internal/src/analyzer/typeUtils.ts index bdbbea8cb705..bb513d5bce31 100644 --- a/packages/pyright-internal/src/analyzer/typeUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeUtils.ts @@ -4102,7 +4102,12 @@ export class TypeVarTransformer { return this.doForEachConstraintSet(() => { let functionType = sourceType; - const declaredReturnType = FunctionType.getEffectiveReturnType(functionType); + // Don't freeze an inferred Unknown when only the parameters require specialization. + const inferredReturnType = functionType.shared.inferredReturnType?.type; + const declaredReturnType = FunctionType.getEffectiveReturnType( + functionType, + /* includeInferred */ !inferredReturnType || !isUnknown(inferredReturnType) + ); const specializedReturnType = declaredReturnType ? this.apply(declaredReturnType, recursionCount) : undefined; @@ -4193,6 +4198,14 @@ export class TypeVarTransformer { } } + if (functionType.priv.boundSelfType) { + const newBoundSelfType = this.apply(functionType.priv.boundSelfType, recursionCount); + if (newBoundSelfType !== functionType.priv.boundSelfType) { + functionType = TypeBase.cloneType(functionType); + functionType.priv.boundSelfType = newBoundSelfType; + } + } + // Do we need to update the strippedFirstParamType? if (functionType.priv.strippedFirstParamType && !isAnyOrUnknown(functionType.priv.strippedFirstParamType)) { const newStrippedType = this.apply(functionType.priv.strippedFirstParamType, recursionCount); diff --git a/packages/pyright-internal/src/analyzer/types.ts b/packages/pyright-internal/src/analyzer/types.ts index ec629405de9a..d91552efc4ac 100644 --- a/packages/pyright-internal/src/analyzer/types.ts +++ b/packages/pyright-internal/src/analyzer/types.ts @@ -1905,6 +1905,10 @@ export interface FunctionDetailsPriv { // the class or object to which the function was bound. boundToType?: ClassType | undefined; + // The actual argument bound to "self" or "cls", including a TypeVar receiver + // that would otherwise be reduced to its class bound in boundToType. + boundSelfType?: Type | undefined; + // The flags for the function prior to binding preBoundFlags?: FunctionTypeFlags; @@ -3676,6 +3680,7 @@ export function isTypeSame(type1: Type, type2: Type, options: TypeSameOptions = !isTypeSame(param, functionType2.shared.typeParams[index], recursiveOptions, recursionCount) ) || !optionalTypesMatch(type1.priv.boundToType, functionType2.priv.boundToType) || + !optionalTypesMatch(type1.priv.boundSelfType, functionType2.priv.boundSelfType) || !optionalTypesMatch(type1.priv.strippedFirstParamType, functionType2.priv.strippedFirstParamType) || params1.some( (param, index) => diff --git a/packages/pyright-internal/src/tests/overloadResult.test.ts b/packages/pyright-internal/src/tests/overloadResult.test.ts index 4055e70ac5d3..356592f58b9f 100644 --- a/packages/pyright-internal/src/tests/overloadResult.test.ts +++ b/packages/pyright-internal/src/tests/overloadResult.test.ts @@ -114,7 +114,7 @@ test('OverloadResult equality does not erase callable defaults, receiver or stri const second = signature(strType); assert(isTypeSame(first, second)); assert(!isTypeSame(first, second, { honorCallBehavior: true })); - for (const field of ['boundToType', 'strippedFirstParamType'] as const) { + for (const field of ['boundToType', 'boundSelfType', 'strippedFirstParamType'] as const) { const left = signature(intType); const right = signature(intType); left.priv[field] = intList; @@ -174,6 +174,7 @@ test('OverloadResult projects callable parameters, defaults, return and bound pa fn.shared.declaredReturnType = alternatives(); fn.priv.strippedFirstParamType = alternatives(); fn.priv.boundToType = ClassType.specialize(listType, [alternatives()]); + fn.priv.boundSelfType = alternatives(); const unchanged = signature(intType); const implementation = signature(intType); const owner = OverloadedType.create([fn, unchanged], implementation); @@ -185,6 +186,7 @@ test('OverloadResult projects callable parameters, defaults, return and bound pa assert.strictEqual(FunctionType.getEffectiveReturnType(projectedFn), intList); assert.strictEqual(projectedFn.priv.strippedFirstParamType, intList); assert.strictEqual(projectedFn.priv.boundToType!.priv.typeArgs![0], intList); + assert.strictEqual(projectedFn.priv.boundSelfType, intList); assert.strictEqual(projectedFn.priv.overloaded, result); assert.strictEqual(projectedUnchanged.priv.overloaded, result); assert.strictEqual(fn.priv.overloaded, owner); diff --git a/packages/pyright-internal/src/tests/samples/callSite5.py b/packages/pyright-internal/src/tests/samples/callSite5.py new file mode 100644 index 000000000000..ebc711a5cac9 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite5.py @@ -0,0 +1,176 @@ +# This sample tests receiver binding during call-site return type inference. + +from typing import Generic, TypeVar + + +class Base: + @property + def label(self) -> object: + return "" + + def pick(self, argument): + if argument: + return self + return argument + + def read_label(self, argument): + if argument: + return self.label + return argument + + @classmethod + def make(cls, argument): + if argument: + return cls() + return argument + + @staticmethod + def identity(argument): + return argument + + +class Derived(Base): + @property + def label(self) -> str: + return "derived" + + def derived_only(self) -> int: + return 42 + + def forwarded(self): + return self.pick(1) + + +class Other(Base): + @property + def label(self) -> int: + return 42 + + +class Further(Derived): + pass + + +def demonstrate(value: Derived, other: Other): + selected = value.pick(1) + reveal_type(selected, expected_text="Derived") + selected.derived_only() + + reveal_type(other.pick(1), expected_text="Other") + reveal_type(value.pick(1), expected_text="Derived") + reveal_type(other.pick(0), expected_text="Other | Literal[0]") + reveal_type(value.pick(""), expected_text="Derived | Literal['']") + reveal_type(other.pick(1), expected_text="Other") + + reveal_type(value.read_label(1), expected_text="str") + reveal_type(other.read_label(1), expected_text="int") + reveal_type(value.read_label(1), expected_text="str") + + reveal_type(Base.pick(value, 1), expected_text="Derived") + reveal_type(Base.pick(other, 1), expected_text="Other") + reveal_type(value.identity(1), expected_text="Unknown") + + # Decorated methods cannot use call-site inference, but the cached + # inferred return type must still retain its receiver specialization. + reveal_type(Derived.make(1), expected_text="Derived | Unknown") + reveal_type(Other.make(1), expected_text="Other | Unknown") + reveal_type(Derived.make(1), expected_text="Derived | Unknown") + reveal_type(Further().forwarded(), expected_text="Further") + + +def unknown_argument(value: Derived, other: Other, argument): + reveal_type(value.pick(argument), expected_text="Derived | Unknown") + reveal_type(other.pick(argument), expected_text="Other | Unknown") + reveal_type(value.pick(argument), expected_text="Derived | Unknown") + + +T = TypeVar("T") + + +class GenericBase(Generic[T]): + def __init__(self, value: T): + self.value = value + + def pick(self, argument): + if argument: + return self + return argument + + def read_value(self, argument): + if argument: + return self.value + return argument + + +class GenericDerived(GenericBase[T]): + pass + + +def generic_receivers(first: GenericDerived[int], second: GenericDerived[str]): + reveal_type(first.pick(1), expected_text="GenericDerived[int]") + reveal_type(second.pick(1), expected_text="GenericDerived[str]") + reveal_type(first.pick(1), expected_text="GenericDerived[int]") + reveal_type(first.read_value(1), expected_text="int") + reveal_type(second.read_value(1), expected_text="str") + reveal_type(first.read_value(1), expected_text="int") + + +class PowerBase: + def __pow__(self, exponent): + if exponent < 0: + return NotImplemented + if exponent > 2: + return exponent + return self + + +class PowerDerived(PowerBase): + pass + + +def power_receiver(value: PowerDerived): + reveal_type(value.__pow__(2), expected_text="NotImplementedType | PowerDerived | Literal[2]") + reveal_type(value ** 2, expected_text="NotImplementedType | Unknown | PowerDerived") + + +# Speculative overload arguments must not leak between receiver contexts. +class PrinterBase: + human: bool = True + + def format_code(self, lines): + raise NotImplementedError + + def print_code(self, content, assign_to=None): + lines = ["one", "two"] + if self.human: + lines = self.format_code(lines) + result = "\n".join(lines) + else: + lines = self.format_code(lines) + result = (set(), set(), "\n".join(lines)) + return result + + +class CPrinter(PrinterBase): + def format_code(self, lines): + return self.indent_code(lines) + + def indent_code(self, code): + if isinstance(code, str): + return "".join(self.indent_code(code.splitlines(True))) + return [str(line) for line in code] + + +class PythonPrinter(PrinterBase): + def format_code(self, lines): + return lines + + +def print_c(content, printer_type=CPrinter): + reveal_type(printer_type().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") + + +def print_python(content): + reveal_type(PythonPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") + reveal_type(CPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") + reveal_type(PythonPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") diff --git a/packages/pyright-internal/src/tests/samples/callSite6.py b/packages/pyright-internal/src/tests/samples/callSite6.py new file mode 100644 index 000000000000..c10199435a84 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite6.py @@ -0,0 +1,64 @@ +# This sample tests control flow and generic recovery during contextual inference. + +from typing import NoReturn, TypeVar + + +class Helper: + def fail(self): + raise ValueError("always raises") + + def fail_declared(self) -> NoReturn: + raise ValueError("always raises") + + def implicit(self) -> int: + self.fail() + return None + + def declared(self) -> int: + self.fail_declared() + return None + + def exception_path(self) -> int: + try: + result = 1 + except Exception: + self.fail() + return result + + +reveal_type(Helper().fail, expected_text="() -> NoReturn") + + +def reverse_or_default(values, default): + if getattr(values, "__reversed__", None): + return next(reversed(values)) + return default + + +def enumerate_input(values): + pool = enumerate(values) + reveal_type(reverse_or_default(pool, (1, None)), expected_text="Unknown | tuple[Literal[1], None]") + first, second = reverse_or_default(pool, (1, None)) + return first, second + + +def known_inputs(): + reveal_type(reverse_or_default([1, 2], (1, None)), expected_text="int | tuple[Literal[1], None]") + reveal_type( + reverse_or_default(enumerate([1, 2]), (1, None)), expected_text="Unknown | tuple[Literal[1], None]" + ) + reveal_type(reverse_or_default(["a", "b"], (1, None)), expected_text="str | tuple[Literal[1], None]") + reveal_type(reverse_or_default([1, 2], (1, None)), expected_text="int | tuple[Literal[1], None]") + + +T = TypeVar("T") + + +def generic_input(values: list[T], default: T): + reveal_type(reverse_or_default(values, default), expected_text="T@generic_input") + + +def invalid_constructor_input(values: enumerate[int]): + # This should generate two errors because enumerate is not reversible. + result = next(reversed(values)) + reveal_type(result, expected_text="Unknown") diff --git a/packages/pyright-internal/src/tests/samples/callSite7.py b/packages/pyright-internal/src/tests/samples/callSite7.py new file mode 100644 index 000000000000..efeff4152639 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite7.py @@ -0,0 +1,75 @@ +# This sample tests concrete transform results forwarded through an inherited mixin. + +from typing import Generic, TypeVar + + +class Transformer: + def fit(self, values): + return self + + def transform(self, values): + return values + + def fit_transform(self, values): + return self.fit(values).transform(values) + + +class DenseTransformer(Transformer): + def transform(self, values) -> list[int]: + return [1, 2] + + +class SparseValues: + def toarray(self) -> list[float]: + return [1.0, 2.0] + + +class SparseTransformer(Transformer): + def transform(self, values) -> SparseValues: + return SparseValues() + + +class UnionTransformer(Transformer): + def transform(self, values) -> list[int] | str: + if isinstance(values, str): + return values + return [1, 2] + + +def transform_results(dense: DenseTransformer, sparse: SparseTransformer, union: UnionTransformer): + reveal_type(dense.fit_transform([1]), expected_text="list[int]") + reveal_type(sparse.fit_transform([1]), expected_text="SparseValues") + reveal_type(dense.fit_transform([1]), expected_text="list[int]") + sparse.fit_transform([1]).toarray() + + result = union.fit_transform([1]) + reveal_type(result, expected_text="list[int] | str") + + # This should generate an error because the declared str alternative must be retained. + result.append(3) + + if isinstance(result, list): + result.append(3) + else: + result.upper() + + reveal_type(sparse.fit_transform([1]), expected_text="SparseValues") + reveal_type(dense.fit_transform([1]), expected_text="list[int]") + + +T = TypeVar("T") + + +class GenericTransformer(Transformer, Generic[T]): + def __init__(self, value: T): + self.value = value + + def transform(self, values) -> list[T]: + return [self.value] + + +def generic_transform_results(first: GenericTransformer[int], second: GenericTransformer[str]): + reveal_type(first.fit_transform([1]), expected_text="list[int]") + reveal_type(second.fit_transform([1]), expected_text="list[str]") + reveal_type(first.fit_transform([1]), expected_text="list[int]") + reveal_type(second.fit_transform([1]), expected_text="list[str]") diff --git a/packages/pyright-internal/src/tests/samples/callSite8.py b/packages/pyright-internal/src/tests/samples/callSite8.py new file mode 100644 index 000000000000..ebca1ccb3990 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite8.py @@ -0,0 +1,72 @@ +# This sample tests overload argument caches across contextual inference calls. + +from typing import Any, TypeVar, overload + + +class Basic: + def matches(self, other: "Basic") -> dict[str, int] | None: + return None + + +class Expr(Basic): + pass + + +class Integer(Expr): + pass + + +class Series: + pass + + +T = TypeVar("T", bound=Basic) + + +@overload +def convert(value: int) -> Integer: ... +@overload +def convert(value: float) -> Expr: ... +@overload +def convert(value: Expr | complex) -> Expr: ... +@overload +def convert(value: T) -> T: ... +@overload +def convert(value: Any) -> Basic: ... +def convert(value: Any) -> Basic: + return Basic() + + +def make(value, flag): + value = convert(value) + if flag: + return value + return Series() + + +def series_calls(value: Any): + reveal_type(convert(value), expected_text="Unknown") + reveal_type(make(Expr(), False), expected_text="Expr | Series") + reveal_type(make(value, True), expected_text="Unknown | Series") + reveal_type(make(Integer(), False), expected_text="Expr | Series") + reveal_type(make(1, False), expected_text="Integer | Series") + reveal_type(make(value, False), expected_text="Unknown | Series") + reveal_type(make(Expr(), True), expected_text="Expr | Series") + + +class Matcher(Expr): + def match(self, pattern): + pattern = convert(pattern) + return pattern.matches(self) + + +class DerivedMatcher(Matcher): + pass + + +def matching_calls(value: Any, known: Expr): + reveal_type(Matcher().match(known), expected_text="dict[str, int] | None") + reveal_type(Matcher().match(value), expected_text="Unknown") + reveal_type(DerivedMatcher().match(known), expected_text="dict[str, int] | None") + reveal_type(Matcher().match(value), expected_text="Unknown") + reveal_type(Matcher().match(known), expected_text="dict[str, int] | None") diff --git a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts index 6fa4b048021a..f48f12ec488f 100644 --- a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts @@ -26,6 +26,32 @@ interface TestCacheEntry extends ContextualTypeCacheEntry { value: number; } +test('Speculative types are isolated by call-site inference context', () => { + const module = parseText('value\n', new DiagnosticSink()).parserOutput.parseTree; + const statement = module.d.statements[0]; + assert.ok(statement.nodeType === ParseNodeType.StatementList); + const node = statement.d.statements[0]; + const tracker = new SpeculativeTypeTracker(); + const type = TypeVarType.createInstance('T'); + const firstContext = {}; + const secondContext = {}; + + tracker.enterSpeculativeContext(node); + tracker.addSpeculativeType(node, { type }, 0, undefined); + assert.ok(tracker.getSpeculativeType(node, undefined)); + assert.strictEqual(tracker.getSpeculativeType(node, undefined, firstContext), undefined); + + tracker.addSpeculativeType(node, { type }, 0, undefined, firstContext); + assert.ok(tracker.getSpeculativeType(node, undefined, firstContext)); + assert.strictEqual(tracker.getSpeculativeType(node, undefined, secondContext), undefined); + assert.strictEqual(tracker.getSpeculativeType(node, undefined), undefined); + + tracker.addSpeculativeType(node, { type }, 0, undefined, secondContext); + assert.ok(tracker.getSpeculativeType(node, undefined, secondContext)); + assert.strictEqual(tracker.getSpeculativeType(node, undefined, firstContext), undefined); + tracker.leaveSpeculativeContext(); +}); + test.each(['complete', 'error', 'cancel'] as const)( 'Exact-node isolation preserves disjoint native speculative contexts: %s', (outcome) => { diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index d6dfd3db4680..9b5d7e44958f 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -90,6 +90,26 @@ test('CallSite4', () => { TestUtils.validateResults(analysisResults, 0, 0, 7); }); +test('CallSite5', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite5.py']); + TestUtils.validateResults(analysisResults, 0); +}); + +test('CallSite6', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite6.py']); + TestUtils.validateResults(analysisResults, 2); +}); + +test('CallSite7', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite7.py']); + TestUtils.validateResults(analysisResults, 1); +}); + +test('CallSite8', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite8.py']); + TestUtils.validateResults(analysisResults, 0); +}); + test('FString1', () => { const configOptions = new ConfigOptions(Uri.empty()); diff --git a/packages/pyright-internal/src/tests/typeUtils.test.ts b/packages/pyright-internal/src/tests/typeUtils.test.ts index 2717074f471c..57a9048402e2 100644 --- a/packages/pyright-internal/src/tests/typeUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeUtils.test.ts @@ -8,7 +8,8 @@ import * as assert from 'assert'; -import { containsLiteralType, mapSignatures, transformTypePair } from '../analyzer/typeUtils'; +import { ConstraintSolution } from '../analyzer/constraintSolution'; +import { applySolvedTypeVars, containsLiteralType, mapSignatures, transformTypePair } from '../analyzer/typeUtils'; import { AnyType, ClassType, @@ -20,6 +21,7 @@ import { isFunction, isOverloaded, isTypeVar, + NeverType, OverloadedType, OverloadResultType, Type, @@ -33,6 +35,96 @@ import { import { Uri } from '../common/uri/uri'; import { ParamCategory } from '../parser/parseNodes'; +test.each([false, true])('Specializing parameters does not freeze inferred Unknown (incomplete: %s)', (incomplete) => { + const typeVar = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('T'), + 'test-scope', + 'test', + TypeVarScopeType.Function + ); + const value = ClassType.cloneAsInstance(createClass('Value')); + const unknown = UnknownType.create(); + const source = createFunction(typeVar, unknown, unknown); + source.shared.declaredReturnType = undefined; + source.shared.inferredReturnType = { type: unknown, isIncomplete: incomplete, evaluationCount: 1 }; + const solution = new ConstraintSolution(); + solution.setType(typeVar, value); + + const specialized = applySolvedTypeVars(source, solution); + + assert.ok(isFunction(specialized)); + assert.strictEqual(FunctionType.getParamType(specialized, 0), value); + assert.strictEqual(specialized.priv.specializedTypes?.returnType, undefined); + source.shared.inferredReturnType = { type: value, isIncomplete: false, evaluationCount: 2 }; + assert.strictEqual(FunctionType.getEffectiveReturnType(specialized), value); +}); + +test.each([false, true])('Specializing parameters preserves inferred NoReturn (incomplete: %s)', (incomplete) => { + const typeVar = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('T'), + 'test-scope', + 'test', + TypeVarScopeType.Function + ); + const value = ClassType.cloneAsInstance(createClass('Value')); + const never = NeverType.createNever(); + const source = createFunction(typeVar, value, never); + source.shared.declaredReturnType = undefined; + source.shared.inferredReturnType = { type: never, isIncomplete: incomplete, evaluationCount: 1 }; + const solution = new ConstraintSolution(); + solution.setType(typeVar, value); + + const specialized = applySolvedTypeVars(source, solution); + + assert.ok(isFunction(specialized)); + assert.strictEqual(FunctionType.getEffectiveReturnType(specialized, /* includeInferred */ false), never); +}); + +test('Specializing parameters preserves known alternatives in an incomplete inferred return', () => { + const typeVar = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('T'), + 'test-scope', + 'test', + TypeVarScopeType.Function + ); + const value = ClassType.cloneAsInstance(createClass('Value')); + const union = UnionType.create(); + union.priv.subtypes = [value, UnknownType.create()]; + const source = createFunction(typeVar, value, union); + source.shared.declaredReturnType = undefined; + source.shared.inferredReturnType = { type: union, isIncomplete: true, evaluationCount: 9 }; + const solution = new ConstraintSolution(); + solution.setType(typeVar, value); + + const specialized = applySolvedTypeVars(source, solution); + + assert.ok(isFunction(specialized)); + assert.strictEqual(FunctionType.getEffectiveReturnType(specialized, /* includeInferred */ false), union); +}); + +test.each([false, true])('Specializing a return type to Unknown is preserved (declared: %s)', (declared) => { + const typeVar = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('T'), + 'test-scope', + 'test', + TypeVarScopeType.Function + ); + const unknown = UnknownType.create(); + const source = createFunction(typeVar, unknown, typeVar); + if (!declared) { + source.shared.declaredReturnType = undefined; + source.shared.inferredReturnType = { type: typeVar, isIncomplete: false, evaluationCount: 1 }; + } + const solution = new ConstraintSolution(); + solution.setType(typeVar, unknown); + + const specialized = applySolvedTypeVars(source, solution); + + assert.ok(isFunction(specialized)); + assert.strictEqual(specialized.priv.specializedTypes?.returnType, unknown); + assert.strictEqual(FunctionType.getEffectiveReturnType(specialized), unknown); +}); + test('Literal detection keeps cancellation and type-argument options local to each walk', () => { const plain = ClassType.cloneAsInstance(createClass('Value')); const literal = ClassType.cloneWithLiteral(plain, 1); From 5c701be21be0e95712638b553620a6716741d495 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Fri, 30 Oct 2026 19:26:38 -0700 Subject: [PATCH 2/6] Preserve distinct bound methods in unions Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- packages/pyright-internal/src/analyzer/types.ts | 9 ++++++++- .../pyright-internal/src/tests/samples/callSite5.py | 5 +++++ .../pyright-internal/src/tests/typeEquality.test.ts | 13 +++++++++++++ .../src/tests/typeEvaluator4.test.ts | 2 +- 4 files changed, 27 insertions(+), 2 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/types.ts b/packages/pyright-internal/src/analyzer/types.ts index d91552efc4ac..f3391c811ccb 100644 --- a/packages/pyright-internal/src/analyzer/types.ts +++ b/packages/pyright-internal/src/analyzer/types.ts @@ -4401,8 +4401,15 @@ function _addTypeIfUnique(unionType: UnionType, typeToAdd: UnionableType, elideR continue; } + // Bound receivers can produce different contextual return types even when + // the remaining function signatures are the same. + const honorCallBehavior = + isFunction(type) && + isFunction(typeToAdd) && + (type.priv.boundSelfType !== undefined || typeToAdd.priv.boundSelfType !== undefined); + // Does this type already exist in the types array? - if (isTypeSame(type, typeToAdd, { honorTypeForm: true })) { + if (isTypeSame(type, typeToAdd, { honorTypeForm: true, honorCallBehavior })) { unionType.priv.subtypes[i] = _mergeInferredTupleLiterals(type, typeToAdd); return; } diff --git a/packages/pyright-internal/src/tests/samples/callSite5.py b/packages/pyright-internal/src/tests/samples/callSite5.py index ebc711a5cac9..0df718ee6fdf 100644 --- a/packages/pyright-internal/src/tests/samples/callSite5.py +++ b/packages/pyright-internal/src/tests/samples/callSite5.py @@ -84,6 +84,11 @@ def unknown_argument(value: Derived, other: Other, argument): reveal_type(value.pick(argument), expected_text="Derived | Unknown") +def union_receiver(value: Derived | Other): + # This should generate an error because Other.read_label returns int. + value.read_label(1).upper() + + T = TypeVar("T") diff --git a/packages/pyright-internal/src/tests/typeEquality.test.ts b/packages/pyright-internal/src/tests/typeEquality.test.ts index c2d6d6338d59..885fa9a58a04 100644 --- a/packages/pyright-internal/src/tests/typeEquality.test.ts +++ b/packages/pyright-internal/src/tests/typeEquality.test.ts @@ -17,6 +17,7 @@ import { combineTypes, FunctionParam, FunctionType, + FunctionTypeFlags, isClassInstance, isTypeSame, isUnion, @@ -169,6 +170,18 @@ test('CombineTypesTypeForms', () => { assert.deepStrictEqual(union.priv.subtypes, [first, unrelated, second]); }); +test('CombineTypesBoundFunctions', () => { + const functionType = FunctionType.createInstance('method', 'module.method', 'module', FunctionTypeFlags.None); + const first = FunctionType.clone(functionType); + const second = FunctionType.clone(functionType); + first.priv.boundSelfType = ClassType.cloneAsInstance(createClassType('First')); + second.priv.boundSelfType = ClassType.cloneAsInstance(createClassType('Second')); + + const union = combineTypes([first, second]); + assert.ok(isUnion(union)); + assert.deepStrictEqual(union.priv.subtypes, [first, second]); +}); + test('CombineTypesBuiltInBoolAliases', () => { const firstBool = ClassType.cloneAsInstance(createClassType('bool', ClassTypeFlags.BuiltIn, 'builtins.bool')); const secondBool = ClassType.cloneAsInstance(createClassType('bool', ClassTypeFlags.BuiltIn, 'alias.bool')); diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index 9b5d7e44958f..ffd2bb947f91 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -92,7 +92,7 @@ test('CallSite4', () => { test('CallSite5', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite5.py']); - TestUtils.validateResults(analysisResults, 0); + TestUtils.validateResults(analysisResults, 1); }); test('CallSite6', () => { From d6e7d4d110ebd18f390ca30b85b10d2442ff953f Mon Sep 17 00:00:00 2001 From: Rich Chiodo false Date: Mon, 2 Nov 2026 15:35:06 -0800 Subject: [PATCH 3/6] Specialize contextual return results for bound receivers Replace the broader receiver metadata, cache, freshness, and constructor changes with post-inference receiver specialization. Preserve the owner-MRO guard and conditional synthesized Self, and cover receiver unions without discarding alternatives. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/constructors.ts | 8 +- .../src/analyzer/overloadResult.ts | 3 - .../src/analyzer/typeCacheUtils.ts | 18 +-- .../src/analyzer/typeEvaluator.ts | 67 ++++++----- .../src/analyzer/typeUtils.ts | 15 +-- .../pyright-internal/src/analyzer/types.ts | 14 +-- .../src/tests/overloadResult.test.ts | 4 +- .../src/tests/samples/callSite5.py | 98 ++-------------- .../src/tests/samples/callSite6.py | 73 +++--------- .../src/tests/samples/callSite7.py | 107 ++++++++++-------- .../src/tests/samples/callSite8.py | 72 ------------ .../src/tests/typeCacheUtils.test.ts | 26 ----- .../src/tests/typeEquality.test.ts | 13 --- .../src/tests/typeEvaluator4.test.ts | 7 +- .../src/tests/typeUtils.test.ts | 94 +-------------- 15 files changed, 131 insertions(+), 488 deletions(-) delete mode 100644 packages/pyright-internal/src/tests/samples/callSite8.py diff --git a/packages/pyright-internal/src/analyzer/constructors.ts b/packages/pyright-internal/src/analyzer/constructors.ts index e42d3155df49..fee55fb8a034 100644 --- a/packages/pyright-internal/src/analyzer/constructors.ts +++ b/packages/pyright-internal/src/analyzer/constructors.ts @@ -635,13 +635,7 @@ function applyExpectedSubtypeForConstructor( return expectedSubtype; } - // The expected type must not let unsolved constructor TypeVars escape. - return applySolvedTypeVars(specializedType, new ConstraintSolution(), { - replaceUnsolved: { - scopeIds: getTypeVarScopeIds(type), - tupleClassType: evaluator.getTupleClassType(), - }, - }); + return specializedType; } // Handles the case where a constructor is a generic type and the type diff --git a/packages/pyright-internal/src/analyzer/overloadResult.ts b/packages/pyright-internal/src/analyzer/overloadResult.ts index 96a3ff66b93b..15aac4c34046 100644 --- a/packages/pyright-internal/src/analyzer/overloadResult.ts +++ b/packages/pyright-internal/src/analyzer/overloadResult.ts @@ -148,7 +148,6 @@ export function projectOverloadResultBaseline( const inferredReturnType = optional(value.shared.inferredReturnType?.type, depth); const strippedFirstParamType = optional(value.priv.strippedFirstParamType, depth); const boundToType = optional(value.priv.boundToType, depth); - const boundSelfType = optional(value.priv.boundSelfType, depth); if (boundToType && !isClass(boundToType)) { throw new ProjectionBlocked('category'); } @@ -160,13 +159,11 @@ export function projectOverloadResultBaseline( returnType !== FunctionType.getEffectiveReturnType(value) || inferredReturnType !== value.shared.inferredReturnType?.type || strippedFirstParamType !== value.priv.strippedFirstParamType || - boundSelfType !== value.priv.boundSelfType || boundToType !== value.priv.boundToType ) { const clone = FunctionType.specialize(value, { parameterTypes, parameterDefaultTypes, returnType }); clone.priv.strippedFirstParamType = strippedFirstParamType; clone.priv.boundToType = boundToType; - clone.priv.boundSelfType = boundSelfType; clone.priv.callSiteReturnTypeCache = undefined; if (value.shared.inferredReturnType && inferredReturnType) { clone.shared = { diff --git a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts index 78f29f590d07..50a043875d0f 100644 --- a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts @@ -44,8 +44,6 @@ export interface SpeculativeTypeEntry extends ContextualTypeCacheEntry { typeResult: TypeResult; incompleteGenerationCount: number; dependentTypes?: DependentType[]; - // Call-site inference can evaluate the same node with different parameter types. - typeContext?: object; } export interface SpeculativeModeOptions { @@ -267,8 +265,7 @@ export class SpeculativeTypeTracker { node: ParseNode, typeResult: TypeResult, incompleteGenerationCount: number, - expectedType: Type | undefined, - typeContext?: object + expectedType: Type | undefined ) { assert(this._speculativeContextStack.length > 0); @@ -276,7 +273,6 @@ export class SpeculativeTypeTracker { typeResult, expectedType, incompleteGenerationCount, - typeContext, }; if (this._activeDependentTypes.length > 0) { @@ -291,11 +287,7 @@ export class SpeculativeTypeTracker { this._speculativeTypeCache.set(node.id, cacheEntries); } - getSpeculativeType( - node: ParseNode, - expectedType: Type | undefined, - typeContext?: object - ): SpeculativeTypeEntry | undefined { + getSpeculativeType(node: ParseNode, expectedType: Type | undefined): SpeculativeTypeEntry | undefined { if ( this._speculativeContextStack.some((context) => ParseTreeUtils.isNodeContainedWithin(node, context.speculativeRootNode) @@ -304,11 +296,7 @@ export class SpeculativeTypeTracker { const entries = this._speculativeTypeCache.get(node.id); if (entries) { for (const entry of entries) { - if ( - entry.typeContext === typeContext && - contextualTypeCacheEntryMatches(entry, expectedType) && - this._dependentTypesMatch(entry) - ) { + if (contextualTypeCacheEntryMatches(entry, expectedType) && this._dependentTypesMatch(entry)) { return entry; } } diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index 622c6703dae3..fba66e9a1a22 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -539,7 +539,6 @@ interface SymbolResolutionStackEntry { interface ReturnTypeInferenceContext { functionNode: FunctionNode; codeFlowAnalyzer: CodeFlowAnalyzer; - speculativeCacheContext: object; } interface ParamSpecArgResult { @@ -951,8 +950,7 @@ export function createTypeEvaluator( node, typeResult, incompleteGenCount, - inferenceContext?.expectedType, - getSpeculativeTypeCacheContext(node) + inferenceContext?.expectedType ); } } @@ -1071,12 +1069,6 @@ export function createTypeEvaluator( return contextNode.codeFlowAnalyzer; } - function getSpeculativeTypeCacheContext(node: ParseNode) { - return isNodeInReturnTypeInferenceContext(node) - ? returnTypeInferenceContextStack[returnTypeInferenceContextStack.length - 1].speculativeCacheContext - : undefined; - } - function getIndexOfSymbolResolution(symbol: Symbol, declaration: Declaration) { return symbolResolutionStack.findIndex( (entry) => entry.symbolId === symbol.id && entry.declaration === declaration @@ -1460,11 +1452,7 @@ export function createTypeEvaluator( // Is it cached in the speculative type cache? const specCacheEntry = useTypeFormCache ? undefined - : speculativeTypeTracker.getSpeculativeType( - node, - inferenceContext?.expectedType, - getSpeculativeTypeCacheContext(node) - ); + : speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType); if (specCacheEntry) { if ( !specCacheEntry.typeResult.isIncomplete || @@ -25846,7 +25834,7 @@ export function createTypeEvaluator( // If the return type has already been lazily evaluated, // don't bother computing it again. if (type.shared.inferredReturnType && !type.shared.inferredReturnType.isIncomplete) { - returnType = type.priv.specializedTypes?.returnType ?? type.shared.inferredReturnType.type; + returnType = type.shared.inferredReturnType.type; } else if (evalCount > maxReturnTypeInferenceAttempts) { // Detect a case where a return type won't converge because of recursion. returnType = UnknownType.create(); @@ -25950,6 +25938,29 @@ export function createTypeEvaluator( } } + const methodClass = type.shared.methodClass; + if ( + type.priv.boundToType && + methodClass && + !FunctionType.isStaticMethod(type) && + type.priv.boundToType.shared.mro.some( + (base) => isClass(base) && ClassType.isSameGenericClass(base, methodClass) + ) + ) { + // A synthesized property's __get__ retains the getter's methodClass but binds + // to the descriptor, which must not replace the getter's Self. + // Preserve a conditional receiver's original Self rather than its class bound. + const selfType = getTypeCondition(type.priv.boundToType)?.find((condition) => + TypeVarType.isSelf(condition.typeVar) + )?.typeVar; + returnType = partiallySpecializeType( + returnType, + methodClass, + getTypeClassType(), + selfType ?? type.priv.boundToType + ); + } + return { type: returnType, isIncomplete }; } @@ -26015,7 +26026,6 @@ export function createTypeEvaluator( returnTypeInferenceContextStack.push({ functionNode, codeFlowAnalyzer: codeFlowEngine.createCodeFlowAnalyzer(), - speculativeCacheContext: {}, }); try { @@ -26047,11 +26057,7 @@ export function createTypeEvaluator( ) { if (functionTypeResult.functionType.shared.parameters.length > 0) { if (functionNode.d.params[0].d.name) { - // Include the bound receiver in both contextual evaluation - // and its cache key, rather than reverting to the declaration. - paramType = - type.priv.boundSelfType ?? - FunctionType.getParamType(functionTypeResult.functionType, 0); + paramType = FunctionType.getParamType(functionTypeResult.functionType, 0); } } } @@ -30981,24 +30987,17 @@ export function createTypeEvaluator( getEffectiveReturnType(memberType); const specializedFunction = solveAndApplyConstraints(memberType, constraints); - let boundFunction: FunctionType | undefined; if (isFunction(specializedFunction)) { - boundFunction = FunctionType.clone(specializedFunction, stripFirstParam, baseType); - } else if (isOverloaded(specializedFunction)) { - // For overloaded functions, use the first overload. This isn't - // strictly correct, but this is an extreme edge case. - boundFunction = FunctionType.clone( - OverloadedType.getOverloads(specializedFunction)[0], - stripFirstParam, - baseType - ); + return FunctionType.clone(specializedFunction, stripFirstParam, baseType); } - if (boundFunction && stripFirstParam) { - boundFunction.priv.boundSelfType = firstParamType; + if (isOverloaded(specializedFunction)) { + // For overloaded functions, use the first overload. This isn't + // strictly correct, but this is an extreme edge case. + return FunctionType.clone(OverloadedType.getOverloads(specializedFunction)[0], stripFirstParam, baseType); } - return boundFunction; + return undefined; } function isFinalVariable(symbol: Symbol): boolean { diff --git a/packages/pyright-internal/src/analyzer/typeUtils.ts b/packages/pyright-internal/src/analyzer/typeUtils.ts index bb513d5bce31..bdbbea8cb705 100644 --- a/packages/pyright-internal/src/analyzer/typeUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeUtils.ts @@ -4102,12 +4102,7 @@ export class TypeVarTransformer { return this.doForEachConstraintSet(() => { let functionType = sourceType; - // Don't freeze an inferred Unknown when only the parameters require specialization. - const inferredReturnType = functionType.shared.inferredReturnType?.type; - const declaredReturnType = FunctionType.getEffectiveReturnType( - functionType, - /* includeInferred */ !inferredReturnType || !isUnknown(inferredReturnType) - ); + const declaredReturnType = FunctionType.getEffectiveReturnType(functionType); const specializedReturnType = declaredReturnType ? this.apply(declaredReturnType, recursionCount) : undefined; @@ -4198,14 +4193,6 @@ export class TypeVarTransformer { } } - if (functionType.priv.boundSelfType) { - const newBoundSelfType = this.apply(functionType.priv.boundSelfType, recursionCount); - if (newBoundSelfType !== functionType.priv.boundSelfType) { - functionType = TypeBase.cloneType(functionType); - functionType.priv.boundSelfType = newBoundSelfType; - } - } - // Do we need to update the strippedFirstParamType? if (functionType.priv.strippedFirstParamType && !isAnyOrUnknown(functionType.priv.strippedFirstParamType)) { const newStrippedType = this.apply(functionType.priv.strippedFirstParamType, recursionCount); diff --git a/packages/pyright-internal/src/analyzer/types.ts b/packages/pyright-internal/src/analyzer/types.ts index f3391c811ccb..ec629405de9a 100644 --- a/packages/pyright-internal/src/analyzer/types.ts +++ b/packages/pyright-internal/src/analyzer/types.ts @@ -1905,10 +1905,6 @@ export interface FunctionDetailsPriv { // the class or object to which the function was bound. boundToType?: ClassType | undefined; - // The actual argument bound to "self" or "cls", including a TypeVar receiver - // that would otherwise be reduced to its class bound in boundToType. - boundSelfType?: Type | undefined; - // The flags for the function prior to binding preBoundFlags?: FunctionTypeFlags; @@ -3680,7 +3676,6 @@ export function isTypeSame(type1: Type, type2: Type, options: TypeSameOptions = !isTypeSame(param, functionType2.shared.typeParams[index], recursiveOptions, recursionCount) ) || !optionalTypesMatch(type1.priv.boundToType, functionType2.priv.boundToType) || - !optionalTypesMatch(type1.priv.boundSelfType, functionType2.priv.boundSelfType) || !optionalTypesMatch(type1.priv.strippedFirstParamType, functionType2.priv.strippedFirstParamType) || params1.some( (param, index) => @@ -4401,15 +4396,8 @@ function _addTypeIfUnique(unionType: UnionType, typeToAdd: UnionableType, elideR continue; } - // Bound receivers can produce different contextual return types even when - // the remaining function signatures are the same. - const honorCallBehavior = - isFunction(type) && - isFunction(typeToAdd) && - (type.priv.boundSelfType !== undefined || typeToAdd.priv.boundSelfType !== undefined); - // Does this type already exist in the types array? - if (isTypeSame(type, typeToAdd, { honorTypeForm: true, honorCallBehavior })) { + if (isTypeSame(type, typeToAdd, { honorTypeForm: true })) { unionType.priv.subtypes[i] = _mergeInferredTupleLiterals(type, typeToAdd); return; } diff --git a/packages/pyright-internal/src/tests/overloadResult.test.ts b/packages/pyright-internal/src/tests/overloadResult.test.ts index 356592f58b9f..4055e70ac5d3 100644 --- a/packages/pyright-internal/src/tests/overloadResult.test.ts +++ b/packages/pyright-internal/src/tests/overloadResult.test.ts @@ -114,7 +114,7 @@ test('OverloadResult equality does not erase callable defaults, receiver or stri const second = signature(strType); assert(isTypeSame(first, second)); assert(!isTypeSame(first, second, { honorCallBehavior: true })); - for (const field of ['boundToType', 'boundSelfType', 'strippedFirstParamType'] as const) { + for (const field of ['boundToType', 'strippedFirstParamType'] as const) { const left = signature(intType); const right = signature(intType); left.priv[field] = intList; @@ -174,7 +174,6 @@ test('OverloadResult projects callable parameters, defaults, return and bound pa fn.shared.declaredReturnType = alternatives(); fn.priv.strippedFirstParamType = alternatives(); fn.priv.boundToType = ClassType.specialize(listType, [alternatives()]); - fn.priv.boundSelfType = alternatives(); const unchanged = signature(intType); const implementation = signature(intType); const owner = OverloadedType.create([fn, unchanged], implementation); @@ -186,7 +185,6 @@ test('OverloadResult projects callable parameters, defaults, return and bound pa assert.strictEqual(FunctionType.getEffectiveReturnType(projectedFn), intList); assert.strictEqual(projectedFn.priv.strippedFirstParamType, intList); assert.strictEqual(projectedFn.priv.boundToType!.priv.typeArgs![0], intList); - assert.strictEqual(projectedFn.priv.boundSelfType, intList); assert.strictEqual(projectedFn.priv.overloaded, result); assert.strictEqual(projectedUnchanged.priv.overloaded, result); assert.strictEqual(fn.priv.overloaded, owner); diff --git a/packages/pyright-internal/src/tests/samples/callSite5.py b/packages/pyright-internal/src/tests/samples/callSite5.py index 0df718ee6fdf..10908e4fe1dc 100644 --- a/packages/pyright-internal/src/tests/samples/callSite5.py +++ b/packages/pyright-internal/src/tests/samples/callSite5.py @@ -1,23 +1,22 @@ -# This sample tests receiver binding during call-site return type inference. +# This sample tests receiver specialization after call-site return inference. from typing import Generic, TypeVar class Base: - @property - def label(self) -> object: - return "" - def pick(self, argument): if argument: return self return argument - def read_label(self, argument): + def concrete(self, argument): if argument: - return self.label + return Base() return argument + def declared(self, argument) -> "Base": + return self + @classmethod def make(cls, argument): if argument: @@ -30,24 +29,11 @@ def identity(argument): class Derived(Base): - @property - def label(self) -> str: - return "derived" - def derived_only(self) -> int: return 42 - def forwarded(self): - return self.pick(1) - class Other(Base): - @property - def label(self) -> int: - return 42 - - -class Further(Derived): pass @@ -61,21 +47,14 @@ def demonstrate(value: Derived, other: Other): reveal_type(other.pick(0), expected_text="Other | Literal[0]") reveal_type(value.pick(""), expected_text="Derived | Literal['']") reveal_type(other.pick(1), expected_text="Other") - - reveal_type(value.read_label(1), expected_text="str") - reveal_type(other.read_label(1), expected_text="int") - reveal_type(value.read_label(1), expected_text="str") - reveal_type(Base.pick(value, 1), expected_text="Derived") reveal_type(Base.pick(other, 1), expected_text="Other") + reveal_type(value.concrete(1), expected_text="Base") + reveal_type(value.declared(1), expected_text="Base") reveal_type(value.identity(1), expected_text="Unknown") - - # Decorated methods cannot use call-site inference, but the cached - # inferred return type must still retain its receiver specialization. reveal_type(Derived.make(1), expected_text="Derived | Unknown") reveal_type(Other.make(1), expected_text="Other | Unknown") reveal_type(Derived.make(1), expected_text="Derived | Unknown") - reveal_type(Further().forwarded(), expected_text="Further") def unknown_argument(value: Derived, other: Other, argument): @@ -85,27 +64,21 @@ def unknown_argument(value: Derived, other: Other, argument): def union_receiver(value: Derived | Other): - # This should generate an error because Other.read_label returns int. - value.read_label(1).upper() + selected = value.pick(1) + reveal_type(selected, expected_text="Derived | Other") + # This should generate an error because Other has no derived_only method. + selected.derived_only() T = TypeVar("T") class GenericBase(Generic[T]): - def __init__(self, value: T): - self.value = value - def pick(self, argument): if argument: return self return argument - def read_value(self, argument): - if argument: - return self.value - return argument - class GenericDerived(GenericBase[T]): pass @@ -115,9 +88,6 @@ def generic_receivers(first: GenericDerived[int], second: GenericDerived[str]): reveal_type(first.pick(1), expected_text="GenericDerived[int]") reveal_type(second.pick(1), expected_text="GenericDerived[str]") reveal_type(first.pick(1), expected_text="GenericDerived[int]") - reveal_type(first.read_value(1), expected_text="int") - reveal_type(second.read_value(1), expected_text="str") - reveal_type(first.read_value(1), expected_text="int") class PowerBase: @@ -135,47 +105,3 @@ class PowerDerived(PowerBase): def power_receiver(value: PowerDerived): reveal_type(value.__pow__(2), expected_text="NotImplementedType | PowerDerived | Literal[2]") - reveal_type(value ** 2, expected_text="NotImplementedType | Unknown | PowerDerived") - - -# Speculative overload arguments must not leak between receiver contexts. -class PrinterBase: - human: bool = True - - def format_code(self, lines): - raise NotImplementedError - - def print_code(self, content, assign_to=None): - lines = ["one", "two"] - if self.human: - lines = self.format_code(lines) - result = "\n".join(lines) - else: - lines = self.format_code(lines) - result = (set(), set(), "\n".join(lines)) - return result - - -class CPrinter(PrinterBase): - def format_code(self, lines): - return self.indent_code(lines) - - def indent_code(self, code): - if isinstance(code, str): - return "".join(self.indent_code(code.splitlines(True))) - return [str(line) for line in code] - - -class PythonPrinter(PrinterBase): - def format_code(self, lines): - return lines - - -def print_c(content, printer_type=CPrinter): - reveal_type(printer_type().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") - - -def print_python(content): - reveal_type(PythonPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") - reveal_type(CPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") - reveal_type(PythonPrinter().print_code(content), expected_text="str | tuple[set[Unknown], set[Unknown], str]") diff --git a/packages/pyright-internal/src/tests/samples/callSite6.py b/packages/pyright-internal/src/tests/samples/callSite6.py index c10199435a84..e1f30c26c631 100644 --- a/packages/pyright-internal/src/tests/samples/callSite6.py +++ b/packages/pyright-internal/src/tests/samples/callSite6.py @@ -1,64 +1,27 @@ -# This sample tests control flow and generic recovery during contextual inference. +# This sample tests recursive property return inference with receiver specialization. -from typing import NoReturn, TypeVar +class Edge: + def __init__(self, parent: "Node"): + self.parent = parent -class Helper: - def fail(self): - raise ValueError("always raises") - def fail_declared(self) -> NoReturn: - raise ValueError("always raises") +class Node: + def __init__(self, edges: dict[str, list[Edge]]): + self.edges = edges - def implicit(self) -> int: - self.fail() - return None + @property + def root(self): + if not self.edges: + return self + edges = next(iter(self.edges.values())) + return edges[0].parent.root - def declared(self) -> int: - self.fail_declared() - return None - def exception_path(self) -> int: - try: - result = 1 - except Exception: - self.fail() - return result +def consume(node: Node) -> None: + pass -reveal_type(Helper().fail, expected_text="() -> NoReturn") - - -def reverse_or_default(values, default): - if getattr(values, "__reversed__", None): - return next(reversed(values)) - return default - - -def enumerate_input(values): - pool = enumerate(values) - reveal_type(reverse_or_default(pool, (1, None)), expected_text="Unknown | tuple[Literal[1], None]") - first, second = reverse_or_default(pool, (1, None)) - return first, second - - -def known_inputs(): - reveal_type(reverse_or_default([1, 2], (1, None)), expected_text="int | tuple[Literal[1], None]") - reveal_type( - reverse_or_default(enumerate([1, 2]), (1, None)), expected_text="Unknown | tuple[Literal[1], None]" - ) - reveal_type(reverse_or_default(["a", "b"], (1, None)), expected_text="str | tuple[Literal[1], None]") - reveal_type(reverse_or_default([1, 2], (1, None)), expected_text="int | tuple[Literal[1], None]") - - -T = TypeVar("T") - - -def generic_input(values: list[T], default: T): - reveal_type(reverse_or_default(values, default), expected_text="T@generic_input") - - -def invalid_constructor_input(values: enumerate[int]): - # This should generate two errors because enumerate is not reversible. - result = next(reversed(values)) - reveal_type(result, expected_text="Unknown") +def demonstrate(node: Node) -> None: + reveal_type(node.root, expected_text="Node | Unknown") + consume(node.root) diff --git a/packages/pyright-internal/src/tests/samples/callSite7.py b/packages/pyright-internal/src/tests/samples/callSite7.py index efeff4152639..97a96261b2c8 100644 --- a/packages/pyright-internal/src/tests/samples/callSite7.py +++ b/packages/pyright-internal/src/tests/samples/callSite7.py @@ -1,75 +1,86 @@ -# This sample tests concrete transform results forwarded through an inherited mixin. +# This sample tests receiver Self preservation through inherited factory calls. from typing import Generic, TypeVar -class Transformer: - def fit(self, values): - return self +class Base: + @classmethod + def build(cls, args): + if not args: + return args + return cls() - def transform(self, values): - return values + def rebuild(self, *args): + return self.build(args) - def fit_transform(self, values): - return self.fit(values).transform(values) + def pick(self, argument): + if argument: + return self + return argument -class DenseTransformer(Transformer): - def transform(self, values) -> list[int]: - return [1, 2] +class Derived(Base): + def derived_only(self) -> int: + return 42 + def forwarded(self): + return self.pick(1) -class SparseValues: - def toarray(self) -> list[float]: - return [1.0, 2.0] +class Other(Base): + pass -class SparseTransformer(Transformer): - def transform(self, values) -> SparseValues: - return SparseValues() +def demonstrate(value: Derived, other: Other) -> None: + reveal_type(value.rebuild(1, 2), expected_text="Unknown | Derived") + value.rebuild(1, 2).derived_only() + reveal_type(value.build((1, 2)), expected_text="Unknown | Derived") + reveal_type(other.rebuild(1, 2), expected_text="Unknown | Other") + reveal_type(value.rebuild(1, 2), expected_text="Unknown | Derived") -class UnionTransformer(Transformer): - def transform(self, values) -> list[int] | str: - if isinstance(values, str): - return values - return [1, 2] +class Further(Derived): + pass -def transform_results(dense: DenseTransformer, sparse: SparseTransformer, union: UnionTransformer): - reveal_type(dense.fit_transform([1]), expected_text="list[int]") - reveal_type(sparse.fit_transform([1]), expected_text="SparseValues") - reveal_type(dense.fit_transform([1]), expected_text="list[int]") - sparse.fit_transform([1]).toarray() - result = union.fit_transform([1]) - reveal_type(result, expected_text="list[int] | str") +def further(value: Further): + reveal_type(value.rebuild(1, 2), expected_text="Unknown | Further") + reveal_type(value.forwarded(), expected_text="Further") - # This should generate an error because the declared str alternative must be retained. - result.append(3) - if isinstance(result, list): - result.append(3) - else: - result.upper() +T = TypeVar("T") - reveal_type(sparse.fit_transform([1]), expected_text="SparseValues") - reveal_type(dense.fit_transform([1]), expected_text="list[int]") +class GenericBase(Generic[T]): + @classmethod + def build(cls, args): + if not args: + return args + return cls() + + def rebuild(self, *args): + return self.build(args) + + +class GenericDerived(GenericBase[T]): + pass + + +def generic_receivers(first: GenericDerived[int], second: GenericDerived[str]): + reveal_type(first.rebuild(1, 2), expected_text="Unknown | GenericDerived[int]") + reveal_type(second.rebuild(1, 2), expected_text="Unknown | GenericDerived[str]") + reveal_type(first.rebuild(1, 2), expected_text="Unknown | GenericDerived[int]") + + +Receiver = TypeVar("Receiver", Derived, Other) -T = TypeVar("T") +def constrained_receiver(value: Receiver) -> Receiver: + return value.pick(1) -class GenericTransformer(Transformer, Generic[T]): - def __init__(self, value: T): - self.value = value - def transform(self, values) -> list[T]: - return [self.value] +BoundReceiver = TypeVar("BoundReceiver", bound=Derived) -def generic_transform_results(first: GenericTransformer[int], second: GenericTransformer[str]): - reveal_type(first.fit_transform([1]), expected_text="list[int]") - reveal_type(second.fit_transform([1]), expected_text="list[str]") - reveal_type(first.fit_transform([1]), expected_text="list[int]") - reveal_type(second.fit_transform([1]), expected_text="list[str]") +def bounded_receiver(value: BoundReceiver) -> BoundReceiver: + return value.pick(1) diff --git a/packages/pyright-internal/src/tests/samples/callSite8.py b/packages/pyright-internal/src/tests/samples/callSite8.py deleted file mode 100644 index ebca1ccb3990..000000000000 --- a/packages/pyright-internal/src/tests/samples/callSite8.py +++ /dev/null @@ -1,72 +0,0 @@ -# This sample tests overload argument caches across contextual inference calls. - -from typing import Any, TypeVar, overload - - -class Basic: - def matches(self, other: "Basic") -> dict[str, int] | None: - return None - - -class Expr(Basic): - pass - - -class Integer(Expr): - pass - - -class Series: - pass - - -T = TypeVar("T", bound=Basic) - - -@overload -def convert(value: int) -> Integer: ... -@overload -def convert(value: float) -> Expr: ... -@overload -def convert(value: Expr | complex) -> Expr: ... -@overload -def convert(value: T) -> T: ... -@overload -def convert(value: Any) -> Basic: ... -def convert(value: Any) -> Basic: - return Basic() - - -def make(value, flag): - value = convert(value) - if flag: - return value - return Series() - - -def series_calls(value: Any): - reveal_type(convert(value), expected_text="Unknown") - reveal_type(make(Expr(), False), expected_text="Expr | Series") - reveal_type(make(value, True), expected_text="Unknown | Series") - reveal_type(make(Integer(), False), expected_text="Expr | Series") - reveal_type(make(1, False), expected_text="Integer | Series") - reveal_type(make(value, False), expected_text="Unknown | Series") - reveal_type(make(Expr(), True), expected_text="Expr | Series") - - -class Matcher(Expr): - def match(self, pattern): - pattern = convert(pattern) - return pattern.matches(self) - - -class DerivedMatcher(Matcher): - pass - - -def matching_calls(value: Any, known: Expr): - reveal_type(Matcher().match(known), expected_text="dict[str, int] | None") - reveal_type(Matcher().match(value), expected_text="Unknown") - reveal_type(DerivedMatcher().match(known), expected_text="dict[str, int] | None") - reveal_type(Matcher().match(value), expected_text="Unknown") - reveal_type(Matcher().match(known), expected_text="dict[str, int] | None") diff --git a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts index f48f12ec488f..6fa4b048021a 100644 --- a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts @@ -26,32 +26,6 @@ interface TestCacheEntry extends ContextualTypeCacheEntry { value: number; } -test('Speculative types are isolated by call-site inference context', () => { - const module = parseText('value\n', new DiagnosticSink()).parserOutput.parseTree; - const statement = module.d.statements[0]; - assert.ok(statement.nodeType === ParseNodeType.StatementList); - const node = statement.d.statements[0]; - const tracker = new SpeculativeTypeTracker(); - const type = TypeVarType.createInstance('T'); - const firstContext = {}; - const secondContext = {}; - - tracker.enterSpeculativeContext(node); - tracker.addSpeculativeType(node, { type }, 0, undefined); - assert.ok(tracker.getSpeculativeType(node, undefined)); - assert.strictEqual(tracker.getSpeculativeType(node, undefined, firstContext), undefined); - - tracker.addSpeculativeType(node, { type }, 0, undefined, firstContext); - assert.ok(tracker.getSpeculativeType(node, undefined, firstContext)); - assert.strictEqual(tracker.getSpeculativeType(node, undefined, secondContext), undefined); - assert.strictEqual(tracker.getSpeculativeType(node, undefined), undefined); - - tracker.addSpeculativeType(node, { type }, 0, undefined, secondContext); - assert.ok(tracker.getSpeculativeType(node, undefined, secondContext)); - assert.strictEqual(tracker.getSpeculativeType(node, undefined, firstContext), undefined); - tracker.leaveSpeculativeContext(); -}); - test.each(['complete', 'error', 'cancel'] as const)( 'Exact-node isolation preserves disjoint native speculative contexts: %s', (outcome) => { diff --git a/packages/pyright-internal/src/tests/typeEquality.test.ts b/packages/pyright-internal/src/tests/typeEquality.test.ts index 885fa9a58a04..c2d6d6338d59 100644 --- a/packages/pyright-internal/src/tests/typeEquality.test.ts +++ b/packages/pyright-internal/src/tests/typeEquality.test.ts @@ -17,7 +17,6 @@ import { combineTypes, FunctionParam, FunctionType, - FunctionTypeFlags, isClassInstance, isTypeSame, isUnion, @@ -170,18 +169,6 @@ test('CombineTypesTypeForms', () => { assert.deepStrictEqual(union.priv.subtypes, [first, unrelated, second]); }); -test('CombineTypesBoundFunctions', () => { - const functionType = FunctionType.createInstance('method', 'module.method', 'module', FunctionTypeFlags.None); - const first = FunctionType.clone(functionType); - const second = FunctionType.clone(functionType); - first.priv.boundSelfType = ClassType.cloneAsInstance(createClassType('First')); - second.priv.boundSelfType = ClassType.cloneAsInstance(createClassType('Second')); - - const union = combineTypes([first, second]); - assert.ok(isUnion(union)); - assert.deepStrictEqual(union.priv.subtypes, [first, second]); -}); - test('CombineTypesBuiltInBoolAliases', () => { const firstBool = ClassType.cloneAsInstance(createClassType('bool', ClassTypeFlags.BuiltIn, 'builtins.bool')); const secondBool = ClassType.cloneAsInstance(createClassType('bool', ClassTypeFlags.BuiltIn, 'alias.bool')); diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index ffd2bb947f91..424dd027cd9a 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -97,16 +97,11 @@ test('CallSite5', () => { test('CallSite6', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite6.py']); - TestUtils.validateResults(analysisResults, 2); + TestUtils.validateResults(analysisResults, 0); }); test('CallSite7', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite7.py']); - TestUtils.validateResults(analysisResults, 1); -}); - -test('CallSite8', () => { - const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite8.py']); TestUtils.validateResults(analysisResults, 0); }); diff --git a/packages/pyright-internal/src/tests/typeUtils.test.ts b/packages/pyright-internal/src/tests/typeUtils.test.ts index 57a9048402e2..2717074f471c 100644 --- a/packages/pyright-internal/src/tests/typeUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeUtils.test.ts @@ -8,8 +8,7 @@ import * as assert from 'assert'; -import { ConstraintSolution } from '../analyzer/constraintSolution'; -import { applySolvedTypeVars, containsLiteralType, mapSignatures, transformTypePair } from '../analyzer/typeUtils'; +import { containsLiteralType, mapSignatures, transformTypePair } from '../analyzer/typeUtils'; import { AnyType, ClassType, @@ -21,7 +20,6 @@ import { isFunction, isOverloaded, isTypeVar, - NeverType, OverloadedType, OverloadResultType, Type, @@ -35,96 +33,6 @@ import { import { Uri } from '../common/uri/uri'; import { ParamCategory } from '../parser/parseNodes'; -test.each([false, true])('Specializing parameters does not freeze inferred Unknown (incomplete: %s)', (incomplete) => { - const typeVar = TypeVarType.cloneForScopeId( - TypeVarType.createInstance('T'), - 'test-scope', - 'test', - TypeVarScopeType.Function - ); - const value = ClassType.cloneAsInstance(createClass('Value')); - const unknown = UnknownType.create(); - const source = createFunction(typeVar, unknown, unknown); - source.shared.declaredReturnType = undefined; - source.shared.inferredReturnType = { type: unknown, isIncomplete: incomplete, evaluationCount: 1 }; - const solution = new ConstraintSolution(); - solution.setType(typeVar, value); - - const specialized = applySolvedTypeVars(source, solution); - - assert.ok(isFunction(specialized)); - assert.strictEqual(FunctionType.getParamType(specialized, 0), value); - assert.strictEqual(specialized.priv.specializedTypes?.returnType, undefined); - source.shared.inferredReturnType = { type: value, isIncomplete: false, evaluationCount: 2 }; - assert.strictEqual(FunctionType.getEffectiveReturnType(specialized), value); -}); - -test.each([false, true])('Specializing parameters preserves inferred NoReturn (incomplete: %s)', (incomplete) => { - const typeVar = TypeVarType.cloneForScopeId( - TypeVarType.createInstance('T'), - 'test-scope', - 'test', - TypeVarScopeType.Function - ); - const value = ClassType.cloneAsInstance(createClass('Value')); - const never = NeverType.createNever(); - const source = createFunction(typeVar, value, never); - source.shared.declaredReturnType = undefined; - source.shared.inferredReturnType = { type: never, isIncomplete: incomplete, evaluationCount: 1 }; - const solution = new ConstraintSolution(); - solution.setType(typeVar, value); - - const specialized = applySolvedTypeVars(source, solution); - - assert.ok(isFunction(specialized)); - assert.strictEqual(FunctionType.getEffectiveReturnType(specialized, /* includeInferred */ false), never); -}); - -test('Specializing parameters preserves known alternatives in an incomplete inferred return', () => { - const typeVar = TypeVarType.cloneForScopeId( - TypeVarType.createInstance('T'), - 'test-scope', - 'test', - TypeVarScopeType.Function - ); - const value = ClassType.cloneAsInstance(createClass('Value')); - const union = UnionType.create(); - union.priv.subtypes = [value, UnknownType.create()]; - const source = createFunction(typeVar, value, union); - source.shared.declaredReturnType = undefined; - source.shared.inferredReturnType = { type: union, isIncomplete: true, evaluationCount: 9 }; - const solution = new ConstraintSolution(); - solution.setType(typeVar, value); - - const specialized = applySolvedTypeVars(source, solution); - - assert.ok(isFunction(specialized)); - assert.strictEqual(FunctionType.getEffectiveReturnType(specialized, /* includeInferred */ false), union); -}); - -test.each([false, true])('Specializing a return type to Unknown is preserved (declared: %s)', (declared) => { - const typeVar = TypeVarType.cloneForScopeId( - TypeVarType.createInstance('T'), - 'test-scope', - 'test', - TypeVarScopeType.Function - ); - const unknown = UnknownType.create(); - const source = createFunction(typeVar, unknown, typeVar); - if (!declared) { - source.shared.declaredReturnType = undefined; - source.shared.inferredReturnType = { type: typeVar, isIncomplete: false, evaluationCount: 1 }; - } - const solution = new ConstraintSolution(); - solution.setType(typeVar, unknown); - - const specialized = applySolvedTypeVars(source, solution); - - assert.ok(isFunction(specialized)); - assert.strictEqual(specialized.priv.specializedTypes?.returnType, unknown); - assert.strictEqual(FunctionType.getEffectiveReturnType(specialized), unknown); -}); - test('Literal detection keeps cancellation and type-argument options local to each walk', () => { const plain = ClassType.cloneAsInstance(createClass('Value')); const literal = ClassType.cloneWithLiteral(plain, 1); From 736625eaafc520c5d3af9bac90ec3ae01199b8d7 Mon Sep 17 00:00:00 2001 From: Rich Chiodo false Date: Wed, 4 Nov 2026 09:46:55 -0800 Subject: [PATCH 4/6] Preserve caller bindings during contextual return inference Capture arguments in the caller context and isolate speculative results during contextual body inference. Preserve borrowed bound type variables and resolve constructor-owned variables during recovery, with regression coverage. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/constructors.ts | 2 +- .../src/analyzer/typeCacheUtils.ts | 10 ++ .../src/analyzer/typeEvaluator.ts | 26 ++-- .../src/analyzer/typeUtils.ts | 3 +- .../src/tests/samples/callSite10.py | 74 ++++++++++ .../src/tests/samples/callSite11.py | 106 ++++++++++++++ .../src/tests/samples/callSite4.py | 2 +- .../src/tests/samples/callSite8.py | 136 ++++++++++++++++++ .../src/tests/samples/callSite9.py | 61 ++++++++ .../src/tests/typeCacheUtils.test.ts | 50 +++++++ .../src/tests/typeEvaluator4.test.ts | 20 +++ .../src/tests/typeUtils.test.ts | 44 +++++- 12 files changed, 522 insertions(+), 12 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/callSite10.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite11.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite8.py create mode 100644 packages/pyright-internal/src/tests/samples/callSite9.py diff --git a/packages/pyright-internal/src/analyzer/constructors.ts b/packages/pyright-internal/src/analyzer/constructors.ts index fee55fb8a034..03ee23139aa5 100644 --- a/packages/pyright-internal/src/analyzer/constructors.ts +++ b/packages/pyright-internal/src/analyzer/constructors.ts @@ -621,7 +621,7 @@ function applyExpectedSubtypeForConstructor( ): Type | undefined { const specializedType = evaluator.solveAndApplyConstraints(ClassType.cloneAsInstance(type), constraints, { replaceUnsolved: { - scopeIds: [], + scopeIds: getTypeVarScopeIds(type), tupleClassType: evaluator.getTupleClassType(), }, }); diff --git a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts index 50a043875d0f..ea9e29212371 100644 --- a/packages/pyright-internal/src/analyzer/typeCacheUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeCacheUtils.ts @@ -163,6 +163,16 @@ export class SpeculativeTypeTracker { private _speculativeTypeCache = new Map(); private _activeDependentTypes: DependentType[] = []; + useSpeculativeTypeCacheIsolation(callback: () => T): T { + const prevCache = this._speculativeTypeCache; + this._speculativeTypeCache = new Map(); + try { + return callback(); + } finally { + this._speculativeTypeCache = prevCache; + } + } + evictCacheEntries(nodeIds: ReadonlySet) { assert(this._speculativeContextStack.length === 0); nodeIds.forEach((id) => this._speculativeTypeCache.delete(id)); diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index fba66e9a1a22..dc6036719af6 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -26018,6 +26018,14 @@ export function createTypeEvaluator( // Suppress diagnostics because we don't want to generate errors. suppressDiagnostics(functionNode, () => { + // Argument expressions belong to the caller's contextual cache. + const argTypes = functionNode.d.params.map((param) => { + const arg = args.find((arg) => param.d.name?.d.value === arg.paramName); + return arg?.argument.valueExpression + ? getTypeOfExpression(arg.argument.valueExpression).type + : undefined; + }); + // Allocate a new temporary type cache for the context of just // this function so we can analyze it separately without polluting // the main type cache. @@ -26035,11 +26043,9 @@ export function createTypeEvaluator( let allArgTypesAreUnknown = true; functionNode.d.params.forEach((param, index) => { if (param.d.name) { - let paramType: Type | undefined; - const arg = args.find((arg) => param.d.name!.d.value === arg.paramName); + let paramType = argTypes[index]; - if (arg && arg.argument.valueExpression) { - paramType = getTypeOfExpression(arg.argument.valueExpression).type; + if (paramType) { if (!isUnknown(paramType)) { allArgTypesAreUnknown = false; } @@ -26098,10 +26104,14 @@ export function createTypeEvaluator( contextualReturnType = cacheEntry.returnType; isResultFromCache = true; } else { - contextualReturnType = inferFunctionReturnType( - functionNode, - FunctionType.isAbstractMethod(type), - callSiteInfo?.errorNode + // Speculative results also depend on these temporary parameter bindings, + // not just the expected types used during overload resolution. + contextualReturnType = speculativeTypeTracker.useSpeculativeTypeCacheIsolation(() => + inferFunctionReturnType( + functionNode, + FunctionType.isAbstractMethod(type), + callSiteInfo?.errorNode + ) )?.type; } } diff --git a/packages/pyright-internal/src/analyzer/typeUtils.ts b/packages/pyright-internal/src/analyzer/typeUtils.ts index bdbbea8cb705..bac9b6f9e7f7 100644 --- a/packages/pyright-internal/src/analyzer/typeUtils.ts +++ b/packages/pyright-internal/src/analyzer/typeUtils.ts @@ -4768,7 +4768,8 @@ class UnificationTypeTransformer extends TypeVarTransformer { } override transformTypeVar(typeVar: TypeVarType) { - if (!this._isTypeVarLive(typeVar)) { + // A borrowed caller variable remains bound even outside its lexical scope. + if (!TypeVarType.isBound(typeVar) && !this._isTypeVarLive(typeVar)) { return TypeVarType.cloneAsUnificationVar(typeVar, this._usageOffset); } diff --git a/packages/pyright-internal/src/tests/samples/callSite10.py b/packages/pyright-internal/src/tests/samples/callSite10.py new file mode 100644 index 000000000000..2e02161f45aa --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite10.py @@ -0,0 +1,74 @@ +# This sample tests constructor-owned type variables in contextual error recovery. + +from collections import deque +from collections.abc import Iterator +from typing import Generic, Self, TypeVar +from typing_extensions import TypeVar as TypeVarWithDefault + +T = TypeVar("T") +DefaultT = TypeVarWithDefault("DefaultT", default=int) +_marker = object() + + +def last(iterable, default=_marker): + try: + if getattr(iterable, "__reversed__", None): + return next(reversed(iterable)) + return deque(iterable, maxlen=1)[-1] + except (IndexError, StopIteration): + if default is _marker: + raise ValueError("empty") + return default + + +reveal_type(last, expected_text="(iterable: Unknown, default: object = _marker) -> (Unknown | object)") + + +def control(values: list[int]): + pool = enumerate(values) + result = last(pool, default=(0, None)) + reveal_type(result, expected_text="Unknown | tuple[int, int] | tuple[Literal[0], None]") + index, item = result + reveal_type(index, expected_text="Unknown | int") + reveal_type(item, expected_text="Unknown | int | None") + + +def reversed_item(values): + return next(reversed(values)) + + +def call_order(integers: list[int], strings: list[str], pool: enumerate[int]): + reveal_type(reversed_item(integers), expected_text="int") + reveal_type(reversed_item(pool), expected_text="Unknown") + reveal_type(reversed_item(strings), expected_text="str") + reveal_type(reversed_item(pool), expected_text="Unknown") + reveal_type(reversed_item(integers), expected_text="int") + + +def valid(values: list[T]): + reveal_type(reversed(values), expected_text="Iterator[T@valid]") + reveal_type(next(reversed(values)), expected_text="T@valid") + reverse: Iterator[T] = reversed(values) + reveal_type(next(reverse), expected_text="T@valid") + + +def invalid(values: enumerate[int]): + # This should generate two errors because enumerate is not reversible. + result = next(reversed(values)) + reveal_type(result, expected_text="Unknown") + + +class DefaultIterator(Generic[DefaultT]): + def __new__(cls, values: list[DefaultT]) -> Self: ... + + def __next__(self) -> DefaultT: ... + + +def defaults(values: list[T]): + reveal_type(next(DefaultIterator(values)), expected_text="T@defaults") + # This should generate an error, but recovery should retain the default. + result = next(DefaultIterator(None)) + reveal_type(result, expected_text="int") + # This should generate an error, but explicit type arguments remain intact. + explicit = next(DefaultIterator[str](None)) + reveal_type(explicit, expected_text="str") diff --git a/packages/pyright-internal/src/tests/samples/callSite11.py b/packages/pyright-internal/src/tests/samples/callSite11.py new file mode 100644 index 000000000000..edf393c8d0e9 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite11.py @@ -0,0 +1,106 @@ +# This sample tests borrowed caller-bound type variables in expected lambda types. + +from collections.abc import Callable +from functools import reduce +from typing import Generic, TypeVar + +T = TypeVar("T", covariant=True) +K = TypeVar("K") +V = TypeVar("V") + + +class Box(Generic[T]): + def merge(self, other: "Box[T]") -> "Box[T]": + return self + + def through_helper(self: "Box[K]") -> "Box[K]": + result = forward((self, self)) + reveal_type(result, expected_text="Box[K@through_helper]") + return result + + +def forward(boxes): + return reduce(lambda acc, other: acc.merge(other), boxes) + + +def direct(value: Box[K]) -> Box[K]: + return reduce(lambda acc, other: acc.merge(other), (value, value)) + + +def through_untyped(value: Box[K]) -> Box[K]: + return forward((value, value)) + + +def annotated_forward(boxes: tuple[Box[K], ...]) -> Box[K]: + return reduce(lambda acc, other: acc.merge(other), boxes) + + +def through_annotated(value: Box[K]) -> Box[K]: + return annotated_forward((value, value)) + + +def concrete(value: Box[int]) -> Box[int]: + return forward((value, value)) + + +def negative(value: Box[int]) -> Box[str]: + # This should generate an error because forwarding retains int. + return forward((value, value)) + + +def apply(value: K, callback: Callable[[K], V]) -> V: + return callback(value) + + +def higher_order(boxes): + return apply(boxes, lambda values: forward(values)) + + +def nested(value: Box[K]) -> Box[K]: + return higher_order((value, value)) + + +def nested_negative(value: Box[K]) -> Box[int]: + # This should generate an error because caller K is not necessarily int. + return higher_order((value, value)) + + +def independent(left: Box[K], right: Box[V]) -> tuple[Box[K], Box[V]]: + first = forward((left, left)) + second = higher_order((right, right)) + reveal_type(first, expected_text="Box[K@independent]") + reveal_type(second, expected_text="Box[V@independent]") + return first, second + + +def independent_negative(left: Box[K], right: Box[V]) -> Box[K]: + # This should generate an error because independent caller variables differ. + return higher_order((right, right)) + + +def factory(values: tuple[Box[K], ...]) -> Callable[[], Box[K]]: + return lambda: forward(values) + + +def deferred(value: Box[K]) -> Callable[[], Box[K]]: + return factory((value, value)) + + +def check_order(integer: Box[int], text: Box[str]) -> None: + reveal_type(forward((integer, integer)), expected_text="Box[int]") + reveal_type(higher_order((text, text)), expected_text="Box[str]") + reveal_type(factory((integer, integer))(), expected_text="Box[int]") + reveal_type(forward((text, text)), expected_text="Box[str]") + + +def identity(value: K) -> K: + return value + + +def compose(first: Callable[[K], V], second: Callable[[V], T]) -> Callable[[K], T]: + return lambda value: second(first(value)) + + +composed = compose(identity, identity) +reveal_type(composed(1), expected_text="int") +reveal_type(composed("value"), expected_text="str") diff --git a/packages/pyright-internal/src/tests/samples/callSite4.py b/packages/pyright-internal/src/tests/samples/callSite4.py index 0815388cb113..550aee7cfc2d 100644 --- a/packages/pyright-internal/src/tests/samples/callSite4.py +++ b/packages/pyright-internal/src/tests/samples/callSite4.py @@ -127,4 +127,4 @@ def pong(self, cls, depth): b = PingPong().ping(Node, 5) -reveal_type(b, expected_text="Unknown | Geometry | | Node") +reveal_type(b, expected_text="Unknown | Geometry | callSite4.PingPong. | Node") diff --git a/packages/pyright-internal/src/tests/samples/callSite8.py b/packages/pyright-internal/src/tests/samples/callSite8.py new file mode 100644 index 000000000000..32a162afa392 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite8.py @@ -0,0 +1,136 @@ +# This sample tests caller argument types passed to contextual helper inference. + +from typing import Callable, Mapping + + +class Basic: + def __init__(self, *args: "Basic") -> None: + self.args = args + + def direct(self, rule): + if self in rule: + return rule[self] + return self + + def wrapped(self, rule): + value, _ = self._flat(rule) + return value + + def _flat(self, rule): + if self in rule: + return rule[self], True + return self, False + + def annotated(self, rule: Mapping["Basic", "Basic"]): + value, _ = self._annotated_flat(rule) + return value + + def _annotated_flat(self, rule: Mapping["Basic", "Basic"]): + if self in rule: + return rule[self], True + return self, False + + def recursive(self, rule): + value, _ = self._recursive(rule) + return value + + def _recursive(self, rule): + if self in rule: + return rule[self], True + elif rule: + args = [] + changed = False + for arg in self.args: + replaced, did_replace = arg._recursive(rule) + args.append(replaced) + changed |= did_replace + if changed: + return type(self)(*args), True + return self, False + + +class Expr(Basic): + def expr_only(self) -> int: + return 42 + + +class Other(Basic): + def other_only(self) -> str: + return "" + + +def replacement(value: Expr, other: Basic, distinct: Other) -> None: + direct = value.direct({value: other}) + reveal_type(direct, expected_text="Basic* | Expr") + # This should generate an error because the replacement can be Basic. + direct.expr_only() + + wrapped = value.wrapped({value: other}) + reveal_type(wrapped, expected_text="Basic* | Expr") + # This should generate an error because the replacement can be Basic. + wrapped.expr_only() + + annotated = value.annotated({value: other}) + reveal_type(annotated, expected_text="Basic | Expr") + # This should generate an error because the replacement can be Basic. + annotated.expr_only() + + reveal_type(value.wrapped({value: distinct}), expected_text="Other* | Expr") + reveal_type(value.wrapped({value: value}), expected_text="Expr* | Expr") + reveal_type(value.wrapped({value: other}), expected_text="Basic* | Expr") + reveal_type(distinct.wrapped({distinct: value}), expected_text="Expr* | Other") + reveal_type(value.wrapped({value: distinct}), expected_text="Other* | Expr") + value.wrapped({value: value}).expr_only() + + recursive = value.recursive({value: other}) + reveal_type(recursive, expected_text="Basic* | Expr") + # This should generate an error because recursion does not exclude Basic. + recursive.expr_only() + + +def identity(value): + return value + + +def forward(value): + return identity(value) + + +def pair(first, second): + return first, second + + +def forward_pair(first, second): + return pair(second=second, first=first) + + +def defaulted(value, fallback=1): + if value: + return value + return fallback + + +def forward_default(value): + return defaulted(value) + + +def callers(first: int, second: str, receiver: Expr) -> None: + reveal_type(forward(first), expected_text="int") + reveal_type(forward(second), expected_text="str") + reveal_type(forward(first), expected_text="int") + reveal_type(forward(receiver), expected_text="Expr") + reveal_type(forward_pair(first, second), expected_text="tuple[int, str]") + reveal_type(forward_pair(second, first), expected_text="tuple[str, int]") + reveal_type(forward_pair(first, second), expected_text="tuple[int, str]") + reveal_type(forward_default(second), expected_text="str | Literal[1]") + reveal_type(forward_default(first), expected_text="int") + reveal_type(forward_default(second), expected_text="str | Literal[1]") + + +def apply_function(f: Callable[[Expr], Expr]) -> None: + pass + + +def callback(rule: Mapping[Basic | complex, Basic | complex]) -> None: + # This should generate an error because the callback can return Basic or complex. + apply_function(lambda value: value.wrapped(rule)) diff --git a/packages/pyright-internal/src/tests/samples/callSite9.py b/packages/pyright-internal/src/tests/samples/callSite9.py new file mode 100644 index 000000000000..23e0ce1643cc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite9.py @@ -0,0 +1,61 @@ +# This sample tests speculative overload results across contextual parameter bindings. + +from typing import TypeAlias, TypeVar + +T = TypeVar("T") +Nested: TypeAlias = list["Nested[T]"] + + +def sort_factors(factors, **args): + def key(factor): + coefficients, multiplicity = factor + return len(coefficients), multiplicity + + return sorted(factors, key=key) + + +def forward(factors): + return sort_factors(factors) + + +def seed(factors: list[tuple[Nested[str], str]]): + return forward(factors) + + +reveal_type( + seed, + expected_text="(factors: list[tuple[list[Nested[str]], str]]) -> list[tuple[list[Nested[str]], str]]", +) + + +def check(coefficients: list[int], nested: list[tuple[Nested[str], str]]) -> None: + reveal_type(sort_factors(nested), expected_text="list[tuple[list[Nested[str]], str]]") + reveal_type(sort_factors([(coefficients, 1)]), expected_text="list[tuple[list[int], int]]") + reveal_type(sort_factors(nested), expected_text="list[tuple[list[Nested[str]], str]]") + reveal_type(sort_factors([(coefficients, 1)]), expected_text="list[tuple[list[int], int]]") + result = forward([(coefficients, 1)]) + reveal_type(result, expected_text="list[tuple[list[int], int]]") + for base, multiplicity in result: + reveal_type(base, expected_text="list[int]") + reveal_type(multiplicity, expected_text="int") + reveal_type(-base[0], expected_text="int") + # This should generate an error because multiplicity remains int. + bad_multiplicity: str = multiplicity + # This should generate an error because the coefficient list is flat. + bad_shape: list[list[int]] = base + + +def sort_by_first(values): + return sorted(values, key=lambda value: value[0]) + + +def first(values: list[tuple[list[list[str]], str]]) -> None: + reveal_type(sort_by_first(values), expected_text="list[tuple[list[list[str]], str]]") + + +def second(values: list[tuple[list[int], int]]) -> None: + reveal_type(sort_by_first(values), expected_text="list[tuple[list[int], int]]") + + +def third(values: list[tuple[list[list[str]], str]]) -> None: + reveal_type(sort_by_first(values), expected_text="list[tuple[list[list[str]], str]]") diff --git a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts index 6fa4b048021a..8a8ac47e7758 100644 --- a/packages/pyright-internal/src/tests/typeCacheUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeCacheUtils.test.ts @@ -26,6 +26,56 @@ interface TestCacheEntry extends ContextualTypeCacheEntry { value: number; } +test.each(['complete', 'error', 'cancel'] as const)( + 'Speculative result isolation preserves active contexts and restores nested caches: %s', + (outcome) => { + const module = parseText('value\n', new DiagnosticSink()).parserOutput.parseTree; + const statement = module.d.statements[0]; + assert.ok(statement.nodeType === ParseNodeType.StatementList); + const node = statement.d.statements[0]; + const tracker = new SpeculativeTypeTracker(); + const first = TypeVarType.createInstance('First'); + const second = TypeVarType.createInstance('Second'); + const third = TypeVarType.createInstance('Third'); + const regularCache = new Map(); + tracker.enterSpeculativeContext(node, { dependentType: first }); + tracker.addSpeculativeType(node, { type: first }, 0, undefined); + const original = tracker.getSpeculativeType(node, undefined); + assert.ok(original); + const error = outcome === 'cancel' ? new OperationCanceledException() : new Error('inference interrupted'); + const isolated = () => + tracker.useSpeculativeTypeCacheIsolation(() => { + assert.equal(tracker.isSpeculative(node), true); + assert.equal(tracker.getSpeculativeType(node, undefined), undefined); + regularCache.set(node.id, second); + tracker.trackEntry(regularCache, node.id); + tracker.addSpeculativeType(node, { type: second }, 0, undefined); + const outer = tracker.getSpeculativeType(node, undefined); + assert.strictEqual(outer?.typeResult.type, second); + tracker.useSpeculativeTypeCacheIsolation(() => { + assert.equal(tracker.getSpeculativeType(node, undefined), undefined); + tracker.addSpeculativeType(node, { type: third }, 0, undefined); + assert.strictEqual(tracker.getSpeculativeType(node, undefined)?.typeResult.type, third); + }); + assert.strictEqual(tracker.getSpeculativeType(node, undefined), outer); + if (outcome !== 'complete') { + throw error; + } + return second; + }); + if (outcome === 'complete') { + assert.strictEqual(isolated(), second); + } else { + assert.throws(isolated, (caught) => caught === error); + } + assert.strictEqual(tracker.getSpeculativeType(node, undefined), original); + assert.strictEqual(regularCache.get(node.id), second); + tracker.leaveSpeculativeContext(); + assert.equal(regularCache.has(node.id), false); + assert.equal(tracker.isSpeculative(undefined), false); + } +); + test.each(['complete', 'error', 'cancel'] as const)( 'Exact-node isolation preserves disjoint native speculative contexts: %s', (outcome) => { diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index 424dd027cd9a..31d202576a8b 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -105,6 +105,26 @@ test('CallSite7', () => { TestUtils.validateResults(analysisResults, 0); }); +test('CallSite8', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite8.py']); + TestUtils.validateResults(analysisResults, 5); +}); + +test('CallSite9', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite9.py']); + TestUtils.validateResults(analysisResults, 2); +}); + +test('CallSite10', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite10.py']); + TestUtils.validateResults(analysisResults, 4); +}); + +test('CallSite11', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite11.py']); + TestUtils.validateResults(analysisResults, 3); +}); + test('FString1', () => { const configOptions = new ConfigOptions(Uri.empty()); diff --git a/packages/pyright-internal/src/tests/typeUtils.test.ts b/packages/pyright-internal/src/tests/typeUtils.test.ts index 2717074f471c..45c20a66413a 100644 --- a/packages/pyright-internal/src/tests/typeUtils.test.ts +++ b/packages/pyright-internal/src/tests/typeUtils.test.ts @@ -8,7 +8,7 @@ import * as assert from 'assert'; -import { containsLiteralType, mapSignatures, transformTypePair } from '../analyzer/typeUtils'; +import { containsLiteralType, mapSignatures, transformExpectedType, transformTypePair } from '../analyzer/typeUtils'; import { AnyType, ClassType, @@ -33,6 +33,48 @@ import { import { Uri } from '../common/uri/uri'; import { ParamCategory } from '../parser/parseNodes'; +test('Expected types preserve borrowed bound variables but unify out-of-scope free variables', () => { + const caller = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('K'), + 'caller', + 'caller', + TypeVarScopeType.Function + ); + const boundCaller = TypeVarType.cloneAsBound(caller); + const local = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('V'), + 'local', + 'local', + TypeVarScopeType.Function + ); + + for (const liveScopes of [[], ['local']]) { + assert.strictEqual(transformExpectedType(boundCaller, liveScopes, 100), boundCaller); + assert.strictEqual(boundCaller.priv.scopeId, TypeVarType.makeBoundScopeId('caller')); + assert.strictEqual(boundCaller.priv.freeTypeVar, caller); + assert.ok(!TypeVarType.isUnification(boundCaller)); + } + + assert.strictEqual(transformExpectedType(caller, ['caller'], 100), caller); + assert.strictEqual(transformExpectedType(boundCaller, ['caller'], 100), boundCaller); + assert.strictEqual(transformExpectedType(local, ['local'], 100), local); + const unified = transformExpectedType(caller, ['local'], 100); + assert.ok(isTypeVar(unified)); + assert.ok(TypeVarType.isUnification(unified)); + assert.ok(!TypeVarType.isBound(unified)); + assert.notStrictEqual(unified.priv.scopeId, caller.priv.scopeId); + assert.strictEqual(caller.priv.scopeId, 'caller'); + + const container = createClass('Container'); + container.shared.typeParams.push(caller, local); + const nested = ClassType.specialize(ClassType.cloneAsInstance(container), [boundCaller, local]); + const transformed = transformExpectedType(nested, [], 200); + assert.ok(isClass(transformed)); + assert.strictEqual(transformed.priv.typeArgs?.[0], boundCaller); + const nestedFree = transformed.priv.typeArgs?.[1]; + assert.ok(nestedFree && isTypeVar(nestedFree) && TypeVarType.isUnification(nestedFree)); +}); + test('Literal detection keeps cancellation and type-argument options local to each walk', () => { const plain = ClassType.cloneAsInstance(createClass('Value')); const literal = ClassType.cloneWithLiteral(plain, 1); From 889f5be3cb8960c53f1c2b4b09f4bb314e19f858 Mon Sep 17 00:00:00 2001 From: Rich Chiodo Date: Wed, 4 Nov 2026 10:33:01 -0800 Subject: [PATCH 5/6] Address selected review feedback --- packages/pyright-internal/src/tests/samples/callSite10.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/tests/samples/callSite10.py b/packages/pyright-internal/src/tests/samples/callSite10.py index 2e02161f45aa..c8020d44ba78 100644 --- a/packages/pyright-internal/src/tests/samples/callSite10.py +++ b/packages/pyright-internal/src/tests/samples/callSite10.py @@ -3,7 +3,7 @@ from collections import deque from collections.abc import Iterator from typing import Generic, Self, TypeVar -from typing_extensions import TypeVar as TypeVarWithDefault +from typing_extensions import TypeVar as TypeVarWithDefault # pyright: ignore[reportMissingModuleSource] T = TypeVar("T") DefaultT = TypeVarWithDefault("DefaultT", default=int) From 9834bc02fa7376b158c5bfdd0fb90c6fa9668e9f Mon Sep 17 00:00:00 2001 From: Rich Chiodo false Date: Wed, 4 Nov 2026 12:50:26 -0800 Subject: [PATCH 6/6] Accept equivalent TypeVar arms in union assignments Compare each remaining source subtype with the destination TypeVar after filtering Any and Unknown. TypeForm metadata can preserve duplicate equivalent arms, so comparing the entire union incorrectly rejected caller-bound variables. Classification: B (Pyright limitation). Preserve TypeForm metadata and type precision; add failing-before cofactor coverage and native equality controls for assignment flags, gradual types, and incompatible neighbors. No typeshed change. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .../src/analyzer/typeEvaluator.ts | 3 +- .../src/tests/constraintSolver.test.ts | 71 ++++++++++++++++++- .../src/tests/samples/callSite12.py | 69 ++++++++++++++++++ .../src/tests/typeEvaluator4.test.ts | 5 ++ 4 files changed, 146 insertions(+), 2 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/callSite12.py diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts index dc6036719af6..58cec46cc9e4 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -27119,7 +27119,8 @@ export function createTypeEvaluator( if (isUnion(srcType)) { const srcWithoutAny = removeFromUnion(srcType, (type) => isAnyOrUnknown(type)); - if (isTypeSame(destType, srcWithoutAny)) { + // TypeForm metadata can keep equivalent TypeVars as separate union arms. + if (!someSubtypes(srcWithoutAny, (subtype) => !isTypeSame(destTypeVar, subtype))) { return true; } } diff --git a/packages/pyright-internal/src/tests/constraintSolver.test.ts b/packages/pyright-internal/src/tests/constraintSolver.test.ts index 88900f01ea07..e01620145209 100644 --- a/packages/pyright-internal/src/tests/constraintSolver.test.ts +++ b/packages/pyright-internal/src/tests/constraintSolver.test.ts @@ -9,7 +9,20 @@ import assert from 'assert'; import { getEnclosingFunction } from '../analyzer/parseTreeUtils'; -import { FunctionType, TypeVarType, isTypeVar } from '../analyzer/types'; +import { AssignTypeFlags } from '../analyzer/typeEvaluatorTypes'; +import { + AnyType, + combineTypes, + FunctionType, + isTypeSame, + isTypeVar, + isUnion, + Type, + TypeBase, + TypeVarScopeType, + TypeVarType, + UnknownType, +} from '../analyzer/types'; import { ParseNodeType } from '../parser/parseNodes'; import { getNodeAtMarker, parseAndGetTestState } from './harness/fourslash/testState'; @@ -43,3 +56,59 @@ test('Recursive source must satisfy the TypeVar bound without a constraint track assert.strictEqual(evaluator.assignType(destType, unrelatedType), false); assert.strictEqual(evaluator.assignType(destType, boundedType), true); }); + +test.each([ + AssignTypeFlags.Default, + AssignTypeFlags.Invariant, + AssignTypeFlags.Contravariant, + AssignTypeFlags.OverloadOverlap, +])('Equivalent TypeVar union arms retain TypeForm metadata during assignment: %s', (flags) => { + const state = parseAndGetTestState(` +// @filename: test.py +//// def /*marker*/func(value: int) -> None: ... + `).state; + const evaluator = state.program.evaluator!; + const node = getNodeAtMarker(state, 'marker'); + const functionNode = getEnclosingFunction(node); + assert(functionNode); + const functionType = evaluator.getTypeOfFunction(functionNode)?.functionType; + assert(functionType); + const intType = FunctionType.getParamType(functionType, 0); + const free = TypeVarType.cloneForScopeId( + TypeVarType.createInstance('T'), + 'caller', + 'caller', + TypeVarScopeType.Function + ); + const bound = TypeVarType.cloneAsBound(free); + const unrelated = TypeVarType.cloneAsBound( + TypeVarType.cloneForScopeId(TypeVarType.createInstance('T'), 'other', 'other', TypeVarScopeType.Function) + ); + + for (const dest of [bound, free]) { + const tagged = TypeBase.cloneWithTypeForm(dest, dest); + assert.ok(isTypeSame(dest, tagged)); + assert.ok(!isTypeSame(dest, tagged, { honorTypeForm: true })); + + for (const gradual of [undefined, AnyType.create(), UnknownType.create()]) { + const arms: Type[] = gradual ? [gradual, dest, tagged] : [dest, tagged]; + for (const ordered of [arms, [...arms].reverse()]) { + const source = combineTypes(ordered); + assert.ok(isUnion(source)); + assert.strictEqual(source.priv.subtypes.length, arms.length); + assert.strictEqual(evaluator.assignType(dest, source, undefined, undefined, flags), true); + assert.strictEqual(tagged.props?.typeForm, dest); + assert.strictEqual(dest.props?.typeForm, undefined); + assert.strictEqual(source.priv.subtypes.length, arms.length); + } + } + } + + for (const incompatible of [unrelated, intType, TypeVarType.cloneAsInstantiable(bound)]) { + const tagged = TypeBase.cloneWithTypeForm(bound, bound); + for (const gradual of [AnyType.create(), UnknownType.create()]) { + const source = combineTypes([gradual, bound, tagged, incompatible]); + assert.strictEqual(evaluator.assignType(bound, source, undefined, undefined, flags), false); + } + } +}); diff --git a/packages/pyright-internal/src/tests/samples/callSite12.py b/packages/pyright-internal/src/tests/samples/callSite12.py new file mode 100644 index 000000000000..cb0468b5d985 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite12.py @@ -0,0 +1,69 @@ +# This sample tests equivalent caller TypeVars with distinct TypeForm metadata. + +from typing import Generic, TypeVar + +T = TypeVar("T") +U = TypeVar("U") + + +class Domain(Generic[T]): + one: T + flag: bool + + def get_ring(self) -> "Ring": + raise NotImplementedError + + def lcm(self, a: T, b: T) -> T: + return a + + def cofactors(self, a: T, b: T) -> tuple[T, T, T]: + return self.one, a, b + + +class Ring(Domain[T]): + pass + + +def inner_clear(values, domain): + common = domain.one + for value in values: + common = domain.lcm(common, value) + return common, values + + +def clear(values, source, target=None, convert=False): + if target is None: + target = source.get_ring() if source.flag else source + return inner_clear(values, target) + + +def original(domain: Domain[T], values: list[T]): + source = None + if domain.flag: + source, domain = domain, domain.get_ring() + common, _ = clear(values, source, domain, convert=True) + reveal_type(common, expected_text="Unknown | T@original") + domain.cofactors(common, common) + else: + common = domain.one + if source is not None: + reveal_type(common, expected_text="Unknown | T@original") + result = domain.cofactors(common, common) + reveal_type(result, expected_text="tuple[T@original, T@original, T@original] | tuple[Unknown, Unknown, Unknown]") + + +def direct(domain: Domain[T], value: T) -> tuple[T, T, T]: + result = domain.cofactors(value, value) + reveal_type(result, expected_text="tuple[T@direct, T@direct, T@direct]") + return result + + +def unrelated(domain: Domain[T], value: U) -> U: + # This should generate two errors because U is not the domain's T. + domain.cofactors(value, value) + return value + + +def concrete_negative(domain: Domain[int], value: str) -> None: + # This should generate two errors because str is not int. + domain.cofactors(value, value) diff --git a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts index 31d202576a8b..b3c550c78994 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -125,6 +125,11 @@ test('CallSite11', () => { TestUtils.validateResults(analysisResults, 3); }); +test('CallSite12', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite12.py']); + TestUtils.validateResults(analysisResults, 4); +}); + test('FString1', () => { const configOptions = new ConfigOptions(Uri.empty());