Add from between positions method (#78)

* feat: add from between positions

* feat: update comment

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* feat: bump version

* feat: update description

* feat: bump version

* feat: update readme comment

* feat: update comment

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: Ph0enixKM

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "heraclitus-compiler"
-version = "1.8.3"
+version = "1.9.0"
 edition = "2021"
 description = "Compiler frontend for developing great programming languages"
 license = "MIT"

Cargo.toml

@@ -45,7 +45,12 @@ let tokens = cc.tokenize()?;
 
 # Change log 🚀
 
-## Version 1.8.2
+## Version 1.9.0
+### Feat:
+- Added `PositionInfo::from_between_positions` method for creating a `PositionInfo` from two positions
+- Breaking Change: `PositionInfo::new` and `PositionInfo::at_pos` now accept `start` parameter which determines the index of the first character in the source code
+
+## Version 1.8.3
 ### Feat:
 - Introduced `ignore_escaped` property on regions to prevent from escaping region boundaries
 

README.md

@@ -240,8 +240,8 @@ mod test {
         // Uncomment to see the error message
         sleep(Duration::from_secs(1));
         let trace = [
-            PositionInfo::at_pos(Some("/path/to/bar".to_string()), (3, 4), 10),
-            PositionInfo::at_pos(Some("/path/to/foo".to_string()), (2, 9), 24),
+            PositionInfo::at_pos(Some("/path/to/bar".to_string()), (3, 4), 10, 10),
+            PositionInfo::at_pos(Some("/path/to/foo".to_string()), (2, 9), 24, 24),
         ];
         super::Logger::new(MessageType::Error, &trace)
             .header(MessageType::Error)
@@ -258,7 +258,7 @@ mod test {
         // Uncomment to see the error message
         sleep(Duration::from_secs(1));
         let trace = [
-            PositionInfo::at_pos(Some("/path/to/foo".to_string()), (2, 6), 1)
+            PositionInfo::at_pos(Some("/path/to/foo".to_string()), (2, 6), 5, 1)
         ];
         super::Logger::new(MessageType::Error, &trace)
             .header(MessageType::Error)

src/compiling/failing/logger.rs

@@ -31,7 +31,7 @@ pub enum MessageType {
 /// ```should_panic
 /// # use heraclitus_compiler::prelude::*;
 /// # let path = Some(format!("path/to/file"));
-/// # let position = PositionInfo::at_pos(path.clone(), (0, 0), 0);
+/// # let position = PositionInfo::at_pos(path.clone(), (0, 0), 0, 0);
 /// # let guess = "type";
 /// # let code = Some(format!("code"));
 /// # let mut meta = DefaultMetadata::new(vec![], path, code);
@@ -195,7 +195,7 @@ mod test {
             "... further code",
         ].join("\n"));
         let path = Some(format!("path/to/file"));
-        let position = PositionInfo::at_pos(path.clone(), (2, 1), 4);
+        let position = PositionInfo::at_pos(path.clone(), (2, 1), 14, 4);
         let guess = "type";
         let mut meta = DefaultMetadata::new(vec![], path, code);
         Message::new_err_at_position(&mut meta, position)

src/compiling/failing/message.rs

@@ -28,6 +28,8 @@ pub struct PositionInfo {
     pub path: Option<String>,
     /// Location of this error
     pub position: Position,
+    /// Character index in the source file where this position starts
+    pub start: usize,
     /// Length of the token
     pub len: usize,
     /// Additional information
@@ -36,10 +38,11 @@ pub struct PositionInfo {
 
 impl PositionInfo {
     /// Create a new error from scratch
-    pub fn new(meta: &impl Metadata, position: Position, len: usize) -> Self {
+    pub fn new(meta: &impl Metadata, position: Position, start: usize, len: usize) -> Self {
         let info = PositionInfo {
             position,
             path: meta.get_path(),
+            start,
             len,
             data: None
         };
@@ -51,17 +54,19 @@ impl PositionInfo {
         let info = PositionInfo {
             path: meta.get_path(),
             position: Position::EOF,
+            start: 0,
             len: 0,
             data: None
         };
         info.updated_pos(meta)
     }
 
     /// Create a new error at given position
-    pub fn at_pos(path: Option<String>, (row, col): (usize, usize), len: usize) -> Self {
+    pub fn at_pos(path: Option<String>, (row, col): (usize, usize), start: usize, len: usize) -> Self {
         PositionInfo {
             path,
             position: Position::Pos(row, col),
+            start,
             len,
             data: None
         }
@@ -94,7 +99,7 @@ impl PositionInfo {
     /// and error once you finished parsing the entire expression
     pub fn from_token(meta: &impl Metadata, token_opt: Option<Token>) -> Self {
         match token_opt {
-            Some(token) => PositionInfo::at_pos(meta.get_path(), token.pos, token.word.chars().count()),
+            Some(token) => PositionInfo::at_pos(meta.get_path(), token.pos, token.start, token.word.chars().count()),
             None => PositionInfo::at_eof(meta)
         }
     }
@@ -106,15 +111,29 @@ impl PositionInfo {
     pub fn from_between_tokens(meta: &impl Metadata, begin: Option<Token>, end: Option<Token>) -> Self {
         if let Some(begin) = begin {
             let (row, col) = begin.pos;
-            let end = end.map_or(usize::max_value(), |tok| tok.start);
-            let len = end - begin.start;
-            PositionInfo::at_pos(meta.get_path(), (row, col), len)
-        }
-        else {
+            let end_pos = end.map_or(usize::max_value(), |tok| tok.start);
+            let len = end_pos - begin.start;
+            PositionInfo::at_pos(meta.get_path(), (row, col), begin.start, len)
+        } else {
             PositionInfo::from_metadata(meta)
         }
     }
 
+    /// Create an error at position between two PositionInfo objects
+    ///
+    /// This function is used to create an error between two positions
+    /// which can be used to express an error in a specific range
+    pub fn from_between_positions(meta: &impl Metadata, begin: PositionInfo, end: PositionInfo) -> Self {
+        let start_index = begin.start;
+        let end_index = end.start + end.len;
+        let len = end_index - start_index;
+        if let Position::Pos(row, col) = begin.position {
+            PositionInfo::at_pos(meta.get_path(), (row, col), start_index, len)
+        } else {
+            PositionInfo::at_eof(meta)
+        }
+    }
+
     /// Attach additional data in form of a string
     pub fn data<T: AsRef<str>>(mut self, data: T) -> Self {
         self.data = Some(data.as_ref().to_string());
@@ -177,7 +196,7 @@ mod test {
 
     #[test]
     fn test_position_info() {
-        let pos = PositionInfo::at_pos(Some("test".to_string()), (1, 1), 1);
+        let pos = PositionInfo::at_pos(Some("test".to_string()), (1, 1), 0, 1);
         assert_eq!(pos.get_path(), "test");
         assert_eq!(pos.get_pos_by_code("test"), (1, 1));
     }
@@ -191,4 +210,15 @@ mod test {
         let pos = PositionInfo::from_between_tokens(&mut meta, Some(begin.clone()), Some(end.clone()));
         assert_eq!(pos.len, end.start - begin.start);
     }
+
+    #[test]
+    fn test_position_info_between_positions() {
+        let begin = PositionInfo::at_pos(Some("test".to_string()), (1, 1), 0, 5);
+        let end = PositionInfo::at_pos(Some("test".to_string()), (1, 10), 9, 3);
+        let mut meta = DefaultMetadata::new(vec![], None, Some("begin to end".to_string()));
+        let pos = PositionInfo::from_between_positions(&mut meta, begin.clone(), end.clone());
+        assert_eq!(pos.start, 0);
+        assert_eq!(pos.len, 12);
+        assert_eq!(pos.get_pos_by_code("begin to end"), (1, 1));
+    }
 }

src/compiling/failing/position_info.rs

@@ -251,7 +251,7 @@ impl Lexer {
                                     let pos = lex_state.reader.get_position();
                                     return Err((
                                         LexerErrorType::Singleline,
-                                        PositionInfo::at_pos(self.path.clone(), pos, 0)
+                                        PositionInfo::at_pos(self.path.clone(), pos, lex_state.reader.get_index(), 0)
                                             .data(region.name.clone()),
                                     ));
                                 }
@@ -316,10 +316,10 @@ impl Lexer {
         }
         self.add_word(&mut lex_state);
         // If some region exists that was not closed
-        if let Err((pos, region)) = lex_state.region_handler.is_region_closed(&lex_state.reader) {
+        if let Err((pos, start, region)) = lex_state.region_handler.is_region_closed(&lex_state.reader) {
             return Err((
                 LexerErrorType::Unclosed,
-                PositionInfo::at_pos(self.path.clone(), pos, 0).data(region.name),
+                PositionInfo::at_pos(self.path.clone(), pos, start, 0).data(region.name),
             ));
         }
 

src/compiling/lexing/lexer.rs

@@ -35,11 +35,11 @@ impl RegionHandler {
     // Error if after code lexing
     // some region was left unclosed
     #[inline]
-    pub fn is_region_closed(&self, reader: &Reader) -> Result<(), ((usize, usize), Region)> {
+    pub fn is_region_closed(&self, reader: &Reader) -> Result<(), ((usize, usize), usize, Region)> {
         if let Some(region) = self.region_stack.last() {
             if !region.allow_unclosed_region {
                 let pos = reader.get_position();
-                return Err((pos, region.clone()));
+                return Err((pos, reader.get_index(), region.clone()));
             }
         }
         Ok(())