"""

# Was this Any type inferred without a type annotation?

unannotated = 1 # type: Final

# Does this Any come from an explicit type annotation?

explicit = 2 # type: Final

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

from_unimported_type = 3 # type: Final

# Does this Any type come from omitted generics?

from_omitted_generics = 4 # type: Final

# Does this Any come from an error?

from_error = 5 # type: Final

# 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 = 6 # type: Final

# Does this Any come from interaction with another Any?

from_another_any = 7 # type: Final

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

if isinstance(data, str):

return Instance.deserialize(data)

classname = data['.class']

method = deserialize_map.get(classname)

if method is not None:

return method(data)

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

__slots__ = ('can_be_true', 'can_be_false')

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) -> Union[JsonDict, str]:

raise NotImplementedError('Cannot serialize {} instance'.format(self.__class__.__name__))

@classmethod

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

"""A type alias to another type.

def __init__(self, alias: Optional[mypy.nodes.TypeAlias], args: List[Type],

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

super().__init__(line, column)

self.alias = alias

self.args = args

self.type_ref = None # type: Optional[str]

def _expand_once(self) -> Type:

"""Expand to the target type exactly once.

assert self.alias is not None

return replace_alias_tvars(self.alias.target, self.alias.alias_tvars, self.args,

self.line, self.column)

def expand_all_if_possible(self) -> Optional['ProperType']:

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

raise NotImplementedError('TODO')

# TODO: remove ignore caused by https://github.com/python/mypy/issues/6759

@property

def can_be_true(self) -> bool: # type: ignore[override]

assert self.alias is not None

return self.alias.target.can_be_true

# TODO: remove ignore caused by https://github.com/python/mypy/issues/6759

@property

def can_be_false(self) -> bool: # type: ignore[override]

assert self.alias is not None

return self.alias.target.can_be_false

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:

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 = {'.class': 'TypeAliasType',

'type_ref': self.alias.fullname(),

'args': [arg.serialize() for arg in self.args]} # type: JsonDict

return data

@classmethod

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

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

args = [] # type: 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'] # TODO: fix this up in fixup.py.

return alias

def copy_modified(self, *,

args: Optional[List[Type]] = None) -> 'TypeAliasType':

return TypeAliasType(

self.alias,

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

"""Not a type alias.

# 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. 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 = 0 # type: int

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

# declared types, or 1 for type inference metavariables.

meta_level = 0 # type: int

# Class variable used for allocating fresh ids for metavariables.

next_raw_id = 1 # type: ClassVar[int]

def __init__(self, raw_id: int, meta_level: int = 0) -> None:

self.raw_id = raw_id

self.meta_level = meta_level

@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:

if isinstance(other, TypeVarId):

return (self.raw_id == other.raw_id and

self.meta_level == other.meta_level)

else:

return False

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

return not (self == other)

def __hash__(self) -> int:

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

def is_meta_var(self) -> bool:

"""Definition of a single type variable."""

name = '' # Name (may be qualified)

fullname = '' # Fully qualified name

id = None # type: TypeVarId

values = None # type: List[Type] # Value restriction, empty list if no restriction

upper_bound = None # type: Type

variance = INVARIANT # type: int

def __init__(self, name: str, fullname: str, id: Union[TypeVarId, int], values: List[Type],

upper_bound: Type, variance: int = INVARIANT, line: int = -1,

column: int = -1) -> None:

super().__init__(line, column)

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

self.name = name

self.fullname = fullname

if isinstance(id, int):

id = TypeVarId(id)

self.id = id

self.values = values

self.upper_bound = upper_bound

self.variance = variance

@staticmethod

def new_unification_variable(old: 'TypeVarDef') -> 'TypeVarDef':

new_id = TypeVarId.new(meta_level=1)

return TypeVarDef(old.name, old.fullname, new_id, old.values,

old.upper_bound, old.variance, old.line, old.column)

def __repr__(self) -> str:

if self.values:

return '{} in {}'.format(self.name, tuple(self.values))

elif not is_named_instance(self.upper_bound, 'builtins.object'):

return '{} <: {}'.format(self.name, self.upper_bound)

else:

return self.name

def serialize(self) -> JsonDict:

assert not self.id.is_meta_var()

return {'.class': 'TypeVarDef',

'name': self.name,

'fullname': self.fullname,

'id': self.id.raw_id,

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

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

'variance': self.variance,

}

@classmethod

def deserialize(cls, data: JsonDict) -> 'TypeVarDef':

assert data['.class'] == 'TypeVarDef'

return TypeVarDef(data['name'],

data['fullname'],

data['id'],

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

deserialize_type(data['upper_bound']),

data['variance'],

"""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: Optional[str],

args: Optional[List[Type]] = None,

line: int = -1,

column: int = -1,

optional: bool = False,

empty_tuple_index: bool = False,

original_str_expr: Optional[str] = None,

original_str_fallback: Optional[str] = None,

) -> None:

super().__init__(line, column)

if not args:

args = []

assert name is not None

self.name = name

self.args = 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[Optional[List[Type]]] = _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'],

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

typ = None # type: Type

name = None # type: Optional[str]

constructor = None # type: Optional[str]

def __init__(self, typ: Type, name: Optional[str], constructor: Optional[str],

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 visitor.visit_callable_argument(self)

def serialize(self) -> JsonDict:

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

items = None # type: 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 visitor.visit_type_list(self)

def serialize(self) -> JsonDict:

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

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

def __init__(self,

type_of_any: int,

source_any: Optional['AnyType'] = None,

missing_import_name: Optional[str] = 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[Optional['AnyType']] = _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,

line=self.line, column=self.column)

def __hash__(self) -> int:

return hash(AnyType)

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

return isinstance(other, AnyType)

def serialize(self) -> JsonDict:

return {'.class': 'AnyType', 'type_of_any': self.type_of_any,

'source_any': self.source_any.serialize() if self.source_any is not None else None,

'missing_import_name': self.missing_import_name}

@classmethod

def deserialize(cls, data: JsonDict) -> 'AnyType':

assert data['.class'] == 'AnyType'

source = data['source_any']

return AnyType(data['type_of_any'],

AnyType.deserialize(source) if source is not None else None,

"""This type has no members.

is_noreturn = False # Does this come from a NoReturn? Purely for error messages.

# It is important to track whether this is an actual NoReturn type, or just a result

# of ambiguous type inference, in the latter case we don't want to mark a branch as

# unreachable in binder.

ambiguous = False # Is this a result of inference for a variable without constraints?

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

super().__init__(line, column)

self.is_noreturn = is_noreturn

def can_be_true_default(self) -> bool:

return False

def can_be_false_default(self) -> bool:

return False

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

return visitor.visit_uninhabited_type(self)

def __hash__(self) -> int:

return hash(UninhabitedType)

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

return isinstance(other, UninhabitedType)

def serialize(self) -> JsonDict:

return {'.class': 'UninhabitedType',

'is_noreturn': self.is_noreturn}

@classmethod

def deserialize(cls, data: JsonDict) -> 'UninhabitedType':

assert data['.class'] == 'UninhabitedType'

"""The type of 'None'.

__slots__ = ()

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

super().__init__(line, column)

def can_be_true_default(self) -> bool:

return False

def __hash__(self) -> int:

return hash(NoneType)

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

return isinstance(other, NoneType)

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

return visitor.visit_none_type(self)

def serialize(self) -> JsonDict:

return {'.class': 'NoneType'}

@classmethod

def deserialize(cls, data: JsonDict) -> 'NoneType':

assert data['.class'] == 'NoneType'

"""Placeholder for an erased type.

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

"""Type of deleted variables.

source = '' # type: Optional[str] # May be None; name that generated this value

def __init__(self, source: Optional[str] = None, line: int = -1, column: int = -1) -> None:

super().__init__(line, column)

self.source = source

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

return visitor.visit_deleted_type(self)

def serialize(self) -> JsonDict:

return {'.class': 'DeletedType',

'source': self.source}

@classmethod

def deserialize(cls, data: JsonDict) -> 'DeletedType':

assert data['.class'] == 'DeletedType'

"""An instance type of form C[T1, ..., Tn].

__slots__ = ('type', 'args', 'erased', 'invalid', 'type_ref', 'last_known_value')

def __init__(self, typ: mypy.nodes.TypeInfo, args: List[Type],

line: int = -1, column: int = -1, erased: bool = False,

last_known_value: Optional['LiteralType'] = None) -> None:

super().__init__(line, column)

self.type = typ

self.args = args

self.type_ref = None # type: Optional[str]

# True if result of type variable substitution

self.erased = erased

# True if recovered after incorrect number of type arguments error

self.invalid = False

# This field keeps track of the underlying Literal[...] value associated with

# this instance, if one is known.

#

# This field is set whenever possible within expressions, but is erased upon

# variable assignment (see erasetype.remove_instance_last_known_values) unless

# the variable is declared to be final.

#

# For example, consider the following program:

#

# a = 1

# b: Final[int] = 2

# c: Final = 3

# print(a + b + c + 4)

#

# The 'Instance' objects associated with the expressions '1', '2', '3', and '4' will

# have last_known_values of type Literal[1], Literal[2], Literal[3], and Literal[4]

# respectively. However, the Instance object assigned to 'a' and 'b' will have their

# last_known_value erased: variable 'a' is mutable; variable 'b' was declared to be

# specifically an int.

#

# Or more broadly, this field lets this Instance "remember" its original declaration

# when applicable. We want this behavior because we want implicit Final declarations

# to act pretty much identically with constants: we should be able to replace any

# places where we use some Final variable with the original value and get the same

# type-checking behavior. For example, we want this program:

#

# def expects_literal(x: Literal[3]) -> None: pass

# var: Final = 3

# expects_literal(var)

#

# ...to type-check in the exact same way as if we had written the program like this:

#

# def expects_literal(x: Literal[3]) -> None: pass

# expects_literal(3)

#

# In order to make this work (especially with literal types), we need var's type

# (an Instance) to remember the "original" value.

#

# Preserving this value within expressions is useful for similar reasons.

#

# Currently most of mypy will ignore this field and will continue to treat this type like

# a regular Instance. We end up using this field only when we are explicitly within a

# Literal context.

self.last_known_value = last_known_value

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

return visitor.visit_instance(self)

def __hash__(self) -> int:

return hash((self.type, tuple(self.args), self.last_known_value))

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

if not isinstance(other, Instance):

return NotImplemented

return (self.type == other.type

and self.args == other.args

and self.last_known_value == other.last_known_value)

def serialize(self) -> Union[JsonDict, str]:

assert self.type is not None

type_ref = self.type.fullname()

if not self.args and not self.last_known_value:

return type_ref

data = {'.class': 'Instance',

} # type: JsonDict

data['type_ref'] = type_ref

data['args'] = [arg.serialize() for arg in self.args]

if self.last_known_value is not None:

data['last_known_value'] = self.last_known_value.serialize()

return data

@classmethod

def deserialize(cls, data: Union[JsonDict, str]) -> 'Instance':

if isinstance(data, str):

inst = Instance(NOT_READY, [])

inst.type_ref = data

return inst

assert data['.class'] == 'Instance'

args = [] # type: List[Type]

if 'args' in data:

args_list = data['args']

assert isinstance(args_list, list)

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

inst = Instance(NOT_READY, args)

inst.type_ref = data['type_ref'] # Will be fixed up by fixup.py later.

if 'last_known_value' in data:

inst.last_known_value = LiteralType.deserialize(data['last_known_value'])

return inst

def copy_modified(self, *,

args: Bogus[List[Type]] = _dummy,

last_known_value: Bogus[Optional['LiteralType']] = _dummy) -> 'Instance':

return Instance(

self.type,

args if args is not _dummy else self.args,

self.line,

self.column,

self.erased,

last_known_value if last_known_value is not _dummy else self.last_known_value,

)

def has_readable_member(self, name: str) -> bool:

"""A type variable type.

__slots__ = ('name', 'fullname', 'id', 'values', 'upper_bound', 'variance')

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

super().__init__(line, column)

self.name = binder.name # Name of the type variable (for messages and debugging)

self.fullname = binder.fullname # type: str

self.id = binder.id # type: TypeVarId

# Value restriction, empty list if no restriction

self.values = binder.values # type: List[Type]

# Upper bound for values

self.upper_bound = binder.upper_bound # type: Type

# See comments in TypeVarDef for more about variance.

self.variance = binder.variance # type: int

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

return visitor.visit_type_var(self)

def __hash__(self) -> int:

return hash(self.id)

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

if not isinstance(other, TypeVarType):

return NotImplemented

return self.id == other.id

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,

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

tvdef = TypeVarDef(data['name'],

data['fullname'],

data['id'],

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

deserialize_type(data['upper_bound']),

data['variance'])

"""Abstract base class for function types."""

__slots__ = ('fallback',)

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

super().__init__(line, column)

self.can_be_false = False

if TYPE_CHECKING: # we don't want a runtime None value

# Corresponding instance type (e.g. builtins.type)

self.fallback = cast(Instance, None)

@abstractmethod

def is_type_obj(self) -> bool: pass

@abstractmethod

def type_object(self) -> mypy.nodes.TypeInfo: pass

@abstractmethod

def items(self) -> List['CallableType']: pass

@abstractmethod

def with_name(self, name: str) -> 'FunctionLike': pass

@abstractmethod

('name', Optional[str]),

('pos', Optional[int]),

('typ', Type),

"""Type of a non-overloaded callable object (such as function)."""

__slots__ = ('arg_types', # Types of function arguments

'arg_kinds', # ARG_ constants

'arg_names', # Argument names; None if not a keyword argument

'min_args', # Minimum number of arguments; derived from arg_kinds

'ret_type', # Return value type

'name', # Name (may be None; for error messages and plugins)

'definition', # For error messages. May be None.

'variables', # Type variables for a generic function

'is_ellipsis_args', # Is this Callable[..., t] (with literal '...')?

'is_classmethod_class', # Is this callable constructed for the benefit

# of a classmethod's 'cls' argument?

'implicit', # Was this type implicitly generated instead of explicitly

# specified by the user?

'special_sig', # Non-None for signatures that require special handling

# (currently only value is 'dict' for a signature similar to

# 'dict')

'from_type_type', # Was this callable generated by analyzing Type[...]

# instantiation?

'bound_args', # Bound type args, mostly unused but may be useful for

# tools that consume mypy ASTs

'def_extras', # Information about original definition we want to serialize.

# This is used for more detailed error messages.

)

def __init__(self,

arg_types: Sequence[Type],

arg_kinds: List[int],

arg_names: Sequence[Optional[str]],

ret_type: Type,

fallback: Instance,

name: Optional[str] = None,

definition: Optional[SymbolNode] = None,

variables: Optional[List[TypeVarDef]] = None,

line: int = -1,

column: int = -1,

is_ellipsis_args: bool = False,

implicit: bool = False,

special_sig: Optional[str] = None,

from_type_type: bool = False,

bound_args: Sequence[Optional[Type]] = (),

def_extras: Optional[Dict[str, Any]] = None,

) -> None:

super().__init__(line, column)

assert len(arg_types) == len(arg_kinds) == len(arg_names)

if variables is None:

variables = []

self.arg_types = list(arg_types)

self.arg_kinds = arg_kinds

self.arg_names = list(arg_names)

self.min_args = arg_kinds.count(ARG_POS)

self.ret_type = ret_type

self.fallback = fallback

assert not name or '<bound method' not in name

self.name = name

self.definition = definition

self.variables = variables

self.is_ellipsis_args = is_ellipsis_args

self.implicit = implicit

self.special_sig = special_sig

self.from_type_type = from_type_type

if not bound_args:

bound_args = ()

self.bound_args = bound_args

if def_extras:

self.def_extras = def_extras

elif isinstance(definition, FuncDef):

# This information would be lost if we don't have definition

# after serialization, but it is useful in error messages.

# TODO: decide how to add more info here (file, line, column)

# without changing interface hash.

self.def_extras = {'first_arg': definition.arg_names[0]

if definition.arg_names and definition.info and

not definition.is_static else None}

else:

self.def_extras = {}

def copy_modified(self,

arg_types: Bogus[Sequence[Type]] = _dummy,

arg_kinds: Bogus[List[int]] = _dummy,

arg_names: Bogus[List[Optional[str]]] = _dummy,

ret_type: Bogus[Type] = _dummy,

fallback: Bogus[Instance] = _dummy,

name: Bogus[Optional[str]] = _dummy,

definition: Bogus[SymbolNode] = _dummy,

variables: Bogus[List[TypeVarDef]] = _dummy,

line: Bogus[int] = _dummy,

column: Bogus[int] = _dummy,

is_ellipsis_args: Bogus[bool] = _dummy,

implicit: Bogus[bool] = _dummy,

special_sig: Bogus[Optional[str]] = _dummy,

from_type_type: Bogus[bool] = _dummy,