diff --git a/guppylang/checker/stmt_checker.py b/guppylang/checker/stmt_checker.py
index 13ca25e6..b4f8db48 100644
--- a/guppylang/checker/stmt_checker.py
+++ b/guppylang/checker/stmt_checker.py
@@ -11,7 +11,7 @@
import ast
from collections.abc import Sequence
-from guppylang.ast_util import AstVisitor, with_loc
+from guppylang.ast_util import AstVisitor, with_loc, with_type
from guppylang.cfg.bb import BB, BBStatement
from guppylang.checker.core import Context, FieldAccess, Variable
from guppylang.checker.expr_checker import ExprChecker, ExprSynthesizer
@@ -53,7 +53,7 @@ def _check_assign(self, lhs: ast.expr, ty: Type, node: ast.stmt) -> ast.expr:
case ast.Name(id=x):
var = Variable(x, ty, lhs)
self.ctx.locals[x] = var
- return with_loc(lhs, PlaceNode(place=var))
+ return with_loc(lhs, with_type(ty, PlaceNode(place=var)))
# The LHS could also be a field `expr.field`
case ast.Attribute(value=value, attr=attr):
@@ -93,7 +93,7 @@ def _check_assign(self, lhs: ast.expr, ty: Type, node: ast.stmt) -> ast.expr:
"Mutation of classical fields is not supported yet", lhs
)
place = FieldAccess(value.place, struct_ty.field_dict[attr], lhs)
- return with_loc(lhs, PlaceNode(place=place))
+ return with_loc(lhs, with_type(ty, PlaceNode(place=place)))
# The only other thing we support right now are tuples
case ast.Tuple(elts=elts) as lhs:
@@ -109,7 +109,7 @@ def _check_assign(self, lhs: ast.expr, ty: Type, node: ast.stmt) -> ast.expr:
self._check_assign(pat, el_ty, node)
for pat, el_ty in zip(elts, tys, strict=True)
]
- return lhs
+ return with_type(ty, lhs)
# TODO: Python also supports assignments like `[a, b] = [1, 2]` or
# `a, *b = ...`. The former would require some runtime checks but
diff --git a/guppylang/compiler/cfg_compiler.py b/guppylang/compiler/cfg_compiler.py
index 8ae096de..fc28daee 100644
--- a/guppylang/compiler/cfg_compiler.py
+++ b/guppylang/compiler/cfg_compiler.py
@@ -1,5 +1,11 @@
import functools
-from typing import TYPE_CHECKING
+from collections.abc import Sequence
+
+from hugr import Wire, ops
+from hugr import cfg as hc
+from hugr import tys as ht
+from hugr.dfg import DP, _DfBase
+from hugr.node_port import ToNode
from guppylang.checker.cfg_checker import CheckedBB, CheckedCFG, Row, Signature
from guppylang.checker.core import Place, Variable
@@ -11,62 +17,68 @@
)
from guppylang.compiler.expr_compiler import ExprCompiler
from guppylang.compiler.stmt_compiler import StmtCompiler
-from guppylang.hugr_builder.hugr import CFNode, Hugr, Node, OutPortV
-from guppylang.tys.builtin import is_bool_type
from guppylang.tys.ty import SumType, row_to_type, type_to_row
-if TYPE_CHECKING:
- from collections.abc import Sequence
-
def compile_cfg(
- cfg: CheckedCFG[Place], graph: Hugr, parent: Node, globals: CompiledGlobals
-) -> None:
+ cfg: CheckedCFG[Place],
+ container: _DfBase[DP],
+ inputs: Sequence[Wire],
+ globals: CompiledGlobals,
+) -> hc.Cfg:
"""Compiles a CFG to Hugr."""
insert_return_vars(cfg)
- blocks: dict[CheckedBB[Place], CFNode] = {}
+ builder = container.add_cfg(*inputs)
+
+ blocks: dict[CheckedBB[Place], ToNode] = {}
for bb in cfg.bbs:
- blocks[bb] = compile_bb(bb, graph, parent, bb == cfg.entry_bb, globals)
+ blocks[bb] = compile_bb(bb, builder, bb == cfg.entry_bb, globals)
for bb in cfg.bbs:
- for succ in bb.successors:
- graph.add_edge(blocks[bb].add_out_port(), blocks[succ].in_port(None))
+ for i, succ in enumerate(bb.successors):
+ builder.branch(blocks[bb][i], blocks[succ])
+
+ return builder
def compile_bb(
bb: CheckedBB[Place],
- graph: Hugr,
- parent: Node,
+ builder: hc.Cfg,
is_entry: bool,
globals: CompiledGlobals,
-) -> CFNode:
- """Compiles a single basic block to Hugr."""
- inputs = bb.sig.input_row if is_entry else sort_vars(bb.sig.input_row)
+) -> ToNode:
+ """Compiles a single basic block to Hugr, and returns the resulting block.
+ If the basic block is the output block, returns `None`.
+ """
# The exit BB is completely empty
if len(bb.successors) == 0:
assert len(bb.statements) == 0
- return graph.add_exit([v.ty for v in inputs], parent)
+ return builder.exit
# Otherwise, we use a regular `Block` node
- block = graph.add_block(parent)
+ block: hc.Block
+ inputs: Sequence[Place]
+ if is_entry:
+ inputs = bb.sig.input_row
+ block = builder.add_entry()
+ else:
+ inputs = sort_vars(bb.sig.input_row)
+ block = builder.add_block(*(v.ty.to_hugr() for v in inputs))
# Add input node and compile the statements
- inp = graph.add_input(output_tys=[v.ty for v in inputs], parent=block)
- dfg = DFContainer(graph, block)
- for i, v in enumerate(inputs):
- dfg[v] = inp.out_port(i)
- dfg = StmtCompiler(graph, globals).compile_stmts(bb.statements, dfg)
+ dfg = DFContainer(block)
+ for v, wire in zip(inputs, block.input_node, strict=True):
+ dfg[v] = wire
+ dfg = StmtCompiler(globals).compile_stmts(bb.statements, dfg)
# If we branch, we also have to compile the branch predicate
if len(bb.successors) > 1:
assert bb.branch_pred is not None
- branch_port = ExprCompiler(graph, globals).compile(bb.branch_pred, dfg)
+ branch_port = ExprCompiler(globals).compile(bb.branch_pred, dfg)
else:
# Even if we don't branch, we still have to add a `Sum(())` predicates
- branch_port = graph.add_tag(
- variants=[[]], tag=0, inputs=[], parent=block
- ).out_port(0)
+ branch_port = dfg.builder.add_op(ops.Tag(0, ht.UnitSum(1)))
# Finally, we have to add the block output.
outputs: Sequence[Place]
@@ -87,7 +99,6 @@ def compile_bb(
# ordering on variables which puts linear variables at the end. The only
# exception are return vars which must be outputted in order.
branch_port = choose_vars_for_tuple_sum(
- graph=graph,
unit_sum=branch_port,
output_vars=[
[
@@ -101,9 +112,7 @@ def compile_bb(
)
outputs = [v for v in first if v.ty.linear and not is_return_var(str(v))]
- graph.add_output(
- inputs=[branch_port] + [dfg[v] for v in sort_vars(outputs)], parent=block
- )
+ block.set_block_outputs(branch_port, *(dfg[v] for v in sort_vars(outputs)))
return block
@@ -130,27 +139,23 @@ def insert_return_vars(cfg: CheckedCFG[Place]) -> None:
def choose_vars_for_tuple_sum(
- graph: Hugr, unit_sum: OutPortV, output_vars: list[Row[Place]], dfg: DFContainer
-) -> OutPortV:
+ unit_sum: Wire, output_vars: list[Row[Place]], dfg: DFContainer
+) -> Wire:
"""Selects an output based on a TupleSum.
Given `unit_sum: Sum(*(), *(), ...)` and output variable rows `#s1, #s2, ...`,
constructs a TupleSum value of type `Sum(#s1, #s2, ...)`.
"""
- assert isinstance(unit_sum.ty, SumType) or is_bool_type(unit_sum.ty)
- assert len(output_vars) == (
- len(unit_sum.ty.element_types) if isinstance(unit_sum.ty, SumType) else 2
- )
assert all(not v.ty.linear for var_row in output_vars for v in var_row)
- conditional = graph.add_conditional(cond_input=unit_sum, inputs=[], parent=dfg.node)
tys = [[v.ty for v in var_row] for var_row in output_vars]
- for i, var_row in enumerate(output_vars):
- case = graph.add_case(conditional)
- graph.add_input(output_tys=[], parent=case)
- inputs = [dfg[v] for v in var_row]
- tag = graph.add_tag(variants=tys, tag=i, inputs=inputs, parent=case).out_port(0)
- graph.add_output(inputs=[tag], parent=case)
- return conditional.add_out_port(SumType([row_to_type(row) for row in tys]))
+ sum_type = SumType([row_to_type(row) for row in tys]).to_hugr()
+
+ with dfg.builder.add_conditional(unit_sum) as conditional:
+ for i, var_row in enumerate(output_vars):
+ with conditional.add_case(i) as case:
+ tag = case.add_op(ops.Tag(i, sum_type), *(dfg[v] for v in var_row))
+ case.set_outputs(tag)
+ return conditional
def compare_var(p1: Place, p2: Place) -> int:
diff --git a/guppylang/compiler/core.py b/guppylang/compiler/core.py
index 5110b65b..0abc642a 100644
--- a/guppylang/compiler/core.py
+++ b/guppylang/compiler/core.py
@@ -1,32 +1,43 @@
from abc import ABC
from dataclasses import dataclass, field
+from typing import cast
+
+from hugr import Wire, ops
+from hugr.dfg import DP, _DfBase
from guppylang.checker.core import FieldAccess, Place, PlaceId, Variable
from guppylang.definition.common import CompiledDef, DefId
from guppylang.error import InternalGuppyError
-from guppylang.hugr_builder.hugr import DFContainingNode, Hugr, OutPortV
from guppylang.tys.ty import StructType
CompiledGlobals = dict[DefId, CompiledDef]
-CompiledLocals = dict[PlaceId, OutPortV]
+CompiledLocals = dict[PlaceId, Wire]
@dataclass
class DFContainer:
"""A dataflow graph under construction.
- This class is passed through the entire compilation pipeline and stores the node
- whose dataflow child-graph is currently being constructed as well as all live local
+ This class is passed through the entire compilation pipeline and stores a builder
+ for the dataflow child-graph currently being constructed as well as all live local
variables. Note that the variable map is mutated in-place and always reflects the
current compilation state.
"""
- graph: Hugr
- node: DFContainingNode
+ builder: _DfBase[ops.DfParentOp]
locals: CompiledLocals = field(default_factory=dict)
- def __getitem__(self, place: Place) -> OutPortV:
- """Constructs a port for a local place in this DFG.
+ def __init__(
+ self, builder: _DfBase[DP], locals: CompiledLocals | None = None
+ ) -> None:
+ generic_builder = cast(_DfBase[ops.DfParentOp], builder)
+ if locals is None:
+ locals = {}
+ self.builder = generic_builder
+ self.locals = locals
+
+ def __getitem__(self, place: Place) -> Wire:
+ """Constructs a wire for a local place in this DFG.
Note that this mutates the Hugr since we might need to pack or unpack some
tuples to obtain a port for places that involve struct fields.
@@ -39,23 +50,24 @@ def __getitem__(self, place: Place) -> OutPortV:
if not isinstance(place.ty, StructType):
raise InternalGuppyError(f"Couldn't obtain a port for `{place}`")
children = [FieldAccess(place, field, None) for field in place.ty.fields]
- child_ports = [self[child] for child in children]
- port = self.graph.add_make_tuple(child_ports, self.node).out_port(0)
+ child_types = [child.ty.to_hugr() for child in children]
+ child_wires = [self[child] for child in children]
+ wire = self.builder.add_op(ops.MakeTuple(child_types), *child_wires)[0]
for child in children:
if child.ty.linear:
self.locals.pop(child.id)
- self.locals[place.id] = port
- return port
+ self.locals[place.id] = wire
+ return wire
- def __setitem__(self, place: Place, port: OutPortV) -> None:
+ def __setitem__(self, place: Place, port: Wire) -> None:
# When assigning a struct value, we immediately unpack it recursively and only
# store the leaf wires.
is_return = isinstance(place, Variable) and is_return_var(place.name)
if isinstance(place.ty, StructType) and not is_return:
- unpack = self.graph.add_unpack_tuple(port, self.node)
- for field, field_port in zip(
- place.ty.fields, unpack.out_ports, strict=True
- ):
+ unpack = self.builder.add_op(
+ ops.UnpackTuple([t.ty.to_hugr() for t in place.ty.fields]), port
+ )
+ for field, field_port in zip(place.ty.fields, unpack, strict=True):
self[FieldAccess(place, field, None)] = field_port
# If we had a previous wire assigned to this place, we need forget about it.
# Otherwise, we might use this old value when looking up the place later
@@ -66,17 +78,15 @@ def __setitem__(self, place: Place, port: OutPortV) -> None:
def __copy__(self) -> "DFContainer":
# Make a copy of the var map so that mutating the copy doesn't
# mutate our variable mapping
- return DFContainer(self.graph, self.node, self.locals.copy())
+ return DFContainer(self.builder, self.locals.copy())
class CompilerBase(ABC):
"""Base class for the Guppy compiler."""
- graph: Hugr
globals: CompiledGlobals
- def __init__(self, graph: Hugr, globals: CompiledGlobals) -> None:
- self.graph = graph
+ def __init__(self, globals: CompiledGlobals) -> None:
self.globals = globals
diff --git a/guppylang/compiler/expr_compiler.py b/guppylang/compiler/expr_compiler.py
index f5935e21..52c1dc9c 100644
--- a/guppylang/compiler/expr_compiler.py
+++ b/guppylang/compiler/expr_compiler.py
@@ -1,10 +1,18 @@
import ast
import json
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
from contextlib import contextmanager
from typing import Any, TypeGuard, TypeVar
-from hugr.serialization import ops, tys
+import hugr
+import hugr.std.float
+import hugr.std.int
+import hugr.std.logic
+from hugr import Wire, ops
+from hugr import tys as ht
+from hugr import val as hv
+from hugr.cond_loop import Conditional
+from hugr.dfg import DP, _DfBase
from typing_extensions import assert_never
from guppylang.ast_util import AstVisitor, get_type, with_loc, with_type
@@ -13,13 +21,6 @@
from guppylang.compiler.core import CompilerBase, DFContainer
from guppylang.definition.value import CompiledCallableDef, CompiledValueDef
from guppylang.error import GuppyError, InternalGuppyError
-from guppylang.hugr_builder.hugr import (
- UNDEFINED,
- DFContainingNode,
- DummyOp,
- OutPortV,
- VNode,
-)
from guppylang.nodes import (
DesugaredGenerator,
DesugaredListComp,
@@ -33,7 +34,6 @@
TypeApply,
)
from guppylang.tys.builtin import (
- bool_type,
get_element_type,
is_bool_type,
is_list_type,
@@ -51,20 +51,18 @@
)
-class ExprCompiler(CompilerBase, AstVisitor[OutPortV]):
+class ExprCompiler(CompilerBase, AstVisitor[Wire]):
"""A compiler from guppylang expressions to Hugr."""
dfg: DFContainer
- def compile(self, expr: ast.expr, dfg: DFContainer) -> OutPortV:
- """Compiles an expression and returns a single port holding the output value."""
+ def compile(self, expr: ast.expr, dfg: DFContainer) -> Wire:
+ """Compiles an expression and returns a single wire holding the output value."""
self.dfg = dfg
- with self.graph.parent(dfg.node):
- res = self.visit(expr)
- return res
+ return self.visit(expr)
- def compile_row(self, expr: ast.expr, dfg: DFContainer) -> list[OutPortV]:
- """Compiles a row expression and returns a list of ports, one for each value in
+ def compile_row(self, expr: ast.expr, dfg: DFContainer) -> list[Wire]:
+ """Compiles a row expression and returns a list of wires, one for each value in
the row.
On Python-level, we treat tuples like rows on top-level. However, nested tuples
@@ -72,25 +70,31 @@ def compile_row(self, expr: ast.expr, dfg: DFContainer) -> list[OutPortV]:
"""
return [self.compile(e, dfg) for e in expr_to_row(expr)]
+ @property
+ def builder(self) -> _DfBase[ops.DfParentOp]:
+ """The current Hugr dataflow graph builder."""
+ return self.dfg.builder
+
@contextmanager
def _new_dfcontainer(
- self, inputs: list[PlaceNode], node: DFContainingNode
+ self, inputs: list[PlaceNode], builder: _DfBase[DP]
) -> Iterator[None]:
"""Context manager to build a graph inside a new `DFContainer`.
Automatically updates `self.dfg` and makes the inputs available.
"""
old = self.dfg
- inp = self.graph.add_input(parent=node)
# Check that the input names are unique
assert len({inp.place.id for inp in inputs}) == len(
inputs
), "Inputs are not unique"
- self.dfg = DFContainer(self.graph, node, self.dfg.locals.copy())
- for input_node in inputs:
- self.dfg[input_node.place] = inp.add_out_port(input_node.place.ty)
- with self.graph.parent(node):
- yield
+ self.dfg = DFContainer(builder, self.dfg.locals.copy())
+ hugr_input = builder.input_node
+ for input_node, wire in zip(inputs, hugr_input, strict=True):
+ self.dfg[input_node.place] = wire
+
+ yield
+
self.dfg = old
@contextmanager
@@ -98,39 +102,44 @@ def _new_loop(
self,
loop_vars: list[PlaceNode],
branch: PlaceNode,
- parent: DFContainingNode | None = None,
) -> Iterator[None]:
"""Context manager to build a graph inside a new `TailLoop` node.
Automatically adds the `Output` node to the loop body once the context manager
exits.
"""
- loop = self.graph.add_tail_loop(
- [self.visit(name) for name in loop_vars], parent
- )
+ loop_inputs = [self.visit(name) for name in loop_vars]
+ loop = self.builder.add_tail_loop([], loop_inputs)
with self._new_dfcontainer(loop_vars, loop):
yield
# Output the branch predicate and the inputs for the next iteration
- self.graph.add_output(
+ loop.set_loop_outputs(
# Note that we have to do fresh calls to `self.visit` here since we're
# in a new context
- [self.visit(branch), *(self.visit(name) for name in loop_vars)]
+ self.visit(branch),
+ *(self.visit(name) for name in loop_vars),
)
# Update the DFG with the outputs from the loop
- for node in loop_vars:
- self.dfg[node.place] = loop.add_out_port(node.place.ty)
+ for node, wire in zip(loop_vars, loop, strict=True):
+ self.dfg[node.place] = wire
@contextmanager
def _new_case(
- self, inputs: list[PlaceNode], outputs: list[PlaceNode], cond_node: VNode
+ self,
+ inputs: list[PlaceNode],
+ outputs: list[PlaceNode],
+ conditional: Conditional,
+ case_id: int,
) -> Iterator[None]:
"""Context manager to build a graph inside a new `Case` node.
Automatically adds the `Output` node once the context manager exits.
"""
- with self._new_dfcontainer(inputs, self.graph.add_case(cond_node)):
+ # TODO: `Case` is `_DfgBase`, but not `Dfg`?
+ case = conditional.add_case(case_id)
+ with self._new_dfcontainer(inputs, case):
yield
- self.graph.add_output([self.visit(name) for name in outputs])
+ case.set_outputs(*(self.visit(name) for name in outputs))
@contextmanager
def _if_true(self, cond: ast.expr, inputs: list[PlaceNode]) -> Iterator[None]:
@@ -138,29 +147,28 @@ def _if_true(self, cond: ast.expr, inputs: list[PlaceNode]) -> Iterator[None]:
In the `false` case, the inputs are outputted as is.
"""
- cond_node = self.graph.add_conditional(
- self.visit(cond), [self.visit(inp) for inp in inputs]
+ conditional = self.builder.add_conditional(
+ self.visit(cond), *(self.visit(inp) for inp in inputs)
)
- # If the condition is false, output the inputs as is
- with self._new_case(inputs, inputs, cond_node):
- pass
# If the condition is true, we enter the `with` block
- with self._new_case(inputs, inputs, cond_node):
+ with self._new_case(inputs, inputs, conditional, 0):
yield
+ # If the condition is false, output the inputs as is
+ with self._new_case(inputs, inputs, conditional, 1):
+ pass
# Update the DFG with the outputs from the Conditional node
- for node in inputs:
- self.dfg[node.place] = cond_node.add_out_port(node.place.ty)
+ for node, wire in zip(inputs, conditional, strict=True):
+ self.dfg[node.place] = wire
- def visit_Constant(self, node: ast.Constant) -> OutPortV:
+ def visit_Constant(self, node: ast.Constant) -> Wire:
if value := python_value_to_hugr(node.value, get_type(node)):
- const = self.graph.add_constant(value, get_type(node)).out_port(0)
- return self.graph.add_load_constant(const).out_port(0)
+ return self.builder.load(value)
raise InternalGuppyError("Unsupported constant expression in compiler")
- def visit_PlaceNode(self, node: PlaceNode) -> OutPortV:
+ def visit_PlaceNode(self, node: PlaceNode) -> Wire:
return self.dfg[node.place]
- def visit_GlobalName(self, node: GlobalName) -> OutPortV:
+ def visit_GlobalName(self, node: GlobalName) -> Wire:
defn = self.globals[node.def_id]
assert isinstance(defn, CompiledValueDef)
if isinstance(defn, CompiledCallableDef) and defn.ty.parametrized:
@@ -169,100 +177,130 @@ def visit_GlobalName(self, node: GlobalName) -> OutPortV:
"supported yet",
node,
)
- return defn.load(self.dfg, self.graph, self.globals, node)
+ return defn.load(self.dfg, self.globals, node)
- def visit_Name(self, node: ast.Name) -> OutPortV:
+ def visit_Name(self, node: ast.Name) -> Wire:
raise InternalGuppyError("Node should have been removed during type checking.")
- def visit_Tuple(self, node: ast.Tuple) -> OutPortV:
- return self.graph.add_make_tuple(
- inputs=[self.visit(e) for e in node.elts]
- ).out_port(0)
+ def visit_Tuple(self, node: ast.Tuple) -> Wire:
+ elems = [self.visit(e) for e in node.elts]
+ types = [get_type(e) for e in node.elts]
+ return self._pack_tuple(elems, types)
- def visit_List(self, node: ast.List) -> OutPortV:
+ def visit_List(self, node: ast.List) -> Wire:
# Note that this is a list literal (i.e. `[e1, e2, ...]`), not a comprehension
- return self.graph.add_node(
- DummyOp("MakeList"), inputs=[self.visit(e) for e in node.elts]
- ).add_out_port(get_type(node))
+ inputs = [self.visit(e) for e in node.elts]
+ in_types = [get_type(e) for e in node.elts]
+ out_type = get_type(node)
+ return self.builder.add_op(
+ make_list_op(in_types, out_type),
+ *inputs,
+ )
- def _unpack_tuple(self, wire: OutPortV) -> list[OutPortV]:
- unpack_node = self.graph.add_unpack_tuple(wire, self.dfg.node)
- return list(unpack_node.out_ports)
+ def _unpack_tuple(self, wire: Wire, types: Sequence[Type]) -> Sequence[Wire]:
+ """Add a tuple unpack operation to the graph"""
+ types = [t.to_hugr() for t in types]
+ return list(self.builder.add_op(ops.UnpackTuple(types), wire))
- def _pack_returns(self, returns: list[OutPortV], return_ty: Type) -> OutPortV:
+ def _pack_tuple(self, wires: Sequence[Wire], types: Sequence[Type]) -> Wire:
+ """Add a tuple pack operation to the graph"""
+ types = [t.to_hugr() for t in types]
+ return self.builder.add_op(ops.MakeTuple(types), *wires)
+
+ def _pack_returns(self, returns: Sequence[Wire], return_ty: Type) -> Wire:
"""Groups function return values into a tuple"""
if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
- assert len(returns) == (
- len(return_ty.element_types) if isinstance(return_ty, TupleType) else 0
- )
- return self.graph.add_make_tuple(inputs=returns).out_port(0)
- assert len(returns) == 1
+ types = type_to_row(return_ty)
+ assert len(returns) == len(types)
+ return self._pack_tuple(returns, types)
+ assert len(returns) == 1, (
+ f"Expected a single return value. Got {returns}. "
+ f"return type {return_ty}"
+ )
return returns[0]
- def visit_LocalCall(self, node: LocalCall) -> OutPortV:
+ def visit_LocalCall(self, node: LocalCall) -> Wire:
func = self.visit(node.func)
- assert isinstance(func.ty, FunctionType)
+ func_ty = get_type(node.func)
+ assert isinstance(func_ty, FunctionType)
args = [self.visit(arg) for arg in node.args]
- call = self.graph.add_indirect_call(func, args)
- rets = [call.out_port(i) for i in range(len(type_to_row(func.ty.output)))]
- return self._pack_returns(rets, func.ty.output)
+ call = self.builder.add_op(ops.CallIndirect(func_ty.to_hugr()), func, *args)
+ return self._pack_returns(list(call), func_ty.output)
- def visit_TensorCall(self, node: TensorCall) -> OutPortV:
- func = self.visit(node.func)
- args = [self.visit(arg) for arg in node.args]
+ def visit_TensorCall(self, node: TensorCall) -> Wire:
+ functions: Wire = self.visit(node.func)
+ function_types = get_type(node.func)
- assert isinstance(func.ty, TupleType)
+ args = [self.visit(arg) for arg in node.args]
+ assert isinstance(function_types, TupleType)
- rets: list[OutPortV] = []
+ rets: list[Wire] = []
remaining_args = args
- for elem in self._unpack_tuple(func):
+ for func, func_ty in zip(
+ self._unpack_tuple(functions, function_types.element_types),
+ function_types.element_types,
+ strict=True,
+ ):
outs, remaining_args = self._compile_tensor_with_leftovers(
- elem, remaining_args
+ func, func_ty, remaining_args
)
rets.extend(outs)
- assert remaining_args == []
+ assert (
+ remaining_args == []
+ ), "Not all function arguments were consumed after a tensor call"
return self._pack_returns(rets, node.out_tys)
def _compile_tensor_with_leftovers(
- self, func: OutPortV, args: list[OutPortV]
+ self, func: Wire, func_ty: Type, args: list[Wire]
) -> tuple[
- list[OutPortV], # Compiled outputs
- list[OutPortV],
- ]: # Leftover args
- if isinstance(func.ty, TupleType):
+ list[Wire], # Compiled outputs
+ list[Wire], # Leftover args
+ ]:
+ """Compiles a function call, consuming as many arguments as needed, and
+ returning the unused ones.
+ """
+ if isinstance(func_ty, TupleType):
remaining_args = args
all_outs = []
- for elem in self._unpack_tuple(func):
+ for elem, ty in zip(
+ self._unpack_tuple(func, func_ty.element_types),
+ func_ty.element_types,
+ strict=True,
+ ):
outs, remaining_args = self._compile_tensor_with_leftovers(
- elem, remaining_args
+ elem, ty, remaining_args
)
all_outs.extend(outs)
return all_outs, remaining_args
- elif isinstance(func.ty, FunctionType):
- input_len = len(func.ty.inputs)
- call = self.graph.add_indirect_call(func, args[0:input_len])
+ elif isinstance(func_ty, FunctionType):
+ input_len = len(func_ty.inputs)
+ consumed_args, other_args = args[0:input_len], args[input_len:]
- return list(call.out_ports), args[input_len:]
+ call = self.builder.add_op(
+ ops.CallIndirect(func_ty.to_hugr()), func, *consumed_args
+ )
+
+ return list(call), other_args
else:
raise InternalGuppyError("Tensor element wasn't function or tuple")
- def visit_GlobalCall(self, node: GlobalCall) -> OutPortV:
+ def visit_GlobalCall(self, node: GlobalCall) -> Wire:
func = self.globals[node.def_id]
assert isinstance(func, CompiledCallableDef)
args = [self.visit(arg) for arg in node.args]
rets = func.compile_call(
- args, list(node.type_args), self.dfg, self.graph, self.globals, node
+ args, list(node.type_args), self.dfg, self.globals, node
)
return self._pack_returns(rets, func.ty.output)
- def visit_Call(self, node: ast.Call) -> OutPortV:
+ def visit_Call(self, node: ast.Call) -> Wire:
raise InternalGuppyError("Node should have been removed during type checking.")
- def visit_TypeApply(self, node: TypeApply) -> OutPortV:
+ def visit_TypeApply(self, node: TypeApply) -> Wire:
# For now, we can only TypeApply global FunctionDefs/Decls.
if not isinstance(node.value, GlobalName):
raise InternalGuppyError("Dynamic TypeApply not supported yet!")
@@ -282,39 +320,34 @@ def visit_TypeApply(self, node: TypeApply) -> OutPortV:
node,
)
- return defn.load_with_args(node.inst, self.dfg, self.graph, self.globals, node)
+ return defn.load_with_args(node.inst, self.dfg, self.globals, node)
- def visit_UnaryOp(self, node: ast.UnaryOp) -> OutPortV:
+ def visit_UnaryOp(self, node: ast.UnaryOp) -> Wire:
# The only case that is not desugared by the type checker is the `not` operation
# since it is not implemented via a dunder method
if isinstance(node.op, ast.Not):
arg = self.visit(node.operand)
- op = ops.CustomOp(extension="logic", name="Not", args=[], parent=UNDEFINED)
- return self.graph.add_node(ops.OpType(op), inputs=[arg]).add_out_port(
- bool_type()
- )
+ return self.builder.add_op(hugr.std.logic.Not, arg)
raise InternalGuppyError("Node should have been removed during type checking.")
- def visit_FieldAccessAndDrop(self, node: FieldAccessAndDrop) -> OutPortV:
+ def visit_FieldAccessAndDrop(self, node: FieldAccessAndDrop) -> Wire:
struct_port = self.visit(node.value)
- unpack = self.graph.add_unpack_tuple(struct_port)
- return unpack.out_port(node.struct_ty.fields.index(node.field))
+ field_idx = node.struct_ty.fields.index(node.field)
+ return self._unpack_tuple(struct_port, [f.ty for f in node.struct_ty.fields])[
+ field_idx
+ ]
- def visit_ResultExpr(self, node: ResultExpr) -> OutPortV:
+ def visit_ResultExpr(self, node: ResultExpr) -> Wire:
extra_args = []
if isinstance(node.base_ty, NumericType):
match node.base_ty.kind:
case NumericType.Kind.Nat:
base_name = "uint"
- extra_args = [
- tys.TypeArg(tys.BoundedNatArg(n=NumericType.INT_WIDTH))
- ]
+ extra_args = [ht.BoundedNatArg(n=NumericType.INT_WIDTH)]
case NumericType.Kind.Int:
base_name = "int"
- extra_args = [
- tys.TypeArg(tys.BoundedNatArg(n=NumericType.INT_WIDTH))
- ]
+ extra_args = [ht.BoundedNatArg(n=NumericType.INT_WIDTH)]
case NumericType.Kind.Float:
base_name = "f64"
case kind:
@@ -328,7 +361,7 @@ def visit_ResultExpr(self, node: ResultExpr) -> OutPortV:
match node.array_len:
case ConstValue(value=value):
assert isinstance(value, int)
- extra_args = [tys.TypeArg(tys.BoundedNatArg(n=value)), *extra_args]
+ extra_args = [ht.BoundedNatArg(n=value), *extra_args]
case BoundConstVar():
# TODO: We need to handle this once we allow function definitions
# that are generic over array lengths
@@ -341,37 +374,44 @@ def visit_ResultExpr(self, node: ResultExpr) -> OutPortV:
assert_never(c)
else:
op_name = f"result_{base_name}"
- args = [tys.TypeArg(tys.StringArg(arg=node.tag)), *extra_args]
- op = ops.CustomOp(
+ args = [
+ ht.StringArg(node.tag),
+ *extra_args,
+ ]
+ sig = ht.FunctionType(
+ input=[get_type(node.value).to_hugr()],
+ output=[],
+ )
+ op = ops.Custom(
extension="tket2.result",
name=op_name,
args=args,
- parent=UNDEFINED,
+ signature=sig,
)
- self.graph.add_node(ops.OpType(op), inputs=[self.visit(node.value)])
+ self.builder.add_op(op, self.visit(node.value))
return self._pack_returns([], NoneType())
- def visit_DesugaredListComp(self, node: DesugaredListComp) -> OutPortV:
+ def visit_DesugaredListComp(self, node: DesugaredListComp) -> Wire:
from guppylang.compiler.stmt_compiler import StmtCompiler
- compiler = StmtCompiler(self.graph, self.globals)
+ compiler = StmtCompiler(self.globals)
# Make up a name for the list under construction and bind it to an empty list
list_ty = get_type(node)
list_place = Variable(next(tmp_vars), list_ty, node)
list_name = with_type(list_ty, with_loc(node, PlaceNode(place=list_place)))
- empty_list = self.graph.add_node(DummyOp("MakeList"))
- self.dfg[list_place] = empty_list.add_out_port(list_ty)
+ self.dfg[list_place] = self.builder.add_op(make_list_op([], list_ty))
def compile_generators(elt: ast.expr, gens: list[DesugaredGenerator]) -> None:
"""Helper function to generate nested TailLoop nodes for generators"""
# If there are no more generators left, just append the element to the list
if not gens:
list_port, elt_port = self.visit(list_name), self.visit(elt)
- push = self.graph.add_node(
- DummyOp("Push"), inputs=[list_port, elt_port]
+ elt_ty = get_type(elt)
+ push = self.builder.add_op(
+ list_push_op(list_ty, elt_ty), list_port, elt_port
)
- self.dfg[list_place] = push.add_out_port(list_port.ty)
+ self.dfg[list_place] = push
return
# Otherwise, compile the first iterator and construct a TailLoop
@@ -407,10 +447,10 @@ def compile_ifs(ifs: list[ast.expr]) -> None:
compile_generators(node.elt, node.generators)
return self.visit(list_name)
- def visit_BinOp(self, node: ast.BinOp) -> OutPortV:
+ def visit_BinOp(self, node: ast.BinOp) -> Wire:
raise InternalGuppyError("Node should have been removed during type checking.")
- def visit_Compare(self, node: ast.Compare) -> OutPortV:
+ def visit_Compare(self, node: ast.Compare) -> Wire:
raise InternalGuppyError("Node should have been removed during type checking.")
@@ -427,25 +467,20 @@ def instantiation_needs_unpacking(func_ty: FunctionType, inst: Inst) -> bool:
return False
-def python_value_to_hugr(v: Any, exp_ty: Type) -> ops.Value | None:
+def python_value_to_hugr(v: Any, exp_ty: Type) -> hv.Value | None:
"""Turns a Python value into a Hugr value.
Returns None if the Python value cannot be represented in Guppy.
"""
- from guppylang.prelude._internal import (
- bool_value,
- float_value,
- int_value,
- list_value,
- )
+ from guppylang.prelude._internal.util import ListVal
match v:
case bool():
- return bool_value(v)
+ return hv.bool_value(v)
case int():
- return int_value(v)
+ return hugr.std.int.IntVal(v, width=NumericType.INT_WIDTH)
case float():
- return float_value(v)
+ return hugr.std.float.FloatVal(v)
case tuple(elts):
assert isinstance(exp_ty, TupleType)
vs = [
@@ -453,12 +488,12 @@ def python_value_to_hugr(v: Any, exp_ty: Type) -> ops.Value | None:
for elt, ty in zip(elts, exp_ty.element_types, strict=True)
]
if doesnt_contain_none(vs):
- return ops.Value(ops.TupleValue(vs=vs))
+ return hv.Tuple(*vs)
case list(elts):
assert is_list_type(exp_ty)
vs = [python_value_to_hugr(elt, get_element_type(exp_ty)) for elt in elts]
if doesnt_contain_none(vs):
- return list_value(vs, get_element_type(exp_ty))
+ return ListVal(vs, get_element_type(exp_ty))
case _:
# Pytket conversion is an optional feature
try:
@@ -469,13 +504,34 @@ def python_value_to_hugr(v: Any, exp_ty: Type) -> ops.Value | None:
Tk2Circuit,
)
- hugr = json.loads(Tk2Circuit(v).to_hugr_json()) # type: ignore[attr-defined, unused-ignore]
- return ops.Value(ops.FunctionValue(hugr=hugr))
+ circ = json.loads(Tk2Circuit(v).to_hugr_json()) # type: ignore[attr-defined, unused-ignore]
+ return hv.Function(circ)
except ImportError:
pass
return None
+def make_dummy_op(
+ name: str, inp: Sequence[Type], out: Sequence[Type]
+) -> ops.DataflowOp:
+ """Dummy operation."""
+ input = [ty.to_hugr() for ty in inp]
+ output = [ty.to_hugr() for ty in out]
+
+ sig = ht.FunctionType(input=input, output=output)
+ return ops.Custom(name=name, extension="dummy", signature=sig, args=[])
+
+
+def make_list_op(in_types: Sequence[Type], out_type: Type) -> ops.DataflowOp:
+ """Creates a dummy operation for constructing a list."""
+ return make_dummy_op("MakeList", in_types, [out_type])
+
+
+def list_push_op(list_ty: Type, elem_ty: Type) -> ops.DataflowOp:
+ """Creates a dummy operation for constructing a list."""
+ return make_dummy_op("Push", [list_ty, elem_ty], [list_ty])
+
+
T = TypeVar("T")
diff --git a/guppylang/compiler/func_compiler.py b/guppylang/compiler/func_compiler.py
index 417116c8..94b6ff7c 100644
--- a/guppylang/compiler/func_compiler.py
+++ b/guppylang/compiler/func_compiler.py
@@ -1,10 +1,14 @@
+from collections.abc import Sequence
from typing import TYPE_CHECKING
+from hugr import Wire, ops
+from hugr import tys as ht
+from hugr.function import Function
+
from guppylang.compiler.cfg_compiler import compile_cfg
from guppylang.compiler.core import CompiledGlobals, DFContainer
-from guppylang.hugr_builder.hugr import DFContainingVNode, Hugr, OutPortV
from guppylang.nodes import CheckedNestedFunctionDef
-from guppylang.tys.ty import FunctionType, type_to_row
+from guppylang.tys.ty import FunctionType, Type
if TYPE_CHECKING:
from guppylang.definition.function import CheckedFunctionDef
@@ -12,55 +16,58 @@
def compile_global_func_def(
func: "CheckedFunctionDef",
- def_node: DFContainingVNode,
- graph: Hugr,
+ builder: Function,
globals: CompiledGlobals,
) -> None:
"""Compiles a top-level function definition to Hugr."""
- _, ports = graph.add_input_with_ports(list(func.ty.inputs), def_node)
- cfg_node = graph.add_cfg(def_node, ports)
- compile_cfg(func.cfg, graph, cfg_node, globals)
-
- # Add output node for the cfg
- graph.add_output(
- inputs=[cfg_node.add_out_port(ty) for ty in type_to_row(func.cfg.output_ty)],
- parent=def_node,
- )
+ cfg = compile_cfg(func.cfg, builder, builder.inputs(), globals)
+
+ builder.set_outputs(*cfg)
def compile_local_func_def(
func: CheckedNestedFunctionDef,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
-) -> OutPortV:
- """Compiles a local (nested) function definition to Hugr."""
+) -> Wire:
+ """Compiles a local (nested) function definition to Hugr and loads it into a value.
+
+ Returns the wire output of the `LoadFunc` operation.
+ """
assert func.ty.input_names is not None
# Pick an order for the captured variables
captured = list(func.captured.values())
+ captured_types = [v.ty for v, _ in captured]
+
+ # Whether the function calls itself recursively.
+ recursive = func.name in func.cfg.live_before[func.cfg.entry_bb]
# Prepend captured variables to the function arguments
closure_ty = FunctionType(
- [v.ty for v, _ in captured] + list(func.ty.inputs),
+ captured_types + list(func.ty.inputs),
func.ty.output,
- [v.name for v, _ in captured] + list(func.ty.input_names),
+ input_names=[v.name for v, _ in captured] + list(func.ty.input_names),
)
+ hugr_closure_ty: ht.FunctionType = closure_ty.to_hugr()
- def_node = graph.add_def(closure_ty, dfg.node, func.name)
- def_input, input_ports = graph.add_input_with_ports(
- list(closure_ty.inputs), def_node
+ func_builder = dfg.builder.define_function(
+ func.name, hugr_closure_ty.input, hugr_closure_ty.output
)
# If we have captured variables and the body contains a recursive occurrence of
# the function itself, then we provide the partially applied function as a local
# variable
- if len(captured) > 0 and func.name in func.cfg.live_before[func.cfg.entry_bb]:
- loaded = graph.add_load_function(def_node.out_port(0), [], def_node).out_port(0)
- partial = graph.add_partial(
- loaded, [def_input.out_port(i) for i in range(len(captured))], def_node
+ call_args: list[Wire] = list(func_builder.inputs())
+ if len(captured) > 0 and recursive:
+ loaded = func_builder.load_function(func_builder, hugr_closure_ty)
+ partial = func_builder.add_op(
+ make_partial_op(closure_ty, captured_types),
+ loaded,
+ *func_builder.input_node[: len(captured)],
)
- input_ports.append(partial.out_port(0))
+
+ call_args.append(partial)
func.cfg.input_tys.append(func.ty)
else:
# Otherwise, we treat the function like a normal global variable
@@ -75,25 +82,62 @@ def compile_local_func_def(
{},
None,
func.cfg,
- def_node,
+ func_builder,
)
}
# Compile the CFG
- cfg_node = graph.add_cfg(def_node, inputs=input_ports)
- compile_cfg(func.cfg, graph, cfg_node, globals)
-
- # Add output node for the cfg
- graph.add_output(
- inputs=[cfg_node.add_out_port(ty) for ty in type_to_row(func.cfg.output_ty)],
- parent=def_node,
- )
+ cfg = compile_cfg(func.cfg, func_builder, call_args, globals)
+ func_builder.set_outputs(*cfg)
# Finally, load the function into the local data-flow graph
- loaded = graph.add_load_function(def_node.out_port(0), [], dfg.node).out_port(0)
+ loaded = dfg.builder.load_function(func_builder, hugr_closure_ty)
if len(captured) > 0:
- loaded = graph.add_partial(
- loaded, [dfg[v] for v, _ in captured], dfg.node
- ).out_port(0)
+ loaded = dfg.builder.add_op(
+ make_partial_op(closure_ty, captured_types),
+ loaded,
+ *(dfg[v] for v, _ in captured),
+ )
return loaded
+
+
+def make_dummy_op(
+ name: str, inp: Sequence[Type], out: Sequence[Type], extension: str = "dummy"
+) -> ops.DataflowOp:
+ """Dummy operation."""
+ input = [ty.to_hugr() for ty in inp]
+ output = [ty.to_hugr() for ty in out]
+
+ sig = ht.FunctionType(input=input, output=output)
+ return ops.Custom(name=name, extension=extension, signature=sig, args=[])
+
+
+def make_partial_op(
+ closure_ty: FunctionType, captured_tys: Sequence[Type]
+) -> ops.DataflowOp:
+ """Creates a dummy operation for partially evaluating a function.
+
+ args:
+ closure_ty: A function type `(c_0, ..., c_k, a_0, ..., a_n) -> b_0, ..., b_m`
+ captured_tys: A list of types `c_0, ..., c_k` that are captured by the function
+
+ returns:
+ An operation with type
+ ` (c_0, ..., c_k, a_0, ..., a_n -> b_0, ..., b_m ), c_0, ..., c_k`
+ `-> (a_0, ..., a_n -> b_0, ..., b_m)`
+ """
+ assert len(closure_ty.inputs) >= len(captured_tys)
+ assert [p.to_hugr() for p in captured_tys] == [
+ ty.to_hugr() for ty in closure_ty.inputs[: len(captured_tys)]
+ ]
+
+ explicit_inputs = closure_ty.inputs[len(captured_tys) :]
+ partially_applied_func = FunctionType(explicit_inputs, closure_ty.output)
+
+ return make_dummy_op(
+ "partial",
+ [closure_ty, *captured_tys],
+ [partially_applied_func],
+ extension="guppylang.unsupported",
+ )
diff --git a/guppylang/compiler/stmt_compiler.py b/guppylang/compiler/stmt_compiler.py
index aa9e2689..cdd7c803 100644
--- a/guppylang/compiler/stmt_compiler.py
+++ b/guppylang/compiler/stmt_compiler.py
@@ -1,6 +1,9 @@
import ast
from collections.abc import Sequence
+from hugr import Wire, ops
+from hugr.dfg import _DfBase
+
from guppylang.ast_util import AstVisitor, get_type
from guppylang.checker.core import Variable
from guppylang.compiler.core import (
@@ -11,9 +14,8 @@
)
from guppylang.compiler.expr_compiler import ExprCompiler
from guppylang.error import InternalGuppyError
-from guppylang.hugr_builder.hugr import Hugr, OutPortV
from guppylang.nodes import CheckedNestedFunctionDef, PlaceNode
-from guppylang.tys.ty import TupleType
+from guppylang.tys.ty import TupleType, Type
class StmtCompiler(CompilerBase, AstVisitor[None]):
@@ -23,9 +25,9 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
dfg: DFContainer
- def __init__(self, graph: Hugr, globals: CompiledGlobals):
- super().__init__(graph, globals)
- self.expr_compiler = ExprCompiler(graph, globals)
+ def __init__(self, globals: CompiledGlobals):
+ super().__init__(globals)
+ self.expr_compiler = ExprCompiler(globals)
def compile_stmts(
self,
@@ -42,14 +44,20 @@ def compile_stmts(
self.visit(s)
return self.dfg
- def _unpack_assign(self, lhs: ast.expr, port: OutPortV, node: ast.stmt) -> None:
+ @property
+ def builder(self) -> _DfBase[ops.DfParentOp]:
+ """The Hugr dataflow graph builder."""
+ return self.dfg.builder
+
+ def _unpack_assign(self, lhs: ast.expr, port: Wire, node: ast.stmt) -> None:
"""Updates the local DFG with assignments."""
if isinstance(lhs, PlaceNode):
self.dfg[lhs.place] = port
elif isinstance(lhs, ast.Tuple):
- unpack = self.graph.add_unpack_tuple(port, self.dfg.node)
- for i, pat in enumerate(lhs.elts):
- self._unpack_assign(pat, unpack.out_port(i), node)
+ types = [get_type(e).to_hugr() for e in lhs.elts]
+ unpack = self.builder.add_op(ops.UnpackTuple(types), port)
+ for pat, wire in zip(lhs.elts, unpack, strict=True):
+ self._unpack_assign(pat, wire, node)
else:
raise InternalGuppyError("Invalid assign pattern in compiler")
@@ -75,17 +83,22 @@ def visit_Return(self, node: ast.Return) -> None:
if node.value is not None:
return_ty = get_type(node.value)
port = self.expr_compiler.compile(node.value, self.dfg)
+
+ row: list[tuple[Wire, Type]]
if isinstance(return_ty, TupleType):
- unpack = self.graph.add_unpack_tuple(port, self.dfg.node)
- row = [unpack.out_port(i) for i in range(len(return_ty.element_types))]
+ types = [e.to_hugr() for e in return_ty.element_types]
+ unpack = self.builder.add_op(ops.UnpackTuple(types), port)
+ row = list(zip(unpack, return_ty.element_types, strict=True))
else:
- row = [port]
- for i, port in enumerate(row):
- var = Variable(return_var(i), port.ty, node.value)
- self.dfg[var] = port
+ row = [(port, return_ty)]
+
+ for i, (wire, ty) in enumerate(row):
+ var = Variable(return_var(i), ty, node.value)
+ self.dfg[var] = wire
def visit_CheckedNestedFunctionDef(self, node: CheckedNestedFunctionDef) -> None:
from guppylang.compiler.func_compiler import compile_local_func_def
var = Variable(node.name, node.ty, node)
- self.dfg[var] = compile_local_func_def(node, self.dfg, self.graph, self.globals)
+ loaded_func = compile_local_func_def(node, self.dfg, self.globals)
+ self.dfg[var] = loaded_func
diff --git a/guppylang/decorator.py b/guppylang/decorator.py
index 442ba6fb..8216c803 100644
--- a/guppylang/decorator.py
+++ b/guppylang/decorator.py
@@ -6,7 +6,8 @@
from types import ModuleType
from typing import Any, TypeVar
-from hugr.serialization import ops, tys
+from hugr import Hugr, ops
+from hugr import tys as ht
from guppylang.ast_util import annotate_location, has_empty_body
from guppylang.definition.common import DefId
@@ -25,8 +26,8 @@
from guppylang.definition.struct import RawStructDef
from guppylang.definition.ty import OpaqueTypeDef, TypeDef
from guppylang.error import GuppyError, MissingModuleError, pretty_errors
-from guppylang.hugr_builder.hugr import Hugr
from guppylang.module import GuppyModule, PyFunc
+from guppylang.tys.subst import Inst
from guppylang.tys.ty import NumericType
FuncDefDecorator = Callable[[PyFunc], RawFunctionDef]
@@ -122,10 +123,10 @@ def dec(c: type) -> type:
def type(
self,
module: GuppyModule,
- hugr_ty: tys.Type,
+ hugr_ty: ht.Type,
name: str = "",
linear: bool = False,
- bound: tys.TypeBound | None = None,
+ bound: ht.TypeBound | None = None,
) -> ClassDecorator:
"""Decorator to annotate a class definitions as Guppy types.
@@ -222,12 +223,22 @@ def dec(f: PyFunc) -> RawCustomFunctionDef:
def hugr_op(
self,
module: GuppyModule,
- op: ops.OpType,
+ op: Callable[[ht.FunctionType, Inst], ops.DataflowOp],
checker: CustomCallChecker | None = None,
higher_order_value: bool = True,
name: str = "",
) -> CustomFuncDecorator:
- """Decorator to annotate function declarations as HUGR ops."""
+ """Decorator to annotate function declarations as HUGR ops.
+
+ Args:
+ module: The module in which the function should be defined.
+ op: A function that takes an instantiation of the type arguments as well as
+ the inferred input and output types and returns a concrete HUGR op.
+ checker: The custom call checker.
+ higher_order_value: Whether the function may be used as a higher-order
+ value.
+ name: The name of the function.
+ """
return self.custom(module, OpCompiler(op), checker, higher_order_value, name)
def declare(self, module: GuppyModule) -> FuncDeclDecorator:
@@ -296,7 +307,7 @@ def take_module(self, id: ModuleIdentifier | None = None) -> GuppyModule:
raise MissingModuleError(err)
return self._modules.pop(id)
- def compile_module(self, id: ModuleIdentifier | None = None) -> Hugr | None:
+ def compile_module(self, id: ModuleIdentifier | None = None) -> Hugr[ops.Module]:
"""Compiles the local module into a Hugr."""
module = self.take_module(id)
if not module:
diff --git a/guppylang/definition/common.py b/guppylang/definition/common.py
index 9a5cf561..61bd073e 100644
--- a/guppylang/definition/common.py
+++ b/guppylang/definition/common.py
@@ -5,7 +5,7 @@
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, ClassVar, TypeAlias
-from guppylang.hugr_builder.hugr import Hugr, Node
+from hugr.dfg import OpVar, _DefinitionBuilder
if TYPE_CHECKING:
from guppylang.checker.core import Globals
@@ -24,6 +24,10 @@ class DefId:
This id is persistent across all compilation stages. It can be used to identify a
definition at any step in the compilation pipeline.
+
+ Args:
+ id: An integer uniquely identifying the definition.
+ module: The module where the definition was defined.
"""
id: int
@@ -43,6 +47,11 @@ class Definition(ABC):
Each definition is identified by a globally unique id. Furthermore, we store the
user-picked name for the defined object and an optional AST node for the definition
location.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
"""
id: DefId
@@ -65,6 +74,11 @@ class ParsableDef(Definition):
For example, raw function definitions first need to parse their signature and check
that all types are valid. The result of parsing should be a definition that is ready
to be checked.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
"""
@abstractmethod
@@ -79,6 +93,11 @@ class CheckableDef(Definition):
"""Abstract base class for definitions that still need to be checked.
The result of checking should be a definition that is ready to be compiled to Hugr.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
"""
@abstractmethod
@@ -97,11 +116,16 @@ class CompilableDef(Definition):
The result of compilation should be a `CompiledDef` with a pointer to the Hugr node
that was created for this definition.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
"""
@abstractmethod
- def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledDef":
- """Adds a Hugr node for the definition to the provided graph.
+ def compile_outer(self, module: _DefinitionBuilder[OpVar]) -> "CompiledDef":
+ """Adds a Hugr node for the definition to the provided Hugr module.
Note that is not required to fill in the contents of the node. At this point,
we don't have access to the globals since they have not all been compiled yet.
@@ -112,9 +136,15 @@ def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledDef":
class CompiledDef(Definition):
- """Abstract base class for definitions that have been added to a Hugr."""
+ """Abstract base class for definitions that have been added to a Hugr.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
+ """
- def compile_inner(self, graph: Hugr, globals: "CompiledGlobals") -> None:
+ def compile_inner(self, globals: "CompiledGlobals") -> None:
"""Optional hook that is called to fill in the content of the Hugr node.
Opposed to `CompilableDef.compile()`, we have access to all other compiled
diff --git a/guppylang/definition/custom.py b/guppylang/definition/custom.py
index 83a452d6..57918cad 100644
--- a/guppylang/definition/custom.py
+++ b/guppylang/definition/custom.py
@@ -1,10 +1,13 @@
import ast
from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
from dataclasses import dataclass, field
-from hugr.serialization import ops
+from hugr import Wire, ops
+from hugr import tys as ht
+from hugr.dfg import _DfBase
-from guppylang.ast_util import AstNode, get_type, with_loc, with_type
+from guppylang.ast_util import AstNode, with_loc, with_type
from guppylang.checker.core import Context, Globals
from guppylang.checker.expr_checker import check_call, synthesize_call
from guppylang.checker.func_checker import check_signature
@@ -12,10 +15,9 @@
from guppylang.definition.common import ParsableDef
from guppylang.definition.value import CompiledCallableDef
from guppylang.error import GuppyError, InternalGuppyError
-from guppylang.hugr_builder.hugr import Hugr, OutPortV
from guppylang.nodes import GlobalCall
from guppylang.tys.subst import Inst, Subst
-from guppylang.tys.ty import FunctionType, NoneType, Type, type_to_row
+from guppylang.tys.ty import FunctionType, NoneType, Type
@dataclass(frozen=True)
@@ -27,6 +29,14 @@ class RawCustomFunctionDef(ParsableDef):
The raw definition stores exactly what the user has written (i.e. the AST together
with the provided checker and compiler), without inspecting the signature.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
+ call_checker: The custom call checker.
+ call_compiler: The custom call compiler.
+ higher_order_value: Whether the function may be used as a higher-order value.
"""
defined_at: ast.FunctionDef
@@ -51,27 +61,7 @@ def parse(self, globals: "Globals") -> "CustomFunctionDef":
code. The only information we need to access is that it's a function type and
that there are no unsolved existential vars.
"""
- # Type annotations are needed if we rely on the default call checker or want
- # to allow the usage of the function as a higher-order value
- requires_type_annotation = (
- isinstance(self.call_checker, DefaultCallChecker) or self.higher_order_value
- )
- has_type_annotation = self.defined_at.returns or any(
- arg.annotation for arg in self.defined_at.args.args
- )
-
- if requires_type_annotation and not has_type_annotation:
- raise GuppyError(
- f"Type signature for function `{self.name}` is required. "
- "Alternatively, try passing `higher_order_value=False` on definition.",
- self.defined_at,
- )
-
- ty = (
- check_signature(self.defined_at, globals)
- if requires_type_annotation
- else FunctionType([], NoneType())
- )
+ ty = self._get_signature(globals) or FunctionType([], NoneType())
return CustomFunctionDef(
self.id,
self.name,
@@ -84,26 +74,73 @@ def parse(self, globals: "Globals") -> "CustomFunctionDef":
def compile_call(
self,
- args: list[OutPortV],
+ args: list[Wire],
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> list[OutPortV]:
+ function_ty: ht.FunctionType,
+ ) -> Sequence[Wire]:
"""Compiles a call to the function."""
- self.call_compiler._setup(type_args, dfg, graph, globals, node)
+ # Note: We have _compiled_ globals rather than `Globals` here,
+ # so we cannot use `self._get_signature()`.
+ self.call_compiler._setup(
+ type_args,
+ dfg,
+ globals,
+ node,
+ function_ty,
+ )
return self.call_compiler.compile(args)
+ def _get_signature(self, globals: Globals) -> FunctionType | None:
+ """Returns the type of the function, if known.
+
+ Type annotations are needed if we rely on the default call checker or
+ want to allow the usage of the function as a higher-order value.
+
+ Some function types like python's `int()` cannot be expressed in the Guppy
+ type system, so we return `None` here and rely on the specialized compiler
+ to handle the call.
+ """
+ requires_type_annotation = (
+ isinstance(self.call_checker, DefaultCallChecker) or self.higher_order_value
+ )
+ has_type_annotation = self.defined_at.returns or any(
+ arg.annotation for arg in self.defined_at.args.args
+ )
+
+ if requires_type_annotation and not has_type_annotation:
+ raise GuppyError(
+ f"Type signature for function `{self.name}` is required. "
+ "Alternatively, try passing `higher_order_value=False` on definition.",
+ self.defined_at,
+ )
+
+ if requires_type_annotation:
+ return check_signature(self.defined_at, globals)
+ else:
+ return None
+
@dataclass(frozen=True)
class CustomFunctionDef(CompiledCallableDef):
- """A custom function with parsed and checked signature."""
+ """A custom function with parsed and checked signature.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the definition.
+ defined_at: The AST node where the definition was defined.
+ ty: The type of the function.
+ call_checker: The custom call checker.
+ call_compiler: The custom call compiler.
+ higher_order_value: Whether the function may be used as a higher-order value.
+ """
defined_at: AstNode
+ ty: FunctionType
call_checker: "CustomCallChecker"
call_compiler: "CustomCallCompiler"
- ty: FunctionType
higher_order_value: bool
description: str = field(default="function", init=False)
@@ -134,15 +171,14 @@ def load_with_args(
self,
type_args: Inst,
dfg: "DFContainer",
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> OutPortV:
+ ) -> Wire:
"""Loads the custom function as a value into a local dataflow graph.
- This will place a `FunctionDef` node into the Hugr module and loads it into the
- DFG. This operation will fail the function is not allowed to be used as a
- higher-order value.
+ This will place a `FunctionDef` node in the local DFG, and load with a
+ `LoadFunc` node. This operation will fail if the function is not allowed
+ to be used as a higher-order value.
"""
# TODO: This should be raised during checking, not compilation!
if not self.higher_order_value:
@@ -156,35 +192,40 @@ def load_with_args(
# function, and returns the results. If the function signature is polymorphic,
# we explicitly monomorphise here and invoke the call compiler with the
# inferred type args.
+ #
+ # TODO: Reuse compiled instances with the same type args?
+ # TODO: Why do we need to monomorphise here? Why not wait for `load_function`?
+ # See https://github.com/CQCL/guppylang/issues/393 for both issues.
fun_ty = self.ty.instantiate(type_args)
- def_node = graph.add_def(fun_ty, dfg.node, self.name)
- with graph.parent(def_node):
- _, inp_ports = graph.add_input_with_ports(list(fun_ty.inputs))
- returns = self.compile_call(
- inp_ports,
- type_args,
- DFContainer(graph, def_node),
- graph,
- globals,
- node,
- )
- graph.add_output(returns)
+ input_types = [ty.to_hugr() for ty in fun_ty.inputs]
+ output_types = [fun_ty.output.to_hugr()]
+ func = dfg.builder.define_function(
+ self.name, input_types, output_types, type_params=[]
+ )
+
+ func_dfg = DFContainer(func, dfg.locals.copy())
+ args: list[Wire] = list(func.inputs())
+ outputs = self.compile_call(args, type_args, func_dfg, globals, node)
+
+ func.set_outputs(*outputs)
# Finally, load the function into the local DFG. We already monomorphised, so we
- # can load with empty type args
- return graph.add_load_function(def_node.out_port(0), [], dfg.node).out_port(0)
+ # don't need to give it type arguments.
+ return dfg.builder.load_function(func)
def compile_call(
self,
- args: list[OutPortV],
+ args: list[Wire],
type_args: Inst,
- dfg: DFContainer,
- graph: Hugr,
+ dfg: "DFContainer",
globals: CompiledGlobals,
node: AstNode,
- ) -> list[OutPortV]:
+ ) -> list[Wire]:
"""Compiles a call to the function."""
- self.call_compiler._setup(type_args, dfg, graph, globals, node)
+ concrete_ty = self.ty.instantiate(type_args)
+ hugr_ty = concrete_ty.to_hugr()
+
+ self.call_compiler._setup(type_args, dfg, globals, node, hugr_ty)
return self.call_compiler.compile(args)
@@ -216,31 +257,47 @@ def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
class CustomCallCompiler(ABC):
- """Abstract base class for custom function call compilers."""
+ """Abstract base class for custom function call compilers.
+
+ Args:
+ builder: The function builder where the function should be defined.
+ type_args: The type arguments for the function.
+ globals: The compiled globals.
+ node: The AST node where the function is defined.
+ ty: The type of the function, if known.
+ """
- type_args: Inst
dfg: DFContainer
- graph: Hugr
+ type_args: Inst
globals: CompiledGlobals
node: AstNode
+ ty: ht.FunctionType
def _setup(
self,
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
+ hugr_ty: ht.FunctionType,
) -> None:
self.type_args = type_args
self.dfg = dfg
- self.graph = graph
self.globals = globals
self.node = node
+ self.ty = hugr_ty
@abstractmethod
- def compile(self, args: list[OutPortV]) -> list[OutPortV]:
- """Compiles a custom function call and returns the resulting ports."""
+ def compile(self, args: list[Wire]) -> list[Wire]:
+ """Compiles a custom function call and returns the resulting ports.
+
+ Use the provided `self.builder` to add nodes to the Hugr graph.
+ """
+
+ @property
+ def builder(self) -> _DfBase[ops.DfParentOp]:
+ """The hugr dataflow builder."""
+ return self.dfg.builder
class DefaultCallChecker(CustomCallChecker):
@@ -265,28 +322,31 @@ class NotImplementedCallCompiler(CustomCallCompiler):
thus doesn't need to be compiled.
"""
- def compile(self, args: list[OutPortV]) -> list[OutPortV]:
+ def compile(self, args: list[Wire]) -> list[Wire]:
raise InternalGuppyError("Function should have been removed during checking")
class OpCompiler(CustomCallCompiler):
- """Call compiler for functions that are directly implemented via Hugr ops."""
+ """Call compiler for functions that are directly implemented via Hugr ops.
- op: ops.OpType
+ args:
+ op: A function that takes an instantiation of the type arguments as well as
+ the monomorphic function type, and returns a concrete HUGR op.
+ """
+
+ op: Callable[[ht.FunctionType, Inst], ops.DataflowOp]
- def __init__(self, op: ops.OpType) -> None:
+ def __init__(self, op: Callable[[ht.FunctionType, Inst], ops.DataflowOp]) -> None:
self.op = op
- def compile(self, args: list[OutPortV]) -> list[OutPortV]:
- node = self.graph.add_node(
- self.op.model_copy(deep=True), inputs=args, parent=self.dfg.node
- )
- return_ty = get_type(self.node)
- return [node.add_out_port(ty) for ty in type_to_row(return_ty)]
+ def compile(self, args: list[Wire]) -> list[Wire]:
+ op = self.op(self.ty, self.type_args)
+ node = self.builder.add_op(op, *args)
+ return list(node)
class NoopCompiler(CustomCallCompiler):
"""Call compiler for functions that are noops."""
- def compile(self, args: list[OutPortV]) -> list[OutPortV]:
+ def compile(self, args: list[Wire]) -> list[Wire]:
return args
diff --git a/guppylang/definition/declaration.py b/guppylang/definition/declaration.py
index 7789318d..aff0743b 100644
--- a/guppylang/definition/declaration.py
+++ b/guppylang/definition/declaration.py
@@ -1,6 +1,11 @@
import ast
from dataclasses import dataclass, field
+from hugr import Node, Wire
+from hugr import function as hf
+from hugr import tys as ht
+from hugr.dfg import OpVar, _DefinitionBuilder
+
from guppylang.ast_util import AstNode, has_empty_body, with_loc
from guppylang.checker.core import Context, Globals
from guppylang.checker.expr_checker import check_call, synthesize_call
@@ -10,10 +15,9 @@
from guppylang.definition.function import PyFunc, parse_py_func
from guppylang.definition.value import CallableDef, CompiledCallableDef
from guppylang.error import GuppyError
-from guppylang.hugr_builder.hugr import Hugr, Node, OutPortV, VNode
from guppylang.nodes import GlobalCall
from guppylang.tys.subst import Inst, Subst
-from guppylang.tys.ty import Type, type_to_row
+from guppylang.tys.ty import Type
@dataclass(frozen=True)
@@ -68,9 +72,16 @@ def synthesize_call(
node = with_loc(node, GlobalCall(def_id=self.id, args=args, type_args=inst))
return node, ty
- def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledFunctionDecl":
+ def compile_outer(
+ self, module: _DefinitionBuilder[OpVar]
+ ) -> "CompiledFunctionDecl":
"""Adds a Hugr `FuncDecl` node for this function to the Hugr."""
- node = graph.add_declare(self.ty, parent, self.name)
+ assert isinstance(
+ module, hf.Module
+ ), "Functions can only be declared in modules"
+ module: hf.Module = module
+
+ node = module.declare_function(self.name, self.ty.to_hugr_poly())
return CompiledFunctionDecl(
self.id,
self.name,
@@ -86,30 +97,32 @@ def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledFunctionDecl":
class CompiledFunctionDecl(CheckedFunctionDecl, CompiledCallableDef):
"""A function declaration with a corresponding Hugr node."""
- hugr_node: VNode
+ declaration: Node
def load_with_args(
self,
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> OutPortV:
+ ) -> Wire:
"""Loads the function as a value into a local Hugr dataflow graph."""
- return graph.add_load_function(
- self.hugr_node.out_port(0), type_args, dfg.node
- ).out_port(0)
+ func_ty: ht.FunctionType = self.ty.instantiate(type_args).to_hugr()
+ type_args: list[ht.TypeArg] = [arg.to_hugr() for arg in type_args]
+ return dfg.builder.load_function(self.declaration, func_ty, type_args)
def compile_call(
self,
- args: list[OutPortV],
+ args: list[Wire],
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> list[OutPortV]:
+ ) -> list[Wire]:
"""Compiles a call to the function."""
- call = graph.add_call(self.hugr_node.out_port(0), args, type_args, dfg.node)
- return [call.out_port(i) for i in range(len(type_to_row(self.ty.output)))]
+ func_ty: ht.FunctionType = self.ty.instantiate(type_args).to_hugr()
+ type_args: list[ht.TypeArg] = [arg.to_hugr() for arg in type_args]
+ call = dfg.builder.call(
+ self.declaration, *args, instantiation=func_ty, type_args=type_args
+ )
+ return list(call)
diff --git a/guppylang/definition/extern.py b/guppylang/definition/extern.py
index ba5d9e6b..867365f9 100644
--- a/guppylang/definition/extern.py
+++ b/guppylang/definition/extern.py
@@ -1,14 +1,14 @@
import ast
from dataclasses import dataclass, field
-from hugr.serialization import ops
+from hugr import Node, Wire, val
+from hugr.dfg import OpVar, _DefinitionBuilder
from guppylang.ast_util import AstNode
from guppylang.checker.core import Globals
from guppylang.compiler.core import CompiledGlobals, DFContainer
from guppylang.definition.common import CompilableDef, ParsableDef
from guppylang.definition.value import CompiledValueDef, ValueDef
-from guppylang.hugr_builder.hugr import Hugr, Node, OutPortV, VNode
from guppylang.tys.parsing import type_from_ast
@@ -39,19 +39,22 @@ def parse(self, globals: Globals) -> "ExternDef":
class ExternDef(RawExternDef, ValueDef, CompilableDef):
"""An extern symbol definition."""
- def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledExternDef":
+ def compile_outer(self, graph: _DefinitionBuilder[OpVar]) -> "CompiledExternDef":
"""Adds a Hugr constant node for the extern definition to the provided graph."""
+ # The `typ` field must be serialized at this point, to ensure that the
+ # `Extension` is serializable.
custom_const = {
"symbol": self.symbol,
- "typ": self.ty.to_hugr(),
+ "typ": self.ty.to_hugr().to_serial_root(),
"constant": self.constant,
}
- value = ops.ExtensionValue(
- extensions=["prelude"],
+ value = val.Extension(
+ name="ConstExternalSymbol",
typ=self.ty.to_hugr(),
- value=ops.CustomConst(c="ConstExternalSymbol", v=custom_const),
+ val=custom_const,
+ extensions=["prelude"],
)
- const_node = graph.add_constant(ops.Value(value), self.ty, parent)
+ const_node = graph.add_const(value)
return CompiledExternDef(
self.id,
self.name,
@@ -68,10 +71,8 @@ def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledExternDef":
class CompiledExternDef(ExternDef, CompiledValueDef):
"""An extern symbol definition that has been compiled to a Hugr constant."""
- const_node: VNode
+ const_node: Node
- def load(
- self, dfg: DFContainer, graph: Hugr, globals: CompiledGlobals, node: AstNode
- ) -> OutPortV:
+ def load(self, dfg: DFContainer, globals: CompiledGlobals, node: AstNode) -> Wire:
"""Loads the extern value into a local Hugr dataflow graph."""
- return graph.add_load_constant(self.const_node.out_port(0)).out_port(0)
+ return dfg.builder.load(self.const_node)
diff --git a/guppylang/definition/function.py b/guppylang/definition/function.py
index 0abf32b6..d7f8c459 100644
--- a/guppylang/definition/function.py
+++ b/guppylang/definition/function.py
@@ -5,6 +5,11 @@
from dataclasses import dataclass, field
from typing import Any
+import hugr.function as hf
+import hugr.tys as ht
+from hugr import Wire
+from hugr.dfg import OpVar, _DefinitionBuilder
+
from guppylang.ast_util import AstNode, annotate_location, with_loc
from guppylang.checker.cfg_checker import CheckedCFG
from guppylang.checker.core import Context, Globals, Place, PyScope
@@ -19,11 +24,10 @@
from guppylang.definition.common import CheckableDef, CompilableDef, ParsableDef
from guppylang.definition.value import CallableDef, CompiledCallableDef
from guppylang.error import GuppyError
-from guppylang.hugr_builder.hugr import DFContainingVNode, Hugr, Node, OutPortV
from guppylang.ipython_inspect import find_ipython_def, is_running_ipython
from guppylang.nodes import GlobalCall
from guppylang.tys.subst import Inst, Subst
-from guppylang.tys.ty import FunctionType, Type, type_to_row
+from guppylang.tys.ty import FunctionType, Type
PyFunc = Callable[..., Any]
@@ -35,6 +39,13 @@ class RawFunctionDef(ParsableDef):
The raw definition stores exactly what the user has written (i.e. the AST), without
any additional checking or parsing. Furthermore, we store the values of the Python
variables in scope at the point of definition.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the function.
+ defined_at: The AST node where the function was defined.
+ python_func: The Python function to be defined.
+ python_scope: The Python scope where the function was defined.
"""
python_func: PyFunc
@@ -61,6 +72,14 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
In particular, this means that we have determined a type for the function and are
ready to check the function body.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the function.
+ defined_at: The AST node where the function was defined.
+ ty: The type of the function.
+ python_scope: The Python scope where the function was defined.
+ docstring: The docstring of the function.
"""
python_scope: PyScope
@@ -110,18 +129,29 @@ class CheckedFunctionDef(ParsedFunctionDef, CompilableDef):
In particular, this means that we have a constructed and type checked a control-flow
graph for the function body.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the function.
+ defined_at: The AST node where the function was defined.
+ ty: The type of the function.
+ python_scope: The Python scope where the function was defined.
+ docstring: The docstring of the function.
+ cfg: The type- and linearity-checked CFG for the function body.
"""
cfg: CheckedCFG[Place]
- def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledFunctionDef":
+ def compile_outer(self, module: _DefinitionBuilder[OpVar]) -> "CompiledFunctionDef":
"""Adds a Hugr `FuncDefn` node for this function to the Hugr.
Note that we don't compile the function body at this point since we don't have
access to the other compiled functions yet. The body is compiled later in
`CompiledFunctionDef.compile_inner()`.
"""
- def_node = graph.add_def(self.ty, parent, self.name)
+ func_type = self.ty.to_hugr()
+ func_def = module.define_function(self.name, func_type.input)
+ func_def.declare_outputs(func_type.output)
return CompiledFunctionDef(
self.id,
self.name,
@@ -130,45 +160,58 @@ def compile_outer(self, graph: Hugr, parent: Node) -> "CompiledFunctionDef":
self.python_scope,
self.docstring,
self.cfg,
- def_node,
+ func_def,
)
@dataclass(frozen=True)
class CompiledFunctionDef(CheckedFunctionDef, CompiledCallableDef):
- """A function definition with a corresponding Hugr node."""
+ """A function definition with a corresponding Hugr node.
+
+ Args:
+ id: The unique definition identifier.
+ name: The name of the function.
+ defined_at: The AST node where the function was defined.
+ ty: The type of the function.
+ python_scope: The Python scope where the function was defined.
+ docstring: The docstring of the function.
+ cfg: The type- and linearity-checked CFG for the function body.
+ func_def: The Hugr function definition.
+ """
- hugr_node: DFContainingVNode
+ func_def: hf.Function
def load_with_args(
self,
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> OutPortV:
+ ) -> Wire:
"""Loads the function as a value into a local Hugr dataflow graph."""
- return graph.add_load_function(
- self.hugr_node.out_port(0), type_args, dfg.node
- ).out_port(0)
+ func_ty: ht.FunctionType = self.ty.instantiate(type_args).to_hugr()
+ type_args: list[ht.TypeArg] = [arg.to_hugr() for arg in type_args]
+ return dfg.builder.load_function(self.func_def, func_ty, type_args)
def compile_call(
self,
- args: list[OutPortV],
+ args: list[Wire],
type_args: Inst,
dfg: DFContainer,
- graph: Hugr,
globals: CompiledGlobals,
node: AstNode,
- ) -> list[OutPortV]:
+ ) -> list[Wire]:
"""Compiles a call to the function."""
- call = graph.add_call(self.hugr_node.out_port(0), args, type_args, dfg.node)
- return [call.out_port(i) for i in range(len(type_to_row(self.ty.output)))]
+ func_ty: ht.FunctionType = self.ty.instantiate(type_args).to_hugr()
+ type_args: list[ht.TypeArg] = [arg.to_hugr() for arg in type_args]
+ call = dfg.builder.call(
+ self.func_def, *args, instantiation=func_ty, type_args=type_args
+ )
+ return list(call)
- def compile_inner(self, graph: Hugr, globals: CompiledGlobals) -> None:
+ def compile_inner(self, globals: CompiledGlobals) -> None:
"""Compiles the body of the function."""
- compile_global_func_def(self, self.hugr_node, graph, globals)
+ compile_global_func_def(self, self.func_def, globals)
def parse_py_func(f: PyFunc) -> tuple[ast.FunctionDef, str | None]:
diff --git a/guppylang/definition/struct.py b/guppylang/definition/struct.py
index 98c5b02e..1552b4f1 100644
--- a/guppylang/definition/struct.py
+++ b/guppylang/definition/struct.py
@@ -3,9 +3,10 @@
import textwrap
from collections.abc import Sequence
from dataclasses import dataclass
-from functools import cached_property
from typing import Any
+from hugr import Wire, ops
+
from guppylang.ast_util import AstNode, annotate_location
from guppylang.checker.core import Globals
from guppylang.definition.common import (
@@ -23,7 +24,6 @@
from guppylang.definition.parameter import ParamDef
from guppylang.definition.ty import TypeDef
from guppylang.error import GuppyError, InternalGuppyError
-from guppylang.hugr_builder.hugr import OutPortV
from guppylang.ipython_inspect import find_ipython_def, is_running_ipython
from guppylang.tys.arg import Argument
from guppylang.tys.param import Parameter, check_all_args
@@ -194,15 +194,14 @@ def check_instantiate(
check_all_args(self.params, args, self.name, loc)
return StructType(args, self)
- @cached_property
def generated_methods(self) -> list[CustomFunctionDef]:
"""Auto-generated methods for this struct."""
class ConstructorCompiler(CustomCallCompiler):
"""Compiler for the `__new__` constructor method of a struct."""
- def compile(self, args: list[OutPortV]) -> list[OutPortV]:
- return [self.graph.add_make_tuple(args).out_port(0)]
+ def compile(self, args: list[Wire]) -> list[Wire]:
+ return list(self.builder.add(ops.MakeTuple()(*args)))
constructor_sig = FunctionType(
inputs=[f.ty for f in self.fields],
diff --git a/guppylang/definition/ty.py b/guppylang/definition/ty.py
index f430fe7d..e50fe4fd 100644
--- a/guppylang/definition/ty.py
+++ b/guppylang/definition/ty.py
@@ -3,7 +3,7 @@
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
-from hugr.serialization import tys
+from hugr import tys
from guppylang.ast_util import AstNode
from guppylang.definition.common import CompiledDef, Definition
diff --git a/guppylang/definition/value.py b/guppylang/definition/value.py
index 801763be..a7ac99ee 100644
--- a/guppylang/definition/value.py
+++ b/guppylang/definition/value.py
@@ -3,10 +3,11 @@
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any
+from hugr import Wire
+
from guppylang.ast_util import AstNode
from guppylang.definition.common import CompiledDef, Definition
from guppylang.error import GuppyError
-from guppylang.hugr_builder.hugr import Hugr, OutPortV
from guppylang.tys.subst import Inst, Subst
from guppylang.tys.ty import FunctionType, Type
@@ -30,8 +31,8 @@ class CompiledValueDef(ValueDef, CompiledDef):
@abstractmethod
def load(
- self, dfg: "DFContainer", graph: Hugr, globals: "CompiledGlobals", node: AstNode
- ) -> OutPortV:
+ self, dfg: "DFContainer", globals: "CompiledGlobals", node: AstNode
+ ) -> Wire:
"""Loads the defined value into a local Hugr dataflow graph."""
@@ -65,13 +66,12 @@ class CompiledCallableDef(CallableDef, CompiledValueDef):
@abstractmethod
def compile_call(
self,
- args: list[OutPortV],
+ args: list[Wire],
type_args: Inst,
dfg: "DFContainer",
- graph: Hugr,
globals: "CompiledGlobals",
node: AstNode,
- ) -> list[OutPortV]:
+ ) -> list[Wire]:
"""Compiles a call to the function."""
@abstractmethod
@@ -79,17 +79,16 @@ def load_with_args(
self,
type_args: Inst,
dfg: "DFContainer",
- graph: Hugr,
globals: "CompiledGlobals",
node: AstNode,
- ) -> OutPortV:
+ ) -> Wire:
"""Loads the function into a local Hugr dataflow graph.
Requires an instantiation for all function parameters.
"""
def load(
- self, dfg: "DFContainer", graph: Hugr, globals: "CompiledGlobals", node: AstNode
- ) -> OutPortV:
+ self, dfg: "DFContainer", globals: "CompiledGlobals", node: AstNode
+ ) -> Wire:
"""Loads the defined value into a local Hugr dataflow graph."""
- return self.load_with_args([], dfg, graph, globals, node)
+ return self.load_with_args([], dfg, globals, node)
diff --git a/guppylang/error.py b/guppylang/error.py
index b0feebce..d81c528d 100644
--- a/guppylang/error.py
+++ b/guppylang/error.py
@@ -106,11 +106,15 @@ def ipython_excepthook(
yield
ipython_shell.set_custom_exc((), None)
except NameError:
- # Otherwise, override the regular sys.excepthook
- old_hook = sys.excepthook
- sys.excepthook = hook
- yield
- sys.excepthook = old_hook
+ pass
+ else:
+ return
+
+ # Otherwise, override the regular sys.excepthook
+ old_hook = sys.excepthook
+ sys.excepthook = hook
+ yield
+ sys.excepthook = old_hook
def format_source_location(
diff --git a/guppylang/hugr_builder/hugr.py b/guppylang/hugr_builder/hugr.py
deleted file mode 100644
index a9b38e08..00000000
--- a/guppylang/hugr_builder/hugr.py
+++ /dev/null
@@ -1,865 +0,0 @@
-import itertools
-from abc import ABC, abstractmethod
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from typing import Any, Optional
-
-import networkx as nx # type: ignore[import-untyped]
-from hugr import node_port
-from hugr.serialization import ops, tys
-from hugr.serialization import serial_hugr as raw
-from hugr.serialization.ops import OpType
-
-from guppylang.tys.subst import Inst
-from guppylang.tys.ty import (
- FunctionType,
- StructType,
- SumType,
- TupleType,
- Type,
- TypeRow,
- row_to_type,
- rows_to_hugr,
- type_to_row,
-)
-
-NodeIdx = int
-PortOffset = int
-
-
-@dataclass(frozen=True)
-class Port(ABC):
- """Base class for ports on nodes."""
-
- node: "Node"
- offset: PortOffset | None
-
-
-class InPort(Port, ABC):
- """Base class for a port that incoming wires connect to."""
-
-
-class OutPort(Port, ABC):
- """Base class for a port that outgoing wires come from."""
-
-
-@dataclass(frozen=True)
-class InPortV(InPort):
- """A typed value input port."""
-
- ty: Type
- offset: PortOffset
-
-
-@dataclass(frozen=True)
-class OutPortV(OutPort):
- """A typed value output port."""
-
- ty: Type
- offset: PortOffset
-
-
-@dataclass(frozen=True)
-class InPortCF(InPort):
- """A control-flow input port."""
-
- # Control flow inputs are unordered so no port offset is needed
- offset: None = field(default=None, init=False)
-
-
-class OutPortCF(OutPort):
- """A control-flow output port."""
-
-
-class DummyOp(OpType):
- """A dummy Hugr op that is replaced with a call to a dummy function declaration
- during serialisation.
-
- This is a placeholder for ops that aren't yet available in Hugr.
- """
-
- root: str # type: ignore[assignment]
-
- @property
- def name(self) -> str:
- """The name of the dummy op."""
- return self.root
-
-
-Edge = tuple[OutPort, InPort]
-
-TypeList = list[Type]
-
-
-@dataclass
-class Node(ABC):
- """Base class for a node in the graph.
-
- Has a number of input and output ports and an associated op type.
- """
-
- idx: NodeIdx
- op: ops.OpType
- parent: Optional["Node"]
- meta_data: dict[str, Any]
-
- @property
- @abstractmethod
- def num_in_ports(self) -> int:
- """The number of input ports on this node."""
-
- @property
- @abstractmethod
- def num_out_ports(self) -> int:
- """The number of output ports on this node."""
-
- @abstractmethod
- def in_port(self, offset: PortOffset | None) -> InPort:
- """Returns the input port at the given offset."""
-
- @abstractmethod
- def out_port(self, offset: PortOffset | None) -> OutPort:
- """Returns the output port at the given offset."""
-
- def update_op(self) -> None: # noqa: B027
- """Updates the op type associated with this node with additional information.
-
- This should be called before serialisation.
- """
-
- @property
- def in_ports(self) -> Iterator[InPort]:
- """Returns an iterator over all input ports from left to right."""
- return (self.in_port(i) for i in range(self.num_in_ports))
-
- @property
- def out_ports(self) -> Iterator[OutPort]:
- """Returns an iterator over all output ports from left to right."""
- return (self.out_port(i) for i in range(self.num_out_ports))
-
-
-@dataclass
-class VNode(Node):
- """A node with typed value ports."""
-
- in_port_types: TypeList
- out_port_types: TypeList
-
- @property
- def num_in_ports(self) -> int:
- """The number of input ports on this node."""
- return len(self.in_port_types)
-
- @property
- def num_out_ports(self) -> int:
- """The number of output ports on this node."""
- return len(self.out_port_types)
-
- def add_in_port(self, ty: Type) -> InPortV:
- """Adds an input port at the end of the node and returns the port."""
- p = InPortV(self, self.num_in_ports, ty)
- self.in_port_types.append(ty)
- return p
-
- def add_out_port(self, ty: Type) -> OutPortV:
- """Adds an output port at the end of the node and returns the port."""
- p = OutPortV(self, self.num_out_ports, ty)
- self.out_port_types.append(ty)
- return p
-
- def in_port(self, offset: PortOffset | None) -> InPortV:
- """Returns the input port at the given offset."""
- assert offset is not None
- assert offset < self.num_in_ports
- assert offset != -1, "Cannot get the port of an order edge"
- return InPortV(self, offset, self.in_port_types[offset])
-
- def out_port(self, offset: PortOffset | None) -> OutPortV:
- """Returns the output port at the given offset."""
- assert offset is not None
- assert offset < self.num_out_ports
- assert offset != -1, "Cannot get the port of an order edge"
- return OutPortV(self, offset, self.out_port_types[offset])
-
- @property
- def in_ports(self) -> Iterator[InPortV]:
- """Returns an iterator over all input ports from left to right."""
- return (self.in_port(i) for i in range(self.num_in_ports))
-
- @property
- def out_ports(self) -> Iterator[OutPortV]:
- """Returns an iterator over all output ports from left to right."""
- return (self.out_port(i) for i in range(self.num_out_ports))
-
- def update_op(self) -> None:
- """Updates the operation associated with this node with type information.
-
- Feeds type information from the in- and out-ports to the operation class to
- update signature information. This function must be called before serialisation.
- """
- # We can't call `to_hugr()` on polymorphic function types, so we have to skip
- # ops that have connected `Function` edges.
- has_poly_func_edge = isinstance(
- self.op.root, ops.FuncDecl | ops.FuncDefn | ops.Call | ops.LoadFunction
- )
- if isinstance(self.op.root, ops.BaseOp) and not has_poly_func_edge:
- in_types = [t.to_hugr() for t in self.in_port_types]
- out_types = [t.to_hugr() for t in self.out_port_types]
- self.op.root.insert_port_types(in_types, out_types)
- super().update_op()
-
-
-class CFNode(Node):
- """A node in a control-flow graph.
-
- Compared to value nodes, the ports on this node are not typed since they correspond
- to control-flow instead of data-flow.
- """
-
- _num_out_ports: int = 0
-
- @property
- def num_in_ports(self) -> int:
- """The number of input ports on this node."""
- return 0
-
- @property
- def num_out_ports(self) -> int:
- """The number of output ports on this node."""
- return self._num_out_ports
-
- def add_out_port(self) -> OutPortCF:
- """Adds an output port at the end of the node and returns the port."""
- p = OutPortCF(self, self.num_out_ports)
- self._num_out_ports += 1
- return p
-
- def in_port(self, offset: PortOffset | None) -> InPortCF:
- assert offset is None
- return InPortCF(self)
-
- def out_port(self, offset: PortOffset | None) -> OutPortCF:
- """Returns the output port at the given offset."""
- assert offset is not None
- assert offset < self.num_out_ports
- return OutPortCF(self, offset)
-
- def update_op(self) -> None:
- super().update_op()
-
-
-class DFContainingNode(Node, ABC):
- """Base class for a node whose children form a dataflow graph.
-
- Compared to a normal node, this node tracks the `Input` and `Output` nodes of its
- child DFG which is required to compute the operation signature.
- """
-
- input_child: Optional["VNode"] = None # Input Node for the child dataflow graph
- output_child: Optional["VNode"] = None # Output Node for the child dataflow graph
-
- def update_op(self) -> None:
- """Updates the operation associated with this node with type information.
-
- Feeds type information from the signature of the contained dataflow graph to
- the operation class to. This function must be called before serialisation.
- """
- assert self.input_child is not None
- assert self.output_child is not None
- assert isinstance(self.op.root, ops.BaseOp)
- # Input and output node may have extra order edges connected, so we filter
- # `None`s here
- ins = [ty.to_hugr() for ty in self.input_child.out_port_types]
- outs = [ty.to_hugr() for ty in self.output_child.in_port_types]
- self.op.root.insert_child_dfg_signature(inputs=ins, outputs=outs)
- super().update_op()
-
-
-class DFContainingVNode(VNode, DFContainingNode):
- """A value node whose children form a dataflow graph"""
-
-
-class BlockNode(DFContainingNode, CFNode):
- """A `Block` node representing a basic block."""
-
-
-OrderEdge = tuple["Node", "Node"]
-ORDER_EDGE_KEY = (-1, -1)
-
-UNDEFINED: node_port.NodeIdx = -1
-
-
-class Hugr:
- """Hierarchical unified graph representation."""
-
- name: str
- root: VNode
- _graph: nx.MultiDiGraph # TODO: We probably don't need networkx.
- _children: dict[NodeIdx, list[Node]]
- _default_parent: Node | None
-
- def __init__(self, name: str | None = None) -> None:
- """Creates a new Hugr."""
- self.name = name or "Unnamed"
- self._default_parent = None
- self._graph = nx.MultiDiGraph()
- self._children = {-1: []}
- self.root = self.add_node(
- op=ops.OpType(ops.Module(parent=UNDEFINED)),
- meta_data={"name": name},
- parent=None,
- )
-
- @contextmanager
- def parent(self, parent: Node) -> Iterator[None]:
- """Context manager to set a default parent for adding new nodes."""
- old_default = self._default_parent
- self._default_parent = parent
- yield
- self._default_parent = old_default
-
- def _insert_node(self, node: Node, inputs: list[OutPortV] | None = None) -> None:
- """Helper method to insert a node into the graph datastructure."""
- self._graph.add_node(node.idx, data=node)
- self._children[node.idx] = []
- self._children[node.parent.idx if node.parent else -1].append(node)
- if inputs is not None:
- for i, port in enumerate(inputs):
- self.add_edge(port, node.in_port(i))
-
- def add_node(
- self,
- op: ops.OpType,
- input_types: TypeList | None = None,
- output_types: TypeList | None = None,
- parent: Node | None = None,
- inputs: list[OutPortV] | None = None,
- meta_data: dict[str, Any] | None = None,
- ) -> VNode:
- """Helper method to add a generic value node to the graph."""
- input_types = input_types or []
- output_types = output_types or []
- parent = parent or self._default_parent
- node = VNode(
- idx=self._graph.number_of_nodes(),
- op=op,
- parent=parent,
- in_port_types=[p.ty for p in inputs] if inputs is not None else input_types,
- out_port_types=output_types,
- meta_data=meta_data or {},
- )
- self._insert_node(node, inputs)
- return node
-
- def _add_dfg_node(
- self,
- op: ops.OpType,
- input_types: TypeList | None = None,
- output_types: TypeList | None = None,
- parent: Node | None = None,
- inputs: list[OutPortV] | None = None,
- meta_data: dict[str, Any] | None = None,
- ) -> DFContainingVNode:
- """Helper method to add a generic dataflow containing value node to the
- graph."""
- input_types = input_types or []
- output_types = output_types or []
- parent = parent or self._default_parent
- node = DFContainingVNode(
- idx=self._graph.number_of_nodes(),
- op=op,
- parent=parent,
- in_port_types=[p.ty for p in inputs] if inputs is not None else input_types,
- out_port_types=output_types,
- meta_data=meta_data or {},
- )
- self._insert_node(node, inputs)
- return node
-
- def set_root_name(self, name: str) -> VNode:
- """Sets the name of the root node."""
- self.root.meta_data["name"] = name
- return self.root
-
- def add_constant(
- self, value: ops.Value, ty: Type, parent: Node | None = None
- ) -> VNode:
- """Adds a constant node holding a given value to the graph."""
- return self.add_node(
- ops.OpType(ops.Const(v=value, parent=UNDEFINED)), [], [ty], parent, None
- )
-
- def add_input(
- self, output_tys: TypeList | None = None, parent: Node | None = None
- ) -> VNode:
- """Adds an `Input` node to the graph."""
- parent = parent or self._default_parent
- node = self.add_node(
- ops.OpType(ops.Input(parent=UNDEFINED)), [], output_tys, parent
- )
- if isinstance(parent, DFContainingNode):
- parent.input_child = node
- return node
-
- def add_input_with_ports(
- self, output_tys: Sequence[Type], parent: Node | None = None
- ) -> tuple[VNode, list[OutPortV]]:
- """Adds an `Input` node to the graph."""
- node = self.add_input(None, parent)
- ports = [node.add_out_port(ty) for ty in output_tys]
- return node, ports
-
- def add_output(
- self,
- inputs: list[OutPortV] | None = None,
- input_tys: TypeList | None = None,
- parent: Node | None = None,
- ) -> VNode:
- """Adds an `Output` node to the graph."""
- parent = parent or self._default_parent
- node = self.add_node(
- ops.OpType(ops.Output(parent=UNDEFINED)), input_tys, [], parent, inputs
- )
- if isinstance(parent, DFContainingNode):
- parent.output_child = node
- return node
-
- def add_block(self, parent: Node | None, num_successors: int = 0) -> BlockNode:
- """Adds a `Block` node to the graph."""
- node = BlockNode(
- idx=self._graph.number_of_nodes(),
- op=ops.OpType(ops.DataflowBlock(parent=UNDEFINED, sum_rows=[])),
- parent=parent,
- meta_data={},
- )
- self._insert_node(node)
- for _ in range(num_successors):
- node.add_out_port()
- return node
-
- def add_exit(self, output_tys: TypeList, parent: Node) -> CFNode:
- """Adds an `Exit` node to the graph."""
- outputs = [ty.to_hugr() for ty in output_tys]
- node = CFNode(
- idx=self._graph.number_of_nodes(),
- op=ops.OpType(ops.ExitBlock(cfg_outputs=outputs, parent=UNDEFINED)),
- parent=parent,
- meta_data={},
- )
- self._insert_node(node)
- return node
-
- def add_dfg(self, parent: Node) -> DFContainingVNode:
- """Adds a nested dataflow `DFG` node to the graph."""
- return self._add_dfg_node(ops.OpType(ops.DFG(parent=UNDEFINED)), [], [], parent)
-
- def add_case(self, parent: Node) -> DFContainingVNode:
- """Adds a `Case` node to the graph."""
- return self._add_dfg_node(
- ops.OpType(ops.Case(parent=UNDEFINED)), [], [], parent
- )
-
- def add_cfg(self, parent: Node, inputs: list[OutPortV]) -> VNode:
- """Adds a nested control-flow `CFG` node to the graph."""
- return self.add_node(
- ops.OpType(ops.CFG(parent=UNDEFINED)), [], [], parent, inputs
- )
-
- def add_conditional(
- self,
- cond_input: OutPortV,
- inputs: list[OutPortV],
- parent: Node | None = None,
- ) -> VNode:
- """Adds a `Conditional` node to the graph."""
- inputs = [cond_input, *inputs]
- return self.add_node(
- ops.OpType(ops.Conditional(sum_rows=[], parent=UNDEFINED)),
- None,
- None,
- parent,
- inputs,
- )
-
- def add_tail_loop(
- self, inputs: list[OutPortV], parent: Node | None = None
- ) -> DFContainingVNode:
- """Adds a `TailLoop` node to the graph."""
- return self._add_dfg_node(
- ops.OpType(ops.TailLoop(parent=UNDEFINED)), None, None, parent, inputs
- )
-
- def add_make_tuple(
- self, inputs: list[OutPortV], parent: Node | None = None
- ) -> VNode:
- """Adds a `MakeTuple` node to the graph."""
- ty = TupleType([port.ty for port in inputs])
- return self.add_node(
- ops.OpType(ops.MakeTuple(parent=UNDEFINED)), None, [ty], parent, inputs
- )
-
- def add_unpack_tuple(
- self, input_tuple: OutPortV, parent: Node | None = None
- ) -> VNode:
- """Adds an `UnpackTuple` node to the graph."""
- match input_tuple.ty:
- case TupleType(element_types=elems):
- tys = list(elems)
- case StructType(fields=fields):
- tys = [field.ty for field in fields]
- case ty:
- raise AssertionError(f"Cannot unpack `{ty}`")
- return self.add_node(
- ops.OpType(ops.UnpackTuple(parent=UNDEFINED)),
- None,
- tys,
- parent,
- [input_tuple],
- )
-
- def add_tag(
- self,
- variants: Sequence[TypeRow],
- tag: int,
- inputs: list[OutPortV],
- parent: Node | None = None,
- ) -> VNode:
- """Adds a `Tag` node to the graph."""
- assert all(inp.ty == ty for inp, ty in zip(inputs, variants[tag], strict=True))
- hugr_variants = rows_to_hugr(variants)
- out_ty = SumType([row_to_type(row) for row in variants])
- return self.add_node(
- ops.OpType(ops.Tag(tag=tag, variants=hugr_variants, parent=UNDEFINED)),
- None,
- [out_ty],
- parent,
- inputs,
- )
-
- def add_load_constant(
- self, const_port: OutPortV, parent: Node | None = None
- ) -> VNode:
- """Adds a `LoadConstant` node to the graph."""
- return self.add_node(
- ops.OpType(
- ops.LoadConstant(datatype=const_port.ty.to_hugr(), parent=UNDEFINED)
- ),
- None,
- [const_port.ty],
- parent,
- [const_port],
- )
-
- def add_load_function(
- self, def_port: OutPortV, inst: Inst, parent: Node | None = None
- ) -> VNode:
- """Adds a `LoadFunction` node to the graph."""
- assert isinstance(def_port.ty, FunctionType)
- assert len(def_port.ty.params) == len(inst)
- instantiation = def_port.ty.instantiate(inst)
- op = ops.LoadFunction(
- func_sig=def_port.ty.to_hugr_poly(),
- type_args=[arg.to_hugr() for arg in inst],
- signature=tys.FunctionType(input=[], output=[instantiation.to_hugr()]),
- parent=UNDEFINED,
- )
- return self.add_node(ops.OpType(op), None, [instantiation], parent, [def_port])
-
- def add_call(
- self,
- def_port: OutPortV,
- args: list[OutPortV],
- inst: Inst,
- parent: Node | None = None,
- ) -> VNode:
- """Adds a `Call` node to the graph."""
- assert isinstance(def_port.ty, FunctionType)
- instantiation = def_port.ty.instantiate(inst)
- op = ops.Call(
- func_sig=def_port.ty.to_hugr_poly(),
- type_args=[arg.to_hugr() for arg in inst],
- instantiation=instantiation.to_hugr().root,
- parent=UNDEFINED,
- )
- return self.add_node(
- ops.OpType(op),
- None,
- list(type_to_row(instantiation.output)),
- parent,
- [*args, def_port],
- )
-
- def add_indirect_call(
- self, fun_port: OutPortV, args: list[OutPortV], parent: Node | None = None
- ) -> VNode:
- """Adds an `IndirectCall` node to the graph."""
- assert isinstance(fun_port.ty, FunctionType)
-
- return self.add_node(
- ops.OpType(ops.CallIndirect(parent=UNDEFINED)),
- None,
- list(type_to_row(fun_port.ty.output)),
- parent,
- [fun_port, *args],
- )
-
- def add_partial(
- self, def_port: OutPortV, inputs: list[OutPortV], parent: Node | None = None
- ) -> VNode:
- """Adds a `Partial` evaluation node to the graph."""
- assert isinstance(def_port.ty, FunctionType)
- assert len(def_port.ty.inputs) >= len(inputs)
- assert [p.ty.to_hugr() for p in inputs] == [
- ty.to_hugr() for ty in def_port.ty.inputs[: len(inputs)]
- ]
- new_ty = FunctionType(
- def_port.ty.inputs[len(inputs) :],
- def_port.ty.output,
- def_port.ty.input_names[len(inputs) :]
- if def_port.ty.input_names is not None
- else None,
- )
- return self.add_node(
- DummyOp("partial"), None, [new_ty], parent, [*inputs, def_port]
- )
-
- def add_def(
- self, fun_ty: FunctionType, parent: Node | None, name: str
- ) -> DFContainingVNode:
- """Adds a `FucnDefn` node to the graph."""
- op = ops.FuncDefn(name=name, signature=fun_ty.to_hugr_poly(), parent=UNDEFINED)
- return self._add_dfg_node(ops.OpType(op), [], [fun_ty], parent, None)
-
- def add_declare(self, fun_ty: FunctionType, parent: Node, name: str) -> VNode:
- """Adds a `FuncDecl` node to the graph."""
- op = ops.FuncDecl(name=name, signature=fun_ty.to_hugr_poly(), parent=UNDEFINED)
- return self.add_node(ops.OpType(op), [], [fun_ty], parent, None)
-
- def add_edge(self, src_port: OutPort, tgt_port: InPort) -> None:
- """Adds an edge between two ports."""
- if isinstance(src_port, OutPortV) or isinstance(tgt_port, InPortV):
- assert isinstance(src_port, OutPortV)
- assert isinstance(tgt_port, InPortV)
- assert src_port.ty == tgt_port.ty
- else:
- assert isinstance(src_port, OutPortCF)
- assert isinstance(tgt_port, InPortCF)
- self._graph.add_edge(
- src_port.node.idx, tgt_port.node.idx, key=(src_port.offset, tgt_port.offset)
- )
-
- def add_order_edge(self, src: Node, tgt: Node) -> None:
- """Adds a order-edge between two nodes."""
- self._graph.add_edge(src.idx, tgt.idx, key=ORDER_EDGE_KEY)
-
- def nodes(self) -> Iterator[Node]:
- """Returns an iterator over all nodes in the graph."""
- return (n["data"] for n in self._graph.nodes.values())
-
- def get_node(self, idx: int) -> Node:
- """Returns the node corresponding to given index."""
- return self._graph.nodes[idx]["data"] # type: ignore[no-any-return]
-
- def children(self, node: Node) -> list[Node]:
- """Returns list of a node's immediate children in the hierarchy."""
- return self._children[node.idx]
-
- def top_level_nodes(self) -> list[Node]:
- """Returns list of nodes at the top level of the hierarchy.
-
- These are nodes that do not have a parent. Usually this will just
- be the `Root` node.
- """
- return self._children[-1]
-
- def edges(self) -> Iterator[Edge]:
- """Returns an iterator over all edges in the graph."""
- return (
- self._to_edge(*e)
- for e in self._graph.edges(keys=True)
- if e[2] != ORDER_EDGE_KEY
- )
-
- def order_edges(self) -> Iterator[OrderEdge]:
- """Returns an iterator over all order-edges in the graph."""
- return (
- (self.get_node(e[0]), self.get_node(e[1]))
- for e in self._graph.edges(keys=True)
- if e[2] == ORDER_EDGE_KEY
- )
-
- def in_edges(self, port: InPort) -> Iterator[Edge]:
- """Returns an iterator over all edges connected to a given in-port."""
- for e in self._graph.in_edges(port.node.idx, keys=True):
- if e[2] == ORDER_EDGE_KEY:
- continue
- src, tgt = self._to_edge(*e)
- if tgt.offset == port.offset:
- yield src, tgt
-
- def out_edges(self, port: OutPort) -> Iterator[Edge]:
- """Returns an iterator over all edges originating from a given out-port."""
- for e in self._graph.out_edges(port.node.idx, keys=True):
- if e[2] == ORDER_EDGE_KEY:
- continue
- src, tgt = self._to_edge(*e)
- if src.offset == port.offset:
- yield src, tgt
-
- def order_successors(self, node: Node) -> Iterator[Node]:
- """Returns an iterator over all nodes that this node connects to via an
- order edge."""
- for _src, tgt, key in self._graph.out_edges(node.idx, keys=True):
- if key == ORDER_EDGE_KEY:
- yield tgt
-
- def order_predecessors(self, node: Node) -> Iterator[Node]:
- """Returns an iterator over all nodes that are connected to this node via an
- order edge."""
- for src, _tgt, key in self._graph.in_edges(node.idx, keys=True):
- if key == ORDER_EDGE_KEY:
- yield src
-
- def _to_edge(self, src: int, tgt: int, key: tuple[int, int]) -> Edge:
- src_node = self.get_node(src)
- tgt_node = self.get_node(tgt)
- return src_node.out_port(key[0]), tgt_node.in_port(key[1])
-
- def remove_edge(self, src_port: OutPort, tgt_port: InPort) -> None:
- """Removes an edge from the graph."""
- self._graph.remove_edge(
- src_port.node.idx, tgt_port.node.idx, key=(src_port.offset, tgt_port.offset)
- )
-
- def remove_dummy_nodes(self) -> "Hugr":
- """Replaces dummy ops with external function calls."""
- if self.root is None:
- raise ValueError("Dummy node removal requires a module root node")
- used_names: dict[str, int] = {}
- for n in list(self.nodes()):
- if isinstance(n, VNode) and isinstance(n.op, DummyOp):
- name = n.op.name
- fun_ty = FunctionType(
- list(n.in_port_types), row_to_type(n.out_port_types)
- )
- if name in used_names:
- used_names[name] += 1
- name = f"{name}${used_names[name]}"
- else:
- used_names[name] = 0
- decl = self.add_declare(fun_ty, self.root, name)
- n.op = ops.OpType(
- ops.Call(
- func_sig=fun_ty.to_hugr_poly(),
- type_args=[],
- instantiation=fun_ty.to_hugr().root,
- parent=UNDEFINED,
- )
- )
- self.add_edge(decl.out_port(0), n.add_in_port(fun_ty))
- return self
-
- def insert_order_edges(self) -> "Hugr":
- """Adds order edges to the source and target inter-graph edges.
-
- This ensures that the source is executed before the target. This action must be
- performed before serialisation.
- """
- for src, tgt in list(self.edges()):
- # Exclude CF and constant edges
- if isinstance(src, OutPortCF) or isinstance(
- src.node.op.root, ops.FuncDecl | ops.FuncDefn | ops.Const
- ):
- continue
-
- if src.node.parent != tgt.node.parent:
- # Walk up the hierarchy from the tgt until we hit a node at the same
- # level as src
- node = tgt.node
- while node.parent != src.node.parent:
- if node.parent is None:
- raise ValueError("Invalid non-local edge!")
- node = node.parent
- # Add order edge to make sure that the src is executed first
- self.add_order_edge(src.node, node)
- return self
-
- def to_raw(self) -> raw.SerialHugr:
- """Returns the raw representation of this HUGR for serialisation."""
- if self.root is None:
- raise ValueError("Serial Hugr requires a root node")
-
- self.remove_dummy_nodes()
- self.insert_order_edges()
- # Hugr requires that Input/Output nodes are the first/second children in a DFG.
- # Furthermore, exit nodes must be the second children of CFGs. We're going to
- # satisfy this trivially by first serialising all inputs, outputs, entry and
- # exit nodes
- input_nodes: list[Node] = []
- output_nodes: list[Node] = []
- entry_nodes: list[Node] = []
- exit_nodes: list[Node] = []
- remaining_nodes: list[Node] = []
- indices = itertools.count()
- raw_index: dict[int, node_port.NodeIdx] = {}
- all_nodes = self.nodes()
- for n in all_nodes:
- if n is self.root:
- continue
- match n.op.root:
- case ops.Input():
- input_nodes.append(n)
- case ops.Output():
- output_nodes.append(n)
- # We can detect entry BBs by looking for BBs without incoming edges
- # since Guppy will never generate an edge pointing back to the entry.
- # Also, Guppy errors on unreachable code, so we will never generate
- # interior BBs without incoming edges. Hence, there are also no false
- # positives.
- case ops.DataflowBlock() if next(
- self.in_edges(n.in_port(None)), None
- ) is None:
- entry_nodes.append(n)
- case ops.ExitBlock():
- exit_nodes.append(n)
- case _:
- remaining_nodes.append(n)
- for n in itertools.chain(
- iter([self.root]),
- iter(entry_nodes),
- iter(exit_nodes),
- iter(input_nodes),
- iter(output_nodes),
- iter(remaining_nodes),
- ):
- raw_index[n.idx] = next(indices)
-
- nodes: list[ops.OpType] = [
- ops.OpType(ops.Module(parent=UNDEFINED))
- ] * self._graph.number_of_nodes()
- for n in self.nodes():
- idx = raw_index[n.idx]
- # Nodes without parent have themselves as parent in the serialised format
- parent = n.parent or n
- n.update_op()
- n.op.root.parent = raw_index[parent.idx]
- nodes[idx] = n.op
-
- edges: list[raw.Edge] = []
- for src, tgt in self.edges():
- edges.append(
- (
- (raw_index[src.node.idx], src.offset),
- (raw_index[tgt.node.idx], tgt.offset),
- )
- )
-
- for src, tgt in self.order_edges():
- edges.append(((raw_index[src.idx], None), (raw_index[tgt.idx], None)))
-
- return raw.SerialHugr(nodes=nodes, edges=edges)
-
- def serialize(self) -> str:
- """Serialize this Hugr in JSON format."""
- return self.to_raw().to_json()
diff --git a/guppylang/hugr_builder/visualise.py b/guppylang/hugr_builder/visualise.py
deleted file mode 100644
index 988f91be..00000000
--- a/guppylang/hugr_builder/visualise.py
+++ /dev/null
@@ -1,283 +0,0 @@
-"""Visualise HUGR using graphviz."""
-
-import ast
-from collections.abc import Iterable
-from typing import TYPE_CHECKING
-
-import graphviz as gv # type: ignore[import-untyped]
-
-from guppylang.cfg.analysis import (
- DefAssignmentDomain,
- LivenessDomain,
- MaybeAssignmentDomain,
-)
-from guppylang.cfg.bb import BB, VId
-from guppylang.hugr_builder.hugr import DummyOp, Hugr, InPort, Node, OutPort, OutPortV
-
-if TYPE_CHECKING:
- from guppylang.cfg.cfg import CFG
-
-# old palettte: https://colorhunt.co/palette/343a407952b3ffc107e1e8eb
-# _COLOURS = {
-# "background": "white",
-# "node": "#7952B3",
-# "edge": "#FFC107",
-# "dark": "#343A40",
-# "const": "#7c55b4",
-# "discard": "#ff8888",
-# "node_border": "#9d80c7",
-# "port_border": "#ffd966",
-# }
-
-# ZX colours
-# _COLOURS = {
-# "background": "white",
-# "node": "#629DD1",
-# "edge": "#297FD5",
-# "dark": "#112D4E",
-# "const": "#a1eea1",
-# "discard": "#ff8888",
-# "node_border": "#D8F8D8",
-# "port_border": "#E8A5A5",
-# }
-
-# Conference talk colours
-_COLOURS = {
- "background": "white",
- "node": "#ACCBF9",
- "edge": "#1CADE4",
- "dark": "black",
- "const": "#77CEEF",
- "discard": "#ff8888",
- "node_border": "white",
- "port_border": "#1CADE4",
-}
-
-
-_FONTFACE = "monospace"
-
-_HTML_LABEL_TEMPLATE = """
-