rubydex 0.2.9 → 0.4.0

data/rust/rubydex/src/model/definitions.rs

@@ -29,6 +29,7 @@ use crate::{
     assert_mem_size,
     model::{
         comment::Comment,
+        id::id_from_parts,
         ids::{self, ConstantReferenceId, DefinitionId, NameId, StringId, UriId},
         visibility::Visibility,
     },
@@ -673,13 +674,13 @@ impl ConstantAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.alias_constant.uri_id(),
+        id_from_parts!(
+            DefinitionId;
+            self.alias_constant.uri_id().get(),
             self.alias_constant.offset().start(),
-            *self.alias_constant.name_id(),
-            *self.target_name_id,
-        ))
+            self.alias_constant.name_id().get(),
+            self.target_name_id.get(),
+        )
     }
 
     #[must_use]
@@ -757,7 +758,7 @@ impl ConstantVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.target))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.target.get())
     }
 
     #[must_use]
@@ -837,7 +838,7 @@ impl MethodVisibilityDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get(), self.flags.bits())
     }
 
     #[must_use]
@@ -1123,7 +1124,7 @@ impl AttrAccessorDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1204,7 +1205,7 @@ impl AttrReaderDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1285,7 +1286,7 @@ impl AttrWriterDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1363,7 +1364,7 @@ impl GlobalVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1436,7 +1437,7 @@ impl InstanceVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1509,7 +1510,7 @@ impl ClassVariableDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!("{}{}{}", *self.uri_id, self.offset.start(), *self.str_id))
+        id_from_parts!(DefinitionId; self.uri_id.get(), self.offset.start(), self.str_id.get())
     }
 
     #[must_use]
@@ -1583,13 +1584,13 @@ impl MethodAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.uri_id,
+        id_from_parts!(
+            DefinitionId;
+            self.uri_id.get(),
             self.offset.start(),
-            *self.new_name_str_id,
-            *self.old_name_str_id,
-        ))
+            self.new_name_str_id.get(),
+            self.old_name_str_id.get(),
+        )
     }
 
     #[must_use]
