"""Classes for representing mypy types."""

from __future__ import annotations

import sys

from abc import abstractmethod

from typing import (

TYPE_CHECKING,

Any,

ClassVar,

Dict,

Iterable,

NamedTuple,

NewType,

Sequence,

TypeVar,

Union,

cast,

)

from typing_extensions import Final, TypeAlias as _TypeAlias, TypeGuard, overload

import mypy.nodes

from mypy.bogus_type import Bogus

from mypy.nodes import (

ARG_POS,

ARG_STAR,

ARG_STAR2,

INVARIANT,

ArgKind,

FakeInfo,

FuncDef,

SymbolNode,

)

from mypy.state import state

from mypy.util import IdMapper

T = TypeVar("T")

JsonDict: _TypeAlias = Dict[str, Any]

# The set of all valid expressions that can currently be contained

# inside of a Literal[...].

#

# Literals can contain bytes and enum-values: we special-case both of these

# and store the value as a string. We rely on the fallback type that's also

# stored with the Literal to determine how a string is being used.

#

# TODO: confirm that we're happy with representing enums (and the

# other types) in the manner described above.

#

# Note: if we change the set of types included below, we must also

# make sure to audit the following methods:

#

# 1. types.LiteralType's serialize and deserialize methods: this method

# needs to make sure it can convert the below types into JSON and back.

#

# 2. types.LiteralType's 'alue_repr` method: this method is ultimately used

# by TypeStrVisitor's visit_literal_type to generate a reasonable

# repr-able output.

#

# 3. server.astdiff.SnapshotTypeVisitor's visit_literal_type_method: this

# method assumes that the following types supports equality checks and

# hashability.

#

# Note: Although "Literal[None]" is a valid type, we internally always convert

# such a type directly into "None". So, "None" is not a valid parameter of

# LiteralType and is omitted from this list.

LiteralValue: _TypeAlias = Union[int, str, bool]

# If we only import type_visitor in the middle of the file, mypy

# breaks, and if we do it at the top, it breaks at runtime because of

# import cycle issues, so we do it at the top while typechecking and

# then again in the middle at runtime.

# We should be able to remove this once we are switched to the new

# semantic analyzer!

if TYPE_CHECKING:

from mypy.type_visitor import (

SyntheticTypeVisitor as SyntheticTypeVisitor,

TypeVisitor as TypeVisitor,

)

TYPED_NAMEDTUPLE_NAMES: Final = ("typing.NamedTuple", "typing_extensions.NamedTuple")

# Supported names of TypedDict type constructors.

TPDICT_NAMES: Final = (

"typing.TypedDict",

"typing_extensions.TypedDict",

"mypy_extensions.TypedDict",

)

# Supported fallback instance type names for TypedDict types.

TPDICT_FB_NAMES: Final = (

"typing._TypedDict",

"typing_extensions._TypedDict",

"mypy_extensions._TypedDict",

)

# Supported names of Protocol base class.

PROTOCOL_NAMES: Final = ("typing.Protocol", "typing_extensions.Protocol")

# Supported TypeAlias names.

TYPE_ALIAS_NAMES: Final = ("typing.TypeAlias", "typing_extensions.TypeAlias")

# Supported Final type names.

FINAL_TYPE_NAMES: Final = ("typing.Final", "typing_extensions.Final")

# Supported @final decorator names.

FINAL_DECORATOR_NAMES: Final = ("typing.final", "typing_extensions.final")

# Supported Literal type names.

LITERAL_TYPE_NAMES: Final = ("typing.Literal", "typing_extensions.Literal")

# Supported Annotated type names.

ANNOTATED_TYPE_NAMES: Final = ("typing.Annotated", "typing_extensions.Annotated")

# We use this constant in various places when checking `tuple` subtyping:

TUPLE_LIKE_INSTANCE_NAMES: Final = (

"builtins.tuple",

"typing.Iterable",

"typing.Container",

"typing.Sequence",

"typing.Reversible",

)

REVEAL_TYPE_NAMES: Final = (

"builtins.reveal_type",

"typing.reveal_type",

"typing_extensions.reveal_type",

)

