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