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 0c4038c17086..58cec46cc9e4 100644 --- a/packages/pyright-internal/src/analyzer/typeEvaluator.ts +++ b/packages/pyright-internal/src/analyzer/typeEvaluator.ts @@ -25938,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 }; } @@ -25995,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. @@ -26012,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; } @@ -26075,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; } } @@ -27086,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/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/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/callSite10.py b/packages/pyright-internal/src/tests/samples/callSite10.py new file mode 100644 index 000000000000..c8020d44ba78 --- /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 # pyright: ignore[reportMissingModuleSource] + +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/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/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/callSite5.py b/packages/pyright-internal/src/tests/samples/callSite5.py new file mode 100644 index 000000000000..10908e4fe1dc --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite5.py @@ -0,0 +1,107 @@ +# This sample tests receiver specialization after call-site return inference. + +from typing import Generic, TypeVar + + +class Base: + def pick(self, argument): + if argument: + return self + return argument + + def concrete(self, argument): + if argument: + return Base() + return argument + + def declared(self, argument) -> "Base": + return self + + @classmethod + def make(cls, argument): + if argument: + return cls() + return argument + + @staticmethod + def identity(argument): + return argument + + +class Derived(Base): + def derived_only(self) -> int: + return 42 + + +class Other(Base): + 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(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") + 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") + + +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") + + +def union_receiver(value: Derived | Other): + 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 pick(self, argument): + if argument: + return self + 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]") + + +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]") 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..e1f30c26c631 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite6.py @@ -0,0 +1,27 @@ +# This sample tests recursive property return inference with receiver specialization. + + +class Edge: + def __init__(self, parent: "Node"): + self.parent = parent + + +class Node: + def __init__(self, edges: dict[str, list[Edge]]): + self.edges = edges + + @property + def root(self): + if not self.edges: + return self + edges = next(iter(self.edges.values())) + return edges[0].parent.root + + +def consume(node: Node) -> None: + pass + + +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 new file mode 100644 index 000000000000..97a96261b2c8 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/callSite7.py @@ -0,0 +1,86 @@ +# This sample tests receiver Self preservation through inherited factory calls. + +from typing import Generic, TypeVar + + +class Base: + @classmethod + def build(cls, args): + if not args: + return args + return cls() + + def rebuild(self, *args): + return self.build(args) + + def pick(self, argument): + if argument: + return self + return argument + + +class Derived(Base): + def derived_only(self) -> int: + return 42 + + def forwarded(self): + return self.pick(1) + + +class Other(Base): + pass + + +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 Further(Derived): + pass + + +def further(value: Further): + reveal_type(value.rebuild(1, 2), expected_text="Unknown | Further") + reveal_type(value.forwarded(), expected_text="Further") + + +T = TypeVar("T") + + +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) + + +def constrained_receiver(value: Receiver) -> Receiver: + return value.pick(1) + + +BoundReceiver = TypeVar("BoundReceiver", bound=Derived) + + +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 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 d6dfd3db4680..b3c550c78994 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator4.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator4.test.ts @@ -90,6 +90,46 @@ test('CallSite4', () => { TestUtils.validateResults(analysisResults, 0, 0, 7); }); +test('CallSite5', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite5.py']); + TestUtils.validateResults(analysisResults, 1); +}); + +test('CallSite6', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite6.py']); + TestUtils.validateResults(analysisResults, 0); +}); + +test('CallSite7', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite7.py']); + 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('CallSite12', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['callSite12.py']); + TestUtils.validateResults(analysisResults, 4); +}); + 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);