Interactions between resource definitions and instances

src/extensions/rotation.rs

@@ -66,7 +66,7 @@ impl Type {
     }
 
     pub fn custom_type(self) -> CustomType {
-        CustomType::new(self.name(), [])
+        CustomType::new(self.name(), [], resource_id())
     }
 
     pub fn type_def(self) -> TypeDef {
@@ -288,3 +288,31 @@ impl Neg for &AngleValue {
         self.unary_op(|x| -x, |x| -x)
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    use crate::resource::SignatureError;
+
+    use super::*;
+
+    #[test]
+    fn test_types() {
+        let resource = resource();
+
+        let angle = resource.types().get("angle").unwrap();
+
+        let custom = angle.instantiate_concrete([]).unwrap();
+
+        angle.check_custom(&custom).unwrap();
+
+        let false_custom = CustomType::new(custom.name().clone(), vec![], "wrong_resource");
+        assert_eq!(
+            angle.check_custom(&false_custom),
+            Err(SignatureError::ResourceMismatch(
+                Some("rotations".into()),
+                Some("wrong_resource".into()),
+            ))
+        );
+    }
+}

src/ops/custom.rs

@@ -186,11 +186,23 @@ impl OpaqueOp {
             signature,
         }
     }
+}
 
-    /// Return the argument values for this operation.
+impl OpaqueOp {
+    /// Unique name of the operation.
+    pub fn name(&self) -> &SmolStr {
+        &self.op_name
+    }
+
+    /// Type arguments.
     pub fn args(&self) -> &[TypeArg] {
         &self.args
     }
+
+    /// Parent resource.
+    pub fn resource(&self) -> &ResourceId {
+        &self.resource
+    }
 }
 
 /// Resolve serialized names of operations into concrete implementation (OpDefs) where possible

src/resource.rs

@@ -11,7 +11,9 @@ use std::sync::Arc;
 use smol_str::SmolStr;
 use thiserror::Error;
 
+use crate::ops::custom::OpaqueOp;
 use crate::types::type_param::{check_type_arg, TypeArgError};
