def make_type_info(name: str,
is_abstract: bool = False,
mro: List[TypeInfo] = None,
bases: List[Instance] = None,
typevars: List[str] = None) -> TypeInfo:
"""Make a TypeInfo suitable for use in unit tests."""
type_def = TypeDef(name, Block([]), None, [])
type_def.fullname = name
if typevars:
v = [] # type: List[TypeVarDef]
id = 1
for n in typevars:
v.append(TypeVarDef(n, id, None))
id += 1
type_def.type_vars = v
info = TypeInfo(SymbolTable(), type_def)
if mro is None:
mro = []
info.mro = [info] + mro
if bases is None:
if mro:
# By default, assume that there is a single non-generic base.
bases = [Instance(mro[0], [])]
else:
bases = []
info.bases = bases
return info
def generic_class_wrapper(self, tdef: TypeDef) -> TypeDef:
"""Construct a wrapper class for a generic type."""
# FIX semanal meta-info for nodes + TypeInfo
defs = [] # type: List[Node]
# Does the type have a superclass, other than builtins.object?
base = tdef.info.mro[1]
has_proper_superclass = base.fullname() != 'builtins.object'
if not has_proper_superclass or self.tf.is_java:
# Generate member variables for wrapper object.
defs.extend(self.make_generic_wrapper_member_vars(tdef))
for alt in [False, BOUND_VAR]:
defs.extend(self.make_tvar_representation(tdef.info, alt))
# Generate constructor.
defs.append(self.make_generic_wrapper_init(tdef.info))
# Generate method wrappers.
for d in tdef.defs.body:
if isinstance(d, FuncDef):
if not d.is_constructor():
defs.extend(self.func_tf.generic_method_wrappers(d))
elif isinstance(d, AssignmentStmt):
defs.extend(self.generic_accessor_wrappers(d))
elif not isinstance(d, PassStmt):
raise RuntimeError(
'Definition {} at line {} not supported'.format(
type(d), d.line))
base_type = self.tf.named_type('builtins.object') # type: Type
# Inherit superclass wrapper if there is one.
if has_proper_superclass:
base = self.find_generic_base_class(tdef.info)
if base:
# TODO bind the type somewhere
base_type = UnboundType(base.defn.name +
self.tf.wrapper_class_suffix())
# Build the type definition.
wrapper = TypeDef(tdef.name + self.tf.wrapper_class_suffix(),
Block(defs),
None,
[base_type])
# FIX fullname
self.tf.add_line_mapping(tdef, wrapper)
return wrapper
def visit_type_def(self, node: TypeDef) -> Node:
new = TypeDef(node.name, self.block(node.defs), node.type_vars,
self.types(node.base_types), node.metaclass)
new.fullname = node.fullname
new.info = node.info
return new
