rune-rs
diff --git a/‎crates/rune-core/src/hash.rs
Lines changed: 1 addition & 2 deletions b/‎crates/rune-core/src/hash.rs
Lines changed: 1 addition & 2 deletions
diff --git a/‎crates/rune-core/src/protocol.rs
Lines changed: 1 addition & 1 deletion b/‎crates/rune-core/src/protocol.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎crates/rune-macros/src/any.rs
Lines changed: 40 additions & 21 deletions b/‎crates/rune-macros/src/any.rs
Lines changed: 40 additions & 21 deletions
diff --git a/‎crates/rune-macros/src/hash.rs
Lines changed: 17 additions & 1 deletion b/‎crates/rune-macros/src/hash.rs
Lines changed: 17 additions & 1 deletion
diff --git a/‎crates/rune-macros/src/lib.rs
Lines changed: 1 addition & 0 deletions b/‎crates/rune-macros/src/lib.rs
Lines changed: 1 addition & 0 deletions
diff --git a/‎crates/rune/src/compile/context.rs
Lines changed: 1 addition & 3 deletions b/‎crates/rune/src/compile/context.rs
Lines changed: 1 addition & 3 deletions
diff --git a/‎crates/rune/src/compile/context_error.rs
Lines changed: 8 additions & 11 deletions b/‎crates/rune/src/compile/context_error.rs
Lines changed: 8 additions & 11 deletions
diff --git a/‎crates/rune/src/compile/meta.rs
Lines changed: 0 additions & 4 deletions b/‎crates/rune/src/compile/meta.rs
Lines changed: 0 additions & 4 deletions
diff --git a/‎crates/rune/src/compile/named.rs
Lines changed: 7 additions & 15 deletions b/‎crates/rune/src/compile/named.rs
Lines changed: 7 additions & 15 deletions
diff --git a/‎crates/rune/src/compile/v1/assemble.rs
Lines changed: 7 additions & 8 deletions b/‎crates/rune/src/compile/v1/assemble.rs
Lines changed: 7 additions & 8 deletions
@@ -76,9 +76,8 @@ const PARAMETERS: [u64; 32] = [
 /// The primitive hash that among other things is used to reference items,
 /// types, and native functions.
 #[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-#[cfg_attr(feature = "musli", derive(Decode, Encode))]
+#[cfg_attr(feature = "musli", derive(Decode, Encode), musli(transparent))]
 #[repr(transparent)]
-#[cfg_attr(feature = "musli", musli(transparent))]
 pub struct Hash(#[doc(hidden)] pub u64);
 
 impl Hash {
 
@@ -454,7 +454,7 @@ define! {
 
     /// Function used to test if a value is a specific variant.
     ///
-    /// Signature: `fn(self, usize) -> bool`.
+    /// Signature: `fn(self, Hash) -> bool`.
     pub const IS_VARIANT: Protocol = Protocol {
         hash: 0xc030d82bbd4dabe8u64,
         /// Test if the provided argument is a variant.
 
@@ -154,22 +154,6 @@ impl Derive {
     ) -> Result<TypeBuilder<'a, syn::Ident>, ()> {
         let mut installers = Vec::new();
 
-        expand_install_with(cx, &self.input, tokens, attr, &mut installers)?;
-
-        if matches!(&self.input.data, syn::Data::Enum(..)) {
-            if let Some(span) = attr.constructor {
-                cx.error(syn::Error::new(
-                    span,
-                    "#[rune(constructor)] is not supported on enums, only its variants",
-                ));
-            }
-        }
-
-        let name = match &attr.name {
-            Some(name) => name,
-            None => &self.input.ident,
-        };
-
         let mut item = match &attr.item {
             Some(item) => item.clone(),
             None => syn::Path {
@@ -178,12 +162,28 @@ impl Derive {
             },
         };
 
+        let name = match &attr.name {
+            Some(name) => name,
+            None => &self.input.ident,
+        };
+
         item.segments.push(syn::PathSegment::from(name.clone()));
 
         let args = crate::hash::Arguments::new(item);
         let type_item = args.build_type_item(cx)?;
         let type_hash = args.build_type_hash(cx)?;
 
+        expand_install_with(cx, &self.input, tokens, attr, &mut installers, &args)?;
+
+        if matches!(&self.input.data, syn::Data::Enum(..)) {
+            if let Some(span) = attr.constructor {
+                cx.error(syn::Error::new(
+                    span,
+                    "#[rune(constructor)] is not supported on enums, only its variants",
+                ));
+            }
+        }
+
         Ok(TypeBuilder {
             attr,
             ident: self.input.ident,
@@ -206,6 +206,7 @@ pub(crate) fn expand_install_with(
     tokens: &Tokens,
     attr: &TypeAttr,
     installers: &mut Vec<TokenStream>,
+    args: &crate::hash::Arguments,
 ) -> Result<(), ()> {
     let ident = &input.ident;
 
@@ -214,7 +215,16 @@ pub(crate) fn expand_install_with(
             expand_struct_install_with(cx, installers, ident, st, tokens, attr)?;
         }
         syn::Data::Enum(en) => {
-            expand_enum_install_with(cx, installers, ident, en, tokens, attr, &input.generics)?;
+            expand_enum_install_with(
+                cx,
+                installers,
+                ident,
+                en,
+                tokens,
+                attr,
+                &input.generics,
+                args,
+            )?;
         }
         syn::Data::Union(..) => {
             cx.error(syn::Error::new_spanned(
@@ -330,6 +340,7 @@ fn expand_enum_install_with(
     tokens: &Tokens,
     attr: &TypeAttr,
     generics: &syn::Generics,
+    args: &crate::hash::Arguments,
 ) -> Result<(), ()> {
     let Tokens {
         protocol,
@@ -339,6 +350,7 @@ fn expand_enum_install_with(
         vm_try,
         any_t,
         try_clone,
+        hash,
         ..
     } = tokens;
 
@@ -370,9 +382,16 @@ fn expand_enum_install_with(
         }
 
         let variant_ident = &variant.ident;
-        variant_names.push(syn::LitStr::new(&variant_ident.to_string(), span));
+        let variant_name = variant_ident.to_string();
+        variant_names.push(syn::LitStr::new(&variant_name, span));
+
+        let Ok(variant_hash) = args.build_type_hash_with(cx, &variant_name) else {
+            continue;
+        };
+
+        let variant_hash = variant_hash.into_inner();
 
-        is_variant.push(quote!((#ident::#variant_ident { .. }, #variant_index) => true));
+        is_variant.push(quote!((#ident::#variant_ident { .. }, #hash(#variant_hash)) => true));
 
         match &variant.fields {
             syn::Fields::Named(fields) => {
@@ -467,8 +486,8 @@ fn expand_enum_install_with(
     }
 
     let is_variant = quote! {
-        module.associated_function(&#protocol::IS_VARIANT, |this: &Self, index: usize| {
-            match (this, index) {
+        module.associated_function(&#protocol::IS_VARIANT, |this: &Self, hash: #hash| {
+            match (this, hash) {
                 #(#is_variant,)*
                 _ => false,
             }
 
@@ -30,8 +30,17 @@ impl Arguments {
         }
     }
 
-    /// Construct a type hash from a Rust path.
+    /// Construct a type hash from a path.
     pub(crate) fn build_type_hash(&self, cx: &Context) -> Result<Hash, ()> {
+        self.build_type_hash_with_inner(cx, None)
+    }
+
+    /// Construct a type hash from a path with an extra string component at the end.
+    pub(crate) fn build_type_hash_with(&self, cx: &Context, extra: &str) -> Result<Hash, ()> {
+        self.build_type_hash_with_inner(cx, Some(extra))
+    }
+
+    fn build_type_hash_with_inner(&self, cx: &Context, extra: Option<&str>) -> Result<Hash, ()> {
         // Construct type hash.
         let mut buf = ItemBuf::new();
         let mut first = self.path.leading_colon.is_some();
@@ -67,6 +76,13 @@ impl Arguments {
             }
         }
 
+        if let Some(extra) = extra {
+            if let Err(error) = buf.push(ComponentRef::Str(extra)) {
+                cx.error(syn::Error::new_spanned(&self.path, error));
+                return Err(());
+            }
+        }
+
         let base = Hash::type_hash(&buf);
 
         let hash = if let Some((_, associated)) = &self.associated {
 
@@ -23,6 +23,7 @@
 //! This is part of the [Rune Language](https://rune-rs.github.io).
 
 #![allow(clippy::manual_map)]
+#![allow(clippy::too_many_arguments)]
 
 mod any;
 mod const_value;
 
@@ -760,11 +760,10 @@ impl Context {
                         constructor,
                         parameters,
                         enum_hash: Hash::EMPTY,
-                        variant_index: 0,
                     }
                 }
                 TypeSpecification::Enum(en) => {
-                    for (index, variant) in en.variants.iter().enumerate() {
+                    for variant in &en.variants {
                         let Some(fields) = &variant.fields else {
                             continue;
                         };
@@ -834,7 +833,6 @@ impl Context {
                                 constructor,
                                 parameters: Hash::EMPTY,
                                 enum_hash: ty.hash,
-                                variant_index: index,
                             },
                             #[cfg(feature = "doc")]
                             deprecated: variant.deprecated.try_clone()?,
 
@@ -103,8 +103,8 @@ pub enum ContextError {
         type_info: TypeInfo,
     },
     ConflictingVariantMeta {
-        index: usize,
         type_info: TypeInfo,
+        name: &'static str,
     },
     ConflictingMetaHash {
         item: ItemBuf,
@@ -123,7 +123,7 @@ pub enum ContextError {
     },
     VariantConstructorConflict {
         type_info: TypeInfo,
-        index: usize,
+        name: &'static str,
     },
     ConflictingConstConstruct {
         type_info: TypeInfo,
@@ -306,10 +306,10 @@ impl fmt::Display for ContextError {
                     "Type `{item}` at `{type_info}` already has a specification"
                 )?;
             }
-            ContextError::ConflictingVariantMeta { index, type_info } => {
+            ContextError::ConflictingVariantMeta { type_info, name } => {
                 write!(
                     f,
-                    "Variant `{index}` for `{type_info}` already has a 
10000
specification"
+                    "Variant `{name}` for `{type_info}` already has a specification"
                 )?;
             }
             ContextError::ConflictingMetaHash {
@@ -329,21 +329,18 @@ impl fmt::Display for ContextError {
                 write!(f, "Variant with `{item}` already exists")?;
             }
             ContextError::ConstructorConflict { type_info } => {
-                write!(
-                    f,
-                    "Constructor for type `{type_info}` has already been registered"
-                )?;
+                write!(f, "Constructor for `{type_info}` already exists")?;
             }
-            ContextError::VariantConstructorConflict { type_info, index } => {
+            ContextError::VariantConstructorConflict { type_info, name } => {
                 write!(
                     f,
-                    "Constructor for variant {index} in `{type_info}` has already been registered"
+                    "Constructor for variant `{name}` for `{type_info}` already exists"
                 )?;
             }
             ContextError::ConflictingConstConstruct { type_info, hash } => {
                 write!(
                     f,
-                    "Conflicting constant constructor with hash {hash} for type {type_info}"
+                    "Constant constructor with hash {hash} for `{type_info}` already exists"
                 )?;
             }
             ContextError::MissingType { item, type_info } => {
 
@@ -183,10 +183,6 @@ pub enum Kind {
         ///
         /// If this is not a variant, this is [Hash::EMPTY].
         enum_hash: Hash,
-        /// If this is a variant, this is the index of the variant in the enum.
-        ///
-        /// For non-variants, this is set to `0`.
-        variant_index: usize,
     },
     /// An enum item.
     Enum {
 
@@ -3,20 +3,20 @@ use core::fmt;
 use core::marker::PhantomData;
 
 use crate as rune;
-use crate::module::InstallWith;
-use crate::{item, Item};
+use crate::{item, Hash, Item};
 
 /// The trait used for something that can be statically named.
 pub trait Named {
     /// The name item.
     const ITEM: &'static Item;
 
-    /// The exact type name
+    /// The full name of the type.
+    #[inline]
     fn full_name(f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", Self::ITEM)
     }
 
-    /// Return a display wrapper for the named type.
+    /// Return a display wrapper for the full name of the type.
     #[inline]
     fn display() -> impl fmt::Display {
         struct DisplayNamed<T>(PhantomData<T>)
@@ -50,34 +50,26 @@ impl Named for i64 {
     const ITEM: &'static Item = item!(::std::i64);
 }
 
-impl InstallWith for i64 {}
-
 impl Named for u64 {
     const ITEM: &'static Item = item!(::std::u64);
 }
 
-impl InstallWith for u64 {}
-
 impl Named for f64 {
     const ITEM: &'static Item = item!(::std::f64);
 }
 
-impl InstallWith for f64 {}
-
 impl Named for char {
     const ITEM: &'static Item = item!(::std::char);
 }
 
-impl InstallWith for char {}
-
 impl Named for bool {
     const ITEM: &'static Item = item!(::std::bool);
 }
 
-impl InstallWith for bool {}
-
 impl Named for Ordering {
     const ITEM: &'static Item = item!(::std::cmp::Ordering);
 }
 
-impl InstallWith for Ordering {}
+impl Named for Hash {
+    const ITEM: &'static Item = item!(::std::any::Hash);
+}
@@ -766,13 +766,11 @@ fn pat_sequence_kind_to_inst(kind: hir::PatSequenceKind, addr: InstAddress, out:
             out,
         },
         hir::PatSequenceKind::Variant {
-            variant_hash,
             enum_hash,
-            index,
-        } => Inst::MatchVariant {
             variant_hash,
+        } => Inst::MatchVariant {
             enum_hash,
-            index,
+            variant_hash,
             addr,
             out,
         },
@@ -827,13 +825,11 @@ fn pat_object<'a, 'hir>(
             out: cond.output(),
         },
         hir::PatSequenceKind::Variant {
-            variant_hash,
             enum_hash,
-            index,
-        } => Inst::MatchVariant {
             variant_hash,
+        } => Inst::MatchVariant {
             enum_hash,
-            index,
+            variant_hash,
             addr: addr.addr(),
             out: cond.output(),
         },
@@ -1138,6 +1134,9 @@ fn const_<'a, 'hir>(
             Inline::Ordering(v) => {
                 cx.asm.push(Inst::ordering(v, out), span)?;
             }
+            Inline::Hash(v) => {
+                cx.asm.push(Inst::hash(v, out), span)?;
+            }
         },
         ConstValueKind::String(ref s) => {
             let slot = cx.q.unit.new_static_string(span, s)?;