@@ -1669,13 +1670,13 @@ impl GlobalVariableAliasDefinition {
 
     #[must_use]
     pub fn id(&self) -> DefinitionId {
-        DefinitionId::from(&format!(
-            "{}{}{}{}",
-            *self.uri_id,
+        id_from_parts!(
+            DefinitionId;
+            self.uri_id.get(),
             self.offset.start(),
-            *self.new_name_str_id,
-            *self.old_name_str_id,
-        ))
+            self.new_name_str_id.get(),
+            self.old_name_str_id.get(),
+        )
     }
 
     #[must_use]

data/rust/rubydex/src/model/document.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use line_index::LineIndex;
 use url::Url;
+use xxhash_rust::xxh3::xxh3_64;
 
 use crate::assert_mem_size;
 use crate::diagnostic::Diagnostic;
@@ -17,8 +18,9 @@ pub struct Document {
     method_reference_ids: Vec<MethodReferenceId>,
     constant_reference_ids: Vec<ConstantReferenceId>,
     diagnostics: Vec<Diagnostic>,
+    content_hash: u64,
 }
-assert_mem_size!(Document, 176);
+assert_mem_size!(Document, 184);
 
 impl Document {
     #[must_use]
@@ -30,6 +32,7 @@ impl Document {
             method_reference_ids: Vec::new(),
             constant_reference_ids: Vec::new(),
             diagnostics: Vec::new(),
+            content_hash: xxh3_64(source.as_bytes()),
         }
     }
 
@@ -38,6 +41,11 @@ impl Document {
         &self.uri
     }
 
+    #[must_use]
+    pub fn content_hash(&self) -> u64 {
+        self.content_hash
+    }
+
     #[must_use]
     pub fn line_index(&self) -> &LineIndex {
         &self.line_index
@@ -84,6 +92,39 @@ impl Document {
         self.diagnostics.push(diagnostic);
     }
 
+    /// The file-system path of this document, decoded from its URI.
+    ///
+    /// Returns `None` when the URI is not a `file://` URL (e.g. the synthetic built-in document) or
+    /// cannot be converted to a path. Uses `Url` so percent-encoding and platform-specific paths
+    /// (including Windows drive paths) are handled correctly.
+    #[must_use]
+    pub fn file_path(&self) -> Option<PathBuf> {
+        let url = Url::parse(&self.uri).ok()?;
+        if url.scheme() != "file" {
+            return None;
+        }
+        url.to_file_path().ok()
+    }
+
+    /// The base file name of this document (the last path segment), decoded from its URI.
+    ///
+    /// Prefers the platform file path, but falls back to the last URL path segment so it still works
+    /// for `file://` URIs that don't convert to a local path on the current platform (e.g. a
+    /// drive-less path like `file:///foo.rb` on Windows). Returns `None` only when the URI has no
+    /// usable path segment (e.g. the synthetic built-in document).
+    #[must_use]
+    pub fn file_name(&self) -> Option<String> {
+        if let Some(path) = self.file_path()
+            && let Some(name) = path.file_name()
+        {
+            return Some(name.to_string_lossy().into_owned());
+        }
+
+        let url = Url::parse(&self.uri).ok()?;
+        let segment = url.path_segments()?.rfind(|segment| !segment.is_empty())?;
+        Some(segment.to_string())
+    }
+
     /// Computes the require path for this document given load paths.
     ///
     /// Returns `None` if:
@@ -97,12 +138,7 @@ impl Document {
     /// Panics if load path entries exceed u16.
     #[must_use]
     pub fn require_path(&self, load_paths: &[PathBuf]) -> Option<(String, u16)> {
-        let url = Url::parse(&self.uri).ok()?;
-        if url.scheme() != "file" {
-            return None;
-        }
-
-        let file_path = url.to_file_path().ok()?;
+        let file_path = self.file_path()?;
         if file_path.extension().is_none_or(|ext| ext != "rb") {
             return None;
         }

data/rust/rubydex/src/model/graph.rs

@@ -1,11 +1,9 @@
 use std::collections::HashSet;
 use std::collections::hash_map::Entry;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
-use crate::assert_mem_size;
 use crate::config::Config;
 use crate::diagnostic::Diagnostic;
-use crate::errors::Errors;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
 use crate::model::declaration::{Ancestor, Declaration, Namespace};
@@ -21,6 +19,7 @@ use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
 use crate::model::visibility::Visibility;
+use crate::{assert_mem_size, assert_send_sync};
 use crate::{query, stats};
 
 /// An entity whose validity depends on a particular `NameId`.
@@ -93,7 +92,8 @@ pub struct Graph {
     /// Project configuration
     config: Config,
 }
-assert_mem_size!(Graph, 352);
+assert_mem_size!(Graph, 368);
+assert_send_sync!(Graph);
 
 impl Graph {
     #[must_use]
@@ -109,7 +109,7 @@ impl Graph {
             position_encoding: Encoding::default(),
             name_dependents: IdentityHashMap::default(),
             pending_work: Vec::default(),
-            config: Config::new(),
+            config: Config::default(),
         };
 
         add_built_in_data(&mut graph);
@@ -146,25 +146,9 @@ impl Graph {
         self.config.workspace_path()
     }
 
-    /// Sets the root directory of the workspace being indexed.
-    pub fn set_workspace_path(&mut self, workspace_path: PathBuf) {
-        self.config.set_workspace_path(workspace_path);
-    }
-
-    /// Loads a configuration file. Pass `None` to load the default `rubydex.toml` configuration file if it exists
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`Errors::ConfigNotFound`] if an explicitly requested file does not exist or an
-    /// [`Errors::ConfigError`] if a file cannot otherwise be read or its contents are malformed.
-    pub fn load_config(&mut self, config_path: Option<&Path>) -> Result<(), Errors> {
-        match config_path {
-            Some(path) => {
-                let path = self.config.workspace_path().join(path);
-                self.config.load_file(&path)
-            }
-            None => self.config.load_default(),
-        }
+    /// Loads a config for the graph
+    pub fn load_config(&mut self, config: &Config) {
+        self.config = config.clone();
     }
 
     /// # Panics
@@ -206,7 +190,15 @@ impl Graph {
                 if should_promote {
                     let mut new_declaration = constructor(fully_qualified_name);
                     let removed_declaration = occupied_entry.remove();
-                    new_declaration.as_namespace_mut().unwrap().extend(removed_declaration);
+                    let singleton_class_id = removed_declaration
+                        .as_namespace()
+                        .and_then(Namespace::singleton_class)
+                        .copied();
+                    let new_namespace = new_declaration.as_namespace_mut().unwrap();
+                    new_namespace.extend(removed_declaration);
+                    if let Some(singleton_class_id) = singleton_class_id {
+                        new_namespace.set_singleton_class_id(singleton_class_id);
+                    }
                     new_declaration.add_definition(definition_id);
                     self.declarations.insert(declaration_id, new_declaration);
                 } else {
@@ -539,7 +531,8 @@ impl Graph {
     /// Registers a name in the graph unless already registered. In regular indexing, this only happens in the local
     /// graph. This method is only used to back the `Graph#resolve_constant` Ruby API because every name must be
     /// registered in the graph to properly resolve
-    pub fn add_name(&mut self, name: Name) -> NameId {
+    pub fn add_name(&mut self, str: StringId, parent_scope: ParentScope, nesting: Option<NameId>) -> NameId {
+        let name = Name::new(&self.names, str, parent_scope, nesting);
         let name_id = name.id();
 
         match self.names.entry(name_id) {
@@ -554,31 +547,6 @@ impl Graph {
         name_id
     }
 
-    /// Searches for the initial attached object for an arbitrarily nested singleton class.
-    /// Walks up the owner chain until finding a non-singleton namespace.
-    ///
-    /// # Example
-    /// For `Foo::<Foo>::<<Foo>>`, returns `Foo`
-    ///
-    /// # Panics
-    ///
-    /// Panics if we attached a singleton class to something that isn't a namespace
-    #[must_use]
-    pub fn attached_object<'a>(&'a self, maybe_singleton: &'a Namespace) -> &'a Namespace {
-        let mut attached_object = maybe_singleton;
-
-        while matches!(attached_object, Namespace::SingletonClass(_)) {
-            attached_object = self
-                .declarations
-                .get(attached_object.owner_id())
-                .unwrap()
-                .as_namespace()
-                .unwrap();
-        }
-
-        attached_object
-    }
-
     #[must_use]
     pub fn get(&self, name: &str) -> Option<Vec<&Definition>> {
         let declaration_id = declaration_id_from_lookup_name(name);
@@ -676,6 +644,9 @@ impl Graph {
     ///
     /// For methods, the latest definition wins. For constants, the latest
     /// `private_constant`/`public_constant` wins, otherwise `Public`.
+    ///
+    /// Methods declared via `module_function :bar` return `Private` on the instance
+    /// side (`Foo#bar`) and `Public` on the singleton side (`Foo::<Foo>#bar`).
     #[must_use]
     pub fn visibility(&self, declaration_id: &DeclarationId) -> Option<Visibility> {
         let declaration = self.declarations.get(declaration_id)?;
@@ -701,7 +672,13 @@ impl Graph {
                     };
 
                     let visibility = match definition {
-                        Definition::MethodVisibility(vis) => Some(*vis.visibility()),
+                        Definition::MethodVisibility(vis) => match *vis.visibility() {
+                            Visibility::ModuleFunction if vis.flags().is_singleton_method_visibility() => {
+                                Some(Visibility::Public)
+                            }
+                            Visibility::ModuleFunction => Some(Visibility::Private),
+                            other => Some(other),
+                        },
                         Definition::Method(method) => Some(*method.visibility()),
                         Definition::AttrAccessor(attr) => Some(*attr.visibility()),
                         Definition::AttrReader(attr) => Some(*attr.visibility()),
@@ -908,12 +885,7 @@ impl Graph {
     ) {
         if let Some(declaration) = self.declarations.get_mut(owner_id) {
             match declaration {
-                Declaration::Namespace(Namespace::Class(it)) => it.add_member(member_str_id, member_declaration_id),
-                Declaration::Namespace(Namespace::Module(it)) => it.add_member(member_str_id, member_declaration_id),
-                Declaration::Namespace(Namespace::SingletonClass(it)) => {
-                    it.add_member(member_str_id, member_declaration_id);
-                }
-                Declaration::Namespace(Namespace::Todo(it)) => it.add_member(member_str_id, member_declaration_id),
+                Declaration::Namespace(namespace) => namespace.add_member(member_str_id, member_declaration_id),
                 Declaration::Constant(_) => {
                     // TODO: temporary hack to avoid crashing on `Struct.new`, `Class.new` and `Module.new`
                 }
@@ -1044,7 +1016,17 @@ impl Graph {
     /// 3. `extend` -- merges the new `LocalGraph` into the now-clean graph
     pub fn consume_document_changes(&mut self, other: LocalGraph) {
         let uri_id = other.uri_id();
-        let old_document = self.documents.remove(&uri_id);
+
+        let old_document = match self.documents.entry(uri_id) {
+            Entry::Occupied(entry) => {
+                // No changes to the document, skip invalidation and merging
+                if entry.get().content_hash() == other.document().content_hash() {
+                    return;
+                }
+                Some(entry.remove())
+            }
+            Entry::Vacant(_) => None,
+        };
 
         // Skip invalidation during boot indexing (no documents have been resolved yet)
         // or when the document is brand new (no old data to invalidate against).
@@ -1298,7 +1280,7 @@ impl Graph {
                         && let Some(anc_decl) = self.declarations.get_mut(&ancestor_id)
                         && let Some(ns) = anc_decl.as_namespace_mut()
                     {
-                        ns.remove_descendant(&decl_id);
+                        ns.remove_descendant(decl_id);
                     }
                 }
             }
@@ -1322,7 +1304,7 @@ impl Graph {
                     && let Some(anc_decl) = self.declarations.get_mut(ancestor_id)
                     && let Some(ns) = anc_decl.as_namespace_mut()
                 {
-                    ns.remove_descendant(&decl_id);
+                    ns.remove_descendant(decl_id);
                 }
             }
 
@@ -1816,7 +1798,7 @@ mod tests {
         context.index_uri("file:///a.rb", "");
 
         {
-            let Declaration::Namespace(Namespace::Class(foo)) =
+            let Declaration::Namespace(foo @ Namespace::Class(_)) =
                 context.graph().declarations().get(&DeclarationId::from("Foo")).unwrap()
             else {
                 panic!("Expected Foo to be a class");
@@ -1824,7 +1806,7 @@ mod tests {
             assert!(matches!(foo.ancestors(), Ancestors::Partial(a) if a.is_empty()));
             assert!(foo.descendants().is_empty());
 
-            let Declaration::Namespace(Namespace::Class(baz)) =
+            let Declaration::Namespace(baz @ Namespace::Class(_)) =
                 context.graph().declarations().get(&DeclarationId::from("Baz")).unwrap()
             else {
                 panic!("Expected Baz to be a class");
@@ -1832,7 +1814,7 @@ mod tests {
             assert!(matches!(baz.ancestors(), Ancestors::Partial(a) if a.is_empty()));
             assert!(baz.descendants().is_empty());
 
-            let Declaration::Namespace(Namespace::Module(bar)) =
+            let Declaration::Namespace(bar @ Namespace::Module(_)) =
                 context.graph().declarations().get(&DeclarationId::from("Bar")).unwrap()
             else {
                 panic!("Expected Bar to be a module");
@@ -2203,9 +2185,9 @@ mod tests {
 
         assert_eq!(
             vec![
-                "parse-error: expected an `end` to close the `class` statement (file:///foo1.rb)",
-                "parse-error: unexpected end-of-input, assuming it is closing the parent top level context (file:///foo1.rb)",
-                "parse-warning: assigned but unused variable - foo (file:///foo2.rb)",
+                "ParseError: expected an `end` to close the `class` statement (file:///foo1.rb)",
+                "ParseError: unexpected end-of-input, assuming it is closing the parent top level context (file:///foo1.rb)",
+                "ParseWarning: assigned but unused variable - foo (file:///foo2.rb)",
             ],
             diagnostics,
         );
@@ -2527,7 +2509,7 @@ mod tests {
         );
 
         // Delete bar.rb — the Bar name should be fully removed
-        let bar_name_id = Name::new(StringId::from("Bar"), ParentScope::None, None).id();
+        let bar_name_id = Name::new(context.graph().names(), StringId::from("Bar"), ParentScope::None, None).id();
         context.index_uri("file:///bar.rb", "");
         context.resolve();
 
@@ -4209,4 +4191,21 @@ mod incremental_resolution_tests {
             );
         }
     }
+
+    #[test]
+    fn unchanged_document_does_not_trigger_invalidation() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///a.rb", "class Foo; end");
+        context.resolve();
+
+        // Re-indexing the same content should not trigger any invalidation or changes
+        context.index_uri("file:///a.rb", "class Foo; end");
+
+        let mut graph = context.into_graph();
+
+        assert!(
+            graph.take_pending_work().is_empty(),
+            "Graph should have no pending work after re-indexing unchanged document"
+        );
+    }
 } // mod incremental_resolution_tests

data/rust/rubydex/src/model/id.rs

@@ -1,6 +1,14 @@
 use std::{marker::PhantomData, num::NonZeroU64, ops::Deref};
 use xxhash_rust::xxh3;
 
+/// Creates an ID by hashing fixed-width integer components in little-endian order.
+macro_rules! id_from_parts {
+    ($id:ty; $($part:expr),+ $(,)?) => {
+        <$id>::from([$(($part).to_le_bytes().as_slice()),+])
+    };
+}
+pub(crate) use id_from_parts;
+
 /// Maps a u64 hash to a `NonZeroU64` by replacing 0 with `u64::MAX`.
 /// The probability of a 64-bit hash being exactly 0 is 2^-64 (~5.4e-20),
 /// and remapping 0 → MAX just means those two inputs collide — the same
@@ -70,6 +78,18 @@ impl<T> From<&String> for Id<T> {
     }
 }
 
+impl<T, const N: usize> From<[&[u8]; N]> for Id<T> {
+    fn from(parts: [&[u8]; N]) -> Self {
+        let mut hasher = xxh3::Xxh3Default::new();
+
+        for part in parts {
+            hasher.update(part);
+        }
+
+        Self::new(hasher.digest())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -78,6 +98,41 @@ mod tests {
     pub struct Marker;
     pub type TestId = Id<Marker>;
 
+    #[test]
+    fn from_byte_slices_matches_concatenated_string() {
+        assert_eq!(
+            TestId::from("foobar"),
+            TestId::from([b"foo".as_slice(), b"bar".as_slice()]),
+        );
+    }
+
+    #[test]
+    fn from_parts_matches_mixed_width_byte_slices() {
+        let id = 42_u64;
+        let offset = 7_u32;
+        let tag = 2_u8;
+
+        assert_eq!(
+            TestId::from([
+                id.to_le_bytes().as_slice(),
+                offset.to_le_bytes().as_slice(),
+                tag.to_le_bytes().as_slice(),
+            ]),
+            id_from_parts!(TestId; id, offset, tag),
+        );
+    }
+
+    #[test]
+    fn from_byte_slices_is_deterministic() {
+        let parts: [&[u8]; 2] = [&[1, 2, 3], &[4, 5]];
+        assert_eq!(TestId::from(parts), TestId::from(parts));
+    }
+
+    #[test]
+    fn from_byte_slices_distinguishes_inputs() {
+        assert_ne!(TestId::from([b"foo".as_slice()]), TestId::from([b"bar".as_slice()]),);
+    }
+
     #[test]
     fn test_create_hash() {
         // Same input should produce same hash (deterministic)

data/rust/rubydex/src/model/ids.rs

@@ -1,6 +1,9 @@
 use crate::{
     assert_mem_size,
-    model::{definitions::Receiver, id::Id},
+    model::{
+        definitions::Receiver,
+        id::{Id, id_from_parts},
+    },
     offset::Offset,
 };
 
@@ -27,7 +30,7 @@ assert_mem_size!(DefinitionId, 8);
 
 #[must_use]
 pub fn namespace_definition_id(uri_id: UriId, offset: &Offset, name_id: NameId) -> DefinitionId {
-    DefinitionId::from(&format!("{}{}{}", *uri_id, offset.start(), *name_id))
+    id_from_parts!(DefinitionId; uri_id.get(), offset.start(), name_id.get())
 }
 
 #[must_use]
@@ -37,14 +40,23 @@ pub fn method_definition_id(
     str_id: StringId,
     receiver: Option<&Receiver>,
 ) -> DefinitionId {
-    let mut formatted_id = format!("{}{}{}", *uri_id, offset.start(), *str_id);
-    if let Some(receiver) = receiver {
-        match receiver {
-            Receiver::SelfReceiver(def_id) => formatted_id.push_str(&def_id.to_string()),
-            Receiver::ConstantReceiver(name_id) => formatted_id.push_str(&name_id.to_string()),
-        }
+    match receiver {
+        Some(Receiver::SelfReceiver(def_id)) => id_from_parts!(
+            DefinitionId;
+            uri_id.get(),
+            offset.start(),
+            str_id.get(),
+            def_id.get(),
+        ),
+        Some(Receiver::ConstantReceiver(name_id)) => id_from_parts!(
+            DefinitionId;
+            uri_id.get(),
+            offset.start(),
+            str_id.get(),
+            name_id.get(),
+        ),
+        None => id_from_parts!(DefinitionId; uri_id.get(), offset.start(), str_id.get()),
     }
-    DefinitionId::from(&formatted_id)
 }
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]