Exemplo n.º 1
0
def generate_slot_map_op(ops: List[str], op: str, base: TypeInfo,
                         typ: TypeInfo) -> None:
    ops.append('def {}(t)'.format(op))
    nslots = num_slots(typ)
    slots = compile_slot_mapping(base)
    a = []  # type: List[str]
    for t in slots:
        a.append(transform_type_to_runtime_repr(t))
    for i in range(len(slots), nslots):
        a.append('__Dyn')
    ops.append('  return [' + ', '.join(a) + ']')
    ops.append('end')
Exemplo n.º 2
0
def generate_slot_map_op(ops: List[str], op: str, base: TypeInfo,
                         typ: TypeInfo) -> None:
    ops.append('def {}(t)'.format(op))
    nslots = num_slots(typ)
    slots = compile_slot_mapping(base)
    a = [] # type: List[str]
    for t in slots:
        a.append(transform_type_to_runtime_repr(t))
    for i in range(len(slots), nslots):
        a.append('__Dyn')
    ops.append('  return [' + ', '.join(a) + ']')
    ops.append('end')
Exemplo n.º 3
0
     
     This is added to a generic wrapper class.
     """
     # The type is 'any' since it should behave covariantly in subclasses.
     return [VarDef([(Var(self.object_member_name(tdef.info)),
                      Any())], False, None)]
 
 str object_member_name(self, TypeInfo info):
     if self.tf.is_java:
         return '__o_{}'.format(info.name)
     else:
         return '__o'
 
 FuncDef make_generic_wrapper_init(self, TypeInfo info):
     """Build constructor of a generic wrapper class."""
     nslots = num_slots(info)
     
     cdefs = <Node> []
     
     # Build superclass constructor call.
     if info.base.full_name() != 'builtins.object' and self.tf.is_java:
         s = SuperExpr('__init__')
         cargs = <Node> [NameExpr('__o')]
         for n in range(num_slots(info.base)):
             cargs.append(NameExpr(tvar_arg_name(n + 1)))
         for n in range(num_slots(info.base)):
             cargs.append(NameExpr(tvar_arg_name(n + 1, BOUND_VAR)))
         c = CallExpr(s, cargs, [nodes.ARG_POS] * len(cargs))
         cdefs.append(ExpressionStmt(c))
     
     # Create initialization of the wrapped object.
Exemplo n.º 4
0

void add_slot_map_support_for_type_pair(str[] map, str[] ops, TypeInfo base,
                                        TypeInfo typ):
    op = '__{}TypeTo{}Slots'.format(base.name(), typ.name())
    map.append('    ({}, {}) : {},'.format(base.name(), typ.name(), op))
    if typ.is_generic():
        map.append('    ({}, {}) : {},'.format(base.name(), typ.name() +
                                               dynamic_suffix(False),
                                               op))
    generate_slot_map_op(ops, op, base, typ)


void generate_slot_map_op(str[] ops, str op, TypeInfo base, TypeInfo typ):
    ops.append('def {}(t)'.format(op))
    nslots = num_slots(typ)
    slots = compile_slot_mapping(base)
    a = <str> []
    for t in slots:
        a.append(transform_type_to_runtime_repr(t))
    for i in range(len(slots), nslots):
        a.append('__Dyn')
    ops.append('  return [' + ', '.join(a) + ']')
    ops.append('end')


str transform_type_to_runtime_repr(Type t):
    if isinstance(t, Instance):
        inst = (Instance)t
        if inst.args == []:
            return inst.type.name()
Exemplo n.º 5
0
Type[] compile_slot_mapping(TypeInfo typ):
    """Return types that represent values of type variable slots of a type.

    The returned types are in terms of type variables of the type.
    
    For example, assume these definitions:
    
    . class C<T, S>(D<E<S>>): ...
    . class D<S>(object): ...
    
    Now slot mappings for C is [E<S>, T] (S and T refer to type variables of
    C).
    """
    Type[] exprs = []
    
    for slot in range(num_slots(typ)):
        # Figure out the superclass which defines the slot; also figure out
        # the tvar index that maps to the slot.
        origin, tv = find_slot_origin(typ, slot)
        
        # Map self type to the superclass -> extract tvar with target index
        # (only contains subclass tvars?? PROBABLY NOT).
        selftype = self_type(typ)
        selftype = map_instance_to_supertype(selftype, origin)
        tvar = selftype.args[tv - 1]
        
        # tvar is the representation of the slot in terms of type arguments.
        exprs.append(tvar)
    
    return exprs