def test_dataflow_assignment_node_attribute(graph: DataflowGraph,
instantiate: bool) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
if instantiate:
y.assign(create_instance().reference(), Statement(), graph)
x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n")
assignment_node: AssignableNode = x_n.assignment_node()
instance: InstanceNode
if instantiate:
assert isinstance(y, VariableNodeReference)
assert len(y.node.instance_assignments) == 1
instance = y.node.instance_assignments[0].rhs.node()
else:
assert isinstance(z, VariableNodeReference)
assert z.node.equivalence.tentative_instance is not None
instance = z.node.equivalence.tentative_instance
# verify tentative nodes only get created once
assignment_node2: AssignableNode = x_n.assignment_node()
assert assignment_node == assignment_node2
assert assignment_node == instance.get_attribute("n")
def test_dataflow_tentative_attribute_propagation_on_equivalence(
graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
z.assign(x, Statement(), graph)
x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n")
x_n.assign(ValueNode(42).reference(), Statement(), graph)
assert isinstance(y, VariableNodeReference)
assert len(y.node.instance_assignments) == 0
y.assign(create_instance().reference(), Statement(), graph)
assert len(y.node.instance_assignments) == 1
y_n: Optional[AttributeNode] = y.node.instance_assignments[0].rhs.node(
).get_attribute("n")
assert y_n is not None
assert len(y_n.value_assignments) == 1
assert y_n.value_assignments[0].rhs.node.value == 42
def test_dataflow_assignment_node_simple(graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
x.assign(y, Statement(), graph)
assert isinstance(x, VariableNodeReference)
assert x.assignment_node() == x.node
def test_dataflow_variable_chain_leaf(graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
leaves: Set[AssignableNode] = set(x.leaf_nodes())
assert isinstance(z, DirectNodeReference)
assert leaves == {z.node}
def test_dataflow_variable_tree_leaves(graph: DataflowGraph,
value_node: Node) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
y.assign(value_node.reference(), Statement(), graph)
leaves: Set[AssignableNode] = set(x.leaf_nodes())
assert isinstance(y, DirectNodeReference)
assert isinstance(z, DirectNodeReference)
assert leaves == {y.node, z.node}
def test_dataflow_model_attribute_assignment_responsible(
dataflow_test_helper: DataflowTestHelper) -> None:
dataflow_test_helper.compile("""
entity Test:
number n
end
implement Test using std::none
x = Test()
x.n = 42
""")
graph: DataflowGraph = dataflow_test_helper.get_graph()
x: AssignableNodeReference = get_dataflow_node(graph, "x")
assert isinstance(x, VariableNodeReference)
assert len(x.node.instance_assignments) == 1
n: Optional[AttributeNode] = x.node.instance_assignments[0].rhs.node(
).get_attribute("n")
assert n is not None
assert len(n.value_assignments) == 1
assignment: Assignment[ValueNodeReference] = n.value_assignments[0]
assert isinstance(assignment.responsible, SetAttribute)
assert assignment.responsible.instance.name == "x"
assert assignment.responsible.attribute_name == "n"
assert isinstance(assignment.responsible.value, Literal)
assert assignment.responsible.value.value == 42
assert assignment.context == graph
def test_dataflow_variable_loop_with_external_assignment_leaves(
graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
z.assign(x, Statement(), graph)
u: AssignableNodeReference = get_dataflow_node(graph, "u")
y.assign(u, Statement(), graph)
leaves: Set[AssignableNode] = set(x.leaf_nodes())
assert isinstance(u, DirectNodeReference)
assert leaves == {u.node}
def test_dataflow_variable_loop_with_value_assignment_leaves(
graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
z.assign(x, Statement(), graph)
y.assign(ValueNode(42).reference(), Statement(), graph)
leaves: Set[AssignableNode] = set(x.leaf_nodes())
assert isinstance(x, DirectNodeReference)
assert isinstance(y, DirectNodeReference)
assert isinstance(z, DirectNodeReference)
assert leaves == {y.node}
def test_dataflow_assignment_node_nested_tentative(
graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
x_a_n: AssignableNodeReference = get_dataflow_node(graph, "x.a.n")
assignment_node: AssignableNode = x_a_n.assignment_node()
assert isinstance(x, VariableNodeReference)
instance: Optional[InstanceNode] = x.node.equivalence.tentative_instance
assert instance is not None
a: Optional[AttributeNode] = instance.get_attribute("a")
assert a is not None
instance2: Optional[InstanceNode] = a.equivalence.tentative_instance
assert instance2 is not None
n: Optional[AttributeNode] = instance2.get_attribute("n")
assert assignment_node == n
def test_dataflow_attribute_reference_nodes(graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
x.assign(y, Statement(), graph)
y.assign(create_instance().reference(), Statement(), graph)
assert isinstance(y, VariableNodeReference)
assert len(y.node.instance_assignments) == 1
y_n: AssignableNodeReference = get_dataflow_node(graph, "y.n")
y_n.assign(ValueNode(42).reference(), Statement(), graph)
x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n")
x_n_nodes: List[AssignableNode] = list(x_n.nodes())
assert len(x_n_nodes) == 1
assert x_n_nodes[0] == y.node.instance_assignments[0].rhs.node(
).get_attribute("n")
def test_dataflow_tentative_attribute_propagation_over_uninitialized_attribute(
graph: DataflowGraph) -> None:
x_y: AssignableNodeReference = get_dataflow_node(graph, "x.y")
u_n: AssignableNodeReference = get_dataflow_node(graph, "u.n")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
u: AssignableNodeReference = get_dataflow_node(graph, "u")
u_n.assign(ValueNode(42).reference(), Statement(), graph)
x_y.assign(y, Statement(), graph)
u.assign(x_y, Statement(), graph)
assert isinstance(y, VariableNodeReference)
instance: Optional[InstanceNode] = y.node.equivalence.tentative_instance
assert instance is not None
n: Optional[AttributeNode] = instance.get_attribute("n")
assert n is not None
assert len(n.value_assignments) == 1
assert n.value_assignments[0].rhs.node.value == 42
def test_dataflow_primitive_assignment(graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
statement: Statement = Statement()
x.assign(ValueNode(42).reference(), statement, graph)
assert isinstance(x, DirectNodeReference)
assert len(x.node.value_assignments) == 1
assignment: Assignment[ValueNodeReference] = x.node.value_assignments[0]
assert assignment.lhs == x.node
assert assignment.rhs.node == ValueNode(42)
assert assignment.responsible == statement
assert assignment.context == graph
def test_attribute_assignment(graph: DataflowGraph, instantiate: bool) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n")
if instantiate:
x.assign(create_instance().reference(), Statement(), graph)
x_n.assign(ValueNode(42).reference(), Statement(), graph)
assert isinstance(x, VariableNodeReference)
instance: InstanceNode
if instantiate:
assert x.node.equivalence.tentative_instance is None
assert len(x.node.instance_assignments) == 1
instance = x.node.instance_assignments[0].rhs.node()
else:
assert x.node.equivalence.tentative_instance is not None
instance = x.node.equivalence.tentative_instance
n: Optional[AttributeNode] = instance.get_attribute("n")
assert n is not None
assert len(n.value_assignments) == 1
assert n.value_assignments[0].rhs == ValueNode(42).reference()
def test_dataflow_index_nodes(graph: DataflowGraph) -> None:
entity: Entity = Entity("DummyEntity", Namespace("dummy_namespace"))
i1: InstanceNode = create_instance(graph, entity)
i2: InstanceNode = create_instance(graph, entity)
i1.register_attribute("n").assign(
ValueNode(0).reference(), Statement(), graph)
i1.register_attribute("n").assign(
ValueNode(0).reference(), Statement(), graph)
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
x.assign(i1.reference(), Statement(), graph)
y.assign(i2.reference(), Statement(), graph)
graph.add_index_match([i.reference() for i in [i1, i2]])
x_n: AssignableNodeReference = get_dataflow_node(graph, "x.n")
y_n: AssignableNodeReference = get_dataflow_node(graph, "y.n")
assert set(x_n.nodes()) == set(y_n.nodes())
def test_dataflow_nodestub(dataflow_test_helper: DataflowTestHelper,
value_string: str, other_stmts: List[str]) -> None:
dataflow_test_helper.compile(
"""
x = %s
%s
""" % (value_string, "\n".join(other_stmts)), )
graph: DataflowGraph = dataflow_test_helper.get_graph()
x: AssignableNodeReference = get_dataflow_node(graph, "x")
assert isinstance(x, VariableNodeReference)
assignments: List[Assignment] = list(x.node.assignments())
assert len(assignments) == 1
assert isinstance(assignments[0].rhs, ValueNodeReference)
assert isinstance(assignments[0].rhs.node, NodeStub)
def test_dataflow_model_primitive_assignment_responsible(
dataflow_test_helper: DataflowTestHelper) -> None:
dataflow_test_helper.compile("""
x = 42
""", )
graph: DataflowGraph = dataflow_test_helper.get_graph()
x: AssignableNodeReference = get_dataflow_node(graph, "x")
assert isinstance(x, VariableNodeReference)
assert len(x.node.value_assignments) == 1
assignment: Assignment[ValueNodeReference] = x.node.value_assignments[0]
assert isinstance(assignment.responsible, Assign)
assert assignment.responsible.name == "x"
assert isinstance(assignment.responsible.value, Literal)
assert assignment.responsible.value.value == 42
assert assignment.context == graph
def test_dataflow_model_implementation_assignment_from_self(
dataflow_test_helper: DataflowTestHelper, explicit: bool) -> None:
dataflow_test_helper.compile(
"""
entity A:
number n
end
entity B:
number n
end
A.b [1] -- B
implementation i for A:
self.b = B(n = %s)
end
implement A using i
implement B using std::none
n = 0
x = A(n = 42)
b = x.b
""" % ("self.n" if explicit else "n"), )
dataflow_test_helper.verify_graphstring(
"""
n -> 0
x -> <instance> x
<instance> x . n -> 42
<instance> x . b -> <instance> b
b -> x . b
""", )
dataflow_test_helper.verify_leaves({"b.n": {"x.n"}})
leaves: List[AssignableNode] = list(
get_dataflow_node(dataflow_test_helper.get_graph(),
"b.n").leaf_nodes())
assert len(leaves) == 1
assert len(leaves[0].value_assignments) == 1
assert leaves[0].value_assignments[0].rhs.node.value == 42
def test_dataflow_tentative_attribute_propagation(
graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
y: AssignableNodeReference = get_dataflow_node(graph, "y")
z: AssignableNodeReference = get_dataflow_node(graph, "z")
x.assign(y, Statement(), graph)
y.assign(z, Statement(), graph)
x_a_n: AssignableNodeReference = get_dataflow_node(graph, "x.a.n")
x_a_n.assign(ValueNode(42).reference(), Statement(), graph)
def assert_tentative_a_n(var: AssignableNode,
values: Optional[Set[int]] = None) -> None:
if values is None:
values = {42}
instance: Optional[InstanceNode] = var.equivalence.tentative_instance
assert instance is not None
a: Optional[AttributeNode] = instance.get_attribute("a")
assert a is not None
instance2: Optional[InstanceNode] = a.equivalence.tentative_instance
assert instance2 is not None
n: Optional[AttributeNode] = instance2.get_attribute("n")
assert n is not None
assert len(n.value_assignments) == len(values)
assert {
assignment.rhs.node.value
for assignment in n.value_assignments
} == values
assert isinstance(z, VariableNodeReference)
assert_tentative_a_n(z.node)
u: AssignableNodeReference = get_dataflow_node(graph, "u")
v: AssignableNodeReference = get_dataflow_node(graph, "v")
u.assign(v, Statement(), graph)
z.assign(u, Statement(), graph)
assert isinstance(z, VariableNodeReference)
assert z.node.equivalence.tentative_instance is None
assert isinstance(v, VariableNodeReference)
assert_tentative_a_n(v.node)
x_a_n.assign(ValueNode(0).reference(), Statement(), graph)
assert_tentative_a_n(v.node, {0, 42})
def test_dataflow_model_primitive_double_assignment_responsible(
dataflow_test_helper: DataflowTestHelper) -> None:
dataflow_test_helper.compile(
"""
x = 42
x = 0
""",
DoubleSetException,
)
graph: DataflowGraph = dataflow_test_helper.get_graph()
x: AssignableNodeReference = get_dataflow_node(graph, "x")
assert isinstance(x, VariableNodeReference)
assignments: List[Assignment] = x.node.value_assignments
assert len(assignments) == 2
zero_index: int = [assignment.rhs for assignment in assignments
].index(ValueNode(0).reference())
for i, assignment in enumerate(assignments):
value: int = 0 if i == zero_index else 42
assert assignment.context == graph
assert isinstance(assignment.responsible, Assign)
assert assignment.responsible.name == "x"
assert isinstance(assignment.responsible.value, Literal)
assert assignment.responsible.value.value == value
def test_dataflow_reference_nodes(graph: DataflowGraph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
x_nodes: List[AssignableNode] = list(x.nodes())
assert len(x_nodes) == 1
assert isinstance(x, DirectNodeReference)
assert x_nodes[0] == x.node
def get_attribute_node(graph: DataflowGraph, attr: str) -> AttributeNode:
node_ref: AssignableNodeReference = get_dataflow_node(graph, attr)
node: AssignableNode = next(node_ref.nodes())
assert isinstance(node, AttributeNode)
return node
def test_dataflow_simple_leaf(graph) -> None:
x: AssignableNodeReference = get_dataflow_node(graph, "x")
leaves: List[AssignableNode] = list(x.leaf_nodes())
assert isinstance(x, DirectNodeReference)
assert leaves == [x.node]