ASSERT_TYPE_NAMES: Final = ("typing.assert_type", "typing_extensions.assert_type")

OVERLOAD_NAMES: Final = ("typing.overload", "typing_extensions.overload")

# Attributes that can optionally be defined in the body of a subclass of

# enum.Enum but are removed from the class __dict__ by EnumMeta.

ENUM_REMOVED_PROPS: Final = ("_ignore_", "_order_", "__order__")

NEVER_NAMES: Final = (

"typing.NoReturn",

"typing_extensions.NoReturn",

"mypy_extensions.NoReturn",

"typing.Never",

"typing_extensions.Never",

)

# A placeholder used for Bogus[...] parameters

_dummy: Final[Any] = object()

class TypeOfAny:

"""

This class describes different types of Any. Each 'Any' can be of only one type at a time.

"""

__slots__ = ()

# Was this Any type inferred without a type annotation?

unannotated: Final = 1

# Does this Any come from an explicit type annotation?

explicit: Final = 2

# Does this come from an unfollowed import? See --disallow-any-unimported option

from_unimported_type: Final = 3

# Does this Any type come from omitted generics?

from_omitted_generics: Final = 4

# Does this Any come from an error?

from_error: Final = 5

# Is this a type that can't be represented in mypy's type system? For instance, type of

# call to NewType...). Even though these types aren't real Anys, we treat them as such.

# Also used for variables named '_'.

special_form: Final = 6

# Does this Any come from interaction with another Any?

from_another_any: Final = 7

# Does this Any come from an implementation limitation/bug?

implementation_artifact: Final = 8

# Does this Any come from use in the suggestion engine? This is

# used to ignore Anys inserted by the suggestion engine when

# generating constraints.

suggestion_engine: Final = 9

def deserialize_type(data: JsonDict | str) -> Type:

if isinstance(data, str):

return Instance.deserialize(data)

classname = data[".class"]

method = deserialize_map.get(classname)

if method is not None:

return method(data)

raise NotImplementedError(f"unexpected .class {classname}")

class Type(mypy.nodes.Context):

"""Abstract base class for all types."""

__slots__ = ("can_be_true", "can_be_false")

# 'can_be_true' and 'can_be_false' mean whether the value of the

# expression can be true or false in a boolean context. They are useful

# when inferring the type of logic expressions like `x and y`.

#

# For example:

# * the literal `False` can't be true while `True` can.

# * a value with type `bool` can be true or false.

# * `None` can't be true

# * ...

def __init__(self, line: int = -1, column: int = -1) -> None:

super().__init__(line, column)

self.can_be_true = self.can_be_true_default()

self.can_be_false = self.can_be_false_default()

def can_be_true_default(self) -> bool:

return True

def can_be_false_default(self) -> bool:

return True

def accept(self, visitor: TypeVisitor[T]) -> T:

raise RuntimeError("Not implemented")

def __repr__(self) -> str:

return self.accept(TypeStrVisitor())

def serialize(self) -> JsonDict | str:

raise NotImplementedError(f"Cannot serialize {self.__class__.__name__} instance")

@classmethod

def deserialize(cls, data: JsonDict) -> Type:

raise NotImplementedError(f"Cannot deserialize {cls.__name__} instance")

def is_singleton_type(self) -> bool:

return False

class TypeAliasType(Type):

"""A type alias to another type.

To support recursive type aliases we don't immediately expand a type alias

during semantic analysis, but create an instance of this type that records the target alias

definition node (mypy.nodes.TypeAlias) and type arguments (for generic aliases).

This is very similar to how TypeInfo vs Instance interact, where a recursive class-based

structure like

class Node:

value: int

children: List[Node]

can be represented in a tree-like manner.

"""

__slots__ = ("alias", "args", "type_ref")

def __init__(

self,

alias: mypy.nodes.TypeAlias | None,

args: list[Type],

line: int = -1,

column: int = -1,

) -> None:

self.alias = alias

self.args = args

self.type_ref: str | None = None

super().__init__(line, column)

def _expand_once(self) -> Type:

