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

from __future__ import annotations

import sys

from abc import abstractmethod

from collections.abc import Iterable, Sequence

from typing import (

Any,

ClassVar,

Final,

NewType,

TypeAlias as _TypeAlias,

TypeGuard,

TypeVar,

cast,

overload,

)

from typing_extensions import Self

from librt.internal import (

read_int as read_int_bare,

read_str as read_str_bare,

write_int as write_int_bare,

write_str as write_str_bare,

)

import mypy.nodes

from mypy.bogus_type import Bogus

from mypy.cache import (

DICT_STR_GEN,

END_TAG,

EXTRA_ATTRS,

LIST_GEN,

LITERAL_NONE,

ReadBuffer,

Tag,

WriteBuffer,

read_bool,

read_int,

read_int_list,

read_literal,

read_str,

read_str_list,

read_str_opt,

read_str_opt_list,

read_tag,

write_bool,

write_int,

write_int_list,

write_literal,

write_str,

write_str_list,

write_str_opt,

write_str_opt_list,

write_tag,

)

from mypy.nodes import ARG_KINDS, ARG_POS, ARG_STAR, ARG_STAR2, INVARIANT, ArgKind, SymbolNode

from mypy.options import Options

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 'value_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.

#

# Note: Float values are only used internally. They are not accepted within

# Literal[...].

LiteralValue: _TypeAlias = int | str | bool | float

TUPLE_NAMES: Final = ("builtins.tuple", "typing.Tuple")

TYPE_NAMES: Final = ("builtins.type", "typing.Type")

TYPE_VAR_LIKE_NAMES: Final = (

"typing.TypeVar",

"typing_extensions.TypeVar",

"typing.ParamSpec",

"typing_extensions.ParamSpec",

"typing.TypeVarTuple",

"typing_extensions.TypeVarTuple",

)

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 @type_check_only names.

TYPE_CHECK_ONLY_NAMES: Final = ("typing.type_check_only", "typing_extensions.type_check_only")

# 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")

# Supported Concatenate type names.

CONCATENATE_TYPE_NAMES: Final = ("typing.Concatenate", "typing_extensions.Concatenate")

# Supported Unpack type names.

UNPACK_TYPE_NAMES: Final = ("typing.Unpack", "typing_extensions.Unpack")

# Supported @deprecated decorator names

DEPRECATED_TYPE_NAMES: Final = ("warnings.deprecated", "typing_extensions.deprecated")

# Supported @disjoint_base decorator names

DISJOINT_BASE_DECORATOR_NAMES: Final = ("typing.disjoint_base", "typing_extensions.disjoint_base")

# 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",

)

IMPORTED_REVEAL_TYPE_NAMES: Final = ("typing.reveal_type", "typing_extensions.reveal_type")

REVEAL_TYPE_NAMES: Final = ("builtins.reveal_type", *IMPORTED_REVEAL_TYPE_NAMES)

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

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

NEVER_NAMES: Final = (

"typing.NoReturn",

"typing_extensions.NoReturn",

"mypy_extensions.NoReturn",

"typing.Never",

"typing_extensions.Never",

)

# Mypyc fixed-width native int types (compatible with builtins.int)

MYPYC_NATIVE_INT_NAMES: Final = (

"mypy_extensions.i64",

"mypy_extensions.i32",

"mypy_extensions.i16",

"mypy_extensions.u8",

)

DATACLASS_TRANSFORM_NAMES: Final = (

"typing.dataclass_transform",

"typing_extensions.dataclass_transform",

)

# Supported @override decorator names.

OVERRIDE_DECORATOR_NAMES: Final = ("typing.override", "typing_extensions.override")

ELLIPSIS_TYPE_NAMES: Final = ("builtins.ellipsis", "types.EllipsisType")

NOT_IMPLEMENTED_TYPE_NAMES: Final = ("builtins._NotImplementedType", "types.NotImplementedType")

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

_dummy: Final[Any] = object()

# A placeholder for int parameters

_dummy_int: Final = -999999

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)

# Value of these can be -1 (use the default, lazy init), 0 (false) or 1 (true)

self._can_be_true = -1

self._can_be_false = -1

@property

def can_be_true(self) -> bool:

if self._can_be_true == -1: # Lazy init helps mypyc

self._can_be_true = self.can_be_true_default()

return bool(self._can_be_true)

@can_be_true.setter

def can_be_true(self, v: bool) -> None:

self._can_be_true = v

@property

def can_be_false(self) -> bool:

if self._can_be_false == -1: # Lazy init helps mypyc

self._can_be_false = self.can_be_false_default()

return bool(self._can_be_false)

@can_be_false.setter

def can_be_false(self, v: bool) -> None:

self._can_be_false = v

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", type(self))

def __repr__(self) -> str:

return self.accept(TypeStrVisitor(options=Options()))

def str_with_options(self, options: Options) -> str:

return self.accept(TypeStrVisitor(options=options))

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 write(self, data: WriteBuffer) -> None:

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

@classmethod

