callee)

elif isinstance(callee, Instance):

call_function = analyze_member_access('__call__', callee, context,

return self.check_call(call_function, args, arg_kinds, context, arg_names,

callable_node, arg_messages)

elif isinstance(callee, TypeVarType):

return self.analyze_ref_expr(e)

else:

# This is a reference to a non-module attribute.

is_lvalue, False, False,

self.named_type, self.not_ready_callback, self.msg,

def analyze_external_member_access(self, member: str, base_type: Type,

context: Context) -> Type:

# TODO remove; no private definitions in mypy

return analyze_member_access(member, base_type, context, False, False, False,

self.named_type, self.not_ready_callback, self.msg,

def visit_int_expr(self, e: IntExpr) -> Type:

"""Type check an integer literal (trivial)."""

method_type = analyze_member_access(method, base_type, context, False, False, True,

self.named_type, self.not_ready_callback, local_errors,

return self.check_call(method_type, [arg], [nodes.ARG_POS],

context, arg_messages=local_errors)

is_lvalue=False, is_super=True, is_operator=False,

builtin_type=self.named_type,

not_ready_callback=self.not_ready_callback,

assert False, 'unreachable'

else:

# Invalid super. This has been reported by the semantic analyzer.

is_operator: bool,

builtin_type: Callable[[str], Instance],

not_ready_callback: Callable[[str, Context], None],

override_info: TypeInfo = None,

chk: 'mypy.checker.TypeChecker' = None) -> Type:

"""Return the type of attribute `name` of typ.

if isinstance(typ, Instance):

if name == '__init__' and not is_super:

# Accessing __init__ in statically typed code would compromise

if method.is_property:

assert isinstance(method, OverloadedFuncDef)

return analyze_var(name, method.items[0].var, typ, info, node, is_lvalue, msg,

if is_lvalue:

msg.cant_assign_to_method(node)

signature = function_type(method, builtin_type('builtins.function'))

msg.disable_type_names += 1

results = [analyze_member_access(name, subtype, node, is_lvalue, is_super,

is_operator, builtin_type, not_ready_callback, msg,

for subtype in typ.items]

msg.disable_type_names -= 1

return UnionType.make_simplified_union(results)

elif isinstance(typ, TupleType):

# Actually look up from the fallback instance type.

return analyze_member_access(name, typ.fallback, node, is_lvalue, is_super,

elif isinstance(typ, FunctionLike) and typ.is_type_obj():

# Class attribute.

# TODO super?

builtin_type: Callable[[str], Instance],

not_ready_callback: Callable[[str, Context], None],

msg: MessageBuilder,

chk: 'mypy.checker.TypeChecker' = None) -> Type:

"""Analyse attribute access that does not target a method.

# It was not a method. Try looking up a variable.

v = lookup_member_var_or_accessor(info, name, is_lvalue)

# The associated Var node of a decorator contains the type.

v = vv.var

if isinstance(v, Var):

elif isinstance(v, FuncDef):

assert False, "Did not expect a function"

elif not v and name not in ['__getattr__', '__setattr__']:

def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Context,

"""Analyze access to an attribute via a Var node.

# Found a member variable.

itype = map_instance_to_supertype(itype, var.info)

typ = var.type

def lookup_member_var_or_accessor(info: TypeInfo, name: str,

"""Find the attribute/accessor node that refers to a member of a type."""

# TODO handle lvalues

node = info.get(name)

builtin_type: Callable[[str], Instance],

not_ready_callback: Callable[[str, Context], None],

msg: MessageBuilder,

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

node = itype.type.get(name)

if not node:

def add_class_tvars(t: Type, itype: Instance, is_classmethod: bool,

builtin_type: Callable[[str], Instance],

"""Instantiate type variables during analyze_class_attribute_access,

info = itype.type # type: TypeInfo

if isinstance(t, CallableType):

# TODO: Should we propagate type variable values?

if is_classmethod:

t = bind_self(t, original_type)

elif isinstance(t, Overloaded):

builtin_type, original_type))

