Summary

This PR achieves the following:

• Add support for checking method calls, and inferring return types from method calls. For example:

  reveal_type("abcde".find("abc"))  # revealed: int
  reveal_type("foo".encode(encoding="utf-8"))  # revealed: bytes
  
  "abcde".find(123)  # error: [invalid-argument-type]
  
  class C:
      def f(self) -> int:
          pass
  
  reveal_type(C.f)  # revealed: <function `f`>
  reveal_type(C().f)  # revealed: <bound method: `f` of `C`>
  
  C.f()  # error: [missing-argument]
  reveal_type(C().f())  # revealed: int

• Implement the descriptor protocol, i.e. properly call the __get__ method when a descriptor object is accessed through a class object or an instance of a class. For example:

  from typing import Literal
  
  class Ten:
      def __get__(self, instance: object, owner: type | None = None) -> Literal[10]:
          return 10
  
  class C:
      ten: Ten = Ten()
  
  reveal_type(C.ten)  # revealed: Literal[10]
  reveal_type(C().ten)  # revealed: Literal[10]

• Add support for member lookup on intersection types.
• Support type inference for inspect.getattr_static(obj, attr) calls. This was mostly used as a debugging tool during development, but seems more generally useful. It can be used to bypass the descriptor protocol. For the example above:

  from inspect import getattr_static
  
  reveal_type(getattr_static(C, "ten"))  # revealed: Ten

• Add a new Type::Callable(…) variant with the following sub-variants:
  • Type::Callable(CallableType::BoundMethod(…)) — represents bound method objects, e.g. C().f above
  • Type::Callable(CallableType::MethodWrapperDunderGet(…)) — represents f.__get__ where f is a function
  • Type::Callable(WrapperDescriptorDunderGet) — represents FunctionType.__get__
• Add new known classes:
  • types.MethodType
  • types.MethodWrapperType
  • types.WrapperDescriptorType
  • builtins.range

Performance analysis

On this branch, we do more work. We need to do more call checking, since we now check all method calls. We also need to do ~twice as many member lookups, because we need to check if a __get__ attribute exists on accessed members.

A brief analysis on tomllib shows that we now call Type::call 1780 times, compared to 612 calls before. We also emit 18 additional diagnostics, which might also explain some of the performance regression.

I did some wall time benchmarks as well and only find a minor 1% regression on black, and a 6% regression on tomllib.

black

tomllib

Limitations

• Data descriptors are not yet supported, i.e. we do not infer correct types for descriptor attribute accesses in Store context and do not check writes to descriptor attributes. I felt like this was something that could be split out as a follow-up without risking a major architectural change.
• We currently distinguish between Type::member (with descriptor protocol) and Type::static_member (without descriptor protocol). The former corresponds to obj.attr, the latter corresponds to getattr_static(obj, "attr"). However, to model some details correctly, we would also need to distinguish between a static member lookup with and without instance variables. The lookup without instance variables corresponds to find_name_in_mro here. We currently approximate both using member_static, which leads to two open TODOs. Changing this would be a larger refactoring of Type::own_instance_member, so I chose to leave it out of this PR.

Please let me know if you would like to see any or both of these limitations be solved in this PR instead.

Test Plan

• New call/methods.md test suite for method calls
• New tests in descriptor_protocol.md
• New call/getattr_static.md test suite for inspect.getattr_static
• Various updated tests