Draft: Solve intermediate variable bug

[randolf-scholz]

Attempted fix for #19304. Looking for feedback, as this was mostly a trial-and-error process.

• Removed self.infer_function_type_arguments_using_context. Instead, we now use a function infer_constraints_from_context that only yields the constraints.
• Modified infer_function_type_arguments to now include the context.
  We compute 2 sets of constraints: the "outer constraints", determined by the context, and the "inner constraints" determined by the callable type. From this, we compute 2 solutions:
  • the "outer solution", which only uses the outer constraints.
  • the "joint solution", which uses both the outer and inner constraints.
• We prefer the "joint solution", unless:
  • it failed to solve some variables
  • the return type of the outer solution is a subtype (i.e. more precise) of the return type of the joint solution
  • the return type of the outer solution is a union, and any member of that union is a subtype of the joint return type.¹
• if the outer solution was selected, we essentially fall back to the original code from the master branch, and first apply the outer solution, and then recompute the inner constraints and apply the inner solution.

Modified tests

• Added test testBinaryOperatorContext (see Assigning to intermediate variable changes type checking results #19304)
• As a nice side effect, we got some improved inference in testRecursiveAliasWithRecursiveInstance.²

Footnotes

1. This was needed to fix testLiteralAndGenericWithUnion, because the outer solution was int | Literal["foo"] whereas the joint solution was Literal["foo"]? which got converted into str later. ↩

2. previously, a=b followed by a=[[b]] made a be inferred as __main__.B followed by builtins.list[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]]. Now, it gets more precisely inferred as builtins.list[builtins.list[__main__.B]]. And afterwards, join(a,b) get more precisely inferred as typing.Sequence[typing.Sequence[__main__.B]] rather than typing.Sequence[Union[__main__.A, typing.Sequence[Union[__main__.A, ...]]]] previously. See: https://mypy-play.net/?mypy=latest&python=3.12&gist=619a7fa6c3ec9d75bd1492bf8e68432c ↩

[randolf-scholz]

Without this hack, testLiteralAndGenericWithUnion fails (see footnote 1 in OP). Not sure if this is the appropriate way to do it

[randolf-scholz]

It seems to work both with/without recomputing arg_types here, but I am not sure.