def read(cls, data: ReadBuffer) -> Type:

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

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:

super().__init__(line, column)

self.alias = alias

self.args = args

self.type_ref: str | None = None

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)

# TODO: this logic duplicates the one in expand_type_by_instance().

if self.alias.tvar_tuple_index is None:

mapping: dict[TypeVarId, Type] = {

v.id: s for (v, s) in zip(self.alias.alias_tvars, self.args)

}

else:

prefix = self.alias.tvar_tuple_index

suffix = len(self.alias.alias_tvars) - self.alias.tvar_tuple_index - 1

start, middle, end = split_with_prefix_and_suffix(tuple(self.args), prefix, suffix)

tvar = self.alias.alias_tvars[prefix]

assert isinstance(tvar, TypeVarTupleType)

mapping = {tvar.id: TupleType(list(middle), tvar.tuple_fallback)}

for tvar, sub in zip(

self.alias.alias_tvars[:prefix] + self.alias.alias_tvars[prefix + 1 :], start + end

):

mapping[tvar.id] = sub

return self.alias.target.accept(InstantiateAliasVisitor(mapping))

@property

def is_recursive(self) -> bool:

"""Whether this type alias is recursive.

Note this doesn't check generic alias arguments, but only if this alias

*definition* is recursive. The property value thus can be cached on the

underlying TypeAlias node. If you want to include all nested types, use

has_recursive_types() function.

"""

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

is_recursive = self.alias._is_recursive

if is_recursive is None:

is_recursive = self.alias in self.alias.target.accept(CollectAliasesVisitor())

# 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 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

)

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 write(self, data: WriteBuffer) -> None:

write_tag(data, TYPE_ALIAS_TYPE)

write_type_list(data, self.args)

assert self.alias is not None

write_str(data, self.alias.fullname)

write_tag(data, END_TAG)

@classmethod

def read(cls, data: ReadBuffer) -> TypeAliasType:

alias = TypeAliasType(None, read_type_list(data))

alias.type_ref = read_str(data)

assert read_tag(data) == END_TAG

return alias

class TypeGuardedType(Type):

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

__slots__ = ("type_guard",)

def __init__(self, type_guard: Type) -> None:

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})"

# This may hide some real bugs, but it is convenient for various "synthetic"

# visitors, similar to RequiredType and ReadOnlyType below.

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

return self.type_guard.accept(visitor)

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 ReadOnlyType(Type):

"""ReadOnly[T] Only usable at top-level of a TypedDict definition."""

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

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

self.item = item

def __repr__(self) -> str:

return f"ReadOnly[{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: Final[int]

# 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 function/method 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:

# Although this call is not expensive (like UnionType or TypedDictType),

# most of the time we get the same object here, so add a fast path.

if self is other:

return True

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 self.raw_id ^ (self.meta_level << 8) ^ hash(self.namespace)

def is_meta_var(self) -> bool:

return self.meta_level > 0

def is_self(self) -> bool:

# This is a special value indicating typing.Self variable.

return self.raw_id == 0

class TypeVarLikeType(ProperType):

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

name: str # Name (may be qualified)

fullname: str # Fully qualified name

id: TypeVarId

upper_bound: Type

default: Type

def __init__(

self,

name: str,

fullname: str,

id: TypeVarId,

upper_bound: Type,

default: Type,

line: int = -1,

column: int = -1,

) -> None:

super().__init__(line, column)

self.name = name

self.fullname = fullname

self.id = id

self.upper_bound = upper_bound

self.default = default

def serialize(self) -> JsonDict:

raise NotImplementedError

@classmethod

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

raise NotImplementedError

def copy_modified(self, *, id: TypeVarId, **kwargs: Any) -> Self:

raise NotImplementedError

@classmethod

def new_unification_variable(cls, old: Self) -> Self:

new_id = TypeVarId.new(meta_level=1)

return old.copy_modified(id=new_id)

def has_default(self) -> bool:

t = get_proper_type(self.default)

return not (isinstance(t, AnyType) and t.type_of_any == TypeOfAny.from_omitted_generics)

def values_or_bound(self) -> ProperType:

if isinstance(self, TypeVarType) and self.values:

return UnionType(self.values)

return get_proper_type(self.upper_bound)

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,

values: list[Type],

upper_bound: Type,

default: Type,

variance: int = INVARIANT,

line: int = -1,

column: int = -1,

) -> None:

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

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

self.values = values

self.variance = variance

def copy_modified(

self,

*,

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

upper_bound: Bogus[Type] = _dummy,

default: Bogus[Type] = _dummy,

id: Bogus[TypeVarId] = _dummy,

line: int = _dummy_int,

column: int = _dummy_int,

**kwargs: Any,

) -> TypeVarType:

return TypeVarType(

name=self.name,

fullname=self.fullname,

id=self.id if id is _dummy else id,

values=self.values if values is _dummy else values,

upper_bound=self.upper_bound if upper_bound is _dummy else upper_bound,

default=self.default if default is _dummy else default,

variance=self.variance,

line=self.line if line == _dummy_int else line,

column=self.column if column == _dummy_int 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, tuple(self.values)))

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

