refactor!: Replace SmolStr identifiers with wrapper types.

hugr/src/builder.rs

@@ -91,7 +91,7 @@ use thiserror::Error;
 use crate::extension::SignatureError;
 use crate::hugr::ValidationError;
 use crate::ops::handle::{BasicBlockID, CfgID, ConditionalID, DfgID, FuncID, TailLoopID};
-use crate::ops::{OpName, OpType};
+use crate::ops::{NamedOp, OpType};
 use crate::types::ConstTypeError;
 use crate::types::Type;
 use crate::{Node, Port, Wire};

hugr/src/builder/circuit.rs

@@ -3,7 +3,7 @@ use std::mem;
 
 use thiserror::Error;
 
-use crate::ops::{OpName, OpType};
+use crate::ops::{NamedOp, OpType};
 use crate::utils::collect_array;
 
 use super::{BuildError, Dataflow};

hugr/src/extension.rs

@@ -9,16 +9,16 @@ use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt::{Debug, Display, Formatter};
 use std::sync::Arc;
 
-use smol_str::SmolStr;
 use thiserror::Error;
 
 use crate::hugr::IdentList;
-use crate::ops;
+use crate::ops::constant::{ValueName, ValueNameRef};
 use crate::ops::custom::{ExtensionOp, OpaqueOp};
+use crate::ops::{self, OpName, OpNameRef};
 use crate::types::type_param::{check_type_args, TypeArgError};
 use crate::types::type_param::{TypeArg, TypeParam};
-use crate::types::FunctionType;
 use crate::types::{check_typevar_decl, CustomType, Substitution, TypeBound, TypeName};
+use crate::types::{FunctionType, TypeNameRef};
 
 #[allow(dead_code)]
 mod infer;
