from abc import abstractmethod

from typing import (

List, Sequence, Dict, Generic, TypeVar, Optional, Any, NamedTuple, Tuple, Callable,

Union, Iterable, Set

)

from typing_extensions import Final, Type, ClassVar

from collections import OrderedDict

from mypy.nodes import ARG_NAMED_OPT, ARG_OPT, ARG_POS, Block, FuncDef, SymbolNode

from mypyc.common import PROPSET_PREFIX

from mypy_extensions import trait

from mypyc.namegen import NameGenerator, exported_name

T = TypeVar('T')

JsonDict = Dict[str, Any]

class RType:

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

DeserMaps = NamedTuple('DeserMaps',

[('classes', Dict[str, 'ClassIR']), ('functions', Dict[str, 'FuncIR'])])

def deserialize_type(data: Union[JsonDict, str], ctx: DeserMaps) -> 'RType':

raise NotImplementedError('unexpected .class {}'.format(data['.class']))

class RTypeVisitor(Generic[T]):

raise NotImplementedError

class RVoid(RType):

return 'void'

void_rtype = RVoid() # type: Final

class RPrimitive(RType):

return '<RPrimitive %s>' % self.name

object_rprimitive = RPrimitive('builtins.object', is_unboxed=False,

is_refcounted=True) # type: Final

int_rprimitive = RPrimitive('builtins.int', is_unboxed=True, is_refcounted=True,

ctype='CPyTagged') # type: Final

short_int_rprimitive = RPrimitive('short_int', is_unboxed=True, is_refcounted=False,

ctype='CPyTagged') # type: Final

float_rprimitive = RPrimitive('builtins.float', is_unboxed=False,

is_refcounted=True) # type: Final

bool_rprimitive = RPrimitive('builtins.bool', is_unboxed=True, is_refcounted=False,

ctype='char') # type: Final

none_rprimitive = RPrimitive('builtins.None', is_unboxed=True, is_refcounted=False,

ctype='char') # type: Final

list_rprimitive = RPrimitive('builtins.list', is_unboxed=False, is_refcounted=True) # type: Final

dict_rprimitive = RPrimitive('builtins.dict', is_unboxed=False, is_refcounted=True) # type: Final

set_rprimitive = RPrimitive('builtins.set', is_unboxed=False, is_refcounted=True) # type: Final

str_rprimitive = RPrimitive('builtins.str', is_unboxed=False, is_refcounted=True) # type: Final

tuple_rprimitive = RPrimitive('builtins.tuple', is_unboxed=False,

is_refcounted=True) # type: Final

def is_int_rprimitive(rtype: RType) -> bool:

return rtype is int_rprimitive

def is_short_int_rprimitive(rtype: RType) -> bool:

return rtype is short_int_rprimitive

def is_float_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.float'

def is_bool_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.bool'

def is_object_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.object'

def is_none_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.None'

def is_list_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.list'

def is_dict_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.dict'

def is_set_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.set'

def is_str_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.str'

def is_tuple_rprimitive(rtype: RType) -> bool:

return isinstance(rtype, RPrimitive) and rtype.name == 'builtins.tuple'

class TupleNameVisitor(RTypeVisitor[str]):

assert False, "rvoid in tuple?"

class RTuple(RType):

return RTuple(types)

exc_rtuple = RTuple([object_rprimitive, object_rprimitive, object_rprimitive])

class RInstance(RType):

return self.name

class RUnion(RType):

return RUnion(types)

def optional_value_type(rtype: RType) -> Optional[RType]:

return None

def is_optional_type(rtype: RType) -> bool:

return optional_value_type(rtype) is not None

class AssignmentTarget(object):

raise NotImplementedError

class AssignmentTargetRegister(AssignmentTarget):

return self.register.name

class AssignmentTargetIndex(AssignmentTarget):

return '{}[{}]'.format(self.base.name, self.index.name)

class AssignmentTargetAttr(AssignmentTarget):

return '{}.{}'.format(self.obj.to_str(env), self.attr)

class AssignmentTargetTuple(AssignmentTarget):

return '({})'.format(', '.join(item.to_str(env) for item in self.items))

class Environment:

return result

class BasicBlock:

self.error_handler = None # type: Optional[BasicBlock]

ERR_NEVER = 0 # type: Final

ERR_MAGIC = 1 # type: Final

ERR_FALSE = 2 # type: Final

NO_TRACEBACK_LINE_NO = -10000

class Value:

raise NotImplementedError

class Register(Value):

return False

class Op(Value):

pass

class ControlOp(Op):

# Basically just for hierarchy organization.

# We could plausibly have a targets() method if we wanted.

pass

class Goto(ControlOp):

return visitor.visit_goto(self)

class Branch(ControlOp):

return visitor.visit_branch(self)

class Return(ControlOp):

return visitor.visit_return(self)

class Unreachable(ControlOp):

return visitor.visit_unreachable(self)

class RegisterOp(Op):

return self.error_kind != ERR_NEVER

class IncRef(RegisterOp):

return visitor.visit_inc_ref(self)

class DecRef(RegisterOp):

return visitor.visit_dec_ref(self)

class Call(RegisterOp):

return visitor.visit_call(self)

class MethodCall(RegisterOp):

return visitor.visit_method_call(self)

class EmitterInterface():

raise NotImplementedError

EmitCallback = Callable[[EmitterInterface, List[str], str], None]

StealsDescription = Union[bool, List[bool]]