def remove_composite_type(target_manager,
remove_type,
reasoner=DUMMY_REASONER,
key_filter=None,
multiplier=1,
enforce_safety_checks=True):
if not reasoner:
reasoner = Reasoner()
types_to_bind = {}
succeeded = build_binding_map_for_type(
None,
remove_type,
target_manager.get_obj(),
target_manager,
key_filter,
MISSING, {},
types_to_bind,
reasoner,
enforce_safety_checks=enforce_safety_checks)
if not succeeded:
raise CompositeTypeIncompatibleWithTarget()
for _, type, target in types_to_bind.values():
get_manager(target).detach_type(type, multiplier=multiplier)
def test_return_with_dereference4(self):
_, result = bootstrap_function(function_lit(
int_type(),
build_break_types(
object_type({
"foo": any_type(),
"bar": any_type()
})),
comma_op(
return_op(
object_template_op({
"foo":
literal_op(42),
"bar":
dereference_op(context_op(), literal_op("argument"),
True)
})))),
argument=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)
self.assertEquals(result.value._get("bar"), 42)
def test_modifying(self):
At = UniversalObjectType({
"foo": IntegerType()
})
Bt = UniversalObjectType({
"bar": At
})
A = PythonObject({
"foo": 5
})
B = PythonObject({
"bar": A
}, bind=Bt)
self.assertEquals(len(get_manager(A).attached_types), 1)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 1)
B.bar = PythonObject({
"foo": 42
}, bind=At)
self.assertEquals(len(get_manager(A).attached_types), 0)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 0)
def type_conditional_converter(expression):
is_conditional = expression.opcode == "conditional"
if not is_conditional:
return expression
condition_is_type_check = expression.condition.opcode == "is"
if not condition_is_type_check:
return expression
lvalue_of_condition_is_dereference = expression.condition.expression.opcode == "unbound_dereference"
if not lvalue_of_condition_is_dereference:
return expression
shadow_name = expression.condition.expression.reference
new_match = match_op(expression.condition.expression, [
prepared_function(
expression.condition.type,
invoke_op(prepared_function(
object_type({shadow_name: expression.condition.type}),
expression.when_true),
argument_expression=object_template_op(
{shadow_name: dereference("argument")}))),
prepared_function(inferred_type(), expression.when_false)
])
get_manager(new_match).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE)
return new_match
def test_basic_tuple_of_ints(self):
foo = PythonList([ 1, 2, 3 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), IntegerType(), IntegerType() ]))
foo[0] = 42
self.assertEqual(foo[0], 42)
def test_double_deep_assignment(self):
foo = PythonObject({
"bar": PythonObject({
"baz": PythonObject({
"bam": 10
})
})
})
Baz = UniversalObjectType({
"bam": IntegerType()
})
Bar = UniversalObjectType({
"baz": Baz
})
get_manager(foo).add_composite_type(
UniversalObjectType({
"bar": Bar
})
)
self.assertEquals(foo.bar.baz.bam, 10)
foo.bar = PythonObject({ "baz": PythonObject({ "bam": 42 }) }, bind=Bar)
self.assertEquals(foo.bar.baz.bam, 42)
def test_outside_tuple_access_allowed(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(UniversalListType(AnyType()))
self.assertEqual(foo[2], 8)
foo[2] = "hello"
self.assertEqual(foo[2], "hello")
def test_add_micro_op_object(self):
class Foo(PythonObject):
pass
obj = Foo({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType())
}, name="test"))
def add_composite_type(target_manager,
new_type,
reasoner=None,
key_filter=None,
multiplier=1,
enforce_safety_checks=True):
"""
Safely adds a new CompositeType to a CompositeObjectManager, so that run time verification
of mutations to the object owned by the CompositeObjectManager can be enforced.
It checks whether the new CompositeType is compatible with any CompositeTypes that
have been added previously. If it is found to conflict, this function raises a
CompositeTypeIncompatibleWithTarget exception.
"""
if not reasoner:
reasoner = Reasoner()
types_to_bind = {}
succeeded = build_binding_map_for_type(
None,
new_type,
target_manager.get_obj(),
target_manager,
key_filter,
MISSING, {},
types_to_bind,
reasoner,
enforce_safety_checks=enforce_safety_checks)
if not succeeded:
raise CompositeTypeIncompatibleWithTarget()
for _, type, target in types_to_bind.values():
get_manager(target).attach_type(type, multiplier=multiplier)
def test_basic_list_of_ints(self):
foo = PythonList([ 1, 2, 3 ])
get_manager(foo).add_composite_type(UniversalListType(IntegerType()))
foo[0] = 42
self.assertEqual(foo[0], 42)
def test_failed_setup_broad_writing_property(self):
with self.assertRaises(CompositeTypeIsInconsistent):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType()),
("set", "foo"): SetterMicroOpType("foo", AnyType())
}, name="test"))
def test_outside_tuple_access_blocked(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), AnyType() ]))
with self.assertRaises(IndexError):
foo[2]
with self.assertRaises(IndexError):
foo[2] = "hello"
def test_basics(self):
foo = PythonObject({
"bar": 42
})
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": UnitType(42)
}))
self.assertEquals(foo.bar, 42)
def test_composite_object_assignment(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType()),
("set", "foo"): SetterMicroOpType("foo", StringType())
}, name="test"))
obj.foo = "what"
def test_composite_object_dereference(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType()),
("set", "foo"): SetterMicroOpType("foo", StringType())
}, name="test"))
self.assertEquals(obj.foo, "hello")
def test_runtime(self):
obj = PythonObject({
"foo": 5
})
get_manager(obj).add_composite_type(
UniversalObjectType({
"foo": OneOfType([ IntegerType(), StringType() ])
})
)
def test_rev_const_can_not_be_added_to_object(self):
rev_const_type = CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType()),
("set", "foo"): SetterMicroOpType("foo", AnyType())
}, name="test")
obj = PythonObject({ "foo": "hello" })
with self.assertRaises(Exception):
get_manager(obj).add_composite_type(rev_const_type)
def test_delete_property(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("delete-wildcard", ): DeletterWildcardMicroOpType(StringType(), True)
}, name="test"))
del obj.foo
self.assertFalse(hasattr(obj, "foo"))
def test_const_property(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType())
}, name="test"))
self.assertEquals(obj.foo, "hello")
with self.assertRaises(Exception):
obj.foo = "what"
def test_composite_object_invalid_assignment(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", StringType()),
("set", "foo"): SetterMicroOpType("foo", StringType())
}, name="test"))
with self.assertRaises(TypeError):
obj.foo = 5
def test_that_python_constraints_dont_spread_to_constrained_children(self):
bar = PythonObject({
"baz": 42
})
foo = PythonObject({
"bar": bar
})
# The first, stronger, type prevents the NO_SETTER_ERROR_COMPOSITE_TYPE spreading from foo to bar
get_manager(bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
get_manager(foo).add_composite_type(NO_SETTER_ERROR_COMPOSITE_TYPE)
self.assertIs(foo.bar, bar)
self.assertEquals(len(get_manager(foo).attached_types), 1)
self.assertEquals(len(get_manager(foo.bar).attached_types), 1)
# ... but when bar is replaced with a new object without constraints, the PythonObjectType
# spreads to the new object
foo.bar = PythonObject({
"baz": 123
})
self.assertIsNot(foo.bar, bar)
self.assertEquals(len(get_manager(foo.bar).attached_types), 1)
# Now that the new object has the PythonObjectType constraint, we can't bind a stronger
# constraint
with self.assertRaises(CompositeTypeIncompatibleWithTarget):
get_manager(foo.bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
def test_python_like_object(self):
obj = PythonObject({ "foo": "hello" })
get_manager(obj).add_composite_type(CompositeType({
("get", "foo"): GetterMicroOpType("foo", AnyType()),
("set", "foo"): SetterMicroOpType("foo", AnyType())
}, name="test"))
self.assertEquals(obj.foo, "hello")
obj.foo = "what"
self.assertEquals(obj.foo, "what")
def test_changes_blocked_without_micro_ops(self):
foo = PythonObject({
"bar": PythonObject({
"baz": 42
})
})
get_manager(foo)
with self.assertRaises(Exception):
foo.bar = "hello"
def test_broadening_with_const_is_ok(self):
foo = PythonObject({
"bar": 42
})
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": UnitType(42)
}))
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": Const(IntegerType())
}))
def test_narrowing_blocked(self):
foo = PythonObject({
"bar": 42
})
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": IntegerType()
}))
with self.assertRaises(CompositeTypeIncompatibleWithTarget):
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": UnitType(42)
}))
def test_insert_on_long_tuple(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(
UniversalLupleType(
[ IntegerType(), IntegerType() ],
IntegerType()
)
)
foo.insert(0, 2)
self.assertEqual(list(foo), [ 2, 4, 6, 8 ])
def test_mixed_type_tuple(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), AnyType() ]))
with self.assertRaises(TypeError):
foo[0] = "hello"
self.assertEqual(foo[0], 4)
foo[1] = "what"
self.assertEqual(foo[1], "what")
def test_python_delete_works(self):
foo = PythonObject({
"bar": PythonObject({
"baz": 42
})
})
get_manager(foo).add_composite_type(DEFAULT_COMPOSITE_TYPE)
del foo.bar
self.assertFalse(hasattr(foo, "bar"))
def test_python_random_read_fails_nicely(self):
foo = PythonObject({
"bar": PythonObject({
"baz": 42
})
})
get_manager(foo).add_composite_type(DEFAULT_COMPOSITE_TYPE)
with self.assertRaises(AttributeError):
foo.bop
def test_default_dict(self):
def default_factory(target, key):
return "{}-123".format(key)
foo = PythonObject({
"bar": "forty-two"
}, default_factory=default_factory)
get_manager(foo).add_composite_type(UniversalDefaultDictType(StringType(), StringType(), name="test"))
self.assertEquals(foo.bar, "forty-two")
self.assertEquals(foo.bam, "bam-123")
