Example #1
0
def add_type_map_support_for_type(map: List[str], ops: List[str],
                                  typ: TypeInfo, alt, suffix: str) -> None:
    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)
Example #2
0
def add_type_map_support_for_type(map: List[str], ops: List[str],
                                  typ: TypeInfo, alt, suffix: str) -> None:
    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)
Example #3
0
 def anal_type_def(self, d):
     self.check_no_global(d.name, d)
     d.full_name = self.qualified_name(d.name)
     info = TypeInfo({}, {}, d)
     info.set_line(d.line)
     self.types[d.full_name] = info
     d.info = info
     self.globals[d.name] = SymbolTableNode(GDEF, info, self.cur_mod_id)
Example #4
0
def add_slot_map_support_for_type_pair(map: List[str], ops: List[str],
                                       base: TypeInfo, typ: TypeInfo) -> None:
    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)
Example #5
0
def add_slot_map_support_for_type_pair(map: List[str], ops: List[str],
                                       base: TypeInfo, typ: TypeInfo) -> None:
    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)
Example #6
0
        self.m1i = make_type_info('M1', (INTERFACES, [self.gfi]),
                                  (BASE_DEFS, [Instance(self.gfi, [self.a])]))

        self.gfa = Instance(self.gfi, [self.a]) # GF<A>
        self.gfb = Instance(self.gfi, [self.b]) # GF<B>

        self.m1 = Instance(self.m1i, []) # M1


TypeInfo make_type_info(any name, any *args):
    """Make a TypeInfo suitable for use in unit tests."""
    map = dict(args)
    
    type_def = TypeDef(name, Block([]), None, [])
    type_def.full_name = name
    
    if VARS in map:
        TypeVarDef[] v = []
        id = 1
        for n in map[VARS]:
            v.append(TypeVarDef(n, id))
            id += 1
        type_def.type_vars = TypeVars(v)
    
    info = TypeInfo({}, {}, type_def)
    info.base = map.get(BASE, None)
    info.bases = map.get(BASE_DEFS, [])
    info.interfaces = map.get(INTERFACES, []) # TODO fix
    
    return info