def generate_type_map_op(ops: List[str], op: str, typ, alt) -> None:
ops.append('def {}(v)'.format(op))
a = [] # type: List[str]
for i in range(len(typ.type_vars)):
p = get_tvar_access_path(typ, i + 1)
expr = 'v.' + tvar_slot_name(p[0] - 1, alt)
for j in p[1:]:
expr += '.args[{}]'.format(j - 1)
a.append(expr)
ops.append(' return [{}]'.format(', '.join(a)))
ops.append('end')
def generate_type_map_op(ops: List[str], op: str, typ, alt) -> None:
ops.append('def {}(v)'.format(op))
a = [] # type: List[str]
for i in range(len(typ.type_vars)):
p = get_tvar_access_path(typ, i + 1)
expr = 'v.' + tvar_slot_name(p[0] - 1, alt)
for j in p[1:]:
expr += '.args[{}]'.format(j - 1)
a.append(expr)
ops.append(' return [{}]'.format(', '.join(a)))
ops.append('end')
return fdef
Node[] make_tvar_representation(self, TypeInfo info, any is_alt=False):
"""Return type variable slot member definitions.
There are of form 'any __tv*'. Only include new slots defined in the
type.
"""
Node[] defs = []
base_slots = num_slots(info.base)
for n in range(len(info.type_vars)):
# Only include a type variable if it introduces a new slot.
slot = get_tvar_access_path(info, n + 1)[0] - 1
if slot >= base_slots:
defs.append(VarDef([(Var(tvar_slot_name(slot, is_alt)),
Any())], False, None))
return defs
void make_instance_tvar_initializer(self, FuncDef creat):
"""Add type variable member initialization code to a constructor.
Modify the constructor body directly.
"""
for n in range(num_slots(creat.info)):
rvalue = self.make_tvar_init_expression(creat.info, n)
init = AssignmentStmt([MemberExpr(self_expr(),
tvar_slot_name(n),
direct=True)],
rvalue)
self.tf.set_type(init.lvalues[0], Any())
td = (TypeDef)d
if td.info is not None:
add_type_map_support_for_type(map, ops, td.info, alt,
suffix)
map.append(' )')
map.append('end')
return '\n'.join(map) + '\n' + '\n'.join(ops)
void add_type_map_support_for_type(str[] map, str[] ops, TypeInfo typ, alt,
str suffix):
op = '__{}ValueToType{}'.format(typ.name(), suffix)
map.append(' {} : {},'.format(typ.name(), op))
if typ.is_generic():
map.append(' {} : {},'.format(typ.name() + dynamic_suffix(False),
op))
generate_type_map_op(ops, op, typ, alt)
void generate_type_map_op(str[] ops, str op, typ, alt):
ops.append('def {}(v)'.format(op))
a = <str> []
for i in range(len(typ.type_vars)):
p = get_tvar_access_path(typ, i + 1)
expr = 'v.' + tvar_slot_name(p[0] - 1, alt)
for j in p[1:]:
expr += '.args[{}]'.format(j - 1)
a.append(expr)
ops.append(' return [{}]'.format(', '.join(a)))
ops.append('end')