and self.values == other.values

)

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(),

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

"variance": self.variance,

}

@classmethod

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

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

return TypeVarType(

name=data["name"],

fullname=data["fullname"],

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

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

upper_bound=deserialize_type(data["upper_bound"]),

default=deserialize_type(data["default"]),

variance=data["variance"],

)

def write(self, data: WriteBuffer) -> None:

write_tag(data, TYPE_VAR_TYPE)

write_str(data, self.name)

write_str(data, self.fullname)

write_int(data, self.id.raw_id)

write_str(data, self.id.namespace)

write_type_list(data, self.values)

self.upper_bound.write(data)

self.default.write(data)

write_int(data, self.variance)

write_tag(data, END_TAG)

@classmethod

def read(cls, data: ReadBuffer) -> TypeVarType:

ret = TypeVarType(

read_str(data),

read_str(data),

TypeVarId(read_int(data), namespace=read_str(data)),

read_type_list(data),

read_type(data),

read_type(data),

read_int(data),

)

assert read_tag(data) == END_TAG

return ret

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,

flavor: int,

upper_bound: Type,

default: Type,

*,

line: int = -1,

column: int = -1,

prefix: Parameters | None = None,

) -> None:

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

self.flavor = flavor

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

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

return ParamSpecType(

self.name,

self.fullname,

self.id,

flavor,

upper_bound=self.upper_bound,

default=self.default,

prefix=self.prefix,

)

def copy_modified(

self,

*,

id: Bogus[TypeVarId] = _dummy,

flavor: int = _dummy_int,

prefix: Bogus[Parameters] = _dummy,

default: Bogus[Type] = _dummy,

**kwargs: Any,

) -> ParamSpecType:

return ParamSpecType(

self.name,

self.fullname,

id if id is not _dummy else self.id,

flavor if flavor != _dummy_int else self.flavor,

self.upper_bound,

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

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, self.prefix))

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 and self.prefix == other.prefix

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,

"namespace": self.id.namespace,

"flavor": self.flavor,

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

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

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

}

@classmethod

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

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

return ParamSpecType(

data["name"],

data["fullname"],

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

data["flavor"],

deserialize_type(data["upper_bound"]),

deserialize_type(data["default"]),

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

)

def write(self, data: WriteBuffer) -> None:

write_tag(data, PARAM_SPEC_TYPE)

self.prefix.write(data)

write_str(data, self.name)

write_str(data, self.fullname)

write_int(data, self.id.raw_id)

write_str(data, self.id.namespace)

write_int(data, self.flavor)

self.upper_bound.write(data)

self.default.write(data)

write_tag(data, END_TAG)

@classmethod

def read(cls, data: ReadBuffer) -> ParamSpecType:

assert read_tag(data) == PARAMETERS

prefix = Parameters.read(data)

ret = ParamSpecType(

read_str(data),

read_str(data),

TypeVarId(read_int(data), namespace=read_str(data)),

read_int(data),

read_type(data),

read_type(data),

prefix=prefix,

)

assert read_tag(data) == END_TAG

return ret

class TypeVarTupleType(TypeVarLikeType):

"""Type that refers to a TypeVarTuple.

See PEP646 for more information.

"""

__slots__ = ("tuple_fallback", "min_len")

def __init__(

self,

name: str,

fullname: str,

id: TypeVarId,

upper_bound: Type,

tuple_fallback: Instance,

default: Type,

*,

line: int = -1,

column: int = -1,

min_len: int = 0,

) -> None:

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

self.tuple_fallback = tuple_fallback

# This value is not settable by a user. It is an internal-only thing to support

# len()-narrowing of variadic tuples.

self.min_len = min_len

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,

"namespace": self.id.namespace,

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

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

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

"min_len": self.min_len,

}

@classmethod

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

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

return TypeVarTupleType(

data["name"],

data["fullname"],

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

deserialize_type(data["upper_bound"]),

Instance.deserialize(data["tuple_fallback"]),

deserialize_type(data["default"]),

min_len=data["min_len"],

)

def write(self, data: WriteBuffer) -> None:

write_tag(data, TYPE_VAR_TUPLE_TYPE)

self.tuple_fallback.write(data)

write_str(data, self.name)

write_str(data, self.fullname)

write_int(data, self.id.raw_id)

write_str(data, self.id.namespace)

self.upper_bound.write(data)

self.default.write(data)

write_int(data, self.min_len)

write_tag(data, END_TAG)

@classmethod

def read(cls, data: ReadBuffer) -> TypeVarTupleType:

assert read_tag(data) == INSTANCE

fallback = Instance.read(data)

ret = TypeVarTupleType(

read_str(data),

read_str(data),

TypeVarId(read_int(data), namespace=read_str(data)),

read_type(data),

fallback,

read_type(data),

min_len=read_int(data),

)

assert read_tag(data) == END_TAG

return ret

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

return visitor.visit_type_var_tuple(self)

def __hash__(self) -> int: