fix: Add some validation for const nodes

hugr-core/resources

@@ -0,0 +1 @@
+../resources/

hugr-core/src/hugr.rs

@@ -221,6 +221,10 @@ pub enum HugrError {
 
 #[cfg(test)]
 mod test {
+    use std::{fs::File, io::BufReader};
+
+    use crate::{extension::PRELUDE_REGISTRY, test_file};
+
     use super::{Hugr, HugrView};
 
     #[test]
@@ -240,4 +244,50 @@ mod test {
         let hugr = simple_dfg_hugr();
         assert_matches!(hugr.get_io(hugr.root()), Some(_));
     }
+
+    #[test]
+    fn hugr_validation_0() {
+        // https://github.com/CQCL/hugr/issues/1091 bad case
+        let mut hugr: Hugr = serde_json::from_reader(BufReader::new(
+            File::open(test_file!("hugr-0.json")).unwrap(),
+        ))
+        .unwrap();
+        assert!(
+            hugr.update_validate(&PRELUDE_REGISTRY).is_err(),
+            "HUGR should not validate."
+        );
+    }
+
+    #[test]
+    fn hugr_validation_1() {
+        // https://github.com/CQCL/hugr/issues/1091 good case
+        let mut hugr: Hugr = serde_json::from_reader(BufReader::new(
+            File::open(test_file!("hugr-1.json")).unwrap(),
+        ))
+        .unwrap();
+        assert!(hugr.update_validate(&PRELUDE_REGISTRY).is_ok());
+    }
+
+    #[test]
+    fn hugr_validation_2() {
+        // https://github.com/CQCL/hugr/issues/1185 bad case
+        let mut hugr: Hugr = serde_json::from_reader(BufReader::new(
+            File::open(test_file!("hugr-2.json")).unwrap(),
+        ))
+        .unwrap();
+        assert!(
+            hugr.update_validate(&PRELUDE_REGISTRY).is_err(),
+            "HUGR should not validate."
+        );
+    }
+
+    #[test]
+    fn hugr_validation_3() {
+        // https://github.com/CQCL/hugr/issues/1185 good case
+        let mut hugr: Hugr = serde_json::from_reader(BufReader::new(
+            File::open(test_file!("hugr-3.json")).unwrap(),
+        ))
+        .unwrap();
+        assert!(hugr.update_validate(&PRELUDE_REGISTRY).is_ok());
+    }
 }

hugr-core/src/hugr/validate.rs

@@ -1,5 +1,6 @@
 //! HUGR invariant checks.
 
+use std::any::TypeId;
 use std::collections::HashMap;
 use std::iter;
 
@@ -13,9 +14,10 @@ use crate::extension::{ExtensionRegistry, ExtensionSet, SignatureError};
 
 use crate::ops::custom::{resolve_opaque_op, CustomOp, CustomOpError};
 use crate::ops::validate::{ChildrenEdgeData, ChildrenValidationError, EdgeValidationError};
-use crate::ops::{FuncDefn, OpParent, OpTag, OpTrait, OpType, ValidateOp};
+use crate::ops::{FuncDefn, OpParent, OpTag, OpTrait, OpType, ValidateOp, Value};
+use crate::std_extensions::arithmetic::float_types::ConstF64;
 use crate::types::type_param::TypeParam;
-use crate::types::{EdgeKind, FunctionType};
+use crate::types::{EdgeKind, FunctionType, SumType, TypeEnum};
 use crate::{Direction, Hugr, Node, Port};
 
 use super::views::{HierarchyView, HugrView, SiblingGraph};
@@ -210,6 +212,35 @@ impl<'a, 'b> ValidationContext<'a, 'b> {
         // Thirdly that the node has correct children
         self.validate_children(node, op_type)?;
 
+        // OpType-specific checks.
+        // TODO Maybe we should delegate these checks to the OpTypes themselves.
+        if let OpType::Const(c) = op_type {
+            match c.get_type().as_type_enum() {
+                TypeEnum::Sum(SumType::Unit { size: _ }) => {
+                    if let Value::Sum {
+                        tag: _,
+                        values,
+                        sum_type: _,
+                    } = c.value()
+                    {
+                        if !values.is_empty() {
+                            return Err(ValidationError::UnitSumWithValues {});
+                        }
+                    }
+                }
+                TypeEnum::Extension(custom_type) => {
+                    if custom_type.name() == "float64" {
+                        if let Value::Extension { e } = c.value() {
+                            if e.value().type_id() != TypeId::of::<ConstF64>() {
+                                return Err(ValidationError::WrongExtensionValueType {});
+                            }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
         Ok(())
     }
 
@@ -752,6 +783,12 @@ pub enum ValidationError {
     /// [Opaque]: crate::ops::CustomOp::Opaque
     #[error(transparent)]
     CustomOpError(#[from] CustomOpError),
+    /// Error in a [SumType::Unit]
+    #[error("A unit sum contained a non-empty list of values")]
+    UnitSumWithValues {},
+    /// Wrong type for an extension value
+    #[error("An extension value was of the wrong type")]
+    WrongExtensionValueType {},
 }
 
 /// Errors related to the inter-graph edge validations.

hugr-core/src/macros.rs

@@ -111,3 +111,13 @@ macro_rules! const_extension_ids {
 }
 
 pub use const_extension_ids;
+
+#[cfg(test)]
+/// Get the full path to a test file given its path relative to the
+/// `resources/test` directory in this crate.
+#[macro_export]
+macro_rules! test_file {
+    ($fname:expr) => {
+        concat!(env!("CARGO_MANIFEST_DIR"), "/resources/test/", $fname)
+    };
+}

resources/test/hugr-0.json

@@ -0,0 +1,36 @@
+{
+    "version": "v1",
+    "nodes":
+    [
+        {
+            "parent": 0,
+            "input_extensions": null,
+            "op": "Const",
+            "v":
+            {
+                "v": "Extension",
+                "extensions":
+                [
+                    "arithmetic.float.types"
+                ],
+                "typ":
+                {
+                    "t": "Opaque",
+                    "extension": "arithmetic.float.types",
+                    "id": "float64",
+                    "args":
+                    [],
+                    "bound": "C"
+                },
+                "value":
+                {
+                    "c": "ConstF64",
+                    "v": 42
+                }
+            }
+        }
+    ],
+    "edges":
+    [],
+    "encoder": null
+}

resources/test/hugr-1.json

@@ -0,0 +1,39 @@
+{
+    "version": "v1",
+    "nodes":
+    [
+        {
+            "parent": 0,
+            "input_extensions": null,
+            "op": "Const",
+            "v":
+            {
+                "v": "Extension",
+                "extensions":
+                [
+                    "arithmetic.float.types"
+                ],
+                "typ":
+                {
+                    "t": "Opaque",
+                    "extension": "arithmetic.float.types",
+                    "id": "float64",
+                    "args":
+                    [],
+                    "bound": "C"
+                },
+                "value":
+                {
+                    "c": "ConstF64",
+                    "v":
+                    {
+                        "value": 42.0
+                    }
+                }
+            }
+        }
+    ],
+    "edges":
+    [],
+    "encoder": null
+}

resources/test/hugr-2.json

@@ -0,0 +1,33 @@
+{
+    "version": "v1",
+    "nodes":
+    [
+        {
+            "parent": 0,
+            "input_extensions": null,
+            "op": "Const",
+            "v":
+            {
+                "v": "Sum",
+                "tag": 1,
+                "typ":
+                {
+                    "t": "Sum",
+                    "s": "Unit",
+                    "size": 2
+                },
+                "vs":
+                [
+                    {
+                        "v": "Tuple",
+                        "vs":
+                        []
+                    }
+                ]
+            }
+        }
+    ],
+    "edges":
+    [],
+    "encoder": null
+}

resources/test/hugr-3.json

@@ -0,0 +1,27 @@
+{
+    "version": "v1",
+    "nodes":
+    [
+        {
+            "parent": 0,
+            "input_extensions": null,
+            "op": "Const",
+            "v":
+            {
+                "v": "Sum",
+                "tag": 1,
+                "typ":
+                {
+                    "t": "Sum",
+                    "s": "Unit",
+                    "size": 2
+                },
+                "vs":
+                []
+            }
+        }
+    ],
+    "edges":
+    [],
+    "encoder": null
+}