def test_count_then_return(self):
_, result = bootstrap_function(
function_lit(
no_value_type(), build_break_types(int_type()), int_type(),
literal_op(0),
loop_op(
comma_op(
assignment_op(
context_op(), literal_op("local"),
addition_op(
dereference_op(context_op(),
literal_op("local"), True),
literal_op(1))),
condition_op(
equality_op(
dereference_op(context_op(),
literal_op("local"), True),
literal_op(42)),
return_op(
dereference_op(context_op(),
literal_op("local"))),
nop())))))
self.assertEquals(result.caught_break_mode, "return")
self.assertEquals(result.value, 42)
def test_basic_false(self):
_, result = bootstrap_function(
function_lit(
no_value_type(), build_break_types(int_type()),
return_op(
condition_op(literal_op(False), literal_op(34),
literal_op(53)))))
self.assertEquals(result.caught_break_mode, "return")
self.assertEquals(result.value, 53)
def visitWhileLoop(self, ctx):
continue_expression = self.visit(ctx.expression())
loop_code = self.visit(ctx.codeBlock())
return transform_op(
"break", "value",
loop_op(
comma_op(
condition_op(continue_expression, nop(),
transform_op("break")),
loop_code.create("expression", get_debug_info(ctx)))))
def visitIfStatement(self, ctx):
expressions = [self.visit(e) for e in ctx.expression()]
code_blocks = [
self.visit(c).create("expression", get_debug_info(ctx))
for c in ctx.codeBlock()
]
if len(expressions) == len(code_blocks):
other_branch = nop()
else:
other_branch = code_blocks[-1]
for condition, when_true in reversed(zip(expressions, code_blocks)):
other_branch = condition_op(condition, when_true, other_branch)
return other_branch
def get_default_global_context():
return PythonObject(
{
"static":
PythonObject(
{
"any":
PythonObject({"type": "Any"},
debug_reason="default-global-context"),
"int":
PythonObject({"type": "Integer"},
debug_reason="default-global-context"),
"bool":
PythonObject({"type": "Boolean"},
debug_reason="default-global-context"),
"string":
PythonObject({"type": "String"},
debug_reason="default-global-context"),
"void":
PythonObject({"type": "NoValue"},
debug_reason="default-global-context"),
"var":
PythonObject({"type": "Inferred"},
debug_reason="default-global-context"),
"range":
prepare(
function_lit(
list_type([int_type(), int_type()], None),
infer_all(), int_type(), dereference("argument.0"),
prepared_function(
loop_op(
condition_op(
binary_integer_op(
"lt", dereference("outer.local"),
dereference("outer.argument.1")),
comma_op(
shift_op(
dereference("outer.local"),
no_value_type()),
assignment_op(
dereference("outer"),
literal_op("local"),
addition_op(
dereference("outer.local"),
literal_op(1)))),
transform_op("break"))))), NO_VALUE,
FrameManager()).close(NO_VALUE),
"list":
prepare(
function_lit(
list_type([
function_type(
no_value_type(), {
"yield":
list_template_op([
object_template_op(
{
"in": no_value_type(),
"out": int_type()
})
]),
"value":
list_template_op([
object_template_op(
{"out": no_value_type()})
]),
}),
], None), infer_all(), inferred_type(),
dereference("argument.0"),
loop_op(
invoke_op(
local_function(
transform(
("yield", "value"),
("value", "end"),
reset_op(
dereference("outer.local"),
nop())),
comma_op(
assignment_op(
dereference("outer"),
literal_op("local"),
dereference(
"local.continuation")),
transform_op(
"value", "continue",
dereference("local.value"))))))
), NO_VALUE, FrameManager()).close(NO_VALUE),
"max":
prepare(
function_lit(
list_type([int_type()], int_type()), infer_all(),
inferred_type(), dereference("argument.0"),
comma_op(
map_op(
dereference("argument"),
prepared_function(
int_type(),
condition_op(
binary_integer_op(
"gt", dereference("argument"),
dereference("outer.local")),
assignment_op(
dereference("outer"),
literal_op("local"),
dereference("argument")),
nop()))), dereference("local"))),
NO_VALUE, FrameManager()).close(NO_VALUE),
},
debug_reason="default-global-context")
},
bind=DEFAULT_READONLY_COMPOSITE_TYPE,
debug_reason="default-global-context")
def visit_conditional_pair(self, condition, when_true, when_false):
return condition_op(condition, when_true, when_false)
def visitTernary(self, ctx):
condition, when_true, when_false = ctx.expression()
return condition_op(self.visit(condition), self.visit(when_true),
self.visit(when_false))
