refactor: errors and begin work on transpiler

Author: LynithDev

packages/cli/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-lang_engine = { workspace = true, features = ["cli"] }
+lang_engine = { workspace = true, features = [] }
 
 # logging
 log = { workspace = true }

packages/engine/Cargo.toml

@@ -6,15 +6,14 @@ edition = "2021"
 [dependencies]
 log = { workspace = true }
 thiserror = { workspace = true }
-colored = { workspace = true, optional = true }
+colored = { workspace = true }
 lang_macro = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = { workspace = true }
 
 [features]
-default = ["cli"]
-cli = ["dep:colored"]
+default = []
 no-color = ["colored/no-color"]
 
 [lib]

packages/engine/src/component.rs

@@ -1,9 +1,11 @@
-use std::iter::Peekable;
+use std::{fmt::Display, iter::Peekable};
 
-use crate::error::ErrorList;
+use crate::error::SourceFile;
 
-pub trait ComponentErrors {
-    fn fetch_errors(&self) -> &ErrorList;
+pub trait ComponentErrors<E>
+where E: Display {
+
+    fn fetch_errors(&self) -> &Vec<E>;
 
     fn has_errors(&self) -> bool {
         !self.fetch_errors().is_empty()
@@ -15,22 +17,7 @@ pub trait ComponentErrors {
         }
     }
 
-    #[cfg(feature = "cli")]
-    fn source(&self) -> &crate::error::SourceFile;
-
-    #[cfg(feature = "cli")]
-    fn get_source_sliced(&self, start: crate::cursor::Cursor, end: crate::cursor::Cursor) -> crate::error::SourceFile {
-        let source_file = self.source();
-
-        let start_index = start.index() as usize;
-        let end_index = end.index() as usize;
-
-        let code = &source_file.as_ref().1;
-
-        let source = &code[start_index..end_index.min(code.len())];
-
-        Box::from((source_file.as_ref().0.clone(), source.to_string()))
-    }
+    fn source(&self) -> &SourceFile;
 }
 
 pub trait ComponentIter<'a, C, T, I> where 

packages/engine/src/error.rs

@@ -1,29 +1,60 @@
-#[cfg(feature = "cli")]
 use colored::Colorize;
 
-use crate::lexer::tokens::LexerTokenKind;
+use crate::cursor::Cursor;
 
-#[derive(thiserror::Error, PartialEq, Eq, Debug, Clone)]
+#[derive(thiserror::Error, Debug)]
 pub enum EngineErrorKind {
     #[error("{0}")]
     LexerError(#[from] crate::lexer::LexerError),
     #[error("{0}")]
     ParserError(#[from] crate::parser::ParserError),
-    #[error("failed to get value as '{0}' from literal '{1}'")]
-    LiteralExtractionError(LexerTokenKind, LexerTokenKind),
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error("exec error")]
+    ExecError,
+    #[error("expected file")]
+    ExpectedFileError,
     #[error("an unreachable error has occurred. this shouldn't ever happen")]
     Unreachable,
     #[error("an unknown error has occurred")]
     UnknownError,
 }
 
 pub type EngineResult<T> = std::result::Result<T, EngineErrorKind>;
-pub type ErrorList = Vec<EngineErrorKind>;
 
-#[cfg(feature = "cli")]
-pub(super) type SourceFile = Box<(Option<std::path::PathBuf>, String)>;
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SourceFile {
+    path: String,
+    code: String,
+}
+
+impl SourceFile {
+    pub fn from(code: String, path: Option<String>) -> Self {
+        Self {
+            code,
+            path: path.unwrap_or(String::from("virtual"))
+        }
+    }
+
+    pub fn get_path(&self) -> &str {
+        &self.path
+    }
+
+    pub fn get_code(&self) -> &str {
+        &self.code
+    }
+
+    pub fn sliced(&self, start: Cursor, end: Cursor) -> SourceFile {
+        let start_index = start.index() as usize;
+        let end_index = end.index() as usize;
+
+        let code = self.get_code();
+        let slice = &code[start_index..end_index.min(code.len())];
+
+        SourceFile::from(slice.to_string(), Some(self.path.clone()))
+    }
+}
 
-#[cfg(feature = "cli")]
 pub trait CodeError<T>
 where T: lang_macro::EnumVariantsTrait + ToString {
     fn kind(&self) -> &T;
@@ -39,8 +70,8 @@ where T: lang_macro::EnumVariantsTrait + ToString {
             self.kind().to_string().bold(),
         )?;
 
-        let (path, source) = *self.source_file().clone();
-        let (path, source) = (path.map_or("VM".to_string(), |path| path.to_string_lossy().to_string()), source);
+        let path = self.source_file().get_path();
+        let code = self.source_file().get_code();
 
         writeln!(f,
             "  {} {}",
@@ -73,7 +104,7 @@ where T: lang_macro::EnumVariantsTrait + ToString {
                 " ".repeat(max_line_len - line_len),
                 line,
                 "|".bright_blue().bold(),
-                source.trim()
+                code.trim()
             )?;
         }
 

packages/engine/src/lexer/error.rs

@@ -1,12 +1,11 @@
-#[cfg(feature = "cli")] 
 use std::fmt::Display;
-
-#[cfg(feature = "cli")]
 use crate::error::{CodeError, SourceFile};
 
 use crate::cursor::Cursor;
 
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq, lang_macro::EnumVariants)]
+use super::tokens::LexerTokenKind;
+
+#[derive(thiserror::Error, Debug, lang_macro::EnumVariants, PartialEq, Eq, Clone)]
 pub enum LexerErrorKind {
     #[error("unexpected end of input")]
     UnexpectedEnd,
@@ -16,31 +15,28 @@ pub enum LexerErrorKind {
     IntegerOverflow(String),
     #[error("expected character '{expected}' but found {found:?}")]
     ExpectedCharacter { expected: String, found: Option<char> },
+    #[error("failed to get value as '{0}' from literal '{1}'")]
+    LiteralExtractionError(LexerTokenKind, LexerTokenKind),
     #[error("unknown token")]
     UnknownToken
 }
 
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-#[cfg_attr(not(feature = "cli"), error("{kind}"))]
+#[derive(thiserror::Error, Debug, PartialEq, Eq, Clone)]
 pub struct LexerError {
     pub kind: LexerErrorKind,
     pub start: Cursor,
     pub end: Cursor,
-
-    #[cfg(feature = "cli")]
     pub source_file: SourceFile,
 }
 
-pub(super) type LexerResult<T> = std::result::Result<T, LexerErrorKind>;
+pub type LexerResult<T> = std::result::Result<T, LexerErrorKind>;
 
-#[cfg(feature = "cli")]
 impl Display for LexerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.format_error(f)
     }
 }
 
