hugr_core/ops/
handle.rs

1//! Handles to nodes in HUGR.
2use crate::Node;
3use crate::core::HugrNode;
4use crate::types::TypeBound;
5
6use derive_more::From as DerFrom;
7use smol_str::SmolStr;
8
9use super::OpTag;
10
11/// Common trait for handles to a node.
12/// Typically wrappers around [`Node`].
13pub trait NodeHandle<N = Node>: Clone {
14    /// The most specific operation tag associated with the handle.
15    const TAG: OpTag;
16
17    /// Index of underlying node.
18    fn node(&self) -> N;
19
20    /// Operation tag for the handle.
21    #[inline]
22    fn tag(&self) -> OpTag {
23        Self::TAG
24    }
25
26    /// Cast the handle to a different more general tag.
27    fn try_cast<T: NodeHandle<N> + From<N>>(&self) -> Option<T> {
28        T::TAG.is_superset(Self::TAG).then(|| self.node().into())
29    }
30
31    /// Checks whether the handle can hold an operation with the given tag.
32    #[must_use]
33    fn can_hold(tag: OpTag) -> bool {
34        Self::TAG.is_superset(tag)
35    }
36}
37
38/// Trait for handles that contain children.
39///
40/// The allowed children handles are defined by the associated type.
41pub trait ContainerHandle<N = Node>: NodeHandle<N> {
42    /// Handle type for the children of this node.
43    type ChildrenHandle: NodeHandle<N>;
44}
45
46#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
47/// Handle to a [`DataflowOp`](crate::ops::dataflow).
48pub struct DataflowOpID<N = Node>(N);
49
50#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
51/// Handle to a [DFG](crate::ops::DFG) node.
52pub struct DfgID<N = Node>(N);
53
54#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
55/// Handle to a [CFG](crate::ops::CFG) node.
56pub struct CfgID<N = Node>(N);
57
58#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
59/// Handle to a module [Module](crate::ops::Module) node.
60pub struct ModuleRootID<N = Node>(N);
61
62#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
63/// Handle to a [module op](crate::ops::module) node.
64pub struct ModuleID<N = Node>(N);
65
66#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
67/// Handle to a [def](crate::ops::OpType::FuncDefn)
68/// or [declare](crate::ops::OpType::FuncDecl) node.
69///
70/// The `DEF` const generic is used to indicate whether the function is
71/// defined or just declared.
72pub struct FuncID<const DEF: bool, N = Node>(N);
73
74#[derive(Debug, Clone, PartialEq, Eq)]
75/// Handle to an [`AliasDefn`](crate::ops::OpType::AliasDefn)
76/// or [`AliasDecl`](crate::ops::OpType::AliasDecl) node.
77///
78/// The `DEF` const generic is used to indicate whether the function is
79/// defined or just declared.
80pub struct AliasID<const DEF: bool, N = Node> {
81    node: N,
82    name: SmolStr,
83    bound: TypeBound,
84}
85
86impl<const DEF: bool, N> AliasID<DEF, N> {
87    /// Construct new `AliasID`
88    pub fn new(node: N, name: SmolStr, bound: TypeBound) -> Self {
89        Self { node, name, bound }
90    }
91
92    /// Retrieve the underlying core type
93    pub fn get_name(&self) -> &SmolStr {
94        &self.name
95    }
96}
97
98#[derive(DerFrom, Debug, Clone, PartialEq, Eq)]
99/// Handle to a [Const](crate::ops::OpType::Const) node.
100pub struct ConstID<N = Node>(N);
101
102#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
103/// Handle to a [`DataflowBlock`](crate::ops::DataflowBlock) or [Exit](crate::ops::ExitBlock) node.
104pub struct BasicBlockID<N = Node>(N);
105
106#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
107/// Handle to a [Case](crate::ops::Case) node.
108pub struct CaseID<N = Node>(N);
109
110#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
111/// Handle to a [`TailLoop`](crate::ops::TailLoop) node.
112pub struct TailLoopID<N = Node>(N);
113
114#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
115/// Handle to a [Conditional](crate::ops::Conditional) node.
116pub struct ConditionalID<N = Node>(N);
117
118#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, DerFrom, Debug)]
119/// Handle to a dataflow container node.
120pub struct DataflowParentID<N = Node>(N);
121
122/// Implements the `NodeHandle` trait for a tuple struct that contains just a
123/// `NodeIndex`. Takes the name of the struct, and the corresponding `OpTag`.
124///
125/// Optionally, the name of the field containing the `NodeIndex` can be specified
126/// as a third argument. Otherwise, it is assumed to be a tuple struct 0th item.
127macro_rules! impl_nodehandle {
128    ($name:ident, $tag:expr) => {
129        impl_nodehandle!($name, $tag, 0);
130    };
131    ($name:ident, $tag:expr, $node_attr:tt) => {
132        impl<N: HugrNode> NodeHandle<N> for $name<N> {
133            const TAG: OpTag = $tag;
134
135            #[inline]
136            fn node(&self) -> N {
137                self.$node_attr
138            }
139        }
140    };
141}
142
143impl_nodehandle!(DataflowParentID, OpTag::DataflowParent);
144impl_nodehandle!(DataflowOpID, OpTag::DataflowChild);
145impl_nodehandle!(ConditionalID, OpTag::Conditional);
146impl_nodehandle!(CaseID, OpTag::Case);
147impl_nodehandle!(DfgID, OpTag::Dfg);
148impl_nodehandle!(TailLoopID, OpTag::TailLoop);
149impl_nodehandle!(CfgID, OpTag::Cfg);
150
151impl_nodehandle!(ModuleRootID, OpTag::ModuleRoot);
152impl_nodehandle!(ModuleID, OpTag::ModuleOp);
153impl_nodehandle!(ConstID, OpTag::Const);
154
155impl_nodehandle!(BasicBlockID, OpTag::DataflowBlock);
156
157impl<const DEF: bool, N: HugrNode> NodeHandle<N> for FuncID<DEF, N> {
158    const TAG: OpTag = OpTag::Function;
159    #[inline]
160    fn node(&self) -> N {
161        self.0
162    }
163}
164
165impl<const DEF: bool, N: HugrNode> NodeHandle<N> for AliasID<DEF, N> {
166    const TAG: OpTag = OpTag::Alias;
167    #[inline]
168    fn node(&self) -> N {
169        self.node
170    }
171}
172
173impl<N: HugrNode> NodeHandle<N> for N {
174    const TAG: OpTag = OpTag::Any;
175    #[inline]
176    fn node(&self) -> N {
177        *self
178    }
179}
180
181/// Implements the `ContainerHandle` trait, with the given child handle type.
182macro_rules! impl_containerHandle {
183    ($name:ident, $children:ident) => {
184        impl<N: HugrNode> ContainerHandle<N> for $name<N> {
185            type ChildrenHandle = $children<N>;
186        }
187    };
188}
189
190impl_containerHandle!(DataflowParentID, DataflowOpID);
191impl_containerHandle!(DfgID, DataflowOpID);
192impl_containerHandle!(TailLoopID, DataflowOpID);
193impl_containerHandle!(ConditionalID, CaseID);
194impl_containerHandle!(CaseID, DataflowOpID);
195impl_containerHandle!(ModuleRootID, ModuleID);
196impl_containerHandle!(CfgID, BasicBlockID);
197impl_containerHandle!(BasicBlockID, DataflowOpID);
198impl<N: HugrNode> ContainerHandle<N> for FuncID<true, N> {
199    type ChildrenHandle = DataflowOpID<N>;
200}
201impl<N: HugrNode> ContainerHandle<N> for AliasID<true, N> {
202    type ChildrenHandle = DataflowOpID<N>;
203}
hugr_core/ops/handle.rs

hugr_core/ops/
handle.rs
