feat: implement all entities

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

Author: rithulkamesh

src/entities/dep.rs

@@ -0,0 +1,36 @@
+//! Module for representing a Rust dependency.
+//!
+//! This module defines the RustDependency struct, which represents a dependency
+//! in a Rust project. Dependencies can be internal or external, and an associated
+//! RustCrate (defined in the parent module) can be tied to the dependency.
+
+use super::rcrate::RustCrate;
+
+/// Represents a Rust dependency, which could be internal or external.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct RustDependency {
+    /// The name of the dependency.
+    pub name: String,
+    /// Indicates if the dependency is external. Defaults to true.
+    pub is_external: bool,
+    /// Associated RustCrate, defined in the parent module.
+    pub crate_ref: Option<RustCrate>,
+}
+
+impl RustDependency {
+    /// Creates a new RustDependency with the given name.
+    ///
+    /// The `is_external` field is set to `true` by default.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - A string representing the dependency's name.
+    /// * `crate_ref` - An optional reference to a RustCrate from the parent module.
+    pub fn new(name: String, crate_ref: Option<RustCrate>) -> Self {
+        RustDependency {
+            name,
+            is_external: true,
+            crate_ref,
+        }
+    }
+}

src/entities/lifetime.rs

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

src/entities/mod.rs

@@ -1,8 +1,13 @@
+use serde::{Deserialize, Serialize};
+
 pub mod attr;
 pub mod callable;
 pub mod callsite;
+pub mod dep;
 pub mod lifetime;
+pub mod module;
 pub mod param;
+pub mod rcrate;
 pub mod renum;
 pub mod rimpl;
 pub mod rmacro;
@@ -11,7 +16,7 @@ pub mod rtrait;
 pub mod rtype;
 pub mod safety;
 pub mod variables;
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum RustVisibility {
     Public,
     Private,

src/entities/module.rs

@@ -0,0 +1,101 @@
+use std::collections::HashMap;
+
+use super::{
+    RustVisibility,
+    attr::RustAttribute,
+    callable::RustCallable,
+    renum::RustEnum,
+    rimpl::RustImpl,
+    rmacro::RustMacro,
+    rstruct::RustStruct,
+    rtrait::RustTrait,
+    rtype::{RustType, RustTypeAlias},
+    variables::RustVariableDeclaration,
+};
+
+/// Represents a Rust module with all possible items.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RustModule {
+    /// The name of the module.
+    pub name: String,
+    /// Documentation comment for the module.
+    pub doc_comment: Option<String>,
+    /// Attributes applied to the module.
+    pub attributes: Vec<RustAttribute>,
+    /// Visibility of the module.
+    pub visibility: RustVisibility,
+
+    // Type definitions
+    /// Map of type definitions.
+    pub types: HashMap<String, RustType>,
+    /// Map of structs.
+    pub structs: HashMap<String, RustStruct>,
+    /// Map of enums.
+    pub enums: HashMap<String, RustEnum>,
+    /// Map of traits.
+    pub traits: HashMap<String, RustTrait>,
+    /// List of implementations.
+    pub impls: Vec<RustImpl>,
+    /// Map of type aliases.
+    pub type_aliases: HashMap<String, RustTypeAlias>,
+
+    // Functions and macros
+    /// Map of functions.
+    pub functions: HashMap<String, RustCallable>,
+    /// Map of safe functions.
+    pub safe_functions: HashMap<String, RustCallable>,
+    /// Map of unsafe functions.
+    pub unsafe_functions: HashMap<String, RustCallable>,
+    /// Map of macros.
+    pub macros: HashMap<String, RustMacro>,
+
+    // Module structure
+    /// Map of submodules.
+    pub submodules: HashMap<String, RustModule>,
+    /// Constants declared in the module.
+    pub constants: Vec<RustVariableDeclaration>,
+    /// List of use declarations.
+    pub use_declarations: Vec<String>,
+    /// List of extern crate declarations.
+    pub extern_crates: Vec<String>,
+
+    // Module properties
+    /// Indicates if the module is marked as unsafe.
+    pub is_unsafe: bool,
+    /// The file path of the module.
+    pub file_path: Option<String>,
+    /// True if the file is named mod.rs.
+    pub is_mod_rs: bool,
+    /// True if this is the root module.
+    pub is_root_module: bool,
+}
+
+impl RustModule {
+    /// Creates a new `RustModule` with the given name.
+    pub fn new(name: String) -> Self {
+        Self {
+            name,
+            doc_comment: None,
+            attributes: Vec::new(),
+            visibility: RustVisibility::Private,
+            types: HashMap::new(),
+            structs: HashMap::new(),
+            enums: HashMap::new(),
+            traits: HashMap::new(),
+            impls: Vec::new(),
+            type_aliases: HashMap::new(),
+            functions: HashMap::new(),
+            safe_functions: HashMap::new(),
+            unsafe_functions: HashMap::new(),
+            macros: HashMap::new(),
+            submodules: HashMap::new(),
+            constants: Vec::new(),
+            use_declarations: Vec::new(),
+            extern_crates: Vec::new(),
+            is_unsafe: false,
+            file_path: None,
+            is_mod_rs: false,
+            is_root_module: false,
+        }
+    }
+}

