"""Return fallback type for a tuple."""

from mypy.join import join_type_list

info = typ.partial_fallback.type

if info.fullname() != 'builtins.tuple':

return typ.partial_fallback

info: TypeInfo,

def_info: TypeInfo,

fallback: Instance,

is_new: bool) -> FunctionLike:

# We first need to record all non-trivial (explicit) self types in __init__,

# since they will not be available after we bind them. Note, we use explicit

# self-types only in the defining class, similar to __new__ (but not exactly the same,

# see comment in class_callable below). This is mostly useful for annotating library

# classes such as subprocess.Popen.

default_self = fill_typevars(info)

if not is_new and def_info == info and not info.is_newtype:

orig_self_types = [(it.arg_types[0] if it.arg_types and it.arg_types[0] != default_self

and it.arg_kinds[0] == ARG_POS else None) for it in signature.items()]

else:

orig_self_types = [None] * len(signature.items())

# The __init__ method might come from a generic superclass 'def_info'

# with type variables that do not map identically to the type variables of

# the class 'info' being constructed. For example:

#

# class A(Generic[T]):

# def __init__(self, x: T) -> None: ...

# class B(A[List[T]]):

# ...

#

# We need to map B's __init__ to the type (List[T]) -> None.

signature = bind_self(signature, original_type=default_self, is_classmethod=is_new)

signature = cast(FunctionLike, map_type_from_supertype(signature, info, def_info))

special_sig = None # type: Optional[str]

if def_info.fullname() == 'builtins.dict':

# Special signature!

special_sig = 'dict'

if isinstance(signature, CallableType):

return class_callable(signature, info, fallback, special_sig, is_new, orig_self_types[0])

else:

# Overloaded __init__/__new__.

assert isinstance(signature, Overloaded)

items = [] # type: List[CallableType]

for item, orig_self in zip(signature.items(), orig_self_types):

items.append(class_callable(item, info, fallback, special_sig, is_new, orig_self))

special_sig: Optional[str],

is_new: bool, orig_self_type: Optional[Type] = None) -> CallableType:

"""Create a type object type based on the signature of __init__."""

variables = [] # type: List[TypeVarDef]

variables.extend(info.defn.type_vars)

variables.extend(init_type.variables)

from mypy.subtypes import is_subtype

init_ret_type = get_proper_type(init_type.ret_type)

orig_self_type = get_proper_type(orig_self_type)

default_ret_type = fill_typevars(info)

if (

is_new

and isinstance(init_ret_type, (Instance, TupleType))

# Only use the return type from __new__ if it is actually returning

# a subtype of what we would return otherwise.

and is_subtype(init_ret_type, default_ret_type, ignore_type_params=True)

):

ret_type = init_ret_type # type: Type

elif isinstance(orig_self_type, (Instance, TupleType)):

ret_type = orig_self_type

else:

ret_type = default_ret_type

callable_type = init_type.copy_modified(

ret_type=ret_type, fallback=type_type, name=None, variables=variables,

special_sig=special_sig)

c = callable_type.with_name(info.name())

sub_info: TypeInfo,

super_info: TypeInfo) -> Type:

"""Map type variables in a type defined in a supertype context to be valid

# Create the type of self in subtype, of form t[a1, ...].

inst_type = fill_typevars(sub_info)

if isinstance(inst_type, TupleType):

inst_type = tuple_fallback(inst_type)

# Map the type of self to supertype. This gets us a description of the

# supertype type variables in terms of subtype variables, i.e. t[t1, ...]

# so that any type variables in tN are to be interpreted in subtype

# context.

inst_type = map_instance_to_supertype(inst_type, super_info)

# Finally expand the type variables in type with those in the previously

# constructed type. Note that both type and inst_type may have type

# variables, but in type they are interpreted in supertype context while

# in inst_type they are interpreted in subtype context. This works even if

# the names of type variables in supertype and subtype overlap.

"""Is this a supported kind of explicit self-types?

if isinstance(typ, TypeType):

return supported_self_type(typ.item)