"""Expand to the target type exactly once.

This doesn't do full expansion, i.e. the result can contain another

(or even this same) type alias. Use this internal helper only when really needed,

its public wrapper mypy.types.get_proper_type() is preferred.

"""

assert self.alias is not None

if self.alias.no_args:

# We know that no_args=True aliases like L = List must have an instance

# as their target.

assert isinstance(self.alias.target, Instance) # type: ignore[misc]

return self.alias.target.copy_modified(args=self.args)

return replace_alias_tvars(

self.alias.target, self.alias.alias_tvars, self.args, self.line, self.column

)

def _partial_expansion(self) -> tuple[ProperType, bool]:

# Private method mostly for debugging and testing.

unroller = UnrollAliasVisitor(set())

unrolled = self.accept(unroller)

assert isinstance(unrolled, ProperType)

return unrolled, unroller.recursed

def expand_all_if_possible(self) -> ProperType | None:

"""Attempt a full expansion of the type alias (including nested aliases).

If the expansion is not possible, i.e. the alias is (mutually-)recursive,

return None.

"""

unrolled, recursed = self._partial_expansion()

if recursed:

return None

return unrolled

@property

def is_recursive(self) -> bool:

assert self.alias is not None, "Unfixed type alias"

is_recursive = self.alias._is_recursive

if is_recursive is None:

is_recursive = self.expand_all_if_possible() is None

# We cache the value on the underlying TypeAlias node as an optimization,

# since the value is the same for all instances of the same alias.

self.alias._is_recursive = is_recursive

return is_recursive

def can_be_true_default(self) -> bool:

if self.alias is not None:

return self.alias.target.can_be_true

return super().can_be_true_default()

def can_be_false_default(self) -> bool:

if self.alias is not None:

return self.alias.target.can_be_false

return super().can_be_false_default()

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_type_alias_type(self)

def __hash__(self) -> int:

return hash((self.alias, tuple(self.args)))

def __eq__(self, other: object) -> bool:

# Note: never use this to determine subtype relationships, use is_subtype().

if not isinstance(other, TypeAliasType):

return NotImplemented

return self.alias == other.alias and self.args == other.args

def serialize(self) -> JsonDict:

assert self.alias is not None

data: JsonDict = {

".class": "TypeAliasType",

"type_ref": self.alias.fullname,

"args": [arg.serialize() for arg in self.args],

}

return data

@classmethod

def deserialize(cls, data: JsonDict) -> TypeAliasType:

assert data[".class"] == "TypeAliasType"

args: list[Type] = []

if "args" in data:

args_list = data["args"]

assert isinstance(args_list, list)

args = [deserialize_type(arg) for arg in args_list]

alias = TypeAliasType(None, args)

alias.type_ref = data["type_ref"]

return alias

def copy_modified(self, *, args: list[Type] | None = None) -> TypeAliasType:

return TypeAliasType(

self.alias, args if args is not None else self.args.copy(), self.line, self.column

)

class TypeGuardedType(Type):

"""Only used by find_isinstance_check() etc."""

__slots__ = ("type_guard",)

def __init__(self, type_guard: Type):

super().__init__(line=type_guard.line, column=type_guard.column)

self.type_guard = type_guard

def __repr__(self) -> str:

return f"TypeGuard({self.type_guard})"

class RequiredType(Type):

"""Required[T] or NotRequired[T]. Only usable at top-level of a TypedDict definition."""

def __init__(self, item: Type, *, required: bool) -> None:

super().__init__(line=item.line, column=item.column)

self.item = item

self.required = required

def __repr__(self) -> str:

if self.required:

return f"Required[{self.item}]"

else:

return f"NotRequired[{self.item}]"

def accept(self, visitor: TypeVisitor[T]) -> T:

return self.item.accept(visitor)

class ProperType(Type):

"""Not a type alias.

Every type except TypeAliasType must inherit from this type.

"""

__slots__ = ()

class TypeVarId:

# A type variable is uniquely identified by its raw id and meta level.

# For plain variables (type parameters of generic classes and

# functions) raw ids are allocated by semantic analysis, using

