def try_finally_entry_blocks(builder: IRBuilder, err_handler: BasicBlock,
return_entry: BasicBlock, main_entry: BasicBlock,
finally_block: BasicBlock,
ret_reg: Optional[Register]) -> Value:
old_exc = builder.alloc_temp(exc_rtuple)
# Entry block for non-exceptional flow
builder.activate_block(main_entry)
if ret_reg:
builder.add(
Assign(ret_reg,
builder.add(LoadErrorValue(builder.ret_types[-1]))))
builder.goto(return_entry)
builder.activate_block(return_entry)
builder.add(Assign(old_exc, builder.add(LoadErrorValue(exc_rtuple))))
builder.goto(finally_block)
# Entry block for errors
builder.activate_block(err_handler)
if ret_reg:
builder.add(
Assign(ret_reg,
builder.add(LoadErrorValue(builder.ret_types[-1]))))
builder.add(Assign(old_exc, builder.call_c(error_catch_op, [], -1)))
builder.goto(finally_block)
return old_exc
def add_handler_block(ir: FuncIR) -> BasicBlock:
block = BasicBlock()
ir.blocks.append(block)
op = LoadErrorValue(ir.ret_type)
block.ops.append(op)
block.ops.append(Return(op))
return block
def transform_del_item(builder: IRBuilder, target: AssignmentTarget,
line: int) -> None:
if isinstance(target, AssignmentTargetIndex):
builder.gen_method_call(target.base,
'__delitem__', [target.index],
result_type=None,
line=line)
elif isinstance(target, AssignmentTargetAttr):
if isinstance(target.obj_type, RInstance):
cl = target.obj_type.class_ir
if not cl.is_deletable(target.attr):
builder.error('"{}" cannot be deleted'.format(target.attr),
line)
builder.note(
'Using "__deletable__ = ' +
'[\'<attr>\']" in the class body enables "del obj.<attr>"',
line)
key = builder.load_str(target.attr)
builder.call_c(py_delattr_op, [target.obj, key], line)
elif isinstance(target, AssignmentTargetRegister):
# Delete a local by assigning an error value to it, which will
# prompt the insertion of uninit checks.
builder.add(
Assign(target.register,
builder.add(LoadErrorValue(target.type, undefines=True))))
elif isinstance(target, AssignmentTargetTuple):
for subtarget in target.items:
transform_del_item(builder, subtarget, line)
def split_blocks_at_uninits(blocks: List[BasicBlock],
pre_must_defined: 'AnalysisDict[Value]') -> List[BasicBlock]:
new_blocks: List[BasicBlock] = []
init_registers = []
init_registers_set = set()
# First split blocks on ops that may raise.
for block in blocks:
ops = block.ops
block.ops = []
cur_block = block
new_blocks.append(cur_block)
for i, op in enumerate(ops):
defined = pre_must_defined[block, i]
for src in op.unique_sources():
# If a register operand is not guaranteed to be
# initialized is an operand to something other than a
# check that it is defined, insert a check.
# Note that for register operand in a LoadAddress op,
# we should be able to use it without initialization
# as we may need to use its address to update itself
if (isinstance(src, Register) and src not in defined
and not (isinstance(op, Branch) and op.op == Branch.IS_ERROR)
and not isinstance(op, LoadAddress)):
new_block, error_block = BasicBlock(), BasicBlock()
new_block.error_handler = error_block.error_handler = cur_block.error_handler
new_blocks += [error_block, new_block]
if src not in init_registers_set:
init_registers.append(src)
init_registers_set.add(src)
cur_block.ops.append(Branch(src,
true_label=error_block,
false_label=new_block,
op=Branch.IS_ERROR,
line=op.line))
raise_std = RaiseStandardError(
RaiseStandardError.UNBOUND_LOCAL_ERROR,
'local variable "{}" referenced before assignment'.format(src.name),
op.line)
error_block.ops.append(raise_std)
error_block.ops.append(Unreachable())
cur_block = new_block
cur_block.ops.append(op)
if init_registers:
new_ops: List[Op] = []
for reg in init_registers:
err = LoadErrorValue(reg.type, undefines=True)
new_ops.append(err)
new_ops.append(Assign(reg, err))
new_blocks[0].ops[0:0] = new_ops
return new_blocks
def native_args_to_positional(self, args: Sequence[Value],
arg_kinds: List[int],
arg_names: Sequence[Optional[str]],
sig: FuncSignature,
line: int) -> List[Value]:
"""Prepare arguments for a native call.
Given args/kinds/names and a target signature for a native call, map
keyword arguments to their appropriate place in the argument list,
fill in error values for unspecified default arguments,
package arguments that will go into *args/**kwargs into a tuple/dict,
and coerce arguments to the appropriate type.
"""
sig_arg_kinds = [arg.kind for arg in sig.args]
sig_arg_names = [arg.name for arg in sig.args]
formal_to_actual = map_actuals_to_formals(
arg_kinds, arg_names, sig_arg_kinds, sig_arg_names,
lambda n: AnyType(TypeOfAny.special_form))
# Flatten out the arguments, loading error values for default
# arguments, constructing tuples/dicts for star args, and
# coercing everything to the expected type.
output_args = []
for lst, arg in zip(formal_to_actual, sig.args):
output_arg = None
if arg.kind == ARG_STAR:
output_arg = self.primitive_op(new_tuple_op,
[args[i] for i in lst], line)
elif arg.kind == ARG_STAR2:
dict_entries = [
(self.load_static_unicode(cast(str,
arg_names[i])), args[i])
for i in lst
]
output_arg = self.make_dict(dict_entries, line)
elif not lst:
output_arg = self.add(
LoadErrorValue(arg.type, is_borrowed=True))
else:
output_arg = args[lst[0]]
output_args.append(self.coerce(output_arg, arg.type, line))
return output_args
def transform_del_item(builder: IRBuilder, target: AssignmentTarget,
line: int) -> None:
if isinstance(target, AssignmentTargetIndex):
builder.gen_method_call(target.base,
'__delitem__', [target.index],
result_type=None,
line=line)
elif isinstance(target, AssignmentTargetAttr):
key = builder.load_static_unicode(target.attr)
builder.call_c(py_delattr_op, [target.obj, key], line)
elif isinstance(target, AssignmentTargetRegister):
# Delete a local by assigning an error value to it, which will
# prompt the insertion of uninit checks.
builder.add(
Assign(target.register,
builder.add(LoadErrorValue(target.type, undefines=True))))
elif isinstance(target, AssignmentTargetTuple):
for subtarget in target.items:
transform_del_item(builder, subtarget, line)
def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
# OK AND NOW THE FUN PART
base_exprs = cdef.base_type_exprs + cdef.removed_base_type_exprs
if base_exprs:
bases = [builder.accept(x) for x in base_exprs]
tp_bases = builder.new_tuple(bases, cdef.line)
else:
tp_bases = builder.add(
LoadErrorValue(object_rprimitive, is_borrowed=True))
modname = builder.load_static_unicode(builder.module_name)
template = builder.add(
LoadStatic(object_rprimitive, cdef.name + "_template",
builder.module_name, NAMESPACE_TYPE))
# Create the class
tp = builder.call_c(pytype_from_template_op, [template, tp_bases, modname],
cdef.line)
# Immediately fix up the trait vtables, before doing anything with the class.
ir = builder.mapper.type_to_ir[cdef.info]
if not ir.is_trait and not ir.builtin_base:
builder.add(
Call(
FuncDecl(cdef.name + '_trait_vtable_setup',
None, builder.module_name,
FuncSignature([], bool_rprimitive)), [], -1))
# Populate a '__mypyc_attrs__' field containing the list of attrs
builder.call_c(py_setattr_op, [
tp,
builder.load_static_unicode('__mypyc_attrs__'),
create_mypyc_attrs_tuple(builder, builder.mapper.type_to_ir[cdef.info],
cdef.line)
], cdef.line)
# Save the class
builder.add(InitStatic(tp, cdef.name, builder.module_name, NAMESPACE_TYPE))
# Add it to the dict
builder.call_c(dict_set_item_op, [
builder.load_globals_dict(),
builder.load_static_unicode(cdef.name),
tp,
], cdef.line)
return tp
