Provide resolution diagnostics

rust/rubydex/src/diagnostic.rs

@@ -105,4 +105,10 @@ rules! {
     TopLevelMixinSelf;
 
     // Resolution
+    KindRedefinition;
+    ParentRedefinition;
+    NonClassSuperclass;
+    CircularDependency;
+    NonModuleMixin;
+    UnresolvedConstantReference;
 }

rust/rubydex/src/model/declaration.rs

@@ -1,4 +1,5 @@
 use crate::model::{
+    definitions::DefinitionKind,
     identity_maps::{IdentityHashMap, IdentityHashSet},
     ids::{DeclarationId, DefinitionId, NameId, ReferenceId, StringId},
 };
@@ -51,6 +52,56 @@ impl<'a> IntoIterator for &'a Ancestors {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DeclarationKind {
+    Class,
+    SingletonClass,
+    Module,
+    Constant,
+    ConstantAlias,
+    Method,
+    GlobalVariable,
+    InstanceVariable,
+    ClassVariable,
+}
+
+impl DeclarationKind {
+    #[must_use]
+    pub fn from_definition_kind(definition_kind: DefinitionKind) -> Self {
+        match definition_kind {
+            DefinitionKind::Class => DeclarationKind::Class,
+            DefinitionKind::SingletonClass => DeclarationKind::SingletonClass,
+            DefinitionKind::Module => DeclarationKind::Module,
+            DefinitionKind::Constant => DeclarationKind::Constant,
+            DefinitionKind::ConstantAlias => DeclarationKind::ConstantAlias,
+            DefinitionKind::Method
+            | DefinitionKind::MethodAlias
+            | DefinitionKind::AttrAccessor
+            | DefinitionKind::AttrReader
+            | DefinitionKind::AttrWriter => DeclarationKind::Method,
+            DefinitionKind::InstanceVariable => DeclarationKind::InstanceVariable,
+            DefinitionKind::ClassVariable => DeclarationKind::ClassVariable,
+            DefinitionKind::GlobalVariable | DefinitionKind::GlobalVariableAlias => DeclarationKind::GlobalVariable,
+        }
+    }
+}
+
+impl std::fmt::Display for DeclarationKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DeclarationKind::Class => write!(f, "class"),
+            DeclarationKind::SingletonClass => write!(f, "singleton class"),
+            DeclarationKind::Module => write!(f, "module"),
+            DeclarationKind::Constant => write!(f, "constant"),
+            DeclarationKind::ConstantAlias => write!(f, "constant alias"),
+            DeclarationKind::Method => write!(f, "method"),
+            DeclarationKind::GlobalVariable => write!(f, "global variable"),
+            DeclarationKind::InstanceVariable => write!(f, "instance variable"),
+            DeclarationKind::ClassVariable => write!(f, "class variable"),
+        }
+    }
+}
+
 macro_rules! all_declarations {
     ($value:expr, $var:ident => $expr:expr) => {
         match $value {
@@ -247,15 +298,15 @@ impl Declaration {
     }
 
     #[must_use]
-    pub fn kind(&self) -> &'static str {
+    pub fn kind(&self) -> DeclarationKind {
         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",
+            Declaration::Constant(_) => DeclarationKind::Constant,
+            Declaration::ConstantAlias(_) => DeclarationKind::ConstantAlias,
+            Declaration::Method(_) => DeclarationKind::Method,
+            Declaration::GlobalVariable(_) => DeclarationKind::GlobalVariable,
+            Declaration::InstanceVariable(_) => DeclarationKind::InstanceVariable,
+            Declaration::ClassVariable(_) => DeclarationKind::ClassVariable,
         }
     }
 
@@ -350,11 +401,11 @@ pub enum Namespace {
 
 impl Namespace {
     #[must_use]
-    pub fn kind(&self) -> &'static str {
+    pub fn kind(&self) -> DeclarationKind {
         match self {
-            Namespace::Class(_) => "Class",
-            Namespace::SingletonClass(_) => "SingletonClass",
-            Namespace::Module(_) => "Module",
+            Namespace::Class(_) => DeclarationKind::Class,
+            Namespace::SingletonClass(_) => DeclarationKind::SingletonClass,
+            Namespace::Module(_) => DeclarationKind::Module,
         }
     }
 

rust/rubydex/src/model/definitions.rs

@@ -49,6 +49,45 @@ impl DefinitionFlags {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum DefinitionKind {
+    Class,
+    SingletonClass,
+    Module,
+    Constant,
+    ConstantAlias,
+    GlobalVariable,
+    InstanceVariable,
+    ClassVariable,
+    AttrAccessor,
+    AttrReader,
+    AttrWriter,
+    Method,
+    MethodAlias,
+    GlobalVariableAlias,
+}
+
+impl std::fmt::Display for DefinitionKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DefinitionKind::Class => write!(f, "class"),
+            DefinitionKind::SingletonClass => write!(f, "singleton class"),
+            DefinitionKind::Module => write!(f, "module"),
+            DefinitionKind::Constant => write!(f, "constant"),
+            DefinitionKind::ConstantAlias => write!(f, "constant alias"),
+            DefinitionKind::Method => write!(f, "method"),
+            DefinitionKind::AttrAccessor => write!(f, "attr_accessor"),
+            DefinitionKind::AttrReader => write!(f, "attr_reader"),
+            DefinitionKind::AttrWriter => write!(f, "attr_writer"),
+            DefinitionKind::GlobalVariable => write!(f, "global variable"),
+            DefinitionKind::InstanceVariable => write!(f, "instance variable"),
+            DefinitionKind::ClassVariable => write!(f, "class variable"),
+            DefinitionKind::MethodAlias => write!(f, "method alias"),
+            DefinitionKind::GlobalVariableAlias => write!(f, "global variable alias"),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum Definition {
     Class(Box<ClassDefinition>),
@@ -115,22 +154,22 @@ impl Definition {
     }
 
     #[must_use]
-    pub fn kind(&self) -> &'static str {
+    pub fn kind(&self) -> DefinitionKind {
         match self {
-            Definition::Class(_) => "Class",
-            Definition::SingletonClass(_) => "SingletonClass",
-            Definition::Module(_) => "Module",
-            Definition::Constant(_) => "Constant",
-            Definition::ConstantAlias(_) => "ConstantAlias",
-            Definition::Method(_) => "Method",
-            Definition::AttrAccessor(_) => "AttrAccessor",
-            Definition::AttrReader(_) => "AttrReader",
-            Definition::AttrWriter(_) => "AttrWriter",
-            Definition::GlobalVariable(_) => "GlobalVariable",
-            Definition::InstanceVariable(_) => "InstanceVariable",
-            Definition::ClassVariable(_) => "ClassVariable",
-            Definition::MethodAlias(_) => "AliasMethod",
-            Definition::GlobalVariableAlias(_) => "GlobalVariableAlias",
+            Definition::Class(_) => DefinitionKind::Class,
+            Definition::SingletonClass(_) => DefinitionKind::SingletonClass,
+            Definition::Module(_) => DefinitionKind::Module,
+            Definition::Constant(_) => DefinitionKind::Constant,
+            Definition::ConstantAlias(_) => DefinitionKind::ConstantAlias,
+            Definition::Method(_) => DefinitionKind::Method,
+            Definition::AttrAccessor(_) => DefinitionKind::AttrAccessor,
+            Definition::AttrReader(_) => DefinitionKind::AttrReader,
+            Definition::AttrWriter(_) => DefinitionKind::AttrWriter,
+            Definition::GlobalVariable(_) => DefinitionKind::GlobalVariable,
+            Definition::InstanceVariable(_) => DefinitionKind::InstanceVariable,
+            Definition::ClassVariable(_) => DefinitionKind::ClassVariable,
+            Definition::MethodAlias(_) => DefinitionKind::MethodAlias,
+            Definition::GlobalVariableAlias(_) => DefinitionKind::GlobalVariableAlias,
         }
     }
 

rust/rubydex/src/model/graph.rs

@@ -3,8 +3,8 @@ use std::sync::LazyLock;
 
 use crate::diagnostic::Diagnostic;
 use crate::indexing::local_graph::LocalGraph;
-use crate::model::declaration::{Ancestor, Declaration, Namespace};
-use crate::model::definitions::Definition;
+use crate::model::declaration::{Ancestor, Declaration, DeclarationKind, Namespace};
+use crate::model::definitions::{Definition, DefinitionKind};
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
@@ -172,11 +172,18 @@ impl Graph {
         &self.method_references
     }
 
+    // Diagnostics
+
     #[must_use]
     pub fn diagnostics(&self) -> &Vec<Diagnostic> {
         &self.diagnostics
     }
 
+    #[must_use]
+    pub fn diagnostics_mut(&mut self) -> &mut Vec<Diagnostic> {
+        &mut self.diagnostics
+    }
+
     /// Interns a string in the graph unless already interned. This method is only used to back the
     /// `Graph#resolve_constant` Ruby API because every string must be interned in the graph to properly resolve.
     pub fn intern_string(&mut self, string: String) -> StringId {
@@ -608,8 +615,8 @@ impl Graph {
 
         let mut declarations_with_docs = 0;
         let mut total_doc_size = 0;
-        let mut declarations_types: HashMap<&str, usize> = HashMap::new();
-        let mut definition_types: HashMap<&str, usize> = HashMap::new();
+        let mut declarations_types: HashMap<DeclarationKind, usize> = HashMap::new();
+        let mut definition_types: HashMap<DefinitionKind, usize> = HashMap::new();
         let mut multi_definition_count = 0;
 
         for declaration in self.declarations.values() {
@@ -664,15 +671,15 @@ impl Graph {
         let mut types: Vec<_> = declarations_types.iter().collect();
         types.sort_by_key(|(_, count)| std::cmp::Reverse(**count));
         for (kind, count) in types {
-            println!("  {kind:20} {count:6}");
+            println!("  {kind:20} {count:6}", kind = kind.to_string());
         }
 
         println!();
         println!("Definition breakdown:");
         let mut types: Vec<_> = definition_types.iter().collect();
         types.sort_by_key(|(_, count)| std::cmp::Reverse(**count));
         for (kind, count) in types {
-            println!("  {kind:20} {count:6}");
+            println!("  {kind:20} {count:6}", kind = kind.to_string());
         }
     }
 }