refactor(hugrv2)!: WIP+RFC: Unify Type and Term

hugr-core/src/builder/dataflow.rs

@@ -469,15 +469,15 @@ pub(crate) mod test {
         BuilderWiringError, CFGBuilder, DataflowSubContainer, ModuleBuilder, TailLoopBuilder,
         endo_sig, inout_sig,
     };
-    use crate::extension::SignatureError;
+
     use crate::extension::prelude::{Noop, bool_t, qb_t, usize_t};
     use crate::hugr::linking::{NameLinkingPolicy, NodeLinkingDirective, OnMultiDefn};
     use crate::hugr::validate::InterGraphEdgeError;
     use crate::metadata::Metadata;
     use crate::ops::{FuncDecl, FuncDefn, OpParent, OpTag, OpTrait, Value, handle::NodeHandle};
     use crate::std_extensions::logic::test::and_op;
-    use crate::types::type_param::TypeParam;
-    use crate::types::{EdgeKind, FuncValueType, RowVariable, Signature, Type, TypeBound, TypeRV};
+    use crate::types::type_param::{TermTypeError, TypeParam};
+    use crate::types::{EdgeKind, FuncValueType, Signature, Type, TypeBound, TypeRV};
     use crate::utils::test_quantum_extension::h_gate;
     use crate::{Wire, builder::test::n_identity, type_row};
 
@@ -930,23 +930,23 @@ pub(crate) mod test {
                 Signature::new(
                     [Type::new_function(FuncValueType::new(
                         [usize_t()],
-                        [tv.clone()],
+                        tv.clone(),
                     ))],
                     [],
                 ),
             ),
         )?;
 
         // But cannot eval it...
-        let ev = e.instantiate_extension_op(
-            "eval",
-            [vec![usize_t().into()].into(), vec![tv.into()].into()],
-        );
+        let ev =
+            e.instantiate_extension_op("eval", [vec![usize_t()].into(), vec![tv.clone()].into()]);
         assert_eq!(
             ev,
-            Err(SignatureError::RowVarWhereTypeExpected {
-                var: RowVariable(0, TypeBound::Copyable)
-            })
+            Err(TermTypeError::TypeMismatch {
+                term: Box::new(tv),
+                type_: Box::new(TypeBound::Linear.into())
+            }
+            .into())
         );
         Ok(())
     }

hugr-core/src/builder/module.rs

@@ -9,12 +9,10 @@ use crate::hugr::{
     ValidationError, hugrmut::InsertedForest, internal::HugrMutInternals, views::HugrView,
 };
 use crate::ops;
-use crate::ops::handle::{AliasID, FuncID, NodeHandle};
-use crate::types::{PolyFuncType, Type, TypeBound};
+use crate::ops::handle::{FuncID, NodeHandle};
+use crate::types::PolyFuncType;
 use crate::{Hugr, Node, Visibility, ops::FuncDefn};
 
-use smol_str::SmolStr;
-
 /// Builder for a HUGR module.
 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct ModuleBuilder<T>(pub(super) T);
@@ -179,49 +177,6 @@ impl<T: AsMut<Hugr> + AsRef<Hugr>> ModuleBuilder<T> {
         self.define_function_op(FuncDefn::new(name, signature))
     }
 
-    /// Add a [`crate::ops::OpType::AliasDefn`] node and return a handle to the Alias.
-    ///
-    /// # Errors
-    ///
-    /// Error in adding [`crate::ops::OpType::AliasDefn`] child node.
-    pub fn add_alias_def(
-        &mut self,
-        name: impl Into<SmolStr>,
-        typ: Type,
-    ) -> Result<AliasID<true>, BuildError> {
-        // TODO: add AliasDefn in other containers
-        // This is currently tricky as they are not connected to anything so do
-        // not appear in topological traversals.
-        // Could be fixed by removing single-entry requirement and sorting from
-        // every 0-input node.
-        let name: SmolStr = name.into();
-        let bound = typ.least_upper_bound();
-        let node = self.add_child_node(ops::AliasDefn {
-            name: name.clone(),
-            definition: typ,
-        });
-
-        Ok(AliasID::new(node, name, bound))
-    }
-
-    /// Add a [`crate::ops::OpType::AliasDecl`] node and return a handle to the Alias.
-    /// # Errors
-    ///
-    /// Error in adding [`crate::ops::OpType::AliasDecl`] child node.
-    pub fn add_alias_declare(
-        &mut self,
-        name: impl Into<SmolStr>,
-        bound: TypeBound,
-    ) -> Result<AliasID<false>, BuildError> {
-        let name: SmolStr = name.into();
-        let node = self.add_child_node(ops::AliasDecl {
-            name: name.clone(),
-            bound,
-        });
-
-        Ok(AliasID::new(node, name, bound))
-    }
-
     /// Add some module-children of another Hugr to this module, with
     /// linking directives specified explicitly by [Node].
     ///
@@ -260,7 +215,7 @@ mod test {
     use cool_asserts::assert_matches;
 
     use crate::builder::test::dfg_calling_defn_decl;
-    use crate::builder::{Dataflow, DataflowSubContainer, test::n_identity};
+    use crate::builder::{Dataflow, DataflowSubContainer};
     use crate::extension::prelude::usize_t;
     use crate::{hugr::linking::NodeLinkingDirective, ops::OpType, types::Signature};
 
@@ -285,28 +240,6 @@ mod test {
         Ok(())
     }
 
-    #[test]
-    fn simple_alias() -> Result<(), BuildError> {
-        let build_result = {
-            let mut module_builder = ModuleBuilder::new();
-
-            let qubit_state_type =
-                module_builder.add_alias_declare("qubit_state", TypeBound::Linear)?;
-
-            let f_build = module_builder.define_function(
-                "main",
-                Signature::new(
-                    vec![qubit_state_type.get_alias_type()],
-                    vec![qubit_state_type.get_alias_type()],
-                ),
-            )?;
-            n_identity(f_build)?;
-            module_builder.finish_hugr()
-        };
-        assert_matches!(build_result, Ok(_));
-        Ok(())
-    }
-
     #[test]
     fn builder_from_existing() -> Result<(), BuildError> {
         let hugr = Hugr::new();