# positive ids 1, 2, ... for generic class parameters and negative

# ids -1, ... for generic function type arguments. A special value 0

# is reserved for Self type variable (autogenerated). This convention

# is only used to keep type variable ids distinct when allocating

# them; the type checker makes no distinction between class and

# function type variables.

# Metavariables are allocated unique ids starting from 1.

raw_id: int = 0

# Level of the variable in type inference. Currently either 0 for

# declared types, or 1 for type inference metavariables.

meta_level: int = 0

# Class variable used for allocating fresh ids for metavariables.

next_raw_id: ClassVar[int] = 1

# Fullname of class (or potentially function in the future) which

# declares this type variable (not the fullname of the TypeVar

# definition!), or ''

namespace: str

def __init__(self, raw_id: int, meta_level: int = 0, *, namespace: str = "") -> None:

self.raw_id = raw_id

self.meta_level = meta_level

self.namespace = namespace

@staticmethod

def new(meta_level: int) -> TypeVarId:

raw_id = TypeVarId.next_raw_id

TypeVarId.next_raw_id += 1

return TypeVarId(raw_id, meta_level)

def __repr__(self) -> str:

return self.raw_id.__repr__()

def __eq__(self, other: object) -> bool:

return (

isinstance(other, TypeVarId)

and self.raw_id == other.raw_id

and self.meta_level == other.meta_level

and self.namespace == other.namespace

)

def __ne__(self, other: object) -> bool:

return not (self == other)

def __hash__(self) -> int:

return hash((self.raw_id, self.meta_level, self.namespace))

def is_meta_var(self) -> bool:

return self.meta_level > 0

class TypeVarLikeType(ProperType):

__slots__ = ("name", "fullname", "id", "upper_bound")

name: str # Name (may be qualified)

fullname: str # Fully qualified name

id: TypeVarId

upper_bound: Type

def __init__(

self,

name: str,

fullname: str,

id: TypeVarId | int,

upper_bound: Type,

line: int = -1,

column: int = -1,

) -> None:

super().__init__(line, column)

self.name = name

self.fullname = fullname

if isinstance(id, int):

id = TypeVarId(id)

self.id = id

self.upper_bound = upper_bound

def serialize(self) -> JsonDict:

raise NotImplementedError

@classmethod

def deserialize(cls, data: JsonDict) -> TypeVarLikeType:

raise NotImplementedError

class TypeVarType(TypeVarLikeType):

"""Type that refers to a type variable."""

__slots__ = ("values", "variance")

values: list[Type] # Value restriction, empty list if no restriction

variance: int

def __init__(

self,

name: str,

fullname: str,

id: TypeVarId | int,

values: list[Type],

upper_bound: Type,

variance: int = INVARIANT,

line: int = -1,

column: int = -1,

) -> None:

super().__init__(name, fullname, id, upper_bound, line, column)

assert values is not None, "No restrictions must be represented by empty list"

self.values = values

self.variance = variance

@staticmethod

def new_unification_variable(old: TypeVarType) -> TypeVarType:

new_id = TypeVarId.new(meta_level=1)

return old.copy_modified(id=new_id)

def copy_modified(

self,

values: Bogus[list[Type]] = _dummy,

upper_bound: Bogus[Type] = _dummy,

id: Bogus[TypeVarId | int] = _dummy,

line: Bogus[int] = _dummy,

column: Bogus[int] = _dummy,

) -> TypeVarType:

return TypeVarType(

self.name,

self.fullname,

self.id if id is _dummy else id,

self.values if values is _dummy else values,

self.upper_bound if upper_bound is _dummy else upper_bound,

self.variance,

self.line if line is _dummy else line,

self.column if column is _dummy else column,

)

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_type_var(self)

def __hash__(self) -> int:

return hash((self.id, self.upper_bound))

def __eq__(self, other: object) -> bool:

if not isinstance(other, TypeVarType):

return NotImplemented

return self.id == other.id and self.upper_bound == other.upper_bound

def serialize(self) -> JsonDict:

assert not self.id.is_meta_var()