+use crate::types::CustomType;
 use crate::types::TypeTag;
 use crate::types::{
     type_param::{TypeArg, TypeParam},
@@ -62,8 +64,14 @@ where
 /// TODO: decide on failure modes
 #[derive(Debug, Clone, Error, PartialEq, Eq)]
 pub enum SignatureError {
+    /// Name mismatch
+    #[error("Definition name ({0}) and instantiation name ({1}) do not match.")]
+    NameMismatch(SmolStr, SmolStr),
+    /// Resource mismatch
+    #[error("Definition resource ({0:?}) and instantiation resource ({1:?}) do not match.")]
+    ResourceMismatch(Option<ResourceId>, Option<ResourceId>),
     /// When the type arguments of the node did not match the params declared by the OpDef
-    #[error("Type arguments of node did not match params declared by OpDef: {0}")]
+    #[error("Type arguments of node did not match params declared by definition: {0}")]
     TypeArgMismatch(#[from] TypeArgError),
 }
 
@@ -139,6 +147,99 @@ impl Debug for LowerFunc {
     }
 }
 
+/// Concrete instantiations of types and operations defined in resources.
+trait CustomConcrete {
+    fn def_name(&self) -> &SmolStr;
+    fn type_args(&self) -> &[TypeArg];
+    fn parent_resource(&self) -> &ResourceId;
+}
+
+impl CustomConcrete for OpaqueOp {
+    fn def_name(&self) -> &SmolStr {
+        self.name()
+    }
+
+    fn type_args(&self) -> &[TypeArg] {
+        self.args()
+    }
+
+    fn parent_resource(&self) -> &ResourceId {
+        self.resource()
+    }
+}
+
+impl CustomConcrete for CustomType {
+    fn def_name(&self) -> &SmolStr {
+        self.name()
+    }
+
+    fn type_args(&self) -> &[TypeArg] {
+        self.args()
+    }
+
+    fn parent_resource(&self) -> &ResourceId {
+        self.resource()
+    }
+}
+
+/// Type-parametrised functionality shared between [`TypeDef`] and [`OpDef`].
+trait TypeParametrised: sealed::SealedDef {
+    /// The concrete object built by binding type arguments to parameters
+    type Concrete: CustomConcrete;
+    /// The resource-unique name.
+    fn name(&self) -> &SmolStr;
+    /// Type parameters.
+    fn params(&self) -> &[TypeParam];
+    /// The parent resource. if any.
+    fn resource(&self) -> Option<&ResourceId>;
+    /// Check provided type arguments are valid against parameters.
+    fn check_args_impl(&self, args: &[TypeArg]) -> Result<(), SignatureError> {
+        for (a, p) in args.iter().zip(self.params().iter()) {
+            check_type_arg(a, p).map_err(SignatureError::TypeArgMismatch)?;
+        }
+        Ok(())
+    }
+
+    /// Check custom instance is a valid instantiation of this definition.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the type of the instance does not
+    /// match the definition.
+    fn check_concrete_impl(&self, custom: &Self::Concrete) -> Result<(), SignatureError> {
+        if self.resource() != Some(custom.parent_resource()) {
+            return Err(SignatureError::ResourceMismatch(
+                self.resource().cloned(),
+                Some(custom.parent_resource().clone()),
+            ));
+        }
+        if self.name() != custom.def_name() {
+            return Err(SignatureError::NameMismatch(
+                self.name().clone(),
+                custom.def_name().clone(),
+            ));
+        }
+
+        self.check_args_impl(custom.type_args())?;
+
+        Ok(())
+    }
+}
+
+mod sealed {
+    use crate::{ops::custom::OpaqueOp, types::CustomType};
+
+    use super::{OpDef, TypeDef};
+
+    pub trait SealedDef {}
+    impl SealedDef for OpDef {}
+    impl SealedDef for TypeDef {}
+
+    pub trait SealedConcrete {}
+    impl SealedConcrete for OpaqueOp {}
+    impl SealedConcrete for CustomType {}
+}
+
 /// Serializable definition for dynamically loaded operations.
 ///
 /// TODO: Define a way to construct new OpDef's from a serialized definition.
@@ -165,6 +266,62 @@ pub struct OpDef {
     lower_funcs: Vec<LowerFunc>,
 }
 
+impl OpDef {
+    /// Check provided type arguments are valid against parameters.
+    pub fn check_args(&self, args: &[TypeArg]) -> Result<(), SignatureError> {
+        self.check_args_impl(args)
+    }
+
+    /// Check [`OpaqueOp`] is a valid instantiation of this definition.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the type of the instance does not
+    /// match the definition.
+    pub fn check_opaque(&self, opaque: &OpaqueOp) -> Result<(), SignatureError> {
+        self.check_concrete_impl(opaque)
+    }
+
+    /// Instantiate a concrete [`OpaqueOp`] by providing type arguments.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the provided arguments are not
+    /// valid instances of the type parameters.
+    pub fn instantiate_opaque(
+        &self,
+        args: impl Into<Vec<TypeArg>>,
+    ) -> Result<OpaqueOp, SignatureError> {
+        let args = args.into();
+        self.check_args(&args)?;
+
+        Ok(OpaqueOp::new(
+            self.resource().expect("Resource not set.").clone(),
+            self.name().clone(),
+            // TODO add description
+            "".to_string(),
+            args,
+            None,
+        ))
+    }
+}
+
+impl TypeParametrised for OpDef {
+    type Concrete = OpaqueOp;
+
+    fn params(&self) -> &[TypeParam] {
+        &self.params
+    }
+
+    fn name(&self) -> &SmolStr {
+        &self.name
+    }
+
+    fn resource(&self) -> Option<&ResourceId> {
+        self.resource.as_ref()
+    }
+}
+
 impl OpDef {
     /// Create an OpDef with a signature (inputs+outputs) read from the YAML
     pub fn new_with_yaml_types(
@@ -244,13 +401,6 @@ impl OpDef {
         Ok(sig)
     }
 
-    fn check_args(&self, args: &[TypeArg]) -> Result<(), SignatureError> {
-        for (a, p) in args.iter().zip(self.params.iter()) {
-            check_type_arg(a, p).map_err(SignatureError::TypeArgMismatch)?;
-        }
-        Ok(())
-    }
-
     /// Optional description of the ports in the signature.
     pub fn signature_desc(&self, args: &[TypeArg]) -> SignatureDescription {
         match &self.signature_func {
@@ -323,6 +473,58 @@ pub struct TypeDef {
     pub tag: TypeDefTag,
 }
 
+impl TypeDef {
+    /// Check provided type arguments are valid against parameters.
+    pub fn check_args(&self, args: &[TypeArg]) -> Result<(), SignatureError> {
+        self.check_args_impl(args)
+    }
+
+    /// Check [`CustomType`] is a valid instantiation of this definition.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the type of the instance does not
+    /// match the definition.
+    pub fn check_custom(&self, custom: &CustomType) -> Result<(), SignatureError> {
+        self.check_concrete_impl(custom)
+    }
+
+    /// Instantiate a concrete [`CustomType`] by providing type arguments.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the provided arguments are not
+    /// valid instances of the type parameters.
+    pub fn instantiate_concrete(
+        &self,
+        args: impl Into<Vec<TypeArg>>,
+    ) -> Result<CustomType, SignatureError> {
+        let args = args.into();
+        self.check_args_impl(&args)?;
+        Ok(CustomType::new(
+            self.name().clone(),
+            args,
+            self.resource().expect("Resource not set.").clone(),
+        ))
+    }
+}
+
+impl TypeParametrised for TypeDef {
+    type Concrete = CustomType;
+
+    fn params(&self) -> &[TypeParam] {
+        &self.params
+    }
+
+    fn name(&self) -> &SmolStr {
+        &self.name
+    }
+
+    fn resource(&self) -> Option<&ResourceId> {
+        self.resource.as_ref()
+    }
+}
+
 impl TypeDef {
     /// The [`TypeTag`] of the definition.
     pub fn tag(&self, args: &[TypeArg]) -> TypeTag {
@@ -387,6 +589,11 @@ impl Resource {
         &self.operations
     }
 
+    /// Allows read-only access to the types in this Resource
+    pub fn types(&self) -> &HashMap<SmolStr, TypeDef> {
+        &self.types
+    }
+
     /// Returns the name of the resource.
     pub fn name(&self) -> &str {
         &self.name