def test_interesting(self): func = function_lit( any_type(), infer_all(), match_op(dereference("argument"), [ prepared_function( object_type({"foo": int_type()}), return_op( addition_op(dereference("argument.foo"), literal_op(3)))), prepared_function(any_type(), return_op(literal_op("invalid"))) ])) _, result = bootstrap_function(func, argument=PythonObject( {"foo": 39}, bind=UniversalObjectType( {"foo": IntegerType()}))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42) _, result = bootstrap_function(func, argument=PythonObject({"foo": "hello"})) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "invalid")
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_static_value_dereference(self): _, result = bootstrap_function( function_lit( return_op(static_op(addition_op(literal_op(5), literal_op(37)))))) 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_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_unbound_reference_to_locals_and_arguments(self): _, result = bootstrap_function(function_lit( object_type({"foo": int_type()}), infer_all(), object_type({"bar": int_type()}), object_template_op({"bar": literal_op(3)}), return_op( addition_op(unbound_dereference("foo"), unbound_dereference("bar")))), argument=PythonObject({"foo": 39})) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_doubler(self): func = function_lit( int_type(), build_break_types(int_type()), return_op( addition_op( dereference_op(context_op(), literal_op("argument"), True), dereference_op(context_op(), literal_op("argument"), True)))) _, result = bootstrap_function(func, argument=21) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.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_repeated_restart(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) 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_continuation = first_yielder.create_continuation( first, {}) first_yielder_continuation.invoke(39, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") def third(): second_yielder_continuation = second_yielder.create_continuation( second, {}) second_yielder_continuation.invoke(3, frame_manager) with frame_manager.capture() as returner: third() self.assertEquals(returner.value, 42)
def test_slightly_strange_try_catch(self): # Function either throws the same string back at you, or returns an int +1 func = function_lit( one_of_type([string_type(), int_type()]), try_catch_op( throw_op(dereference("argument")), prepared_function( int_type(), return_op( addition_op(literal_op(1), dereference("argument")))), nop())) _, result = bootstrap_function(func, argument="hello world", check_safe_exit=False) self.assertEquals(result.caught_break_mode, "exception") self.assertEquals(result.value, "hello world") _, result = bootstrap_function(func, argument=41, check_safe_exit=False) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.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 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 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 visitAddition(self, ctx): lvalue, rvalue = ctx.expression() lvalue = self.visit(lvalue) rvalue = self.visit(rvalue) return addition_op(lvalue, rvalue)