return {

".class": "TypeVarType",

"name": self.name,

"fullname": self.fullname,

"id": self.id.raw_id,

"namespace": self.id.namespace,

"values": [v.serialize() for v in self.values],

"upper_bound": self.upper_bound.serialize(),

"variance": self.variance,

}

@classmethod

def deserialize(cls, data: JsonDict) -> TypeVarType:

assert data[".class"] == "TypeVarType"

return TypeVarType(

data["name"],

data["fullname"],

TypeVarId(data["id"], namespace=data["namespace"]),

[deserialize_type(v) for v in data["values"]],

deserialize_type(data["upper_bound"]),

data["variance"],

)

class ParamSpecFlavor:

# Simple ParamSpec reference such as "P"

BARE: Final = 0

# P.args

ARGS: Final = 1

# P.kwargs

KWARGS: Final = 2

class ParamSpecType(TypeVarLikeType):

"""Type that refers to a ParamSpec.

A ParamSpec is a type variable that represents the parameter

types, names and kinds of a callable (i.e., the signature without

the return type).

This can be one of these forms

* P (ParamSpecFlavor.BARE)

* P.args (ParamSpecFlavor.ARGS)

* P.kwargs (ParamSpecFLavor.KWARGS)

The upper_bound is really used as a fallback type -- it's shared

with TypeVarType for simplicity. It can't be specified by the user

and the value is directly derived from the flavor (currently

always just 'object').

"""

__slots__ = ("flavor", "prefix")

flavor: int

prefix: Parameters

def __init__(

self,

name: str,

fullname: str,

id: TypeVarId | int,

flavor: int,

upper_bound: Type,

*,

line: int = -1,

column: int = -1,

prefix: Parameters | None = None,

) -> None:

super().__init__(name, fullname, id, upper_bound, line=line, column=column)

self.flavor = flavor

self.prefix = prefix or Parameters([], [], [])

@staticmethod

def new_unification_variable(old: ParamSpecType) -> ParamSpecType:

new_id = TypeVarId.new(meta_level=1)

return old.copy_modified(id=new_id)

def with_flavor(self, flavor: int) -> ParamSpecType:

return ParamSpecType(

self.name,

self.fullname,

self.id,

flavor,

upper_bound=self.upper_bound,

prefix=self.prefix,

)

def copy_modified(

self,

*,

id: Bogus[TypeVarId | int] = _dummy,

flavor: Bogus[int] = _dummy,

prefix: Bogus[Parameters] = _dummy,

) -> ParamSpecType:

return ParamSpecType(

self.name,

self.fullname,

id if id is not _dummy else self.id,

flavor if flavor is not _dummy else self.flavor,

self.upper_bound,

line=self.line,

column=self.column,

prefix=prefix if prefix is not _dummy else self.prefix,

)

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_param_spec(self)

def name_with_suffix(self) -> str:

n = self.name

if self.flavor == ParamSpecFlavor.ARGS:

return f"{n}.args"

elif self.flavor == ParamSpecFlavor.KWARGS:

return f"{n}.kwargs"

return n

def __hash__(self) -> int:

return hash((self.id, self.flavor))

def __eq__(self, other: object) -> bool:

if not isinstance(other, ParamSpecType):

return NotImplemented

# Upper bound can be ignored, since it's determined by flavor.

return self.id == other.id and self.flavor == other.flavor

def serialize(self) -> JsonDict:

assert not self.id.is_meta_var()

return {

".class": "ParamSpecType",

"name": self.name,

"fullname": self.fullname,

"id": self.id.raw_id,

"flavor": self.flavor,

"upper_bound": self.upper_bound.serialize(),

"prefix": self.prefix.serialize(),

}

@classmethod

def deserialize(cls, data: JsonDict) -> ParamSpecType:

assert data[".class"] == "ParamSpecType"

return ParamSpecType(

data["name"],

data["fullname"],

data["id"],

data["flavor"],

deserialize_type(data["upper_bound"]),

prefix=Parameters.deserialize(data["prefix"]),

)

class TypeVarTupleType(TypeVarLikeType):

"""Type that refers to a TypeVarTuple.

See PEP646 for more information.

"""

