Merge branch 'main' into feat/persistenthugr

Author: lmondada

Cargo.lock

@@ -60,6 +60,7 @@ rstest = "0.24.0"
 semver = "1.0.26"
 serde = "1.0.219"
 serde_json = "1.0.140"
+serde_with = "3.12.0"
 serde_yaml = "0.9.34"
 smol_str = "0.3.1"
 static_assertions = "1.1.0"

Cargo.toml

@@ -5,7 +5,7 @@ use hugr::envelope::{read_envelope, EnvelopeError};
 use hugr::extension::ExtensionRegistry;
 use hugr::package::Package;
 use hugr::{Extension, Hugr};
-use std::io::BufReader;
+use std::io::{BufReader, Read};
 use std::path::PathBuf;
 
 use crate::CliError;
@@ -57,12 +57,23 @@ impl HugrInputArgs {
 
     /// Read a hugr JSON file from the input.
     ///
-    /// If [HugrInputArgs::hugr_json] is `false`, [HugrInputArgs::get_package] should be called instead as
-    /// reading an input envelope as a HUGR json will fail.
+    /// This is a legacy option for reading old HUGR JSON files when the
+    /// [HugrInputArgs::hugr_json] flag is used.
+    ///
+    /// For most cases, [HugrInputArgs::get_package] should be called instead.
     pub fn get_hugr(&mut self) -> Result<Hugr, CliError> {
         let extensions = self.load_extensions()?;
         let mut buffer = BufReader::new(&mut self.input);
-        let hugr = Hugr::load_json(&mut buffer, &extensions)?;
+
+        /// Wraps the hugr JSON so that it defines a valid envelope.
+        const PREPEND: &str = r#"HUGRiHJv?@{"modules": ["#;
+        const APPEND: &str = r#"],"extensions": []}"#;
+
+        let mut envelope = PREPEND.to_string();
+        buffer.read_to_string(&mut envelope)?;
+        envelope.push_str(APPEND);
+
+        let hugr = Hugr::load_str(envelope, Some(&extensions))?;
         Ok(hugr)
     }
 

hugr-cli/src/hugr_io.rs

@@ -60,8 +60,7 @@ use clap::{crate_version, Parser};
 use clap_verbosity_flag::log::Level;
 use clap_verbosity_flag::{InfoLevel, Verbosity};
 use hugr::envelope::EnvelopeError;
-use hugr::hugr::LoadHugrError;
-use hugr::package::{PackageEncodingError, PackageValidationError};
+use hugr::package::PackageValidationError;
 use std::ffi::OsString;
 
 pub mod extensions;
@@ -97,12 +96,6 @@ pub enum CliError {
     /// Error parsing input.
     #[display("Error parsing package: {_0}")]
     Parse(serde_json::Error),
-    /// Package load error.
-    #[display("Error parsing package: {_0}")]
-    PackageLoad(PackageEncodingError),
-    /// Hugr load error.
-    #[display("Error loading hugr: {_0}")]
-    HugrLoad(LoadHugrError),
     #[display("Error validating HUGR: {_0}")]
     /// Errors produced by the `validate` subcommand.
     Validate(PackageValidationError),

hugr-cli/src/lib.rs

@@ -3,7 +3,7 @@
 use clap::Parser;
 use clap_verbosity_flag::log::Level;
 use hugr::package::PackageValidationError;
-use hugr::Hugr;
+use hugr::{Hugr, HugrView};
 
 use crate::hugr_io::HugrInputArgs;
 use crate::{CliError, OtherArgs};

hugr-cli/src/validate.rs

@@ -48,7 +48,7 @@ fn test_package(#[default(bool_t())] id_type: Type) -> Package {
     df.finish_with_outputs([i]).unwrap();
     let hugr = module.hugr().clone(); // unvalidated
 
-    Package::new(vec![hugr]).unwrap()
+    Package::new(vec![hugr])
 }
 
 #[fixture]
@@ -110,30 +110,28 @@ fn bad_hugr_string() -> String {
     let df = DFGBuilder::new(Signature::new_endo(vec![qb_t()])).unwrap();
     let bad_hugr = df.hugr().clone();
 
-    serde_json::to_string(&bad_hugr).unwrap()
+    bad_hugr.store_str(EnvelopeConfig::text()).unwrap()
 }
 
 #[rstest]
 fn test_mermaid_invalid(bad_hugr_string: String, mut cmd: Command) {
     cmd.arg("mermaid");
     cmd.arg("--validate");
-    cmd.arg("--hugr-json");
     cmd.write_stdin(bad_hugr_string);
     cmd.assert()
         .failure()
-        .stderr(contains("has an unconnected port"));
+        .stderr(contains("Error validating HUGR"));
 }
 
 #[rstest]
 fn test_bad_hugr(bad_hugr_string: String, mut val_cmd: Command) {
     val_cmd.write_stdin(bad_hugr_string);
-    val_cmd.arg("--hugr-json");
     val_cmd.arg("-");
 
     val_cmd
         .assert()
         .failure()
-        .stderr(contains("Node(1)").and(contains("unconnected port")));
+        .stderr(contains("Error validating HUGR"));
 }
 
 #[rstest]
@@ -195,7 +193,6 @@ fn test_package_validation(package_string: String, mut val_cmd: Command) {
     // package with float extension and hugr that uses floats can validate
     val_cmd.write_stdin(package_string);
     val_cmd.arg("-");
-    val_cmd.arg("--no-std");
 
     val_cmd.assert().success().stderr(contains(VALID_PRINT));
 }

hugr-cli/tests/validate.rs

@@ -31,7 +31,12 @@ hugr-model = { version = "0.19.1", path = "../hugr-model" }
 
 cgmath = { workspace = true, features = ["serde"] }
 delegate = { workspace = true }
-derive_more = { workspace = true, features = ["display", "error", "from"] }
+derive_more = { workspace = true, features = [
+    "display",
+    "error",
+    "from",
+    "into",
+] }
 downcast-rs = { workspace = true }
 enum_dispatch = { workspace = true }
 fxhash.workspace = true
@@ -46,6 +51,7 @@ regex = { workspace = true }
 # Rc used here for Extension, but unfortunately we must turn the feature on globally
 serde = { workspace = true, features = ["derive", "rc"] }
 serde_json = { workspace = true }
+serde_with = { workspace = true }
 serde_yaml = { workspace = true, optional = true }
 smol_str = { workspace = true, features = ["serde"] }
 static_assertions = { workspace = true }

hugr-core/Cargo.toml

@@ -26,7 +26,7 @@
 //! `CircuitBuilder`.
 //!
 //! ```rust
-//! # use hugr::Hugr;
+//! # use hugr::{Hugr, HugrView};
 //! # use hugr::builder::{BuildError, BuildHandle, Container, DFGBuilder, Dataflow, DataflowHugr, ModuleBuilder, DataflowSubContainer, HugrBuilder};
 //! use hugr::extension::prelude::bool_t;
 //! use hugr::std_extensions::logic::{self, LogicOp};
@@ -138,7 +138,7 @@ pub fn inout_sig(inputs: impl Into<TypeRow>, outputs: impl Into<TypeRow>) -> Sig
 pub enum BuildError {
     /// The constructed HUGR is invalid.
     #[error("The constructed HUGR is invalid: {0}.")]
-    InvalidHUGR(#[from] ValidationError),
+    InvalidHUGR(#[from] ValidationError<Node>),
     /// SignatureError in trying to construct a node (differs from
     /// [ValidationError::SignatureError] in that we could not construct a node to report about)
     #[error(transparent)]
@@ -151,6 +151,10 @@ pub enum BuildError {
     /// CFG can only have one entry.
     #[error("CFG entry node already built for CFG node: {0}.")]
     EntryBuiltError(Node),
+    /// We don't allow creating `BasicBlockBuilder<Hugr>`s when the sum-rows
+    /// are not homogeneous. Use a CFGBuilder and create a valid graph instead.
+    #[error("Cannot initialize hugr for a BasicBlockBuilder with complex sum-rows. Use a CFGBuilder instead.")]
+    BasicBlockTooComplex,
     /// Node was expected to have a certain type but was found to not.
     #[error("Node with index {node} does not have type {op_desc} as expected.")]
     #[allow(missing_docs)]
@@ -164,6 +168,13 @@ pub enum BuildError {
     #[error("Error building Conditional node: {0}.")]
     ConditionalError(#[from] conditional::ConditionalBuildError),
 
+    /// Node not found in Hugr
+    #[error("{node} not found in the Hugr")]
+    NodeNotFound {
+        /// Missing node
+        node: Node,
+    },
+
     /// Wire not found in Hugr
     #[error("Wire not found in Hugr: {0}.")]
     WireNotFound(Wire),
@@ -303,31 +314,32 @@ pub(crate) mod test {
     #[fixture]
     pub(crate) fn simple_package() -> Package {
         let hugr = simple_module_hugr();
-        Package::new([hugr]).unwrap()
+        Package::new([hugr])
     }
 
     #[fixture]
     pub(crate) fn multi_module_package() -> Package {
         let hugr0 = simple_module_hugr();
         let hugr1 = simple_module_hugr();
-        Package::new([hugr0, hugr1]).unwrap()
+        Package::new([hugr0, hugr1])
     }
 
     /// A helper method which creates a DFG rooted hugr with Input and Output node
     /// only (no wires), given a function type with extension delta.
     // TODO consider taking two type rows and using TO_BE_INFERRED
     pub(crate) fn closed_dfg_root_hugr(signature: Signature) -> Hugr {
-        let mut hugr = Hugr::new(ops::DFG {
+        let mut hugr = Hugr::new_with_entrypoint(ops::DFG {
             signature: signature.clone(),
-        });
+        })
+        .unwrap();
         hugr.add_node_with_parent(
-            hugr.root(),
+            hugr.entrypoint(),
             ops::Input {
                 types: signature.input,
             },
         );
         hugr.add_node_with_parent(
-            hugr.root(),
+            hugr.entrypoint(),
             ops::Output {
                 types: signature.output,
             },

hugr-core/src/builder.rs

@@ -94,7 +94,7 @@ pub trait Container {
         name: impl Into<String>,
         signature: impl Into<PolyFuncType>,
     ) -> Result<FunctionBuilder<&mut Hugr>, BuildError> {
-        let signature = signature.into();
+        let signature: PolyFuncType = signature.into();
         let body = signature.body().clone();
         let f_node = self.add_child_node(ops::FuncDefn {
             name: name.into(),
@@ -161,7 +161,7 @@ pub trait Container {
 /// (with varying root node types)
 pub trait HugrBuilder: Container {
     /// Finish building the HUGR, perform any validation checks and return it.
-    fn finish_hugr(self) -> Result<Hugr, ValidationError>;
+    fn finish_hugr(self) -> Result<Hugr, ValidationError<Node>>;
 }
 
 /// Types implementing this trait build a container graph region by borrowing a HUGR
@@ -228,9 +228,9 @@ pub trait Dataflow: Container {
         hugr: Hugr,
         input_wires: impl IntoIterator<Item = Wire>,
     ) -> Result<BuildHandle<DataflowOpID>, BuildError> {
-        let optype = hugr.get_optype(hugr.root()).clone();
+        let optype = hugr.get_optype(hugr.entrypoint()).clone();
         let num_outputs = optype.value_output_count();
-        let node = self.add_hugr(hugr).new_root;
+        let node = self.add_hugr(hugr).inserted_entrypoint;
 
         wire_up_inputs(input_wires, node, self)
             .map_err(|error| BuildError::OperationWiring { op: optype, error })?;
@@ -250,8 +250,8 @@ pub trait Dataflow: Container {
         hugr: &impl HugrView,
         input_wires: impl IntoIterator<Item = Wire>,
     ) -> Result<BuildHandle<DataflowOpID>, BuildError> {
-        let node = self.add_hugr_view(hugr).new_root;
-        let optype = hugr.get_optype(hugr.root()).clone();
+        let node = self.add_hugr_view(hugr).inserted_entrypoint;
+        let optype = hugr.get_optype(hugr.entrypoint()).clone();
         let num_outputs = optype.value_output_count();
 
         wire_up_inputs(input_wires, node, self)
@@ -284,6 +284,7 @@ pub trait Dataflow: Container {
     /// # Panics
     ///
     /// Panics if the number of input Wires does not match the size of the array.
+    #[track_caller]
     fn input_wires_arr<const N: usize>(&self) -> [Wire; N] {
         collect_array(self.input_wires())
     }
@@ -676,7 +677,7 @@ fn add_node_with_wires<T: Dataflow + ?Sized>(
     nodetype: impl Into<OpType>,
     inputs: impl IntoIterator<Item = Wire>,
 ) -> Result<(Node, usize), BuildError> {
-    let op = nodetype.into();
+    let op: OpType = nodetype.into();
     let num_outputs = op.value_output_count();
     let op_node = data_builder.add_child_node(op.clone());