def test_rev_const_merge_types_in_list(self):
rev_const_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, StringType()),
("get", 1): GetterMicroOpType(1, IntegerType()),
("set", 1): SetterMicroOpType(1, IntegerType()),
("get", 2): GetterMicroOpType(2, AnyType()),
("set", 2): SetterMicroOpType(2, AnyType()),
("insert-start", ): InsertStartMicroOpType(StringType(), False)
}, name="test")
normal_broad_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, StringType()),
("get", 1): GetterMicroOpType(1, IntegerType()),
("set", 1): SetterMicroOpType(1, IntegerType()),
("get", 2): GetterMicroOpType(2, AnyType()),
("set", 2): SetterMicroOpType(2, AnyType()),
}, name="test")
self.assertFalse(rev_const_type.is_self_consistent(DUMMY_REASONER))
rev_const_type = prepare_lhs_type(rev_const_type, None)
self.assertTrue(rev_const_type.is_self_consistent(DUMMY_REASONER))
self.assertTrue(normal_broad_type.is_copyable_from(rev_const_type, DUMMY_REASONER))
def test_basic_ignored(self):
foo = UniversalObjectType({
"bar": StringType()
})
foo = prepare_lhs_type(foo, UniversalObjectType({
"bar": IntegerType()
}))
self.assertIsInstance(foo.get_micro_op_type(("get", "bar")).value_type, StringType)
def test_dangling_error(self):
foo = UniversalObjectType({
"bar": InferredType()
})
with self.assertRaises(DanglingInferredType):
foo = prepare_lhs_type(foo, UniversalObjectType({
"bam": StringType()
}))
check_dangling_inferred_types(foo, {})
def test_composite_types_inferred(self):
foo = UniversalObjectType({
"bar": InferredType()
})
foo = prepare_lhs_type(foo, UniversalObjectType({
"bar": UniversalObjectType({
"bam": IntegerType()
})
}))
self.assertIsInstance(foo.get_micro_op_type(("get", "bar")).value_type.get_micro_op_type(("get", "bam")).value_type, IntegerType)
def test_double_nested(self):
Initial_Foo = UniversalObjectType({
"bar": UniversalObjectType({
"bam": InferredType()
})
})
RHS_Foo = UniversalObjectType({
"bar": UniversalObjectType({
"bam": IntegerType()
})
})
resolved_Foo = prepare_lhs_type(Initial_Foo, RHS_Foo)
self.assertIsInstance(resolved_Foo.get_micro_op_type(("get", "bar")).value_type.get_micro_op_type(("get", "bam")).value_type, IntegerType)
def prepare_piece_of_context(declared_type, suggested_type):
if suggested_type and not isinstance(suggested_type, Type):
raise FatalError()
final_type = prepare_lhs_type(declared_type, suggested_type)
if not check_dangling_inferred_types(final_type, {}):
raise PreparationException("Invalid inferred types")
is_piece_self_consistent_reasoner = Reasoner()
if isinstance(
final_type, CompositeType
) and not final_type.is_self_consistent(is_piece_self_consistent_reasoner):
raise FatalError(is_piece_self_consistent_reasoner.to_message())
return final_type
def test_rev_const_flatten_tuple(self):
rev_const_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, AnyType())
}, name="test")
normal_broad_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, StringType())
}, name="test")
rev_const_type = prepare_lhs_type(rev_const_type, None)
self.assertTrue(isinstance(rev_const_type.get_micro_op_type(("set", 0)).value_type, StringType))
self.assertTrue(normal_broad_type.is_copyable_from(rev_const_type, DUMMY_REASONER))
def test_rev_const_wildcard(self):
rev_const_type = CompositeType({
("get-wildcard", ): GetterWildcardMicroOpType(StringType(), StringType(), True),
("set-wildcard", ): SetterWildcardMicroOpType(StringType(), AnyType(), False, False)
}, name="test")
normal_broad_type = CompositeType({
("get", "foo"): GetterWildcardMicroOpType(StringType(), StringType(), True),
("set", "foo"): SetterWildcardMicroOpType(StringType(), StringType(), False, False)
}, name="test")
rev_const_type = prepare_lhs_type(rev_const_type, None)
self.assertTrue(isinstance(rev_const_type.get_micro_op_type(("set-wildcard",)).value_type, StringType))
self.assertTrue(normal_broad_type.is_copyable_from(rev_const_type, DUMMY_REASONER))
def prepare(data, outer_context, frame_manager, immediate_context=None):
if not isinstance(data, Composite):
raise FatalError()
get_manager(data).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE)
if not hasattr(data, "code"):
raise PreparationException("Code missing from function")
actual_break_types_factory = BreakTypesFactory(None)
context = Universal(True,
initial_wrapped={"prepare": outer_context},
bind=DEFAULT_READONLY_COMPOSITE_TYPE,
debug_reason="static-prepare-context")
static = evaluate(
enrich_opcode(
data.static,
combine(type_conditional_converter,
UnboundDereferenceBinder(context))), context,
frame_manager)
get_manager(static).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE)
argument_type = enrich_type(static._get("argument"))
outer_type = enrich_type(static._get("outer"))
suggested_argument_type = suggested_outer_type = None
if immediate_context:
suggested_argument_type = immediate_context.get(
"suggested_argument_type", None)
suggested_outer_type = immediate_context.get("suggested_outer_type",
None)
if suggested_outer_type is None:
suggested_outer_type = NoValueType()
try:
argument_type = prepare_piece_of_context(argument_type,
suggested_argument_type)
except DanglingInferredType:
raise PreparationException(
"Failed to infer argument types in {} from {}".format(
argument_type, suggested_argument_type))
try:
outer_type = prepare_piece_of_context(outer_type, suggested_outer_type)
except DanglingInferredType:
raise PreparationException(
"Failed to infer outer types in {} from {}".format(
argument_type, suggested_argument_type))
local_type = enrich_type(static._get("local"))
context = Universal(
True,
initial_wrapped={
"prepare":
outer_context,
"static":
static,
# "types": derich_type(
# UniversalObjectType({
# "outer": outer_type,
# "argument": argument_type,
## "local": local_type
# }), {}
# ),
"_types":
Universal(
True,
initial_wrapped={
"outer": outer_type,
"argument": argument_type,
# "local": local_type
},
debug_reason="local-prepare-context")
},
bind=DEFAULT_READONLY_COMPOSITE_TYPE,
debug_reason="local-prepare-context")
# optimization to avoid generating context_type lazily
get_manager(context)._context_type = UniversalObjectType(
{
"outer": outer_type,
"argument": argument_type,
# "local": local_type
},
wildcard_type=AnyType(),
name="local-prepare-context-type")
local_initializer = enrich_opcode(
data.local_initializer,
combine(type_conditional_converter, UnboundDereferenceBinder(context)))
actual_local_type, local_other_break_types = get_expression_break_types(
local_initializer, context, frame_manager)
get_manager(context).remove_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE)
if actual_local_type is MISSING:
raise PreparationException(
"Actual local type missing. local_other_break_types: {}".format(
local_other_break_types))
actual_local_type = flatten_out_types(actual_local_type)
local_type = prepare_piece_of_context(local_type, actual_local_type)
local_type_reasoner = Reasoner()
if not local_type.is_copyable_from(actual_local_type, local_type_reasoner):
raise PreparationException("Invalid local type: {} != {}: {}".format(
local_type, actual_local_type, local_type_reasoner.to_message()))
actual_break_types_factory.merge(local_other_break_types)
declared_break_types = PythonDict({
mode: PythonList([
enrich_break_type(break_type)
for break_type in break_types._values()
])
for mode, break_types in static._get("break_types")._items()
})
get_manager(declared_break_types).add_composite_type(
DEFAULT_READONLY_COMPOSITE_TYPE)
context = Universal(
True,
initial_wrapped={
"prepare":
outer_context,
"static":
static,
# "types": derich_type(
# UniversalObjectType({
# "outer": outer_type,
# "argument": argument_type,
# "local": local_type
# }), {}
# ),
"_types":
Universal(True,
initial_wrapped={
"outer": outer_type,
"argument": argument_type,
"local": local_type
},
debug_reason="code-prepare-context")
},
bind=DEFAULT_READONLY_COMPOSITE_TYPE,
debug_reason="code-prepare-context")
get_manager(context)._context_type = UniversalObjectType(
{
"outer": outer_type,
"argument": argument_type,
"local": local_type
},
wildcard_type=AnyType(),
name="code-prepare-context-type")
code = enrich_opcode(
data.code,
combine(type_conditional_converter, UnboundDereferenceBinder(context)))
code_break_types = code.get_break_types(context, frame_manager)
get_manager(context).remove_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE)
actual_break_types_factory.merge(code_break_types)
final_declared_break_types = BreakTypesFactory(None)
for mode, actual_break_types in actual_break_types_factory.build().items():
for actual_break_type in actual_break_types:
declared_break_types_for_mode = declared_break_types.get(
mode, declared_break_types.get("wildcard", []))
for declared_break_type_for_mode in declared_break_types_for_mode:
# Check if this declared_break_type_for_mode is enough to capture the actual_break_types
declared_out = declared_break_type_for_mode["out"]
declared_in = declared_break_type_for_mode.get("in", None)
actual_out = actual_break_type["out"]
actual_in = actual_break_type.get("in", None)
final_out = prepare_lhs_type(declared_out, actual_out)
if declared_in is not None:
if isinstance(declared_in,
InferredType) and actual_in is None:
final_in = None
else:
final_in = prepare_lhs_type(declared_in, actual_in)
else:
final_in = declared_in
# if declared_in is not None and actual_in is None:
# continue
out_is_compatible = final_out.is_copyable_from(
actual_out, DUMMY_REASONER)
in_is_compatible = final_in is None or actual_in.is_copyable_from(
final_in, DUMMY_REASONER)
if out_is_compatible and in_is_compatible:
final_declared_break_types.add(mode, final_out, final_in)
break
else:
raise PreparationException(
"""Nothing declared for {}, {}.\nFunction declares break types {}.\nBut local_initialization breaks {}, code breaks {}"""
.format(mode, actual_break_type, declared_break_types,
local_other_break_types, code_break_types))
return OpenFunction(data, code, outer_context, static, argument_type,
outer_type, local_type, local_initializer,
final_declared_break_types.build())
def test_reified_extreme_type_contains_no_conflicts(self):
foo = prepare_lhs_type(UniversalLupleType([ IntegerType() ], IntegerType()), None)
self.assertTrue(foo.is_self_consistent(DUMMY_REASONER))
def test_basic(self):
foo = InferredType()
foo = prepare_lhs_type(foo, IntegerType())
self.assertIsInstance(foo, IntegerType)