@@ -177,18 +177,22 @@ pub enum SignatureError {
 
 /// Concrete instantiations of types and operations defined in extensions.
 trait CustomConcrete {
+    /// The identifier type for the concrete object.
+    type Identifier;
     /// A generic identifier to the element.
     ///
     /// This may either refer to a [`TypeName`] or an [`OpName`].
-    fn def_name(&self) -> &SmolStr;
+    fn def_name(&self) -> &Self::Identifier;
     /// The concrete type arguments for the instantiation.
     fn type_args(&self) -> &[TypeArg];
     /// Extension required by the instantiation.
     fn parent_extension(&self) -> &ExtensionId;
 }
 
 impl CustomConcrete for OpaqueOp {
-    fn def_name(&self) -> &SmolStr {
+    type Identifier = OpName;
+
+    fn def_name(&self) -> &OpName {
         self.name()
     }
 
@@ -202,7 +206,9 @@ impl CustomConcrete for OpaqueOp {
 }
 
 impl CustomConcrete for CustomType {
-    fn def_name(&self) -> &SmolStr {
+    type Identifier = TypeName;
+
+    fn def_name(&self) -> &TypeName {
         // Casts the `TypeName` to a generic string.
         self.name()
     }
@@ -221,7 +227,7 @@ trait TypeParametrised {
     /// The concrete object built by binding type arguments to parameters
     type Concrete: CustomConcrete;
     /// The extension-unique name.
-    fn name(&self) -> &SmolStr;
+    fn name(&self) -> &<Self::Concrete as CustomConcrete>::Identifier;
     /// Type parameters.
     fn params(&self) -> &[TypeParam];
     /// The parent extension.
@@ -237,7 +243,7 @@ trait TypeParametrised {
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct ExtensionValue {
     extension: ExtensionId,
-    name: SmolStr,
+    name: ValueName,
     typed_value: ops::Value,
 }
 
@@ -249,7 +255,7 @@ impl ExtensionValue {
 
     /// Returns a reference to the name of this [`ExtensionValue`].
     pub fn name(&self) -> &str {
-        self.name.as_ref()
+        self.name.as_str()
     }
 
     /// Returns a reference to the extension this [`ExtensionValue`] belongs to.
@@ -276,14 +282,14 @@ pub struct Extension {
     /// Types defined by this extension.
     types: HashMap<TypeName, TypeDef>,
     /// Static values defined by this extension.
-    values: HashMap<SmolStr, ExtensionValue>,
+    values: HashMap<ValueName, ExtensionValue>,
     /// Operation declarations with serializable definitions.
     // Note: serde will serialize this because we configure with `features=["rc"]`.
     // That will clone anything that has multiple references, but each
     // OpDef should appear exactly once in this map (keyed by its name),
     // and the other references to the OpDef are from ExternalOp's in the Hugr
     // (which are serialized as OpaqueOp's i.e. Strings).
-    operations: HashMap<SmolStr, Arc<op_def::OpDef>>,
+    operations: HashMap<OpName, Arc<op_def::OpDef>>,
 }
 
 impl Extension {
@@ -304,18 +310,18 @@ impl Extension {
     }
 
     /// Allows read-only access to the operations in this Extension
-    pub fn get_op(&self, op_name: &str) -> Option<&Arc<op_def::OpDef>> {
+    pub fn get_op(&self, op_name: &OpNameRef) -> Option<&Arc<op_def::OpDef>> {
         self.operations.get(op_name)
     }
 
     /// Allows read-only access to the types in this Extension
-    pub fn get_type(&self, type_name: &str) -> Option<&type_def::TypeDef> {
+    pub fn get_type(&self, type_name: &TypeNameRef) -> Option<&type_def::TypeDef> {
         self.types.get(type_name)
     }
 
     /// Allows read-only access to the values in this Extension
-    pub fn get_value(&self, type_name: &str) -> Option<&ExtensionValue> {
-        self.values.get(type_name)
+    pub fn get_value(&self, value_name: &ValueNameRef) -> Option<&ExtensionValue> {
+        self.values.get(value_name)
     }
 
     /// Returns the name of the extension.
@@ -324,7 +330,7 @@ impl Extension {
     }
 
     /// Iterator over the operations of this [`Extension`].
-    pub fn operations(&self) -> impl Iterator<Item = (&SmolStr, &Arc<OpDef>)> {
+    pub fn operations(&self) -> impl Iterator<Item = (&OpName, &Arc<OpDef>)> {
         self.operations.iter()
     }
 
@@ -336,7 +342,7 @@ impl Extension {
     /// Add a named static value to the extension.
     pub fn add_value(
         &mut self,
-        name: impl Into<SmolStr>,
+        name: impl Into<ValueName>,
         typed_value: ops::Value,
     ) -> Result<&mut ExtensionValue, ExtensionBuildError> {
         let extension_value = ExtensionValue {
@@ -346,7 +352,7 @@ impl Extension {
         };
         match self.values.entry(extension_value.name.clone()) {
             hash_map::Entry::Occupied(_) => {
-                Err(ExtensionBuildError::OpDefExists(extension_value.name))
+                Err(ExtensionBuildError::ValueExists(extension_value.name))
             }
             hash_map::Entry::Vacant(ve) => Ok(ve.insert(extension_value)),
         }
@@ -355,7 +361,7 @@ impl Extension {
     /// Instantiate an [`ExtensionOp`] which references an [`OpDef`] in this extension.
     pub fn instantiate_extension_op(
         &self,
-        op_name: &str,
+        op_name: &OpNameRef,
         args: impl Into<Vec<TypeArg>>,
         ext_reg: &ExtensionRegistry,
     ) -> Result<ExtensionOp, SignatureError> {
@@ -396,10 +402,13 @@ pub enum ExtensionRegistryError {
 pub enum ExtensionBuildError {
     /// Existing [`OpDef`]
     #[error("Extension already has an op called {0}.")]
-    OpDefExists(SmolStr),
+    OpDefExists(OpName),
     /// Existing [`TypeDef`]
     #[error("Extension already has an type called {0}.")]
-    TypeDefExists(SmolStr),
+    TypeDefExists(TypeName),
+    /// Existing [`ExtensionValue`]
+    #[error("Extension already has an extension value called {0}.")]
+    ValueExists(ValueName),
 }
 
 /// A set of extensions identified by their unique [`ExtensionId`].

hugr/src/extension/declarative.rs

@@ -32,6 +32,7 @@ use std::fs::File;
 use std::path::Path;
 
 use crate::extension::prelude::PRELUDE_ID;
+use crate::ops::OpName;
 use crate::types::TypeName;
 use crate::Extension;
 
@@ -221,7 +222,7 @@ pub enum ExtensionDeclarationError {
         /// The extension that referenced the unsupported op parameter.
         ext: ExtensionId,
         /// The operation.
-        op: SmolStr,
+        op: OpName,
     },
     /// Operation definitions with no signature are not currently supported.
     ///
@@ -233,7 +234,7 @@ pub enum ExtensionDeclarationError {
         /// The extension containing the operation.
         ext: ExtensionId,
         /// The operation with no signature.
-        op: SmolStr,
+        op: OpName,
     },
     /// An unknown type was specified in a signature.
     #[error("Type {ty} is not in scope. In extension {ext}.")]
@@ -261,7 +262,7 @@ pub enum ExtensionDeclarationError {
         /// The extension.
         ext: crate::hugr::IdentList,
         /// The operation with the lowering definition.
-        op: SmolStr,
+        op: OpName,
     },
 }
 

hugr/src/extension/declarative/ops.rs

@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 
 use crate::extension::{OpDef, SignatureFunc};
+use crate::ops::OpName;
 use crate::types::type_param::TypeParam;
 use crate::Extension;
 
@@ -25,7 +26,7 @@ use super::{DeclarationContext, ExtensionDeclarationError};
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub(super) struct OperationDeclaration {
     /// The identifier the operation.
-    name: SmolStr,
+    name: OpName,
     /// A description for the operation.
     #[serde(default)]
     #[serde(skip_serializing_if = "crate::utils::is_default")]

hugr/src/extension/declarative/signature.rs

@@ -206,17 +206,13 @@ impl TypeDeclaration {
         }
 
         // Try to resolve the type in the current extension.
-        if let Some(ty) = ext.get_type(self.0.as_str()) {
+        if let Some(ty) = ext.get_type(&self.0) {
             return Some(ty);
         }
 
         // Try to resolve the type in the other extensions in scope.
         for ext in ctx.scope.iter() {
-            if let Some(ty) = ctx
-                .registry
-                .get(ext)
-                .and_then(|ext| ext.get_type(self.0.as_str()))
-            {
+            if let Some(ty) = ctx.registry.get(ext).and_then(|ext| ext.get_type(&self.0)) {
                 return Some(ty);
             }
         }

hugr/src/extension/op_def.rs

@@ -4,13 +4,12 @@ use std::collections::HashMap;
 use std::fmt::{Debug, Formatter};
 use std::sync::Arc;
 
-use smol_str::SmolStr;
-
 use super::{
     ConstFold, ConstFoldResult, Extension, ExtensionBuildError, ExtensionId, ExtensionRegistry,
     ExtensionSet, SignatureError,
 };
 
+use crate::ops::{OpName, OpNameRef};
 use crate::types::type_param::{check_type_args, TypeArg, TypeParam};
 use crate::types::{FunctionType, PolyFuncType};
 use crate::Hugr;
@@ -108,7 +107,7 @@ pub trait CustomLowerFunc: Send + Sync {
     /// TODO: some error type to indicate Extensions required?
     fn try_lower(
         &self,
-        name: &SmolStr,
+        name: &OpNameRef,
         arg_values: &[TypeArg],
         misc: &HashMap<String, serde_yaml::Value>,
         available_extensions: &ExtensionSet,
@@ -295,7 +294,7 @@ pub struct OpDef {
     extension: ExtensionId,
     /// Unique identifier of the operation. Used to look up OpDefs in the registry
     /// when deserializing nodes (which store only the name).
-    name: SmolStr,
+    name: OpName,
     /// Human readable description of the operation.
     description: String,
     /// Miscellaneous data associated with the operation.
@@ -376,7 +375,7 @@ impl OpDef {
     }
 
     /// Returns a reference to the name of this [`OpDef`].
-    pub fn name(&self) -> &SmolStr {
+    pub fn name(&self) -> &OpName {
         &self.name
     }
 
@@ -442,7 +441,7 @@ impl Extension {
     /// function for computing the signature given type arguments (`impl [CustomSignatureFunc]`).
     pub fn add_op(
         &mut self,
-        name: SmolStr,
+        name: OpName,
         description: String,
         signature_func: impl Into<SignatureFunc>,
     ) -> Result<&mut OpDef, ExtensionBuildError> {
@@ -468,15 +467,13 @@ impl Extension {
 mod test {
     use std::num::NonZeroU64;
 
-    use smol_str::SmolStr;
-
     use super::SignatureFromArgs;
     use crate::builder::{DFGBuilder, Dataflow, DataflowHugr};
     use crate::extension::op_def::LowerFunc;
     use crate::extension::prelude::USIZE_T;
     use crate::extension::{ExtensionRegistry, ExtensionSet, PRELUDE};
     use crate::extension::{SignatureError, EMPTY_REG, PRELUDE_REGISTRY};
-    use crate::ops::CustomOp;
+    use crate::ops::{CustomOp, OpName};
     use crate::std_extensions::collections::{EXTENSION, LIST_TYPENAME};
     use crate::types::Type;
     use crate::types::{type_param::TypeParam, FunctionType, PolyFuncType, TypeArg, TypeBound};
@@ -494,7 +491,7 @@ mod test {
         const TP: TypeParam = TypeParam::Type { b: TypeBound::Any };
         let list_of_var =
             Type::new_extension(list_def.instantiate(vec![TypeArg::new_var_use(0, TP)])?);
-        const OP_NAME: SmolStr = SmolStr::new_inline("Reverse");
+        const OP_NAME: OpName = OpName::new_inline("Reverse");
         let type_scheme = PolyFuncType::new(vec![TP], FunctionType::new_endo(vec![list_of_var]));
 
         let def = e.add_op(OP_NAME, "desc".into(), type_scheme)?;