-#[cfg(feature = "cli")]
 impl CodeError<LexerErrorKind> for LexerError {
     fn kind(&self) -> &LexerErrorKind {
         &self.kind

packages/engine/src/lexer/mod.rs

@@ -4,10 +4,7 @@ use error::LexerResult;
 use tokens::{LexerLiteral, LexerToken, LexerTokenKind, LexerTokenList};
 
 use crate::{
-    component::{ComponentErrors, ComponentIter},
-    constants::{MAX_I32_LEN, MAX_I64_LEN},
-    error::{EngineErrorKind, ErrorList},
-    cursor::Cursor,
+    component::{ComponentErrors, ComponentIter}, cursor::Cursor, error::SourceFile
 };
 
 pub use error::{LexerError, LexerErrorKind};
@@ -17,54 +14,35 @@ pub mod tokens;
 
 pub struct Lexer<'a> {
     chars: Peekable<Chars<'a>>,
-    errors: ErrorList,
+    errors: Vec<LexerError>,
     cursor: Cursor,
     tokens: LexerTokenList,
     max_int_len: u8,
-
-    #[cfg(feature = "cli")]
-    source: crate::error::SourceFile,
+    source_file: &'a SourceFile,
 }
 
 impl<'a> Lexer<'a> {
     pub fn create(
-        input: &'a str,
-        #[cfg(feature = "cli")] path: Option<std::path::PathBuf>,
+        source_file: &'a SourceFile,
     ) -> Self {
         Self::create_bits(
-            input,
-            #[cfg(feature = "cli")]
-            path,
-            MAX_I64_LEN,
-        )
-    }
-
-    pub fn create_32b(
-        input: &'a str,
-        #[cfg(feature = "cli")] path: Option<std::path::PathBuf>,
-    ) -> Self {
-        Self::create_bits(
-            input,
-            #[cfg(feature = "cli")]
-            path,
-            MAX_I32_LEN,
+            source_file,
+            #[cfg(target_pointer_width = "32")] crate::constants::MAX_I32_LEN,
+            #[cfg(target_pointer_width = "64")] crate::constants::MAX_I64_LEN,
         )
     }
 
     pub fn create_bits(
-        input: &'a str,
-        #[cfg(feature = "cli")] path: Option<std::path::PathBuf>,
+        source_file: &'a SourceFile,
         max_int_len: u8,
     ) -> Self {
         let lexer = Self {
-            chars: input.trim().chars().peekable(),
-            errors: ErrorList::new(),
+            chars: source_file.get_code().trim().chars().peekable(),
+            errors: Vec::new(),
             cursor: Cursor::create(),
             tokens: LexerTokenList::new(),
             max_int_len,
-
-            #[cfg(feature = "cli")]
-            source: Box::from((path, input.to_string())),
+            source_file,
         };
 
         debug!("created lexer");
@@ -253,13 +231,12 @@ impl<'a> Lexer<'a> {
         start: Cursor,
         err: LexerErrorKind
     ) {
-        self.errors.push(EngineErrorKind::LexerError(LexerError {
-            #[cfg(feature = "cli")]
-            source_file: self.get_source_sliced(start, self.cursor),
+        self.errors.push(LexerError {
+            source_file: self.source().sliced(start, self.cursor),
             start,
             end: self.cursor,
             kind: err,
-        }))
+        })
     }
 
     /// Consumes a single-line comment (aka skips to the end of the line and returns nothing)
@@ -487,14 +464,13 @@ impl<'a> Lexer<'a> {
     }
 }
 
-impl ComponentErrors for Lexer<'_> {
-    fn fetch_errors(&self) -> &ErrorList {
+impl ComponentErrors<LexerError> for Lexer<'_> {
+    fn fetch_errors(&self) -> &Vec<LexerError> {
         &self.errors
     }
 
-    #[cfg(feature = "cli")]
     fn source(&self) -> &crate::error::SourceFile {
-        &self.source
+        self.source_file
     }
 }
 

packages/engine/src/lexer/tokens.rs

@@ -2,10 +2,9 @@ use std::fmt::Display;
 
 use lang_macro::EnumVariantsTrait;
 
-use crate::{
-    error::{EngineErrorKind, EngineResult},
-    cursor::Cursor,
-};
+use crate::cursor::Cursor;
+
+use super::{error::LexerResult, LexerErrorKind};
 
 #[repr(u8)]
 #[derive(lang_macro::EnumVariants, Debug, PartialEq, Eq, Clone)]
@@ -182,51 +181,51 @@ pub struct LexerToken {
 }
 
 impl LexerToken {
-    pub fn as_identifier(&self) -> EngineResult<&String> {
+    pub fn as_identifier(&self) -> LexerResult<&String> {
         self.value
             .as_ref()
             .and_then(|v| v.as_identifier())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
+            .ok_or(LexerErrorKind::LiteralExtractionError(
                 LexerTokenKind::Identifier, 
                 self.kind.clone(),
             ))
     }
 
-    pub fn as_string(&self) -> EngineResult<&String> {
+    pub fn as_string(&self) -> LexerResult<&String> {
         self.value
             .as_ref()
             .and_then(|v| v.as_string())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
+            .ok_or(LexerErrorKind::LiteralExtractionError(
                 LexerTokenKind::String,
                 self.kind.clone(),
             ))
     }
 
-    pub fn as_integer(&self) -> EngineResult<&isize> {
+    pub fn as_integer(&self) -> LexerResult<&isize> {
         self.value
             .as_ref()
             .and_then(|v| v.as_integer())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
+            .ok_or(LexerErrorKind::LiteralExtractionError(
                 LexerTokenKind::Integer,
                 self.kind.clone(),
             ))
     }
 
-    pub fn as_boolean(&self) -> EngineResult<&bool> {
+    pub fn as_boolean(&self) -> LexerResult<&bool> {
         self.value
             .as_ref()
             .and_then(|v| v.as_boolean())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
+            .ok_or(LexerErrorKind::LiteralExtractionError(
                 LexerTokenKind::Boolean,
                 self.kind.clone(),
             ))
     }
 
-    pub fn as_shell_command(&self) -> EngineResult<&ShellCommand> {
+    pub fn as_shell_command(&self) -> LexerResult<&ShellCommand> {
         self.value
             .as_ref()
             .and_then(|v| v.as_shell_command())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
+            .ok_or(LexerErrorKind::LiteralExtractionError(
                 LexerTokenKind::ShellCommand,
                 self.kind.clone(),
             ))