def test_single_restart(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( addition_op(shift_op(literal_op("hello"), int_type()), literal_op(40)))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as yielder: first() self.assertEquals(yielder.value, "hello") def second(): yielder.create_continuation(first, {}).invoke(2, frame_manager) with frame_manager.capture("return") as returner: second() self.assertEquals(returner.value, 42)
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_restart_into_local_initialization(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), int_type(), shift_op(literal_op("hello"), int_type()), return_op( dereference_op(context_op(), literal_op("local"), True))), context, frame_manager).close(None) def start(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as yielder: start() self.assertEquals(yielder.value, "hello") def restart(): yielder_restart_continuation = yielder.create_continuation( start, func.get_type().break_types) yielder_restart_continuation.invoke(32, frame_manager) with frame_manager.capture("return") as returner: restart() self.assertEquals(returner.value, 32)
def test_basic_inferrence(self): _, result = bootstrap_function( function_lit(no_value_type(), build_break_types(inferred_type()), return_op(literal_op(42)))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_infer_all(self): _, result = bootstrap_function( function_lit(no_value_type(), infer_all(), return_op(literal_op(42)))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_immediate_return(self): _, result = bootstrap_function( function_lit(no_value_type(), build_break_types(int_type()), loop_op(return_op(literal_op(42))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_comma(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(int_type()), return_op(comma_op(literal_op(5), literal_op(8), literal_op(42)))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_infer_exception(self): _, result = bootstrap_function(function_lit( no_value_type(), infer_all(), addition_op(literal_op("hello"), literal_op(5))), check_safe_exit=False) self.assertEquals(result.caught_break_mode, "exception") self.assertEquals(result.value.type, "TypeError")
def test_basic_function(self): func = function_lit(no_value_type(), build_break_types(value_type=int_type()), literal_op(42)) _, result = bootstrap_function(func) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
def test_addition(self): func = function_lit( no_value_type(), build_break_types(int_type()), return_op(addition_op(literal_op(40), literal_op(2)))) _, result = bootstrap_function(func) 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 test_basic_with_inferred_local_type(self): _, result = bootstrap_function( function_lit( no_value_type(), infer_all(), inferred_type(), close_op( static_op( prepare_op( literal_op( function_lit(no_value_type(), infer_all(), return_op(literal_op(42)))))), context_op()), return_op( invoke_op( dereference_op(context_op(), literal_op("local"), True))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_basic(self): _, result = bootstrap_function( function_lit( no_value_type(), build_break_types(int_type()), return_op( invoke_op( close_op( static_op( prepare_op( literal_op( function_lit( no_value_type(), build_break_types(int_type()), return_op(literal_op(42)))))), context_op()))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_initialization(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(int_type()), int_type(), literal_op(42), comma_op( return_op( dereference_op(context_op(), literal_op("local"), True)))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_return(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(object_type({"foo": int_type()})), comma_op(return_op(object_template_op({"foo": literal_op(42)})))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertTrue(isinstance(result.value, Universal)) get_manager( result.value).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE) self.assertEquals(result.value._get("foo"), 42)
def test_restart_comma(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(int_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( comma_op(literal_op(5), shift_op(literal_op("first"), int_type()), shift_op(literal_op("second"), int_type())))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() self.assertEquals(first_yielder.value, "first") def second(): first_yield_restart_continuation = first_yielder.create_continuation( first, func.get_type().break_types) first_yield_restart_continuation.invoke(4, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") def third(): second_yield_restart_continuation = second_yielder.create_continuation( second, func.get_type().break_types) second_yield_restart_continuation.invoke(42, frame_manager) with frame_manager.capture("return") as returner: third() self.assertEquals(returner.value, 42)
def test_misc1(self): _, result = bootstrap_function( function_lit( no_value_type(), infer_all(), object_type({ "foo": int_type(), "bar": int_type() }), object_template_op({ "foo": literal_op(39), "bar": literal_op(3) }), return_op( addition_op(dereference("local.foo"), dereference("local.bar"))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_restart_into_local_initialization_and_code(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), int_type(), shift_op(literal_op("first"), int_type()), return_op( addition_op( dereference_op(context_op(), literal_op("local"), True), shift_op(literal_op("second"), int_type())))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() self.assertEquals(first_yielder.value, "first") def second(): first_restart_continuation = first_yielder.create_continuation( first, func.get_type().break_types) first_restart_continuation.invoke(40, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") with frame_manager.capture("return") as returner: second_restart_continuation = second_yielder.create_continuation( first, func.get_type().break_types) second_restart_continuation.invoke(2, frame_manager) self.assertEquals(returner.value, 42)
def test_add_locals(self): func = function_lit( no_value_type(), build_break_types(int_type()), return_op( addition_op( dereference_op( dereference_op( dereference_op(context_op(), literal_op("outer"), True), literal_op("local"), True), literal_op(0), True), dereference_op( dereference_op( dereference_op(context_op(), literal_op("outer"), True), literal_op("local"), True), literal_op(1), True)))) context = PythonObject( { "local": PythonList([39, 3]), "_types": PythonObject({ "local": UniversalTupleType([IntegerType(), IntegerType()]) }) }, bind=UniversalObjectType({ "local": UniversalTupleType([IntegerType(), IntegerType()]), "_types": DEFAULT_READONLY_COMPOSITE_TYPE })) _, result = bootstrap_function(func, outer_context=context) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_repeated_restart_while_using_restart_values(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( addition_op(shift_op(literal_op(30), int_type()), shift_op(literal_op(10), int_type())))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() def second(): first_yielder.create_continuation(first, {}).invoke( first_yielder.value + 1, frame_manager) with frame_manager.capture("yield") as second_yielder: second() def third(): second_yielder.create_continuation(second, {}).invoke( second_yielder.value + 1, frame_manager) with frame_manager.capture("return") as returner: third() self.assertEquals(returner.value, 42)
def test_repeated_restart_with_outer_return_handling(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(int_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( addition_op(shift_op(literal_op("first"), int_type()), shift_op(literal_op("second"), int_type())))), context, frame_manager).close(None) with frame_manager.capture("return") as return_capturer: def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() self.assertEquals(first_yielder.value, "first") def second(): first_yielder.create_continuation(first, {}).invoke( 39, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") second_yielder.create_continuation(second, {}).invoke(3, frame_manager) self.assertEquals(return_capturer.value, 42)
def test_return_variable(self): func = function_lit( no_value_type(), build_break_types(int_type()), return_op( dereference_op( dereference_op(context_op(), literal_op("outer"), True), literal_op("local"), True))) context = PythonObject( { "local": 42, "_types": PythonObject({"local": IntegerType()}) }, bind=UniversalObjectType( { "local": IntegerType(), "_types": DEFAULT_READONLY_COMPOSITE_TYPE }, wildcard_type=RICH_READONLY_TYPE)) _, result = bootstrap_function(func, outer_context=context) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_without_infer_exception_fails(self): with self.assertRaises(Exception): bootstrap_function( function_lit(no_value_type(), build_break_types(int_type()), addition_op(literal_op("hello"), literal_op(5))))
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 create(self, output_mode, debug_info): if output_mode not in ("first-class-function", "second-class-function", "expression"): raise FatalError() code_expressions = default(self.code_expressions, MISSING, []) for c in code_expressions: if not is_opcode(c): raise FatalError() if not self.requires_function() and output_mode == "expression": return combine_opcodes(code_expressions) if self.argument_type_expression is not MISSING: argument_type = self.argument_type_expression else: argument_type = no_value_type() if self.local_variable_type is not MISSING: local_type = self.local_variable_type else: local_type = object_type( {}) # For future python local variables... if self.local_initializer is not MISSING: local_initializer = self.local_initializer else: local_initializer = object_template_op({}) if self.breaks_types is not MISSING: break_types = self.breaks_types else: break_types = infer_all() if self.extra_statics is not MISSING: extra_statics = self.extra_statics else: extra_statics = {} if output_mode == "first-class-function": # A function created by the user, which mangles returns as expected code = transform_op("return", "value", combine_opcodes(code_expressions), **debug_info) return function_lit(extra_statics, argument_type, break_types, local_type, local_initializer, code, **debug_info) if output_mode == "second-class-function": # A function created by the environment, which leaves returns unmangled code = combine_opcodes(code_expressions) return function_lit(extra_statics, argument_type, break_types, local_type, local_initializer, code, **debug_info) elif output_mode == "expression": return invoke_op( prepare_function_lit( function_lit(extra_statics, argument_type, break_types, local_type, local_initializer, combine_opcodes(code_expressions), **debug_info), **debug_info), **debug_info)