src/entities/param.rs

@@ -1,10 +1,12 @@
+use serde::{Deserialize, Serialize};
+
 use crate::entities::rtype::RustType;
 
 /// Represents a generic type parameter in Rust.
 ///
 /// 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, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct RustGenericParam {
     /// The name of the generic parameter
     pub name: String,

src/entities/rcrate.rs

@@ -0,0 +1,48 @@
+use super::{dep::RustDependency, module::RustModule};
+
+/// Represents a complete Rust crate.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RustCrate {
+    /// The name of the crate.
+    pub name: String,
+    /// The version of the crate.
+    pub version: String,
+    /// Indicates if the crate is a library.
+    pub is_lib: bool,
+    /// List of modules in the crate.
+    pub modules: Vec<RustModule>,
+    /// The edition of the crate (default is "2021").
+    pub edition: String,
+    /// Features enabled in the crate.
+    pub features: Vec<String>,
+    /// Dependencies of the crate.
+    pub dependencies: Vec<RustDependency>,
+}
+
+impl RustCrate {
+    /// Creates a new `RustCrate` with the given name, version, and modules.
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - A string representing the crate's name.
+    /// * `version` - A string representing the crate's version.
+    /// * `modules` - A vector containing the crate's modules.
+    ///
+    /// # Returns
+    ///
+    /// A new instance of `RustCrate` with default values:
+    /// - `is_lib` set to `false`
+    /// - `edition` set to `"2021"`
+    /// - Empty vectors for `features` and `dependencies`
+    pub fn new(name: String, version: String, modules: Vec<RustModule>) -> Self {
+        RustCrate {
+            name,
+            version,
+            is_lib: false,
+            modules,
+            edition: "2021".to_owned(),
+            features: Vec::new(),
+            dependencies: Vec::new(),
+        }
+    }
+}

src/entities/renum.rs

@@ -6,7 +6,7 @@ use super::{
 };
 
 /// Represents a Rust enum.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustEnum {
     /// The name of the enum.
     pub name: String,
@@ -39,7 +39,7 @@ pub struct RustEnum {
 }
 
 /// Represents a variant in a Rust enum.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustEnumVariant {
     /// The name of the variant.
     pub name: String,

src/entities/rimpl.rs

@@ -5,7 +5,7 @@ use super::{
 };
 
 /// Represents a Rust impl block.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustImpl {
     /// The type name that the impl block is for.
     pub type_name: String,

src/entities/rmacro.rs

@@ -6,7 +6,7 @@ use super::{RustVisibility, attr::RustAttribute};
 /// 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)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RustMacro {
     /// The name of the macro.
     pub name: String,

src/entities/rtype.rs

@@ -2,6 +2,10 @@ use std::fmt;
 
 use serde::{Deserialize, Serialize};
 
+use super::{
+    RustVisibility, attr::RustAttribute, lifetime::RustLifetimeParam, param::RustGenericParam,
+};
+
 /// Represents a Rust type.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Eq)]
 pub struct RustType {
@@ -55,3 +59,28 @@ impl fmt::Display for RustType {
         write!(f, "{}", self.name)
     }
 }
+
+/// Represents a Rust type alias.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Eq)]
+pub struct RustTypeAlias {
+    /// Name of the type alias.
+    pub name: String,
+    /// Visibility of the type alias.
+    pub visibility: RustVisibility,
+    /// Optional documentation comment.
+    pub doc_comment: Option<String>,
+    /// Attributes associated with the type alias.
+    pub attributes: Vec<RustAttribute>,
+    /// Generic parameters for the type alias.
+    pub generic_params: Vec<RustGenericParam>,
+    /// Lifetime parameters for the type alias.
+    pub lifetime_params: Vec<RustLifetimeParam>,
+    /// Where clauses for the type alias.
+    pub where_clauses: Vec<String>,
+    /// The target type that the alias refers to.
+    pub target_type: RustType,
+    /// Starting line number in the source file.
+    pub start_line: usize,
+    /// Ending line number in the source file.
+    pub end_line: usize,
+}