Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion packages/pyright-internal/src/analyzer/constructors.ts
Original file line number Diff line number Diff line change
Expand Up @@ -621,7 +621,7 @@ function applyExpectedSubtypeForConstructor(
): Type | undefined {
const specializedType = evaluator.solveAndApplyConstraints(ClassType.cloneAsInstance(type), constraints, {
replaceUnsolved: {
scopeIds: [],
scopeIds: getTypeVarScopeIds(type),
tupleClassType: evaluator.getTupleClassType(),
},
});
Expand Down
10 changes: 10 additions & 0 deletions packages/pyright-internal/src/analyzer/typeCacheUtils.ts
Original file line number Diff line number Diff line change
Expand Up @@ -163,6 +163,16 @@ export class SpeculativeTypeTracker {
private _speculativeTypeCache = new Map<number, SpeculativeTypeEntry[]>();
private _activeDependentTypes: DependentType[] = [];

useSpeculativeTypeCacheIsolation<T>(callback: () => T): T {
const prevCache = this._speculativeTypeCache;
this._speculativeTypeCache = new Map<number, SpeculativeTypeEntry[]>();
try {
return callback();
} finally {
this._speculativeTypeCache = prevCache;
}
}

evictCacheEntries(nodeIds: ReadonlySet<number>) {
assert(this._speculativeContextStack.length === 0);
nodeIds.forEach((id) => this._speculativeTypeCache.delete(id));
Expand Down
52 changes: 43 additions & 9 deletions packages/pyright-internal/src/analyzer/typeEvaluator.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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 };
}

Expand Down Expand Up @@ -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.
Expand All @@ -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;
}
Expand Down Expand Up @@ -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;
}
}
Expand Down Expand Up @@ -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;
}
}
Expand Down
3 changes: 2 additions & 1 deletion packages/pyright-internal/src/analyzer/typeUtils.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}

Expand Down
71 changes: 70 additions & 1 deletion packages/pyright-internal/src/tests/constraintSolver.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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';

Expand Down Expand Up @@ -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);
}
}
});
74 changes: 74 additions & 0 deletions packages/pyright-internal/src/tests/samples/callSite10.py
Original file line number Diff line number Diff line change
@@ -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")
106 changes: 106 additions & 0 deletions packages/pyright-internal/src/tests/samples/callSite11.py
Original file line number Diff line number Diff line change
@@ -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")
Loading
Loading