From d05682ae1e109f99eea67f543fed1481e4bc9176 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Thu, 17 Oct 2024 14:55:07 +0100 Subject: [PATCH 1/7] feat: Ensure packages always have modules at the root --- hugr-cli/src/lib.rs | 61 +++++++++++-- hugr-cli/src/mermaid.rs | 2 +- hugr-cli/src/validate.rs | 6 +- hugr-cli/tests/validate.rs | 40 +++++--- hugr-core/src/package.rs | 181 +++++++++++++++++++++++++++++++++++-- 5 files changed, 259 insertions(+), 31 deletions(-) diff --git a/hugr-cli/src/lib.rs b/hugr-cli/src/lib.rs index a75752af9..a93cd4b6b 100644 --- a/hugr-cli/src/lib.rs +++ b/hugr-cli/src/lib.rs @@ -4,7 +4,9 @@ use clap::Parser; use clap_verbosity_flag::{InfoLevel, Verbosity}; use clio::Input; use derive_more::{Display, Error, From}; -use hugr::package::{PackageEncodingError, PackageValidationError}; +use hugr::extension::ExtensionRegistry; +use hugr::package::PackageValidationError; +use hugr::Hugr; use std::{ffi::OsString, path::PathBuf}; pub mod extensions; @@ -40,11 +42,8 @@ pub enum CliError { #[display("Error reading from path: {_0}")] InputFile(std::io::Error), /// Error parsing input. - #[display("Error parsing input: {_0}")] - Parse(serde_json::Error), - /// Error loading a package. #[display("Error parsing package: {_0}")] - Package(PackageEncodingError), + Parse(serde_json::Error), #[display("Error validating HUGR: {_0}")] /// Errors produced by the `validate` subcommand. Validate(PackageValidationError), @@ -74,10 +73,56 @@ pub struct HugrArgs { pub extensions: Vec, } +/// A simple enum containing either a package or a single hugr. +/// +/// This is required since `Package`s can only contain module-rooted hugrs. +#[derive(Debug, Clone, PartialEq)] +pub enum PackageOrHugr { + /// A package with module-rooted HUGRs and some required extensions. + Package(Package), + /// An arbitrary HUGR. + Hugr(Hugr), +} + +impl PackageOrHugr { + /// Returns the slice of hugrs in the package. + pub fn hugrs(&self) -> &[Hugr] { + match self { + PackageOrHugr::Package(pkg) => &pkg.modules, + PackageOrHugr::Hugr(hugr) => std::slice::from_ref(hugr), + } + } + + /// Returns the list of hugrs in the package. + pub fn into_hugrs(self) -> Vec { + match self { + PackageOrHugr::Package(pkg) => pkg.modules, + PackageOrHugr::Hugr(hugr) => vec![hugr], + } + } + + /// Validates the package or hugr. + /// + /// Updates the extension registry with any new extensions defined in the package. + pub fn update_validate( + &mut self, + reg: &mut ExtensionRegistry, + ) -> Result<(), PackageValidationError> { + match self { + PackageOrHugr::Package(pkg) => pkg.validate(reg), + PackageOrHugr::Hugr(hugr) => hugr.update_validate(reg).map_err(Into::into), + } + } +} + impl HugrArgs { /// Read either a package or a single hugr from the input. - pub fn get_package(&mut self) -> Result { - let pkg = Package::from_json_reader(&mut self.input)?; - Ok(pkg) + pub fn get_package_or_hugr(&mut self) -> Result { + let val: serde_json::Value = serde_json::from_reader(&mut self.input)?; + if let Ok(hugr) = serde_json::from_value::(val.clone()) { + return Ok(PackageOrHugr::Hugr(hugr)); + } + let pkg = serde_json::from_value::(val.clone())?; + Ok(PackageOrHugr::Package(pkg)) } } diff --git a/hugr-cli/src/mermaid.rs b/hugr-cli/src/mermaid.rs index 0e67a1598..ee3bbabd1 100644 --- a/hugr-cli/src/mermaid.rs +++ b/hugr-cli/src/mermaid.rs @@ -32,7 +32,7 @@ impl MermaidArgs { let hugrs = if self.validate { self.hugr_args.validate()?.0 } else { - self.hugr_args.get_package()?.modules + self.hugr_args.get_package_or_hugr()?.into_hugrs() }; for hugr in hugrs { diff --git a/hugr-cli/src/validate.rs b/hugr-cli/src/validate.rs index b7fac3b5c..eaf3bfccd 100644 --- a/hugr-cli/src/validate.rs +++ b/hugr-cli/src/validate.rs @@ -44,7 +44,7 @@ impl HugrArgs { /// Returns the validated modules and the extension registry the modules /// were validated against. pub fn validate(&mut self) -> Result<(Vec, ExtensionRegistry), CliError> { - let mut package = self.get_package()?; + let mut package = self.get_package_or_hugr()?; let mut reg: ExtensionRegistry = if self.no_std { hugr::extension::PRELUDE_REGISTRY.to_owned() @@ -60,8 +60,8 @@ impl HugrArgs { .map_err(PackageValidationError::Extension)?; } - package.validate(&mut reg)?; - Ok((package.modules, reg)) + package.update_validate(&mut reg)?; + Ok((package.into_hugrs(), reg)) } /// Test whether a `level` message should be output. diff --git a/hugr-cli/tests/validate.rs b/hugr-cli/tests/validate.rs index fb80e8809..32b81010e 100644 --- a/hugr-cli/tests/validate.rs +++ b/hugr-cli/tests/validate.rs @@ -6,7 +6,7 @@ use assert_cmd::Command; use assert_fs::{fixture::FileWriteStr, NamedTempFile}; -use hugr::builder::DFGBuilder; +use hugr::builder::{DFGBuilder, DataflowSubContainer, ModuleBuilder}; use hugr::types::Type; use hugr::{ builder::{Container, Dataflow}, @@ -31,6 +31,29 @@ fn val_cmd(mut cmd: Command) -> Command { cmd } +// path to the fully serialized float extension +const FLOAT_EXT_FILE: &str = concat!( + env!("CARGO_MANIFEST_DIR"), + "/../specification/std_extensions/arithmetic/float/types.json" +); + +/// A test package, containing a module-rooted HUGR. +#[fixture] +fn test_package(#[default(BOOL_T)] id_type: Type) -> Package { + let mut module = ModuleBuilder::new(); + let df = module + .define_function("test", Signature::new_endo(id_type)) + .unwrap(); + let [i] = df.input_wires_arr(); + df.finish_with_outputs([i]).unwrap(); + let hugr = module.hugr().clone(); // unvalidated + + let rdr = std::fs::File::open(FLOAT_EXT_FILE).unwrap(); + let float_ext: hugr::Extension = serde_json::from_reader(rdr).unwrap(); + Package::new(vec![hugr], vec![float_ext]).unwrap() +} + +/// A DFG-rooted HUGR. #[fixture] fn test_hugr(#[default(BOOL_T)] id_type: Type) -> Hugr { let mut df = DFGBuilder::new(Signature::new_endo(id_type)).unwrap(); @@ -169,12 +192,6 @@ fn test_no_std_fail(float_hugr_string: String, mut val_cmd: Command) { .stderr(contains(" Extension 'arithmetic.float.types' not found")); } -// path to the fully serialized float extension -const FLOAT_EXT_FILE: &str = concat!( - env!("CARGO_MANIFEST_DIR"), - "/../specification/std_extensions/arithmetic/float/types.json" -); - #[rstest] fn test_float_extension(float_hugr_string: String, mut val_cmd: Command) { val_cmd.write_stdin(float_hugr_string); @@ -186,15 +203,12 @@ fn test_float_extension(float_hugr_string: String, mut val_cmd: Command) { val_cmd.assert().success().stderr(contains(VALID_PRINT)); } #[fixture] -fn package_string(#[with(FLOAT64_TYPE)] test_hugr: Hugr) -> String { - let rdr = std::fs::File::open(FLOAT_EXT_FILE).unwrap(); - let float_ext: hugr::Extension = serde_json::from_reader(rdr).unwrap(); - let package = Package::new(vec![test_hugr], vec![float_ext]); - serde_json::to_string(&package).unwrap() +fn package_string(#[with(FLOAT64_TYPE)] test_package: Package) -> String { + serde_json::to_string(&test_package).unwrap() } #[rstest] -fn test_package(package_string: String, mut val_cmd: Command) { +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("-"); diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index bcdf4282f..b32bf2232 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -1,11 +1,13 @@ //! Bundles of hugr modules along with the extension required to load them. use derive_more::{Display, Error, From}; +use std::collections::HashMap; use std::path::Path; use std::{fs, io}; use crate::extension::{ExtensionRegistry, ExtensionRegistryError}; -use crate::hugr::ValidationError; +use crate::hugr::{HugrView, ValidationError}; +use crate::ops::{NamedOp, OpType}; use crate::{Extension, Hugr}; #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)] @@ -20,14 +22,71 @@ pub struct Package { impl Package { /// Create a new package from a list of hugrs and extensions. + /// + /// All the HUGRs must have a `Module` operation at the root. + /// + /// # Errors + /// + /// Returns an error if any of the HUGRs does not have a `Module` root. pub fn new( modules: impl IntoIterator, extensions: impl IntoIterator, - ) -> Self { - Self { - modules: modules.into_iter().collect(), - extensions: extensions.into_iter().collect(), + ) -> Result { + let modules: Vec = modules.into_iter().collect(); + for (idx, module) in modules.iter().enumerate() { + let root_op = module.get_optype(module.root()); + if !root_op.is_module() { + return Err(PackageError::NonModuleHugr { + module_index: idx, + root_op: root_op.clone(), + }); + } } + Ok(Self { + modules, + extensions: extensions.into_iter().collect(), + }) + } + + /// Create a new package from a list of hugrs and extensions. + /// + /// HUGRs that do not have a `Module` root will be wrapped in a new `Module` root, + /// depending on the root optype. + /// + /// - Currently all non-module roots will raise [PackageError::CannotWrapHugr]. + /// + /// # Errors + /// + /// Returns an error if any of the HUGRs cannot be wrapped in a module. + pub fn from_hugrs( + modules: impl IntoIterator, + extensions: impl IntoIterator, + ) -> Result { + let modules: Vec = modules + .into_iter() + .map(to_module_hugr) + .collect::>()?; + Ok(Self { + modules, + extensions: extensions.into_iter().collect(), + }) + } + + /// Create a new package containing a single HUGR, and no extension definitions. + /// + /// If the Hugr is not a module, a new [OpType::Module] root will be added. + /// This behaviours depends on the root optype. + /// + /// - Currently all non-module roots will raise [PackageError::CannotWrapHugr]. + /// + /// # Errors + /// + /// Returns an error if the hugr cannot be wrapped in a module. + pub fn from_hugr(hugr: Hugr) -> Result { + let mut package = Self::default(); + let module = to_module_hugr(hugr)?; + package.modules.push(module); + Ok(package) } /// Validate the package against an extension registry. @@ -54,7 +113,7 @@ impl Package { }; if let Ok(hugr) = serde_json::from_value::(val) { - return Ok(Package::new([hugr], [])); + return Ok(Package::from_hugr(hugr)?); } // Return the original error from parsing the package. @@ -99,6 +158,60 @@ impl Package { } } +impl PartialEq for Package { + fn eq(&self, other: &Self) -> bool { + if self.modules != other.modules || self.extensions.len() != other.extensions.len() { + return false; + } + // Extensions may be in different orders, so we compare them as sets. + let exts = self + .extensions + .iter() + .map(|e| (&e.name, e)) + .collect::>(); + other + .extensions + .iter() + .all(|e| exts.get(&e.name).map_or(false, |&e2| e == e2)) + } +} + +/// Alter an arbitrary hugr to contain an [OpType::Module] root. +/// +/// The behaviour depends on the root optype. See [Package::from_hugr] for details. +/// +/// # Returns +/// +fn to_module_hugr(hugr: Hugr) -> Result { + let root_op = hugr.get_optype(hugr.root()); + match root_op { + OpType::Module(_) => Ok(hugr), + _ => Err(PackageError::CannotWrapHugr { + root_op: root_op.clone(), + }), + } +} + +/// Error raised while loading a package. +#[derive(Debug, Display, Error)] +#[non_exhaustive] +pub enum PackageError { + /// A hugr in the package does not have an [OpType::Module] root. + #[display("Module {module_index} in the package does not have an OpType::Module root, but {}", root_op.name())] + NonModuleHugr { + /// The module index. + module_index: usize, + /// The invalid root operation. + root_op: OpType, + }, + /// Tried to initialize a package with a hugr that cannot be wrapped in a module. + #[display("A hugr with optype {} cannot be wrapped in a module.", root_op.name())] + CannotWrapHugr { + /// The invalid root operation. + root_op: OpType, + }, +} + /// Error raised while loading a package. #[derive(Debug, Display, Error, From)] #[non_exhaustive] @@ -107,6 +220,8 @@ pub enum PackageEncodingError { JsonEncoding(serde_json::Error), /// Error raised while reading from a file. IOError(io::Error), + /// Improper package definition. + Package(PackageError), } /// Error raised while validating a package. @@ -118,3 +233,57 @@ pub enum PackageValidationError { /// Error raised while validating the package hugrs. Validation(ValidationError), } + +#[cfg(test)] +mod test { + use crate::builder::test::{ + simple_cfg_hugr, simple_dfg_hugr, simple_funcdef_hugr, simple_module_hugr, + }; + use crate::extension::ExtensionId; + + use super::*; + use rstest::{fixture, rstest}; + use semver::Version; + + #[fixture] + fn simple_package() -> Package { + let hugr0 = simple_module_hugr(); + let hugr1 = simple_module_hugr(); + + let ext_1_id = ExtensionId::new("ext1").unwrap(); + let ext_2_id = ExtensionId::new("ext2").unwrap(); + let ext1 = Extension::new(ext_1_id.clone(), Version::new(2, 4, 8)); + let ext2 = Extension::new(ext_2_id, Version::new(1, 0, 0)); + + Package { + modules: vec![hugr0, hugr1], + extensions: vec![ext1, ext2], + } + } + + #[rstest] + #[case::empty(Package::default())] + #[case::simple(simple_package())] + fn package_roundtrip(#[case] package: Package) { + let json = package.to_json().unwrap(); + let new_package = Package::from_json(&json).unwrap(); + assert_eq!(package, new_package); + } + + #[rstest] + #[case::module(simple_module_hugr(), false)] + #[case::dfg(simple_funcdef_hugr(), true)] + #[case::dfg(simple_dfg_hugr(), true)] + #[case::cfg(simple_cfg_hugr(), true)] + fn hugr_to_package(#[case] hugr: Hugr, #[case] errors: bool) { + match (Package::from_hugr(hugr), errors) { + (Ok(package), false) => { + assert_eq!(package.modules.len(), 1); + let root_op = package.modules[0].get_optype(package.modules[0].root()); + assert!(root_op.is_module()); + } + (Err(_), true) => {} + (p, _) => panic!("Unexpected result {:?}", p), + } + } +} From 40a0b2a239e04db8c1161995f2b74dfee55b19e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Thu, 17 Oct 2024 16:06:49 +0100 Subject: [PATCH 2/7] Wrap non-module hugrs if possible --- hugr-core/src/package.rs | 60 +++++++++++++++++++++++++++++++--------- 1 file changed, 47 insertions(+), 13 deletions(-) diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index b32bf2232..f5d1f1c75 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -3,11 +3,13 @@ use derive_more::{Display, Error, From}; use std::collections::HashMap; use std::path::Path; -use std::{fs, io}; +use std::{fs, io, mem}; +use crate::builder::{Container, Dataflow, DataflowSubContainer, ModuleBuilder}; use crate::extension::{ExtensionRegistry, ExtensionRegistryError}; +use crate::hugr::internal::HugrMutInternals; use crate::hugr::{HugrView, ValidationError}; -use crate::ops::{NamedOp, OpType}; +use crate::ops::{Module, NamedOp, OpTag, OpTrait, OpType}; use crate::{Extension, Hugr}; #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)] @@ -180,16 +182,40 @@ impl PartialEq for Package { /// /// The behaviour depends on the root optype. See [Package::from_hugr] for details. /// -/// # Returns +/// # Errors /// -fn to_module_hugr(hugr: Hugr) -> Result { - let root_op = hugr.get_optype(hugr.root()); - match root_op { - OpType::Module(_) => Ok(hugr), - _ => Err(PackageError::CannotWrapHugr { - root_op: root_op.clone(), - }), +/// Returns [PackageError::] +fn to_module_hugr(mut hugr: Hugr) -> Result { + let root = hugr.root(); + let root_op = hugr.get_optype(root); + let tag = root_op.tag(); + + // Modules can be returned as is. + if root_op.is_module() { + return Ok(hugr); + } + // If possible, wrap the hugr directly in a module. + if OpTag::ModuleOp.is_superset(tag) { + let new_root = hugr.add_node(Module::new().into()); + hugr.set_root(new_root); + hugr.set_parent(root, new_root); + return Ok(hugr); + } + // Wrap it in a function definition named "main" inside the module otherwise. + if OpTag::DataflowChild.is_superset(tag) && !root_op.is_input() && !root_op.is_output() { + let signature = root_op + .dataflow_signature() + .unwrap_or_else(|| panic!("Dataflow child {} without signature", root_op.name())); + let mut new_hugr = ModuleBuilder::new(); + let mut func = new_hugr.define_function("main", signature).unwrap(); + let dataflow_node = func.add_hugr_with_wires(hugr, func.input_wires()).unwrap(); + func.finish_with_outputs(dataflow_node.outputs()).unwrap(); + return Ok(mem::take(new_hugr.hugr_mut())); } + // Reject all other hugrs. + Err(PackageError::CannotWrapHugr { + root_op: root_op.clone(), + }) } /// Error raised while loading a package. @@ -240,6 +266,8 @@ mod test { simple_cfg_hugr, simple_dfg_hugr, simple_funcdef_hugr, simple_module_hugr, }; use crate::extension::ExtensionId; + use crate::ops::dataflow::IOTrait; + use crate::ops::Input; use super::*; use rstest::{fixture, rstest}; @@ -261,6 +289,11 @@ mod test { } } + #[fixture] + fn simple_input_node() -> Hugr { + Hugr::new(Input::new(vec![])) + } + #[rstest] #[case::empty(Package::default())] #[case::simple(simple_package())] @@ -272,9 +305,10 @@ mod test { #[rstest] #[case::module(simple_module_hugr(), false)] - #[case::dfg(simple_funcdef_hugr(), true)] - #[case::dfg(simple_dfg_hugr(), true)] - #[case::cfg(simple_cfg_hugr(), true)] + #[case::funcdef(simple_funcdef_hugr(), false)] + #[case::dfg(simple_dfg_hugr(), false)] + #[case::cfg(simple_cfg_hugr(), false)] + #[case::unsupported_input(simple_input_node(), true)] fn hugr_to_package(#[case] hugr: Hugr, #[case] errors: bool) { match (Package::from_hugr(hugr), errors) { (Ok(package), false) => { From 98990b962e759f63df927ab5fa574584715df6a5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Thu, 17 Oct 2024 17:41:02 +0100 Subject: [PATCH 3/7] more tests --- hugr-core/src/package.rs | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index f5d1f1c75..210007175 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -219,7 +219,7 @@ fn to_module_hugr(mut hugr: Hugr) -> Result { } /// Error raised while loading a package. -#[derive(Debug, Display, Error)] +#[derive(Debug, Display, Error, PartialEq)] #[non_exhaustive] pub enum PackageError { /// A hugr in the package does not have an [OpType::Module] root. @@ -262,10 +262,12 @@ pub enum PackageValidationError { #[cfg(test)] mod test { + use cool_asserts::assert_matches; + use crate::builder::test::{ simple_cfg_hugr, simple_dfg_hugr, simple_funcdef_hugr, simple_module_hugr, }; - use crate::extension::ExtensionId; + use crate::extension::{ExtensionId, EMPTY_REG}; use crate::ops::dataflow::IOTrait; use crate::ops::Input; @@ -310,7 +312,7 @@ mod test { #[case::cfg(simple_cfg_hugr(), false)] #[case::unsupported_input(simple_input_node(), true)] fn hugr_to_package(#[case] hugr: Hugr, #[case] errors: bool) { - match (Package::from_hugr(hugr), errors) { + match (&Package::from_hugr(hugr.clone()), errors) { (Ok(package), false) => { assert_eq!(package.modules.len(), 1); let root_op = package.modules[0].get_optype(package.modules[0].root()); @@ -320,4 +322,24 @@ mod test { (p, _) => panic!("Unexpected result {:?}", p), } } + + #[rstest] + fn package_properties() { + let module = simple_module_hugr(); + let dfg = simple_dfg_hugr(); + + assert_matches!( + Package::new([module.clone(), dfg.clone()], []), + Err(PackageError::NonModuleHugr { + module_index: 1, + root_op: OpType::DFG(_), + }) + ); + + let mut pkg = Package::from_hugrs([module, dfg], []).unwrap(); + let mut reg = EMPTY_REG.clone(); + pkg.validate(&mut reg).unwrap(); + + assert_eq!(pkg.modules.len(), 2); + } } From 440f9a29b026e05f62554c02d428d1f00590fb6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Mon, 21 Oct 2024 11:43:04 +0100 Subject: [PATCH 4/7] AsRef<[Hugr]> --- hugr-cli/src/lib.rs | 17 +++++++++-------- hugr-core/src/package.rs | 6 ++++++ 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/hugr-cli/src/lib.rs b/hugr-cli/src/lib.rs index a93cd4b6b..af0dd6472 100644 --- a/hugr-cli/src/lib.rs +++ b/hugr-cli/src/lib.rs @@ -85,14 +85,6 @@ pub enum PackageOrHugr { } impl PackageOrHugr { - /// Returns the slice of hugrs in the package. - pub fn hugrs(&self) -> &[Hugr] { - match self { - PackageOrHugr::Package(pkg) => &pkg.modules, - PackageOrHugr::Hugr(hugr) => std::slice::from_ref(hugr), - } - } - /// Returns the list of hugrs in the package. pub fn into_hugrs(self) -> Vec { match self { @@ -115,6 +107,15 @@ impl PackageOrHugr { } } +impl AsRef<[Hugr]> for PackageOrHugr { + fn as_ref(&self) -> &[Hugr] { + match self { + PackageOrHugr::Package(pkg) => &pkg.modules, + PackageOrHugr::Hugr(hugr) => std::slice::from_ref(hugr), + } + } +} + impl HugrArgs { /// Read either a package or a single hugr from the input. pub fn get_package_or_hugr(&mut self) -> Result { diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index 210007175..bdf65b2ed 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -178,6 +178,12 @@ impl PartialEq for Package { } } +impl AsRef<[Hugr]> for Package { + fn as_ref(&self) -> &[Hugr] { + &self.modules + } +} + /// Alter an arbitrary hugr to contain an [OpType::Module] root. /// /// The behaviour depends on the root optype. See [Package::from_hugr] for details. From 9dd74697375127adc086482978f6cce35ab55399 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Mon, 21 Oct 2024 11:43:41 +0100 Subject: [PATCH 5/7] remove unneeded clone --- hugr-core/src/package.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index bdf65b2ed..3eac382d8 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -318,7 +318,7 @@ mod test { #[case::cfg(simple_cfg_hugr(), false)] #[case::unsupported_input(simple_input_node(), true)] fn hugr_to_package(#[case] hugr: Hugr, #[case] errors: bool) { - match (&Package::from_hugr(hugr.clone()), errors) { + match (&Package::from_hugr(hugr), errors) { (Ok(package), false) => { assert_eq!(package.modules.len(), 1); let root_op = package.modules[0].get_optype(package.modules[0].root()); From 4935748600a8c01275b8927403447887ce8e4968 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Mon, 21 Oct 2024 11:45:41 +0100 Subject: [PATCH 6/7] s/update/update_validate --- hugr-core/src/package.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index 3eac382d8..eeb0b6692 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -90,11 +90,13 @@ impl Package { package.modules.push(module); Ok(package) } - /// Validate the package against an extension registry. /// /// `reg` is updated with any new extensions. - pub fn validate(&mut self, reg: &mut ExtensionRegistry) -> Result<(), PackageValidationError> { + pub fn update_validate( + &mut self, + reg: &mut ExtensionRegistry, + ) -> Result<(), PackageValidationError> { for ext in &self.extensions { reg.register_updated_ref(ext)?; } From 61aae85cc129d2170526a4414946b27909f58800 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Agust=C3=ADn=20Borgna?= Date: Mon, 21 Oct 2024 11:48:55 +0100 Subject: [PATCH 7/7] Missing some renames --- hugr-cli/src/lib.rs | 2 +- hugr-core/src/package.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/hugr-cli/src/lib.rs b/hugr-cli/src/lib.rs index af0dd6472..41db94653 100644 --- a/hugr-cli/src/lib.rs +++ b/hugr-cli/src/lib.rs @@ -101,7 +101,7 @@ impl PackageOrHugr { reg: &mut ExtensionRegistry, ) -> Result<(), PackageValidationError> { match self { - PackageOrHugr::Package(pkg) => pkg.validate(reg), + PackageOrHugr::Package(pkg) => pkg.update_validate(reg), PackageOrHugr::Hugr(hugr) => hugr.update_validate(reg).map_err(Into::into), } } diff --git a/hugr-core/src/package.rs b/hugr-core/src/package.rs index eeb0b6692..7dd10010b 100644 --- a/hugr-core/src/package.rs +++ b/hugr-core/src/package.rs @@ -346,7 +346,7 @@ mod test { let mut pkg = Package::from_hugrs([module, dfg], []).unwrap(); let mut reg = EMPTY_REG.clone(); - pkg.validate(&mut reg).unwrap(); + pkg.update_validate(&mut reg).unwrap(); assert_eq!(pkg.modules.len(), 2); }