rubydex 0.2.1 → 0.2.2

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

@@ -40,6 +40,7 @@ bitflags! {
     pub struct DefinitionFlags: u8 {
         const DEPRECATED = 0b0001;
         const PROMOTABLE = 0b0010;
+        const SINGLETON_METHOD_VISIBILITY = 0b0100;
     }
 }
 
@@ -53,6 +54,11 @@ impl DefinitionFlags {
     pub fn is_promotable(&self) -> bool {
         self.contains(Self::PROMOTABLE)
     }
+
+    #[must_use]
+    pub fn is_singleton_method_visibility(&self) -> bool {
+        self.contains(Self::SINGLETON_METHOD_VISIBILITY)
+    }
 }
 
 #[derive(Debug)]
@@ -1033,6 +1039,23 @@ pub enum Parameter {
 }
 assert_mem_size!(Parameter, 24);
 
+impl Parameter {
+    #[must_use]
+    pub fn inner(&self) -> &ParameterStruct {
+        match self {
+            Parameter::RequiredPositional(s)
+            | Parameter::OptionalPositional(s)
+            | Parameter::RestPositional(s)
+            | Parameter::Post(s)
+            | Parameter::RequiredKeyword(s)
+            | Parameter::OptionalKeyword(s)
+            | Parameter::RestKeyword(s)
+            | Parameter::Forward(s)
+            | Parameter::Block(s) => s,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct ParameterStruct {
     offset: Offset,

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

@@ -6,7 +6,7 @@ use crate::diagnostic::Diagnostic;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
 use crate::model::declaration::{Ancestor, Declaration, Namespace};
-use crate::model::definitions::{Definition, Receiver};
+use crate::model::definitions::{Definition, MethodVisibilityDefinition, Receiver};
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
@@ -333,10 +333,15 @@ impl Graph {
                     .or_else(|| self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref())),
                 it.target(),
             ),
-            Definition::MethodVisibility(it) => (
-                self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                it.str_id(),
-            ),
+            Definition::MethodVisibility(it) => {
+                if it.flags().is_singleton_method_visibility() {
+                    return self.find_singleton_method_visibility_declaration(it);
+                }
+                (
+                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                    it.str_id(),
+                )
+            }
             Definition::GlobalVariable(it) => (
                 self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
                 it.str_id(),
@@ -375,13 +380,15 @@ impl Graph {
                 )
             }
             Definition::MethodAlias(it) => {
-                if let Some(Receiver::SelfReceiver(def_id)) = it.receiver() {
-                    return self.find_self_receiver_declaration(*def_id, *it.new_name_str_id());
-                }
-                (
-                    self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
-                    it.new_name_str_id(),
-                )
+                let nesting_name_id = match it.receiver() {
+                    Some(Receiver::SelfReceiver(def_id)) => {
+                        return self.find_self_receiver_declaration(*def_id, *it.new_name_str_id());
+                    }
+                    Some(Receiver::ConstantReceiver(name_id)) => Some(name_id),
+                    None => self.find_enclosing_namespace_name_id(it.lexical_nesting_id().as_ref()),
+                };
+
+                (nesting_name_id, it.new_name_str_id())
             }
         };
 
@@ -413,6 +420,27 @@ impl Graph {
         None
     }
 
+    /// Looks up the declaration for a singleton method visibility through the singleton class.
+    fn find_singleton_method_visibility_declaration(
+        &self,
+        definition: &MethodVisibilityDefinition,
+    ) -> Option<&DeclarationId> {
+        let nesting_name_id = self.find_enclosing_namespace_name_id(definition.lexical_nesting_id().as_ref());
+        let nesting_declaration_id = match nesting_name_id {
+            Some(name_id) => self.name_id_to_declaration_id(*name_id),
+            None => Some(&*OBJECT_ID),
+        }?;
+        let singleton_id = self
+            .declarations
+            .get(nesting_declaration_id)?
+            .as_namespace()?
+            .singleton_class()?;
+        self.declarations
+            .get(singleton_id)?
+            .as_namespace()?
+            .member(definition.str_id())
+    }
+
     /// Looks up the declaration for a `SelfReceiver` method/alias through the singleton class.
     fn find_self_receiver_declaration(&self, def_id: DefinitionId, member_str_id: StringId) -> Option<&DeclarationId> {
         let owner_decl_id = self.definition_id_to_declaration_id(def_id)?;