feat: add more entities

Signed-off-by: Rithul Kamesh <hi@rithul.dev>

Author: rithulkamesh

src/entities/attr.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct RustAttribute {
     pub name: String,
     pub arguments: Vec<String>,

src/entities/callable.rs

@@ -10,7 +10,7 @@ use super::{
 };
 
 /// Represents a Rust function or method.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct RustCallable {
     /// The name of the function or method.
     pub name: String,

src/entities/callsite.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use super::rtype::RustType;
 
 /// Represents a location where a function is called.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
 pub struct CallSite {
     /// The line number where the function is called
     pub line_number: u32,

src/entities/lifetime.rs

@@ -4,7 +4,7 @@ use std::vec::Vec;
 ///
 /// This struct holds information about a lifetime parameter, including its name
 /// and any bounds associated with it.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustLifetimeParam {
     /// The name of the lifetime parameter (e.g., 'a, 'b)
     pub name: String,

src/entities/mod.rs

@@ -3,10 +3,15 @@ pub mod callable;
 pub mod callsite;
 pub mod lifetime;
 pub mod param;
+pub mod renum;
+pub mod rimpl;
+pub mod rmacro;
+pub mod rstruct;
+pub mod rtrait;
 pub mod rtype;
 pub mod safety;
 pub mod variables;
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RustVisibility {
     Public,
     Private,
@@ -27,7 +32,7 @@ impl RustVisibility {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SafetyClassification {
     Safe,
     Unsafe,
@@ -65,7 +70,7 @@ impl SafetyClassification {
 /// let reason = UnsafeReason::RawPointerDeref;
 /// assert_eq!(reason.as_str(), "raw_pointer_deref");
 /// ```
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum UnsafeReason {
     RawPointerDeref,
     MutableStatic,
@@ -110,7 +115,7 @@ impl UnsafeReason {
 /// - `Normal`: A regular struct with named fields.
 /// - `Tuple`: A tuple struct with unnamed fields.
 /// - `Unit`: A unit struct without any fields.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RustStructKind {
     /// Regular struct with named fields.
     Normal,

src/entities/param.rs

@@ -4,7 +4,7 @@ use crate::entities::rtype::RustType;
 ///
 /// This struct holds information about a generic parameter, including its name,
 /// trait bounds, default type (if any), and whether it's a const generic.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustGenericParam {
     /// The name of the generic parameter
     pub name: String,
@@ -32,7 +32,7 @@ impl RustGenericParam {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustParameter {
     /// Name of the parameter
     pub name: String,

src/entities/renum.rs

@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+
+use super::{
+    attr::RustAttribute, callable::RustCallable, lifetime::RustLifetimeParam,
+    param::RustGenericParam, rstruct::RustStructField, rtype::RustType, *,
+};
+
+/// Represents a Rust enum.
+#[derive(Debug, Clone)]
+pub struct RustEnum {
+    /// The name of the enum.
+    pub name: String,
+    /// The visibility of the enum.
+    pub visibility: RustVisibility,
+    /// Optional documentation comment.
+    pub doc_comment: Option<String>,
+    /// Attributes associated with the enum.
+    pub attributes: Vec<RustAttribute>,
+    /// Variants defined for the enum.
+    pub variants: Vec<RustEnumVariant>,
+    /// Generic parameters.
+    pub generic_params: Vec<RustGenericParam>,
+    /// Lifetime parameters.
+    pub lifetime_params: Vec<RustLifetimeParam>,
+    /// Where clauses.
+    pub where_clauses: Vec<String>,
+    /// Traits to derive.
+    pub derives: Vec<String>,
+    /// Associated items mapped by their name.
+    pub associated_items: HashMap<String, RustCallable>,
+    /// Traits implemented for the enum.
+    pub impl_traits: Vec<String>,
+    /// Indicates if the enum is public.
+    pub is_public: bool,
+    /// The starting line in the source file.
+    pub start_line: i32,
+    /// The ending line in the source file.
+    pub end_line: i32,
+}
+
+/// Represents a variant in a Rust enum.
+#[derive(Debug, Clone)]
+pub struct RustEnumVariant {
+    /// The name of the variant.
+    pub name: String,
+    /// Fields for a struct variant.
+    pub fields: Option<Vec<RustStructField>>,
+    /// Types for a tuple variant.
+    pub tuple_types: Option<Vec<RustType>>,
+    /// Explicit discriminant for the variant.
+    pub discriminant: Option<String>,
+    /// Optional documentation comment.
+    pub doc_comment: Option<String>,
+    /// Attributes associated with the variant.
+    pub attributes: Vec<RustAttribute>,
+}

src/entities/rimpl.rs

@@ -0,0 +1,34 @@
+use std::collections::HashMap;
+
+use super::{
+    callable::RustCallable, lifetime::RustLifetimeParam, param::RustGenericParam, rtype::RustType,
+};
+
+/// Represents a Rust impl block.
+#[derive(Debug, Clone)]
+pub struct RustImpl {
+    /// The type name that the impl block is for.
+    pub type_name: String,
+    /// Optional trait name; None for inherent impls.
+    pub trait_name: Option<String>,
+    /// Generic parameters of the impl.
+    pub generic_params: Vec<RustGenericParam>,
+    /// Lifetime parameters of the impl.
+    pub lifetime_params: Vec<RustLifetimeParam>,
+    /// Where clauses associated with the impl.
+    pub where_clauses: Vec<String>,
+    /// Methods in the impl; the key is the method name.
+    pub methods: HashMap<String, RustCallable>,
+    /// Associated types defined in the impl.
+    pub associated_types: HashMap<String, RustType>,
+    /// Associated constants defined in the impl.
+    pub associated_consts: HashMap<String, String>,
+    /// Whether the impl is marked as unsafe.
+    pub is_unsafe: bool,
+    /// Whether the impl is a negative impl (e.g., `!Send`).
+    pub is_negative: bool,
+    /// The starting line number of the impl block in the source.
+    pub start_line: usize,
+    /// The ending line number of the impl block in the source.
+    pub end_line: usize,
+}

src/entities/rmacro.rs

@@ -0,0 +1,61 @@
+use super::{RustVisibility, attr::RustAttribute};
+
+/// Represents a Rust macro definition.
+///
+/// This struct encapsulates details about a macro defined
+/// in Rust source code. It contains the macro's name, visibility,
+/// documentation comment, any attributes associated with it,
+/// its defining rules, and metadata regarding its type and location.
+#[derive(Debug, Clone)]
+pub struct RustMacro {
+    /// The name of the macro.
+    pub name: String,
+    /// The visibility of the macro (e.g., public or private).
+    pub visibility: RustVisibility,
+    /// An optional documentation comment for the macro.
+    pub doc_comment: Option<String>,
+    /// Attributes applied to the macro, such as annotations.
+    pub attributes: Vec<RustAttribute>,
+    /// Rules or tokens that define the macro's behavior.
+    pub rules: Vec<String>,
+    /// Indicates if the macro is procedural.
+    pub is_procedural: bool,
+    /// Indicates if the macro is a derive macro.
+    pub is_derive: bool,
+    /// Indicates if the macro is an attribute macro.
+    pub is_attribute: bool,
+    /// Indicates if the macro follows the function-like syntax.
+    pub is_function_like: bool,
+    /// True if the macro is exported via a macro_use directive.
+    pub exported_from_macro_use: bool,
+    /// The starting line number of the macro definition.
+    pub start_line: usize,
+    /// The ending line number of the macro definition.
+    pub end_line: usize,
+}
+
+impl RustMacro {
+    /// Creates a new `RustMacro` instance with default values.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - The name of the macro.
+    /// * `start_line` - The starting line of the macro definition.
+    /// * `end_line` - The ending line of the macro definition.
+    pub fn new(name: String, start_line: usize, end_line: usize) -> Self {
+        Self {
+            name,
+            visibility: RustVisibility::Private, // Defaults to PRIVATE visibility.
+            doc_comment: None,
+            attributes: Vec::new(),
+            rules: Vec::new(),
+            is_procedural: false,
+            is_derive: false,
+            is_attribute: false,
+            is_function_like: true,
+            exported_from_macro_use: false,
+            start_line,
+            end_line,
+        }
+    }
+}

src/entities/rstruct.rs

@@ -0,0 +1,97 @@
+use std::collections::HashMap;
+
+use super::{
+    RustStructKind, RustVisibility, attr::RustAttribute, callable::RustCallable,
+    lifetime::RustLifetimeParam, param::RustGenericParam, rtype::RustType,
+};
+
+/// Represents a field in a Rust struct.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RustStructField {
+    /// Name of the field.
+    pub name: String,
+    /// The type of the field.
+    pub ty: RustType,
+    /// Visibility of the field. Defaults to `RustVisibility::PRIVATE`.
+    pub visibility: RustVisibility,
+    /// Optional documentation comment.
+    pub doc_comment: Option<String>,
+    /// List of attributes associated with the field.
+    pub attributes: Vec<RustAttribute>,
+}
+
+impl RustStructField {
+    /// Creates a new `RustStructField` with the given name and type.
+    /// Visibility is set to `PRIVATE`, no doc comment, and an empty attributes list.
+    pub fn new(name: String, ty: RustType) -> Self {
+        Self {
+            name,
+            ty,
+            visibility: RustVisibility::Private,
+            doc_comment: None,
+            attributes: Vec::new(),
+        }
+    }
+}
+
+/// Represents a Rust struct definition.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RustStruct {
+    /// Name of the Rust struct.
+    pub name: String,
+    /// Kind of the struct. Defaults to `RustStructKind::NORMAL`.
+    pub kind: RustStructKind,
+    /// Visibility of the struct. Defaults to `RustVisibility::PRIVATE`.
+    pub visibility: RustVisibility,
+    /// Optional documentation comment.
+    pub doc_comment: Option<String>,
+    /// List of attributes associated with the struct.
+    pub attributes: Vec<RustAttribute>,
+    /// List of fields contained in the struct.
+    pub fields: Vec<RustStructField>,
+    /// Generic parameters for the struct.
+    pub generic_params: Vec<RustGenericParam>,
+    /// Lifetime parameters for the struct.
+    pub lifetime_params: Vec<RustLifetimeParam>,
+    /// Where clauses applied to the struct.
+    pub where_clauses: Vec<String>,
+    /// Derives applied to the struct.
+    pub derives: Vec<String>,
+    /// Associated items (e.g., methods, functions) where key is the item name.
+    pub associated_items: HashMap<String, RustCallable>,
+    /// Traits that this struct implements.
+    pub impl_traits: Vec<String>,
+    /// Indicates whether the struct is public.
+    pub is_public: bool,
+    /// Indicates whether the struct contains unsafe code.
+    pub contains_unsafe: bool,
+    /// The starting line number of the struct definition in the source file.
+    pub start_line: usize,
+    /// The ending line number of the struct definition in the source file.
+    pub end_line: usize,
+}
+
+impl RustStruct {
+    /// Creates a new `RustStruct` with the given name, start_line, and end_line.
+    /// Default values are used for the remaining fields.
+    pub fn new(name: String, start_line: usize, end_line: usize) -> Self {
+        Self {
+            name,
+            kind: RustStructKind::Normal,
+            visibility: RustVisibility::Private,
+            doc_comment: None,
+            attributes: Vec::new(),
+            fields: Vec::new(),
+            generic_params: Vec::new(),
+            lifetime_params: Vec::new(),
+            where_clauses: Vec::new(),
+            derives: Vec::new(),
+            associated_items: HashMap::new(),
+            impl_traits: Vec::new(),
+            is_public: false,
+            contains_unsafe: false,
+            start_line,
+            end_line,
+        }
+    }
+}