return (isinstance(typ, TypeVarType) or

"""Return a copy of `method`, with the type of its first parameter (usually

from mypy.infer import infer_type_arguments

if isinstance(method, Overloaded):

return cast(F, Overloaded([bind_self(c, original_type, is_classmethod)

for c in method.items()]))

assert isinstance(method, CallableType)

func = method

if not func.arg_types:

# Invalid method, return something.

return cast(F, func)

if func.arg_kinds[0] == ARG_STAR:

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

# In this case we shouldn't drop the first arg,

# since func will be absorbed by the *args.

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

return cast(F, func)

self_param_type = get_proper_type(func.arg_types[0])

if func.variables and supported_self_type(self_param_type):

if original_type is None:

# TODO: type check method override (see #7861).

original_type = erase_to_bound(self_param_type)

original_type = get_proper_type(original_type)

ids = [x.id for x in func.variables]

typearg = get_proper_type(infer_type_arguments(ids, self_param_type,

original_type, is_supertype=True)[0])

if (is_classmethod and isinstance(typearg, UninhabitedType)

and isinstance(original_type, (Instance, TypeVarType, TupleType))):

# In case we call a classmethod through an instance x, fallback to type(x)

typearg = get_proper_type(infer_type_arguments(ids, self_param_type,

TypeType(original_type),

is_supertype=True)[0])

def expand(target: Type) -> Type:

assert typearg is not None

return expand_type(target, {func.variables[0].id: typearg})

arg_types = [expand(x) for x in func.arg_types[1:]]

ret_type = expand(func.ret_type)

variables = func.variables[1:]

else:

arg_types = func.arg_types[1:]

ret_type = func.ret_type

variables = func.variables

original_type = get_proper_type(original_type)

if isinstance(original_type, CallableType) and original_type.is_type_obj():

original_type = TypeType.make_normalized(original_type.ret_type)

res = func.copy_modified(arg_types=arg_types,

arg_kinds=func.arg_kinds[1:],

arg_names=func.arg_names[1:],

variables=variables,

ret_type=ret_type,

bound_args=[original_type])

# TODO: use value restrictions to produce a union?

t = get_proper_type(t)

if isinstance(t, TypeVarType):

return t.upper_bound

if isinstance(t, TypeType):

if isinstance(t.item, TypeVarType):

return TypeType.make_normalized(t.item.upper_bound)

model: FormalArgument) -> Optional[FormalArgument]:

"""Return the argument a function that corresponds to `model`"""

by_name = typ.argument_by_name(model.name)

by_pos = typ.argument_by_position(model.pos)

if by_name is None and by_pos is None:

return None

if by_name is not None and by_pos is not None:

if by_name == by_pos:

return by_name

# If we're dealing with an optional pos-only and an optional

# name-only arg, merge them. This is the case for all functions

# taking both *args and **args, or a pair of functions like so:

# def right(a: int = ...) -> None: ...

# def left(__a: int = ..., *, a: int = ...) -> None: ...

from mypy.subtypes import is_equivalent

if (not (by_name.required or by_pos.required)

and by_pos.name is None

and by_name.pos is None

and is_equivalent(by_name.typ, by_pos.typ)):

return FormalArgument(by_name.name, by_pos.pos, by_name.typ, False)

line: int = -1, column: int = -1) -> ProperType:

"""Build union type with redundant union items removed.

items = get_proper_types(items)

while any(isinstance(typ, UnionType) for typ in items):

all_items = [] # type: List[ProperType]

for typ in items:

if isinstance(typ, UnionType):

all_items.extend(typ.items)

else:

all_items.append(typ)

items = all_items

from mypy.subtypes import is_proper_subtype

removed = set() # type: Set[int]

for i, ti in enumerate(items):

if i in removed: continue

# Keep track of the truishness info for deleted subtypes which can be relevant

cbt = cbf = False

for j, tj in enumerate(items):

if i != j and is_proper_subtype(tj, ti):

# We found a redundant item in the union.

removed.add(j)

cbt = cbt or tj.can_be_true

cbf = cbf or tj.can_be_false

# if deleted subtypes had more general truthiness, use that

if not ti.can_be_true and cbt:

items[i] = true_or_false(ti)

elif not ti.can_be_false and cbf:

items[i] = true_or_false(ti)

simplified_set = [items[i] for i in range(len(items)) if i not in removed]

"""

t = get_proper_type(t)

if not t.can_be_true:

# All values of t are False-ish, so there are no true values in it

return UninhabitedType(line=t.line, column=t.column)

elif not t.can_be_false:

# All values of t are already True-ish, so true_only is idempotent in this case

return t

elif isinstance(t, UnionType):

# The true version of a union type is the union of the true versions of its components

new_items = [true_only(item) for item in t.items]

return make_simplified_union(new_items, line=t.line, column=t.column)

else:

new_t = copy_type(t)

new_t.can_be_false = False

"""

t = get_proper_type(t)

if not t.can_be_false:

if state.strict_optional:

# All values of t are True-ish, so there are no false values in it

return UninhabitedType(line=t.line)

else:

# When strict optional checking is disabled, everything can be

# False-ish since anything can be None

return NoneType(line=t.line)

elif not t.can_be_true:

# All values of t are already False-ish, so false_only is idempotent in this case

return t

elif isinstance(t, UnionType):

# The false version of a union type is the union of the false versions of its components

new_items = [false_only(item) for item in t.items]

return make_simplified_union(new_items, line=t.line, column=t.column)

else:

new_t = copy_type(t)

new_t.can_be_true = False

"""

t = get_proper_type(t)

if isinstance(t, UnionType):

new_items = [true_or_false(item) for item in t.items]

return make_simplified_union(new_items, line=t.line, column=t.column)

new_t = copy_type(t)

new_t.can_be_true = new_t.can_be_true_default()

new_t.can_be_false = new_t.can_be_false_default()

if tdef.values:

return make_simplified_union(tdef.values)

else:

if typ.values:

return make_simplified_union(typ.values)

else:

if func.type:

assert isinstance(func.type, FunctionLike)

return func.type

else:

# Implicit type signature with dynamic types.

if isinstance(func, FuncItem):

return callable_type(func, fallback)

else:

# Broken overloads can have self.type set to None.

# TODO: should we instead always set the type in semantic analyzer?

assert isinstance(func, OverloadedFuncDef)

any_type = AnyType(TypeOfAny.from_error)

dummy = CallableType([any_type, any_type],

[ARG_STAR, ARG_STAR2],

[None, None], any_type,

fallback,

line=func.line, is_ellipsis_args=True)

# Return an Overloaded, because some callers may expect that

# an OverloadedFuncDef has an Overloaded type.

ret_type: Optional[Type] = None) -> CallableType:

# TODO: somewhat unfortunate duplication with prepare_method_signature in semanal

if fdef.info and not fdef.is_static and fdef.arg_names:

self_type = fill_typevars(fdef.info) # type: Type

if fdef.is_class or fdef.name() == '__new__':

self_type = TypeType.make_normalized(self_type)

args = [self_type] + [AnyType(TypeOfAny.unannotated)] * (len(fdef.arg_names)-1)

else:

args = [AnyType(TypeOfAny.unannotated)] * len(fdef.arg_names)

return CallableType(

args,

fdef.arg_kinds,

[None if argument_elide_name(n) else n for n in fdef.arg_names],

ret_type or AnyType(TypeOfAny.unannotated),

fallback,

name=fdef.name(),

line=fdef.line,

column=fdef.column,

implicit=True,

"""If the given expression or type corresponds to a string literal

typ = get_proper_type(typ)

if isinstance(expr, StrExpr):

return [expr.value]

if isinstance(typ, Instance) and typ.last_known_value is not None:

possible_literals = [typ.last_known_value] # type: List[Type]

elif isinstance(typ, UnionType):

possible_literals = list(typ.items)

else:

possible_literals = [typ]

strings = []

for lit in get_proper_types(possible_literals):

if isinstance(lit, LiteralType) and lit.fallback.type.fullname() == 'builtins.str':

val = lit.value

assert isinstance(val, str)

strings.append(val)

else:

return None