rubydex 0.1.0.beta12-aarch64-linux

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

@@ -0,0 +1,671 @@
+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 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));
+    }
+
+    #[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");
+    }
+}