rubydex 0.1.0.beta11 → 0.1.0.beta13

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

@@ -1,588 +1,679 @@
-use crate::assert_mem_size;
-use crate::diagnostic::Diagnostic;
-use crate::model::{
-    identity_maps::{IdentityHashMap, IdentityHashSet},
-    ids::{DeclarationId, DefinitionId, NameId, ReferenceId, StringId},
-};
-
-/// A single ancestor in the linearized ancestor chain
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Ancestor {
-    /// A complete ancestor that we have fully linearized
-    Complete(DeclarationId),
-    /// A partial ancestor that is missing linearization
-    Partial(NameId),
-}
-
-/// The ancestor chain and its current state
-#[derive(Debug, Clone)]
-pub enum Ancestors {
-    /// A complete linearization of ancestors with all parts resolved
-    Complete(Vec<Ancestor>),
-    /// A cyclic linearization of ancestors (e.g.: a module that includes itself)
-    Cyclic(Vec<Ancestor>),
-    /// A partial linearization of ancestors with some parts unresolved. This chain state always triggers retries
-    Partial(Vec<Ancestor>),
-}
-assert_mem_size!(Ancestors, 32);
-
-impl Ancestors {
-    pub fn iter(&self) -> std::slice::Iter<'_, Ancestor> {
-        match self {
-            Ancestors::Complete(ancestors) | Ancestors::Partial(ancestors) | Ancestors::Cyclic(ancestors) => {
-                ancestors.iter()
-            }
-        }
-    }
-
-    #[must_use]
-    pub fn to_partial(self) -> Self {
-        match self {
-            Ancestors::Complete(ancestors) | Ancestors::Cyclic(ancestors) | Ancestors::Partial(ancestors) => {
-                Ancestors::Partial(ancestors)
-            }
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a Ancestors {
-    type Item = &'a Ancestor;
-    type IntoIter = std::slice::Iter<'a, Ancestor>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-macro_rules! all_declarations {
-    ($value:expr, $var:ident => $expr:expr) => {
-        match $value {
-            Declaration::Namespace(Namespace::Class($var)) => $expr,
-            Declaration::Namespace(Namespace::Module($var)) => $expr,
-            Declaration::Namespace(Namespace::SingletonClass($var)) => $expr,
-            Declaration::Namespace(Namespace::Todo($var)) => $expr,
-            Declaration::Constant($var) => $expr,
-            Declaration::ConstantAlias($var) => $expr,
-            Declaration::Method($var) => $expr,
-            Declaration::GlobalVariable($var) => $expr,
-            Declaration::InstanceVariable($var) => $expr,
-            Declaration::ClassVariable($var) => $expr,
-        }
-    };
-}
-
-macro_rules! all_namespaces {
-    ($value:expr, $var:ident => $expr:expr) => {
-        match $value {
-            Namespace::Class($var) => $expr,
-            Namespace::Module($var) => $expr,
-            Namespace::SingletonClass($var) => $expr,
-            Namespace::Todo($var) => $expr,
-        }
-    };
-}
-
-/// Macro to generate a new struct for namespace-like declarations such as classes and modules
-macro_rules! namespace_declaration {
-    ($variant:ident, $name:ident) => {
-        #[derive(Debug)]
-        pub struct $name {
-            /// The fully qualified name of this declaration
-            name: String,
-            /// The list of definition IDs that compose this declaration
-            definition_ids: Vec<DefinitionId>,
-            /// The set of references that are made to this declaration
-            references: IdentityHashSet<ReferenceId>,
-            /// The ID of the owner of this declaration. For singleton classes, this is the ID of the attached object
-            owner_id: DeclarationId,
-            /// The entities that are owned by this declaration. For example, constants and methods that are defined inside of
-            /// the namespace. Note that this is a hashmap of unqualified name IDs to declaration IDs. That assists the
-            /// traversal of the graph when trying to resolve constant references or trying to discover which methods exist in a
-            /// class
-            members: IdentityHashMap<StringId, DeclarationId>,
-            /// The linearized ancestor chain for this declaration. These are the other declarations that this
-            /// declaration inherits from
-            ancestors: Ancestors,
-            /// The set of declarations that inherit from this declaration
-            descendants: IdentityHashSet<DeclarationId>,
-            /// The singleton class associated with this declaration
-            singleton_class_id: Option<DeclarationId>,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
-        }
-
-        impl $name {
-            #[must_use]
-            pub fn new(name: String, owner_id: DeclarationId) -> Self {
-                Self {
-                    name,
-                    definition_ids: Vec::new(),
-                    members: IdentityHashMap::default(),
-                    references: IdentityHashSet::default(),
-                    owner_id,
-                    ancestors: Ancestors::Partial(Vec::new()),
-                    descendants: IdentityHashSet::default(),
-                    singleton_class_id: None,
-                    diagnostics: Vec::new(),
-                }
-            }
-
-            pub fn extend(&mut self, mut other: Declaration) {
-                self.definition_ids.extend(other.definitions());
-                self.references.extend(other.references());
-                self.diagnostics.extend(other.take_diagnostics());
-
-                if let Declaration::Namespace(namespace) = other {
-                    self.members.extend(namespace.members());
-                }
-            }
-
-            pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
-                self.singleton_class_id = Some(declaration_id);
-            }
-
-            pub fn singleton_class_id(&self) -> Option<&DeclarationId> {
-                self.singleton_class_id.as_ref()
-            }
-
-            #[must_use]
-            pub fn members(&self) -> &IdentityHashMap<StringId, DeclarationId> {
-                &self.members
-            }
-
-            pub fn add_member(&mut self, string_id: StringId, declaration_id: DeclarationId) {
-                self.members.insert(string_id, declaration_id);
-            }
-
-            pub fn remove_member(&mut self, string_id: &StringId) -> Option<DeclarationId> {
-                self.members.remove(string_id)
-            }
-
-            #[must_use]
-            pub fn member(&self, string_id: &StringId) -> Option<&DeclarationId> {
-                self.members.get(string_id)
-            }
-
-            pub fn set_ancestors(&mut self, ancestors: Ancestors) {
-                self.ancestors = ancestors;
-            }
-
-            pub fn ancestors(&self) -> &Ancestors {
-                &self.ancestors
-            }
-
-            pub fn ancestors_mut(&mut self) -> &mut Ancestors {
-                &mut self.ancestors
-            }
-
-            #[must_use]
-            pub fn clone_ancestors(&self) -> Ancestors {
-                self.ancestors.clone()
-            }
-
-            #[must_use]
-            pub fn has_complete_ancestors(&self) -> bool {
-                matches!(&self.ancestors, Ancestors::Complete(_) | Ancestors::Cyclic(_))
-            }
-
-            pub fn add_descendant(&mut self, descendant_id: DeclarationId) {
-                self.descendants.insert(descendant_id);
-            }
-
-            fn remove_descendant(&mut self, descendant_id: &DeclarationId) {
-                self.descendants.remove(descendant_id);
-            }
-
-            pub fn clear_descendants(&mut self) {
-                self.descendants.clear();
-            }
-
-            pub fn descendants(&self) -> &IdentityHashSet<DeclarationId> {
-                &self.descendants
-            }
-        }
-    };
-}
-
-/// Macro to generate a new struct for simple declarations like variables and methods
-macro_rules! simple_declaration {
-    ($name:ident) => {
-        #[derive(Debug)]
-        pub struct $name {
-            /// The fully qualified name of this declaration
-            name: String,
-            /// The list of definition IDs that compose this declaration
-            definition_ids: Vec<DefinitionId>,
-            /// The set of references that are made to this declaration
-            references: IdentityHashSet<ReferenceId>,
-            /// The ID of the owner of this declaration
-            owner_id: DeclarationId,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
-        }
-
-        impl $name {
-            #[must_use]
-            pub fn new(name: String, owner_id: DeclarationId) -> Self {
-                Self {
-                    name,
-                    definition_ids: Vec::new(),
-                    references: IdentityHashSet::default(),
-                    owner_id,
-                    diagnostics: Vec::new(),
-                }
-            }
-
-            pub fn extend(&mut self, mut other: Declaration) {
-                self.definition_ids.extend(other.definitions());
-                self.references.extend(other.references());
-                self.diagnostics.extend(other.take_diagnostics());
-            }
-        }
-    };
-}
-
-/// A `Declaration` represents the global concept of an entity in Ruby. For example, the class `Foo` may be defined 3
-/// times in different files and the `Foo` declaration is the combination of all of those definitions that contribute to
-/// the same fully qualified name
-#[derive(Debug)]
-pub enum Declaration {
-    Namespace(Namespace),
-    Constant(Box<ConstantDeclaration>),
-    ConstantAlias(Box<ConstantAliasDeclaration>),
-    Method(Box<MethodDeclaration>),
-    GlobalVariable(Box<GlobalVariableDeclaration>),
-    InstanceVariable(Box<InstanceVariableDeclaration>),
-    ClassVariable(Box<ClassVariableDeclaration>),
-}
-assert_mem_size!(Declaration, 16);
-
-impl Declaration {
-    #[must_use]
-    pub fn name(&self) -> &str {
-        all_declarations!(self, it => &it.name)
-    }
-
-    #[must_use]
-    pub fn kind(&self) -> &'static str {
-        match self {
-            Declaration::Namespace(namespace) => namespace.kind(),
-            Declaration::Constant(_) => "Constant",
-            Declaration::ConstantAlias(_) => "ConstantAlias",
-            Declaration::Method(_) => "Method",
-            Declaration::GlobalVariable(_) => "GlobalVariable",
-            Declaration::InstanceVariable(_) => "InstanceVariable",
-            Declaration::ClassVariable(_) => "ClassVariable",
-        }
-    }
-
-    #[must_use]
-    pub fn as_namespace(&self) -> Option<&Namespace> {
-        match self {
-            Declaration::Namespace(namespace) => Some(namespace),
-            _ => None,
-        }
-    }
-
-    #[must_use]
-    pub fn as_namespace_mut(&mut self) -> Option<&mut Namespace> {
-        match self {
-            Declaration::Namespace(namespace) => Some(namespace),
-            _ => None,
-        }
-    }
-
-    #[must_use]
-    pub fn references(&self) -> &IdentityHashSet<ReferenceId> {
-        all_declarations!(self, it => &it.references)
-    }
-
-    #[must_use]
-    pub fn definitions(&self) -> &[DefinitionId] {
-        all_declarations!(self, it => &it.definition_ids)
-    }
-
-    #[must_use]
-    pub fn has_no_definitions(&self) -> bool {
-        all_declarations!(self, it => it.definition_ids.is_empty())
-    }
-
-    pub fn add_definition(&mut self, definition_id: DefinitionId) {
-        all_declarations!(self, it => {
-            debug_assert!(
-                !it.definition_ids.contains(&definition_id),
-                "Cannot add the same exact definition to a declaration twice. Duplicate definition IDs"
-            );
-
-            it.definition_ids.push(definition_id);
-        });
-    }
-
-    pub fn add_reference(&mut self, id: ReferenceId) {
-        all_declarations!(self, it => {
-            it.references.insert(id);
-        });
-    }
-
-    pub fn remove_reference(&mut self, reference_id: &ReferenceId) {
-        all_declarations!(self, it => {
-            it.references.remove(reference_id);
-        });
-    }
-
-    // Deletes a definition from this declaration
-    pub fn remove_definition(&mut self, definition_id: &DefinitionId) -> bool {
-        all_declarations!(self, it => {
-            if let Some(pos) = it.definition_ids.iter().position(|id| id == definition_id) {
-                it.definition_ids.swap_remove(pos);
-                it.definition_ids.shrink_to_fit();
-                true
-            } else {
-                false
-            }
-        })
-    }
-
-    #[must_use]
-    pub fn owner_id(&self) -> &DeclarationId {
-        all_declarations!(self, it => &it.owner_id)
-    }
-
-    // Splits the fully qualified name either in the last `::` or the `#` to return the simple name of this declaration
-    #[must_use]
-    pub fn unqualified_name(&self) -> String {
-        all_declarations!(self, it => {
-            let after_colons = it.name.rsplit("::").next().unwrap_or(&it.name);
-            after_colons.rsplit('#').next().unwrap_or(after_colons).to_string()
-        })
-    }
-
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_declarations!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_declarations!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
-    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
-        all_declarations!(self, it => it.diagnostics.push(diagnostic));
-    }
-
-    pub fn clear_diagnostics(&mut self) {
-        all_declarations!(self, it => it.diagnostics.clear());
-    }
-}
-
-#[derive(Debug)]
-pub enum Namespace {
-    Class(Box<ClassDeclaration>),
-    SingletonClass(Box<SingletonClassDeclaration>),
-    Module(Box<ModuleDeclaration>),
-    Todo(Box<TodoDeclaration>),
-}
-assert_mem_size!(Namespace, 16);
-
-impl Namespace {
-    #[must_use]
-    pub fn kind(&self) -> &'static str {
-        match self {
-            Namespace::Class(_) => "Class",
-            Namespace::SingletonClass(_) => "SingletonClass",
-            Namespace::Module(_) => "Module",
-            Namespace::Todo(_) => "<TODO>",
-        }
-    }
-
-    #[must_use]
-    pub fn references(&self) -> &IdentityHashSet<ReferenceId> {
-        all_namespaces!(self, it => &it.references)
-    }
-
-    #[must_use]
-    pub fn definitions(&self) -> &[DefinitionId] {
-        all_namespaces!(self, it => &it.definition_ids)
-    }
-
-    #[must_use]
-    pub fn members(&self) -> &IdentityHashMap<StringId, DeclarationId> {
-        all_namespaces!(self, it => &it.members)
-    }
-
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_namespaces!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_namespaces!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
-    pub fn extend(&mut self, other: Declaration) {
-        all_namespaces!(self, it => it.extend(other));
-    }
-
-    #[must_use]
-    pub fn ancestors(&self) -> &Ancestors {
-        all_namespaces!(self, it => it.ancestors())
-    }
-
-    #[must_use]
-    pub fn clone_ancestors(&self) -> Ancestors {
-        all_namespaces!(self, it => it.clone_ancestors())
-    }
-
-    pub fn set_ancestors(&mut self, ancestors: Ancestors) {
-        all_namespaces!(self, it => it.set_ancestors(ancestors));
-    }
-
-    #[must_use]
-    pub fn has_complete_ancestors(&self) -> bool {
-        all_namespaces!(self, it => it.has_complete_ancestors())
-    }
-
-    #[must_use]
-    pub fn descendants(&self) -> &IdentityHashSet<DeclarationId> {
-        all_namespaces!(self, it => it.descendants())
-    }
-
-    pub fn add_descendant(&mut self, descendant_id: DeclarationId) {
-        all_namespaces!(self, it => it.add_descendant(descendant_id));
-    }
-
-    pub fn remove_descendant(&mut self, descendant_id: &DeclarationId) {
-        all_namespaces!(self, it => it.remove_descendant(descendant_id));
-    }
-
-    pub fn for_each_ancestor<F>(&self, mut f: F)
-    where
-        F: FnMut(&Ancestor),
-    {
-        all_namespaces!(self, it => it.ancestors().iter().for_each(&mut f));
-    }
-
-    pub fn for_each_descendant<F>(&self, mut f: F)
-    where
-        F: FnMut(&DeclarationId),
-    {
-        all_namespaces!(self, it => it.descendants().iter().for_each(&mut f));
-    }
-
-    pub fn clear_ancestors(&mut self) {
-        all_namespaces!(self, it => it.set_ancestors(Ancestors::Partial(vec![])));
-    }
-
-    pub fn clear_descendants(&mut self) {
-        all_namespaces!(self, it => it.clear_descendants());
-    }
-
-    #[must_use]
-    pub fn member(&self, str_id: &StringId) -> Option<&DeclarationId> {
-        all_namespaces!(self, it => it.member(str_id))
-    }
-
-    pub fn remove_member(&mut self, str_id: &StringId) -> Option<DeclarationId> {
-        all_namespaces!(self, it => it.remove_member(str_id))
-    }
-
-    #[must_use]
-    pub fn singleton_class(&self) -> Option<&DeclarationId> {
-        all_namespaces!(self, it => it.singleton_class_id())
-    }
-
-    pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
-        all_namespaces!(self, it => it.set_singleton_class_id(declaration_id));
-    }
-
-    #[must_use]
-    pub fn owner_id(&self) -> &DeclarationId {
-        all_namespaces!(self, it => &it.owner_id)
-    }
-
-    #[must_use]
-    pub fn name(&self) -> &str {
-        all_namespaces!(self, it => &it.name)
-    }
-}
-
-namespace_declaration!(Class, ClassDeclaration);
-assert_mem_size!(ClassDeclaration, 216);
-namespace_declaration!(Module, ModuleDeclaration);
-assert_mem_size!(ModuleDeclaration, 216);
-namespace_declaration!(SingletonClass, SingletonClassDeclaration);
-assert_mem_size!(SingletonClassDeclaration, 216);
-namespace_declaration!(Todo, TodoDeclaration);
-assert_mem_size!(TodoDeclaration, 216);
-simple_declaration!(ConstantDeclaration);
-assert_mem_size!(ConstantDeclaration, 112);
-simple_declaration!(MethodDeclaration);
-assert_mem_size!(MethodDeclaration, 112);
-simple_declaration!(GlobalVariableDeclaration);
-assert_mem_size!(GlobalVariableDeclaration, 112);
-simple_declaration!(InstanceVariableDeclaration);
-assert_mem_size!(InstanceVariableDeclaration, 112);
-simple_declaration!(ClassVariableDeclaration);
-assert_mem_size!(ClassVariableDeclaration, 112);
-simple_declaration!(ConstantAliasDeclaration);
-assert_mem_size!(ConstantAliasDeclaration, 112);
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    #[should_panic(expected = "Cannot add the same exact definition to a declaration twice. Duplicate definition IDs")]
-    fn inserting_duplicate_definitions() {
-        let mut decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
-            "MyDecl".to_string(),
-            DeclarationId::from("Object"),
-        ))));
-        let def_id = DefinitionId::new(123);
-
-        // The second call will panic because we're adding the same exact ID twice
-        decl.add_definition(def_id);
-        decl.add_definition(def_id);
-    }
-
-    #[test]
-    fn adding_and_removing_members() {
-        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
-            "Foo".to_string(),
-            DeclarationId::from("Object"),
-        ))));
-        let member_name_id = StringId::from("Bar");
-        let member_decl_id = DeclarationId::from("Foo::Bar");
-
-        let Declaration::Namespace(Namespace::Class(mut class)) = decl else {
-            panic!("Expected a class declaration");
-        };
-        class.add_member(member_name_id, member_decl_id);
-        assert_eq!(class.members.len(), 1);
-
-        let removed = class.remove_member(&member_name_id);
-        assert_eq!(removed, Some(member_decl_id));
-        assert_eq!(class.members.len(), 0);
-    }
-
-    #[test]
-    fn unqualified_name() {
-        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
-            "Foo".to_string(),
-            DeclarationId::from("Foo"),
-        ))));
-        assert_eq!(decl.unqualified_name(), "Foo");
-
-        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
-            "Foo::Bar".to_string(),
-            DeclarationId::from("Foo"),
-        ))));
-        assert_eq!(decl.unqualified_name(), "Bar");
-
-        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
-            "Foo::Bar#baz".to_string(),
-            DeclarationId::from("Foo::Bar"),
-        ))));
-        assert_eq!(decl.unqualified_name(), "baz");
-    }
-}
+use crate::assert_mem_size;
+use crate::diagnostic::Diagnostic;
+use crate::model::ids::{
+    ClassVariableReferenceId, GlobalVariableReferenceId, InstanceVariableReferenceId, MethodReferenceId,
+};
+use crate::model::{
+    identity_maps::{IdentityHashMap, IdentityHashSet},
+    ids::{ConstantReferenceId, DeclarationId, DefinitionId, NameId, StringId},
+};
+
+/// A single ancestor in the linearized ancestor chain
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Ancestor {
+    /// A complete ancestor that we have fully linearized
+    Complete(DeclarationId),
+    /// A partial ancestor that is missing linearization
+    Partial(NameId),
+}
+
+/// The ancestor chain and its current state
+#[derive(Debug, Clone)]
+pub enum Ancestors {
+    /// A complete linearization of ancestors with all parts resolved
+    Complete(Vec<Ancestor>),
+    /// A cyclic linearization of ancestors (e.g.: a module that includes itself)
+    Cyclic(Vec<Ancestor>),
+    /// A partial linearization of ancestors with some parts unresolved. This chain state always triggers retries
+    Partial(Vec<Ancestor>),
+}
+assert_mem_size!(Ancestors, 32);
+
+impl Ancestors {
+    pub fn iter(&self) -> std::slice::Iter<'_, Ancestor> {
+        match self {
+            Ancestors::Complete(ancestors) | Ancestors::Partial(ancestors) | Ancestors::Cyclic(ancestors) => {
+                ancestors.iter()
+            }
+        }
+    }
+
+    #[must_use]
+    pub fn to_partial(self) -> Self {
+        match self {
+            Ancestors::Complete(ancestors) | Ancestors::Cyclic(ancestors) | Ancestors::Partial(ancestors) => {
+                Ancestors::Partial(ancestors)
+            }
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a Ancestors {
+    type Item = &'a Ancestor;
+    type IntoIter = std::slice::Iter<'a, Ancestor>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+macro_rules! all_declarations {
+    ($value:expr, $var:ident => $expr:expr) => {
+        match $value {
+            Declaration::Namespace(Namespace::Class($var)) => $expr,
+            Declaration::Namespace(Namespace::Module($var)) => $expr,
+            Declaration::Namespace(Namespace::SingletonClass($var)) => $expr,
+            Declaration::Namespace(Namespace::Todo($var)) => $expr,
+            Declaration::Constant($var) => $expr,
+            Declaration::ConstantAlias($var) => $expr,
+            Declaration::Method($var) => $expr,
+            Declaration::GlobalVariable($var) => $expr,
+            Declaration::InstanceVariable($var) => $expr,
+            Declaration::ClassVariable($var) => $expr,
+        }
+    };
+}
+
+macro_rules! all_namespaces {
+    ($value:expr, $var:ident => $expr:expr) => {
+        match $value {
+            Namespace::Class($var) => $expr,
+            Namespace::Module($var) => $expr,
+            Namespace::SingletonClass($var) => $expr,
+            Namespace::Todo($var) => $expr,
+        }
+    };
+}
+
+/// Macro to generate a new struct for namespace-like declarations such as classes and modules
+macro_rules! namespace_declaration {
+    ($variant:ident, $name:ident) => {
+        #[derive(Debug)]
+        pub struct $name {
+            /// The fully qualified name of this declaration
+            name: String,
+            /// The list of definition IDs that compose this declaration
+            definition_ids: Vec<DefinitionId>,
+            /// The set of references that are made to this declaration
+            references: IdentityHashSet<ConstantReferenceId>,
+            /// The ID of the owner of this declaration. For singleton classes, this is the ID of the attached object
+            owner_id: DeclarationId,
+            /// The entities that are owned by this declaration. For example, constants and methods that are defined inside of
+            /// the namespace. Note that this is a hashmap of unqualified name IDs to declaration IDs. That assists the
+            /// traversal of the graph when trying to resolve constant references or trying to discover which methods exist in a
+            /// class
+            members: IdentityHashMap<StringId, DeclarationId>,
+            /// The linearized ancestor chain for this declaration. These are the other declarations that this
+            /// declaration inherits from
+            ancestors: Ancestors,
+            /// The set of declarations that inherit from this declaration
+            descendants: IdentityHashSet<DeclarationId>,
+            /// The singleton class associated with this declaration
+            singleton_class_id: Option<DeclarationId>,
+            /// Diagnostics associated with this declaration
+            diagnostics: Vec<Diagnostic>,
+        }
+
+        impl $name {
+            #[must_use]
+            pub fn new(name: String, owner_id: DeclarationId) -> Self {
+                Self {
+                    name,
+                    definition_ids: Vec::new(),
+                    members: IdentityHashMap::default(),
+                    references: IdentityHashSet::default(),
+                    owner_id,
+                    ancestors: Ancestors::Partial(Vec::new()),
+                    descendants: IdentityHashSet::default(),
+                    singleton_class_id: None,
+                    diagnostics: Vec::new(),
+                }
+            }
+
+            pub fn extend(&mut self, mut other: Declaration) {
+                self.definition_ids.extend(other.definitions());
+                self.diagnostics.extend(other.take_diagnostics());
+
+                match other {
+                    Declaration::Namespace(namespace) => {
+                        self.members.extend(namespace.members());
+                        self.references.extend(namespace.references());
+                    }
+                    Declaration::Constant(constant) => {
+                        self.references.extend(constant.references());
+                    }
+                    Declaration::ConstantAlias(constant_alias) => {
+                        self.references.extend(constant_alias.references());
+                    }
+                    Declaration::Method(_)
+                    | Declaration::GlobalVariable(_)
+                    | Declaration::InstanceVariable(_)
+                    | Declaration::ClassVariable(_) => {
+                        panic!("Cannot extend a namespace declaration with a non-namespace declaration");
+                    }
+                }
+            }
+
+            pub fn add_reference(&mut self, reference_id: ConstantReferenceId) {
+                self.references.insert(reference_id);
+            }
+
+            pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
+                self.singleton_class_id = Some(declaration_id);
+            }
+
+            pub fn clear_singleton_class_id(&mut self) {
+                self.singleton_class_id = None;
+            }
+
+            pub fn singleton_class_id(&self) -> Option<&DeclarationId> {
+                self.singleton_class_id.as_ref()
+            }
+
+            #[must_use]
+            pub fn members(&self) -> &IdentityHashMap<StringId, DeclarationId> {
+                &self.members
+            }
+
+            pub fn add_member(&mut self, string_id: StringId, declaration_id: DeclarationId) {
+                self.members.insert(string_id, declaration_id);
+            }
+
+            pub fn remove_member(&mut self, string_id: &StringId) -> Option<DeclarationId> {
+                self.members.remove(string_id)
+            }
+
+            #[must_use]
+            pub fn member(&self, string_id: &StringId) -> Option<&DeclarationId> {
+                self.members.get(string_id)
+            }
+
+            pub fn set_ancestors(&mut self, ancestors: Ancestors) {
+                self.ancestors = ancestors;
+            }
+
+            pub fn ancestors(&self) -> &Ancestors {
+                &self.ancestors
+            }
+
+            pub fn ancestors_mut(&mut self) -> &mut Ancestors {
+                &mut self.ancestors
+            }
+
+            #[must_use]
+            pub fn clone_ancestors(&self) -> Ancestors {
+                self.ancestors.clone()
+            }
+
+            #[must_use]
+            pub fn has_complete_ancestors(&self) -> bool {
+                matches!(&self.ancestors, Ancestors::Complete(_) | Ancestors::Cyclic(_))
+            }
+
+            pub fn add_descendant(&mut self, descendant_id: DeclarationId) {
+                self.descendants.insert(descendant_id);
+            }
+
+            fn remove_descendant(&mut self, descendant_id: &DeclarationId) {
+                self.descendants.remove(descendant_id);
+            }
+
+            pub fn clear_descendants(&mut self) {
+                self.descendants.clear();
+            }
+
+            pub fn descendants(&self) -> &IdentityHashSet<DeclarationId> {
+                &self.descendants
+            }
+        }
+    };
+}
+
+/// Macro to generate a new struct for simple declarations like variables and methods
+macro_rules! simple_declaration {
+    ($name:ident, $reference_type:ty) => {
+        #[derive(Debug)]
+        pub struct $name {
+            /// The fully qualified name of this declaration
+            name: String,
+            /// The list of definition IDs that compose this declaration
+            definition_ids: Vec<DefinitionId>,
+            /// The set of references that are made to this declaration
+            references: IdentityHashSet<$reference_type>,
+            /// The ID of the owner of this declaration
+            owner_id: DeclarationId,
+            /// Diagnostics associated with this declaration
+            diagnostics: Vec<Diagnostic>,
+        }
+
+        impl $name {
+            #[must_use]
+            pub fn new(name: String, owner_id: DeclarationId) -> Self {
+                Self {
+                    name,
+                    definition_ids: Vec::new(),
+                    references: IdentityHashSet::default(),
+                    owner_id,
+                    diagnostics: Vec::new(),
+                }
+            }
+
+            pub fn extend(&mut self, mut other: $name) {
+                self.definition_ids.extend(other.definitions());
+                self.diagnostics.extend(other.take_diagnostics());
+                self.references.extend(other.references());
+            }
+
+            #[must_use]
+            pub fn references(&self) -> &IdentityHashSet<$reference_type> {
+                &self.references
+            }
+
+            pub fn add_reference(&mut self, reference_id: $reference_type) {
+                self.references.insert(reference_id);
+            }
+
+            pub fn remove_reference(&mut self, reference_id: &$reference_type) {
+                self.references.remove(reference_id);
+            }
+
+            pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
+                std::mem::take(&mut self.diagnostics)
+            }
+
+            #[must_use]
+            pub fn definitions(&self) -> &[DefinitionId] {
+                &self.definition_ids
+            }
+        }
+    };
+}
+
+/// A `Declaration` represents the global concept of an entity in Ruby. For example, the class `Foo` may be defined 3
+/// times in different files and the `Foo` declaration is the combination of all of those definitions that contribute to
+/// the same fully qualified name
+#[derive(Debug)]
+pub enum Declaration {
+    Namespace(Namespace),
+    Constant(Box<ConstantDeclaration>),
+    ConstantAlias(Box<ConstantAliasDeclaration>),
+    Method(Box<MethodDeclaration>),
+    GlobalVariable(Box<GlobalVariableDeclaration>),
+    InstanceVariable(Box<InstanceVariableDeclaration>),
+    ClassVariable(Box<ClassVariableDeclaration>),
+}
+assert_mem_size!(Declaration, 16);
+
+impl Declaration {
+    #[must_use]
+    pub fn name(&self) -> &str {
+        all_declarations!(self, it => &it.name)
+    }
+
+    #[must_use]
+    pub fn kind(&self) -> &'static str {
+        match self {
+            Declaration::Namespace(namespace) => namespace.kind(),
+            Declaration::Constant(_) => "Constant",
+            Declaration::ConstantAlias(_) => "ConstantAlias",
+            Declaration::Method(_) => "Method",
+            Declaration::GlobalVariable(_) => "GlobalVariable",
+            Declaration::InstanceVariable(_) => "InstanceVariable",
+            Declaration::ClassVariable(_) => "ClassVariable",
+        }
+    }
+
+    #[must_use]
+    pub fn as_namespace(&self) -> Option<&Namespace> {
+        match self {
+            Declaration::Namespace(namespace) => Some(namespace),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn as_namespace_mut(&mut self) -> Option<&mut Namespace> {
+        match self {
+            Declaration::Namespace(namespace) => Some(namespace),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn definitions(&self) -> &[DefinitionId] {
+        all_declarations!(self, it => &it.definition_ids)
+    }
+
+    #[must_use]
+    pub fn has_no_definitions(&self) -> bool {
+        all_declarations!(self, it => it.definition_ids.is_empty())
+    }
+
+    pub fn add_definition(&mut self, definition_id: DefinitionId) {
+        all_declarations!(self, it => {
+            debug_assert!(
+                !it.definition_ids.contains(&definition_id),
+                "Cannot add the same exact definition to a declaration twice. Duplicate definition IDs"
+            );
+
+            it.definition_ids.push(definition_id);
+        });
+    }
+
+    // Deletes a definition from this declaration
+    pub fn remove_definition(&mut self, definition_id: &DefinitionId) -> bool {
+        all_declarations!(self, it => {
+            if let Some(pos) = it.definition_ids.iter().position(|id| id == definition_id) {
+                it.definition_ids.swap_remove(pos);
+                it.definition_ids.shrink_to_fit();
+                true
+            } else {
+                false
+            }
+        })
+    }
+
+    #[must_use]
+    pub fn owner_id(&self) -> &DeclarationId {
+        all_declarations!(self, it => &it.owner_id)
+    }
+
+    // Splits the fully qualified name either in the last `::` or the `#` to return the simple name of this declaration
+    #[must_use]
+    pub fn unqualified_name(&self) -> String {
+        all_declarations!(self, it => {
+            let after_colons = it.name.rsplit("::").next().unwrap_or(&it.name);
+            after_colons.rsplit('#').next().unwrap_or(after_colons).to_string()
+        })
+    }
+
+    #[must_use]
+    pub fn diagnostics(&self) -> &[Diagnostic] {
+        all_declarations!(self, it => &it.diagnostics)
+    }
+
+    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
+        all_declarations!(self, it => std::mem::take(&mut it.diagnostics))
+    }
+
+    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
+        all_declarations!(self, it => it.diagnostics.push(diagnostic));
+    }
+
+    pub fn clear_diagnostics(&mut self) {
+        all_declarations!(self, it => it.diagnostics.clear());
+    }
+
+    #[must_use]
+    pub fn reference_count(&self) -> usize {
+        all_declarations!(self, it => it.references.len())
+    }
+
+    /// Returns the constant reference IDs for declarations that track constant references (`Namespace`, `Constant`,
+    /// `ConstantAlias`). Returns `None` for other declaration types.
+    #[must_use]
+    pub fn constant_references(&self) -> Option<&IdentityHashSet<ConstantReferenceId>> {
+        match self {
+            Declaration::Namespace(it) => Some(it.references()),
+            Declaration::Constant(it) => Some(it.references()),
+            Declaration::ConstantAlias(it) => Some(it.references()),
+            _ => None,
+        }
+    }
+
+    /// Adds a constant reference to this declaration.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called on a declaration that doesn't track constant references.
+    pub fn add_constant_reference(&mut self, reference_id: ConstantReferenceId) {
+        match self {
+            Declaration::Namespace(it) => it.add_reference(reference_id),
+            Declaration::Constant(it) => it.add_reference(reference_id),
+            Declaration::ConstantAlias(it) => it.add_reference(reference_id),
+            _ => unreachable!("Cannot add constant reference to {} declaration", self.kind()),
+        }
+    }
+
+    /// Removes a constant reference from this declaration.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called on a declaration that doesn't track constant references.
+    pub fn remove_constant_reference(&mut self, reference_id: &ConstantReferenceId) {
+        match self {
+            Declaration::Namespace(it) => it.remove_reference(reference_id),
+            Declaration::Constant(it) => it.remove_reference(reference_id),
+            Declaration::ConstantAlias(it) => it.remove_reference(reference_id),
+            _ => unreachable!("Cannot remove constant reference from {} declaration", self.kind()),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum Namespace {
+    Class(Box<ClassDeclaration>),
+    SingletonClass(Box<SingletonClassDeclaration>),
+    Module(Box<ModuleDeclaration>),
+    Todo(Box<TodoDeclaration>),
+}
+assert_mem_size!(Namespace, 16);
+
+impl Namespace {
+    #[must_use]
+    pub fn kind(&self) -> &'static str {
+        match self {
+            Namespace::Class(_) => "Class",
+            Namespace::SingletonClass(_) => "SingletonClass",
+            Namespace::Module(_) => "Module",
+            Namespace::Todo(_) => "<TODO>",
+        }
+    }
+
+    #[must_use]
+    pub fn references(&self) -> &IdentityHashSet<ConstantReferenceId> {
+        all_namespaces!(self, it => &it.references)
+    }
+
+    pub fn remove_reference(&mut self, reference_id: &ConstantReferenceId) {
+        all_namespaces!(self, it => {
+            it.references.remove(reference_id);
+        });
+    }
+
+    pub fn add_reference(&mut self, reference_id: ConstantReferenceId) {
+        all_namespaces!(self, it => {
+            it.references.insert(reference_id);
+        });
+    }
+
+    #[must_use]
+    pub fn definitions(&self) -> &[DefinitionId] {
+        all_namespaces!(self, it => &it.definition_ids)
+    }
+
+    #[must_use]
+    pub fn members(&self) -> &IdentityHashMap<StringId, DeclarationId> {
+        all_namespaces!(self, it => &it.members)
+    }
+
+    #[must_use]
+    pub fn diagnostics(&self) -> &[Diagnostic] {
+        all_namespaces!(self, it => &it.diagnostics)
+    }
+
+    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
+        all_namespaces!(self, it => std::mem::take(&mut it.diagnostics))
+    }
+
+    pub fn extend(&mut self, other: Declaration) {
+        all_namespaces!(self, it => it.extend(other));
+    }
+
+    #[must_use]
+    pub fn ancestors(&self) -> &Ancestors {
+        all_namespaces!(self, it => it.ancestors())
+    }
+
+    #[must_use]
+    pub fn clone_ancestors(&self) -> Ancestors {
+        all_namespaces!(self, it => it.clone_ancestors())
+    }
+
+    pub fn set_ancestors(&mut self, ancestors: Ancestors) {
+        all_namespaces!(self, it => it.set_ancestors(ancestors));
+    }
+
+    #[must_use]
+    pub fn has_complete_ancestors(&self) -> bool {
+        all_namespaces!(self, it => it.has_complete_ancestors())
+    }
+
+    #[must_use]
+    pub fn descendants(&self) -> &IdentityHashSet<DeclarationId> {
+        all_namespaces!(self, it => it.descendants())
+    }
+
+    pub fn add_descendant(&mut self, descendant_id: DeclarationId) {
+        all_namespaces!(self, it => it.add_descendant(descendant_id));
+    }
+
+    pub fn remove_descendant(&mut self, descendant_id: &DeclarationId) {
+        all_namespaces!(self, it => it.remove_descendant(descendant_id));
+    }
+
+    pub fn for_each_ancestor<F>(&self, mut f: F)
+    where
+        F: FnMut(&Ancestor),
+    {
+        all_namespaces!(self, it => it.ancestors().iter().for_each(&mut f));
+    }
+
+    pub fn for_each_descendant<F>(&self, mut f: F)
+    where
+        F: FnMut(&DeclarationId),
+    {
+        all_namespaces!(self, it => it.descendants().iter().for_each(&mut f));
+    }
+
+    pub fn clear_ancestors(&mut self) {
+        all_namespaces!(self, it => it.set_ancestors(Ancestors::Partial(vec![])));
+    }
+
+    pub fn clear_descendants(&mut self) {
+        all_namespaces!(self, it => it.clear_descendants());
+    }
+
+    #[must_use]
+    pub fn member(&self, str_id: &StringId) -> Option<&DeclarationId> {
+        all_namespaces!(self, it => it.member(str_id))
+    }
+
+    pub fn remove_member(&mut self, str_id: &StringId) -> Option<DeclarationId> {
+        all_namespaces!(self, it => it.remove_member(str_id))
+    }
+
+    #[must_use]
+    pub fn singleton_class(&self) -> Option<&DeclarationId> {
+        all_namespaces!(self, it => it.singleton_class_id())
+    }
+
+    pub fn set_singleton_class_id(&mut self, declaration_id: DeclarationId) {
+        all_namespaces!(self, it => it.set_singleton_class_id(declaration_id));
+    }
+
+    pub fn clear_singleton_class_id(&mut self) {
+        all_namespaces!(self, it => it.clear_singleton_class_id());
+    }
+
+    #[must_use]
+    pub fn owner_id(&self) -> &DeclarationId {
+        all_namespaces!(self, it => &it.owner_id)
+    }
+
+    #[must_use]
+    pub fn name(&self) -> &str {
+        all_namespaces!(self, it => &it.name)
+    }
+}
+
+namespace_declaration!(Class, ClassDeclaration);
+assert_mem_size!(ClassDeclaration, 216);
+namespace_declaration!(Module, ModuleDeclaration);
+assert_mem_size!(ModuleDeclaration, 216);
+namespace_declaration!(SingletonClass, SingletonClassDeclaration);
+assert_mem_size!(SingletonClassDeclaration, 216);
+namespace_declaration!(Todo, TodoDeclaration);
+assert_mem_size!(TodoDeclaration, 216);
+simple_declaration!(ConstantDeclaration, ConstantReferenceId);
+assert_mem_size!(ConstantDeclaration, 112);
+simple_declaration!(MethodDeclaration, MethodReferenceId);
+assert_mem_size!(MethodDeclaration, 112);
+simple_declaration!(GlobalVariableDeclaration, GlobalVariableReferenceId);
+assert_mem_size!(GlobalVariableDeclaration, 112);
+simple_declaration!(InstanceVariableDeclaration, InstanceVariableReferenceId);
+assert_mem_size!(InstanceVariableDeclaration, 112);
+simple_declaration!(ClassVariableDeclaration, ClassVariableReferenceId);
+assert_mem_size!(ClassVariableDeclaration, 112);
+simple_declaration!(ConstantAliasDeclaration, ConstantReferenceId);
+assert_mem_size!(ConstantAliasDeclaration, 112);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "Cannot add the same exact definition to a declaration twice. Duplicate definition IDs")]
+    fn inserting_duplicate_definitions() {
+        let mut decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "MyDecl".to_string(),
+            DeclarationId::from("Object"),
+        ))));
+        let def_id = DefinitionId::new(123);
+
+        // The second call will panic because we're adding the same exact ID twice
+        decl.add_definition(def_id);
+        decl.add_definition(def_id);
+    }
+
+    #[test]
+    fn adding_and_removing_members() {
+        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Foo".to_string(),
+            DeclarationId::from("Object"),
+        ))));
+        let member_name_id = StringId::from("Bar");
+        let member_decl_id = DeclarationId::from("Foo::Bar");
+
+        let Declaration::Namespace(Namespace::Class(mut class)) = decl else {
+            panic!("Expected a class declaration");
+        };
+        class.add_member(member_name_id, member_decl_id);
+        assert_eq!(class.members.len(), 1);
+
+        let removed = class.remove_member(&member_name_id);
+        assert_eq!(removed, Some(member_decl_id));
+        assert_eq!(class.members.len(), 0);
+    }
+
+    #[test]
+    fn unqualified_name() {
+        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Foo".to_string(),
+            DeclarationId::from("Foo"),
+        ))));
+        assert_eq!(decl.unqualified_name(), "Foo");
+
+        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Foo::Bar".to_string(),
+            DeclarationId::from("Foo"),
+        ))));
+        assert_eq!(decl.unqualified_name(), "Bar");
+
+        let decl = Declaration::Namespace(Namespace::Class(Box::new(ClassDeclaration::new(
+            "Foo::Bar#baz".to_string(),
+            DeclarationId::from("Foo::Bar"),
+        ))));
+        assert_eq!(decl.unqualified_name(), "baz");
+    }
+}