mypy.checkmember

Instantiate type variables during analyze_class_attribute_access, e.g T and Q in the following:

class A(Generic[T]):

@classmethod def foo(cls: Type[Q]) -> Tuple[T, Q]: ...

class B(A[str]): pass B.foo()

Args:

t: Declared type of the method (or property) isuper: Current instance mapped to the superclass where method was defined, this

is usually done by map_instance_to_supertype()

is_classmethod: True if this method is decorated with @classmethod original_type: The value of the type B in the expression B.foo() or the corresponding

component in case of a union (this is used to bind the self-types)

original_vars: Type variables of the class callable on which the method was accessed

Returns:

Expanded method type with added type variables (when needed).

Analyze access to an attribute on a class object.

itype is the return type of the class object callable, original_type is the type of E in the expression E.var, original_vars are type variables of the class callable (for generic classes).

Analyzes the type behind method access.

The function itself can possibly be decorated. See: https://github.com/python/mypy/issues/10409

Type check descriptor access.

Arguments:

descriptor_type: The type of the descriptor attribute being accessed

(the type of f in a.f when f is a descriptor).

mx: The current member access context.

Return:

The return type of the appropriate __get__ overload for the descriptor.

Undocumented

Undocumented

Return the type of attribute 'name' of 'typ'.

The actual implementation is in '_analyze_member_access' and this docstring also applies to it.

This is a general operation that supports various different variations:

1. lvalue or non-lvalue access (setter or getter access)
2. supertype access when using super() (is_super == True and 'override_info' should refer to the supertype)

'original_type' is the most precise inferred or declared type of the base object that we have available. When looking for an attribute of 'typ', we may perform recursive calls targeting the fallback type, and 'typ' may become some supertype of 'original_type'. 'original_type' is always preserved as the 'typ' type used in the initial, non-recursive call. The 'self_type' is a component of 'original_type' to which generic self should be bound (a narrower type that has a fallback to instance). Currently this is used only for union types.

'module_symbol_table' is passed to this function if 'typ' is actually a module and we want to keep track of the available attributes of the module (since they are not available via the type object directly)

Analyse attribute access that does not target a method.

This is logically part of analyze_member_access and the arguments are similar.

original_type is the type of E in the expression E.var

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Analyze access to an attribute via a Var node.

This is conceptually part of analyze_member_access and the arguments are similar.

itype is the class object in which var is defined original_type is the type of E in the expression E.var if implicit is True, the original Var was created as an assignment to self

Check that an instance has a valid type for a method with annotated 'self'.

For example if the method is defined as:

class A:

def f(self: S) -> T: ...

then for 'x.f' we check that meet(type(x), A) <: S. If the method is overloaded, we select only overloads items that satisfy this requirement. If there are no matching overloads, an error is generated.

Note: dispatched_arg_type uses a meet to select a relevant item in case if the original type of 'x' is a union. This is done because several special methods treat union types in ad-hoc manner, so we can't use MemberContext.self_type yet.

Undocumented

Type of a type alias node targeting an instance, when appears in runtime context.

As usual, we first erase any unbound type variables to Any.

Does this node represents a valid constructor method?

This includes normal functions, overloaded functions, and decorators that return a callable type.

Return the type of a type object.

For a generic type G with type variables T and S the type is generally of form

Callable[..., G[T, S]]

where ... are argument types for the __init__/__new__ method (without the self argument). Also, the fallback type will be 'type' instead of 'function'.