Update dependencies and refactor error handling with SDKErr enum; begin writing Codebase structure for AST parsing

Author: 0xGeorgii

Cargo.toml

@@ -4,7 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-syn = "2.0.86"
+syn = { version = "2.0.87", features = ["full"] }
+thiserror = "1.0.67"
 
 [dev-dependencies]
 soroban-sdk = "21.7.6"

src/ast.rs

@@ -0,0 +1,99 @@
+#![warn(clippy::pedantic)]
+use crate::errors::SDKErr;
+use std::collections::HashMap;
+
+fn parse_file(file_name: &str, content: &mut str) -> Result<syn::File, SDKErr> {
+    if let Ok(ast) = syn::parse_file(content) {
+        Ok(ast)
+    } else {
+        Err(SDKErr::AstParseError(file_name.to_string()))
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct Codebase {
+    ast_map: HashMap<String, syn::File>,
+    free_functions: Vec<Function>,
+    contracts: Vec<Contract>,
+}
+
+impl Codebase {
+    pub fn new() -> Self {
+        Codebase {
+            ast_map: HashMap::new(),
+            free_functions: Vec::new(),
+            contracts: Vec::new(),
+        }
+    }
+
+    pub fn parse_and_add_file(&mut self, file_name: &str, content: &mut str) -> Result<(), SDKErr> {
+        let file = parse_file(file_name, content)?;
+        self.ast_map.insert(file_name.to_string(), file);
+        Ok(())
+    }
+
+    pub fn build_api(&mut self) {
+        for (file_name, file) in &self.ast_map {
+            for item in &file.items {
+                match item {
+                    syn::Item::Fn(f) => {
+                        println!("Function: {}", f.sig.ident);
+                    }
+                    syn::Item::Struct(s) => {
+                        println!("Struct: {}", s.ident);
+                    }
+                    syn::Item::Enum(e) => {
+                        println!("Enum: {}", e.ident);
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Contract {
+    name: String,
+    functions: Vec<Function>,
+    structs: Vec<Struct>,
+    enums: Vec<Enum>,
+}
+
+impl Contract {
+    pub fn new(name: &str) -> Self {
+        Contract {
+            name: name.to_string(),
+            functions: Vec::new(),
+            structs: Vec::new(),
+            enums: Vec::new(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Function {}
+
+impl Function {
+    pub fn new() -> Self {
+        Function {}
+    }
+}
+
+#[derive(Clone)]
+pub struct Struct {}
+
+impl Struct {
+    pub fn new() -> Self {
+        Struct {}
+    }
+}
+
+#[derive(Clone)]
+pub struct Enum {}
+
+impl Enum {
+    pub fn new() -> Self {
+        Enum {}
+    }
+}

src/errors.rs

@@ -0,0 +1,13 @@
+#![warn(clippy::pedantic)]
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[non_exhaustive]
+pub enum SDKErr {
+    #[error("source file not found: {0}")]
+    SrcFileNotFound(String),
+    #[error("failed to read file: {0}")]
+    IOError(#[from] std::io::Error),
+    #[error("failed to parse ast for file: {0}")]
+    AstParseError(String),
+}

src/lib.rs

@@ -1,23 +1,27 @@
 #![warn(clippy::pedantic)]
+use ast::Codebase;
+use errors::SDKErr;
 use std::path::Path;
 
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum SDKErr {
-    SrcFileNotFound(String),
-}
-
+mod ast;
+pub mod errors;
 /// Build the code model from the given files.
 /// # Errors
-/// - If the file is not found.
-pub fn build_code_model(files: Vec<String>) -> Result<bool, SDKErr> {
+/// - `SDKErr::SrcFileNotFound` If the file is not found.
+/// - `std::io::Error` If there is an error reading the file.
+/// - `SDKErr::AstParseError` If there is an error parsing the AST.
+pub fn build_code_model(files: Vec<String>) -> Result<Box<Codebase>, SDKErr> {
+    let mut codebasae = Box::new(Codebase::default());
     for file in files {
         let path = Path::new(&file);
         if !path.exists() {
-            return Err(SDKErr::SrcFileNotFound(format!("file not found: {file}")));
+            return Err(SDKErr::SrcFileNotFound(file));
         }
+        let mut content = std::fs::read_to_string(path)?;
+        codebasae.parse_and_add_file(&file, &mut content)?;
     }
-    Ok(true)
+    codebasae.build_api();
+    Ok(codebasae)
 }
 
 #[cfg(test)]