Start working on a HashMap implementation using hashbrown::raw

Cargo.toml

@@ -18,3 +18,6 @@ default-members = [
 [profile.bench]
 lto = false
 debug = true
+
+[patch.crates-io]
+hashbrown = { git = "https://github.com/udoprog/hashbrown", branch = "raw-infallible-context" }

crates/rune-core/src/protocol.rs

@@ -478,4 +478,12 @@ define! {
         repr: Some("value?"),
         doc: ["Allows the `?` operator to apply to values of this type."],
     };
+
+    /// Protocol used when calculating a hash.
+    pub const [HASH, HASH_HASH]: Protocol = Protocol {
+        name: "hash",
+        hash: 0xf6cf2d9f416cef08u64,
+        repr: Some("let output = hash($value)"),
+        doc: ["Hash the given value."],
+    };
 }

crates/rune-macros/src/any.rs

@@ -503,6 +503,7 @@ where
         value,
         vm_result,
         install_with,
+        non_null,
         ..
     } = &tokens;
 
@@ -602,7 +603,7 @@ where
                         #vm_result::Err(err) => return #vm_result::Err(err),
                     };
 
-                    #vm_result::Ok((&*value, guard))
+                    #vm_result::Ok((#non_null::as_ref(&value), guard))
                 }
             }
 
@@ -611,12 +612,12 @@ where
                 type Guard = #raw_into_mut;
 
                 unsafe fn unsafe_to_mut<'a>(value: #value) -> #vm_result<(&'a mut Self, Self::Guard)> {
-                    let (value, guard) = match value.into_any_mut() {
+                    let (mut value, guard) = match value.into_any_mut() {
                         #vm_result::Ok(value) => value,
                         #vm_result::Err(err) => return #vm_result::Err(err),
                     };
 
-                    #vm_result::Ok((&mut *value, guard))
+                    #vm_result::Ok((#non_null::as_mut(&mut value), guard))
                 }
             }
 

crates/rune-macros/src/context.rs

@@ -612,6 +612,7 @@ impl Context {
             iterator: path(&core, ["iter", "Iterator"]),
             double_ended_iterator: path(&core, ["iter", "DoubleEndedIterator"]),
             option: path(&core, ["option", "Option"]),
+            non_null: path(&core, ["ptr", "NonNull"]),
         }
     }
 }
@@ -693,6 +694,7 @@ pub(crate) struct Tokens {
     pub(crate) iterator: syn::Path,
     pub(crate) double_ended_iterator: syn::Path,
     pub(crate) option: syn::Path,
+    pub(crate) non_null: syn::Path,
 }
 
 impl Tokens {

crates/rune/Cargo.toml

@@ -42,7 +42,7 @@ serde = { version = "1.0.163", default-features = false, features = ["derive", "
 serde_bytes = { version = "0.11.9", default-features = false, features = ["alloc"] }
 smallvec = { version = "1.10.0", default-features = false, features = ["serde", "const_new"] }
 tracing =  { version = "0.1.37", default-features = false, features = ["attributes"] }
-hashbrown = { version = "0.13.2", features = ["serde"] }
+hashbrown = { version = "0.14.0", features = ["raw", "serde"] }
 musli = { version = "0.0.42", default-features = false, features = ["alloc"] }
 slab = { version = "0.4.8", default-features = false }
 

crates/rune/src/internal_macros.rs

@@ -119,7 +119,7 @@ macro_rules! from_value {
                 let value = vm_try!(value.$into());
                 let value = vm_try!(value.into_ref());
                 let (value, guard) = $crate::runtime::Ref::into_raw(value);
-                $crate::runtime::VmResult::Ok((&*value, guard))
+                $crate::runtime::VmResult::Ok((value.as_ref(), guard))
             }
         }
 
@@ -131,8 +131,8 @@ macro_rules! from_value {
             ) -> $crate::runtime::VmResult<(&'a mut Self, Self::Guard)> {
                 let value = vm_try!(value.$into());
                 let value = vm_try!(value.into_mut());
-                let (value, guard) = $crate::runtime::Mut::into_raw(value);
-                $crate::runtime::VmResult::Ok((&mut *value, guard))
+                let (mut value, guard) = $crate::runtime::Mut::into_raw(value);
+                $crate::runtime::VmResult::Ok((value.as_mut(), guard))
             }
         }