return t

return cast(F, func)

if func.arg_kinds[0] == ARG_STAR:

# The signature is of the form 'def foo(*args, ...)'.

# since func will be absorbed by the *args.

# TODO: infer bounds on the type of *args?

return cast(F, func)

self_param_type = func.arg_types[0]

if func.variables and (isinstance(self_param_type, TypeVarType) or

if original_type is None:

# Type check method override

# XXX value restriction as union?

ret_type = func.ret_type

variables = func.variables

res = func.copy_modified(arg_types=arg_types,

return cast(F, res)

from mypy.errors import Errors, report_internal_error

from mypy.types import (

NoneTyp, CallableType, Overloaded, Instance, Type, TypeVarType, AnyType,

TupleType, UnionType, StarType, EllipsisType, function_type)

from mypy.nodes import implicit_module_attrs

from mypy.typeanal import TypeAnalyser, TypeAnalyserPass3, analyze_type_alias

add_field(Var('_field_types', dictype), is_initialized_in_class=True)

add_field(Var('_source', strtype), is_initialized_in_class=True)

def add_method(funcname: str, ret: Type, args: List[Argument], name=None,

is_classmethod=False) -> None:

types = [arg.type_annotation for arg in args]

items = [arg.variable.name() for arg in args]

arg_kinds = [arg.kind for arg in args]

signature = CallableType(types, arg_kinds, items, ret, function_type,

name=name or info.name() + '.' + funcname)

func = FuncDef(funcname, args, Block([]), typ=signature)

func.info = info

func.is_class = is_classmethod

args=[Argument(var, var.type, EllipsisExpr(), ARG_NAMED) for var in vars])

add_method('__init__', ret=NoneTyp(), name=info.name(),

args=[Argument(var, var.type, None, ARG_POS) for var in vars])

add_method('_asdict', args=[], ret=ordereddictype)

args=[Argument(Var('iterable', iterable_type), iterable_type, None, ARG_POS),

Argument(Var('new'), AnyType(), EllipsisExpr(), ARG_NAMED),

Argument(Var('len'), AnyType(), EllipsisExpr(), ARG_NAMED)])

else:

x[0] # E: Value of type "int" is not indexable

x + 1

x + 1 # E: Unsupported operand types for + (likely involving Union)

[builtins fixtures/isinstancelist.pyi]

[out]

x._replace(x=5)

x._replace(y=5) # E: Argument 1 to X._replace has incompatible type "int"; expected "str"

[case testNamedTupleMake]

from typing import NamedTuple

X = NamedTuple('X', [('x', int), ('y', str)])

reveal_type(X._make([5, 'a'])) # E: Revealed type is 'Tuple[builtins.int, builtins.str, fallback=__main__.X]'

X._make('a b') # E: Argument 1 to X._make has incompatible type "str"; expected Iterable[Any]

-- x = None # type: X

-- reveal_type(x._make([5, 'a'])) # E: Revealed type is 'Tuple[builtins.int, builtins.str, fallback=__main__.X]'

-- x._make('a b') # E: Argument 1 to X._make has incompatible type "str"; expected Iterable[Any]

g(D()) # E: Argument 1 to "g" has incompatible type "D"; expected "C"

y = None # type: C

y = D() # E: Incompatible types in assignment (expression has type "D", variable has type "C")

a = None # type: A

a + (a, a) # E: Unsupported operand types for + ("A" and "Tuple[A, A]")

f((a, a)) # E: Argument 1 to "f" has incompatible type "Tuple[A, A]"; expected "A"

def f(x: 'A') -> None: pass

s = t.__len__() # E: Incompatible types in assignment (expression has type "int", variable has type "str")

i = t.__str__() # E: Incompatible types in assignment (expression has type "str", variable has type "int")

i = s in t # E: Incompatible types in assignment (expression has type "bool", variable has type "int")

i = t.__len__()

s = t.__str__()