def serialize(self) -> JsonDict:

assert not self.id.is_meta_var()

return {

".class": "TypeVarTupleType",

"name": self.name,

"fullname": self.fullname,

"id": self.id.raw_id,

"upper_bound": self.upper_bound.serialize(),

}

@classmethod

def deserialize(cls, data: JsonDict) -> TypeVarTupleType:

assert data[".class"] == "TypeVarTupleType"

return TypeVarTupleType(

data["name"], data["fullname"], data["id"], deserialize_type(data["upper_bound"])

)

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_type_var_tuple(self)

def __hash__(self) -> int:

return hash(self.id)

def __eq__(self, other: object) -> bool:

if not isinstance(other, TypeVarTupleType):

return NotImplemented

return self.id == other.id

@staticmethod

def new_unification_variable(old: TypeVarTupleType) -> TypeVarTupleType:

new_id = TypeVarId.new(meta_level=1)

return old.copy_modified(id=new_id)

def copy_modified(self, id: Bogus[TypeVarId | int] = _dummy) -> TypeVarTupleType:

return TypeVarTupleType(

self.name,

self.fullname,

self.id if id is _dummy else id,

self.upper_bound,

line=self.line,

column=self.column,

)

class UnboundType(ProperType):

"""Instance type that has not been bound during semantic analysis."""

__slots__ = (

"name",

"args",

"optional",

"empty_tuple_index",

"original_str_expr",

"original_str_fallback",

)

def __init__(

self,

name: str | None,

args: Sequence[Type] | None = None,

line: int = -1,

column: int = -1,

optional: bool = False,

empty_tuple_index: bool = False,

original_str_expr: str | None = None,

original_str_fallback: str | None = None,

) -> None:

super().__init__(line, column)

if not args:

args = []

assert name is not None

self.name = name

self.args = tuple(args)

# Should this type be wrapped in an Optional?

self.optional = optional

# Special case for X[()]

self.empty_tuple_index = empty_tuple_index

# If this UnboundType was originally defined as a str or bytes, keep track of

# the original contents of that string-like thing. This way, if this UnboundExpr

# ever shows up inside of a LiteralType, we can determine whether that

# Literal[...] is valid or not. E.g. Literal[foo] is most likely invalid

# (unless 'foo' is an alias for another literal or something) and

# Literal["foo"] most likely is.

#

# We keep track of the entire string instead of just using a boolean flag

# so we can distinguish between things like Literal["foo"] vs

# Literal[" foo "].

#

# We also keep track of what the original base fallback type was supposed to be

# so we don't have to try and recompute it later

self.original_str_expr = original_str_expr

self.original_str_fallback = original_str_fallback

def copy_modified(self, args: Bogus[Sequence[Type] | None] = _dummy) -> UnboundType:

if args is _dummy:

args = self.args

return UnboundType(

name=self.name,

args=args,

line=self.line,

column=self.column,

optional=self.optional,

empty_tuple_index=self.empty_tuple_index,

original_str_expr=self.original_str_expr,

original_str_fallback=self.original_str_fallback,

)

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_unbound_type(self)

def __hash__(self) -> int:

return hash((self.name, self.optional, tuple(self.args), self.original_str_expr))

def __eq__(self, other: object) -> bool:

if not isinstance(other, UnboundType):

return NotImplemented

return (

self.name == other.name

and self.optional == other.optional

and self.args == other.args

and self.original_str_expr == other.original_str_expr

and self.original_str_fallback == other.original_str_fallback

)

def serialize(self) -> JsonDict:

return {

".class": "UnboundType",

"name": self.name,

"args": [a.serialize() for a in self.args],

"expr": self.original_str_expr,

"expr_fallback": self.original_str_fallback,

}

@classmethod

def deserialize(cls, data: JsonDict) -> UnboundType:

assert data[".class"] == "UnboundType"

return UnboundType(

data["name"],

[deserialize_type(a) for a in data["args"]],

original_str_expr=data["expr"],

original_str_fallback=data["expr_fallback"],

)

class CallableArgument(ProperType):

"""Represents a Arg(type, 'name') inside a Callable's type list.

Note that this is a synthetic type for helping parse ASTs, not a real type.

"""

__slots__ = ("typ", "name", "constructor")

typ: Type

name: str | None

constructor: str | None

def __init__(

self,

typ: Type,

name: str | None,

constructor: str | None,

line: int = -1,

column: int = -1,

) -> None:

super().__init__(line, column)

self.typ = typ

self.name = name

self.constructor = constructor

def accept(self, visitor: TypeVisitor[T]) -> T:

assert isinstance(visitor, SyntheticTypeVisitor)

return cast(T, visitor.visit_callable_argument(self))

def serialize(self) -> JsonDict:

assert False, "Synthetic types don't serialize"

class TypeList(ProperType):

"""Information about argument types and names [...].

This is used for the arguments of a Callable type, i.e. for

[arg, ...] in Callable[[arg, ...], ret]. This is not a real type

but a syntactic AST construct. UnboundTypes can also have TypeList

types before they are processed into Callable types.

"""

__slots__ = ("items",)

items: list[Type]

def __init__(self, items: list[Type], line: int = -1, column: int = -1) -> None:

super().__init__(line, column)

self.items = items

def accept(self, visitor: TypeVisitor[T]) -> T:

assert isinstance(visitor, SyntheticTypeVisitor)

return cast(T, visitor.visit_type_list(self))

def serialize(self) -> JsonDict:

assert False, "Synthetic types don't serialize"

def __hash__(self) -> int:

return hash(tuple(self.items))

def __eq__(self, other: object) -> bool:

return isinstance(other, TypeList) and self.items == other.items

class UnpackType(ProperType):

"""Type operator Unpack from PEP646. Can be either with Unpack[]

or unpacking * syntax.

The inner type should be either a TypeVarTuple, a constant size

tuple, or a variable length tuple, or a union of one of those.

"""

__slots__ = ["type"]

def __init__(self, typ: Type, line: int = -1, column: int = -1) -> None:

super().__init__(line, column)

self.type = typ

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_unpack_type(self)

def serialize(self) -> JsonDict:

return {".class": "UnpackType", "type": self.type.serialize()}

@classmethod

def deserialize(cls, data: JsonDict) -> UnpackType:

assert data[".class"] == "UnpackType"

typ = data["type"]

return UnpackType(deserialize_type(typ))

class AnyType(ProperType):

"""The type 'Any'."""

__slots__ = ("type_of_any", "source_any", "missing_import_name")

def __init__(

self,

type_of_any: int,

source_any: AnyType | None = None,

missing_import_name: str | None = None,

line: int = -1,

column: int = -1,

) -> None:

super().__init__(line, column)

self.type_of_any = type_of_any

# If this Any was created as a result of interacting with another 'Any', record the source

# and use it in reports.

self.source_any = source_any

if source_any and source_any.source_any:

self.source_any = source_any.source_any

if source_any is None:

self.missing_import_name = missing_import_name

else:

self.missing_import_name = source_any.missing_import_name

# Only unimported type anys and anys from other anys should have an import name

assert missing_import_name is None or type_of_any in (

TypeOfAny.from_unimported_type,

TypeOfAny.from_another_any,

)

# Only Anys that come from another Any can have source_any.

assert type_of_any != TypeOfAny.from_another_any or source_any is not None

# We should not have chains of Anys.

assert not self.source_any or self.source_any.type_of_any != TypeOfAny.from_another_any

@property

def is_from_error(self) -> bool:

return self.type_of_any == TypeOfAny.from_error

def accept(self, visitor: TypeVisitor[T]) -> T:

return visitor.visit_any(self)

def copy_modified(

self,

# Mark with Bogus because _dummy is just an object (with type Any)

type_of_any: Bogus[int] = _dummy,

original_any: Bogus[AnyType | None] = _dummy,

) -> AnyType:

if type_of_any is _dummy:

type_of_any = self.type_of_any

if original_any is _dummy:

original_any = self.source_any

return AnyType(

type_of_any=type_of_any,

source_any=original_any,

missing_import_name=self.missing_import_name,