experimental: support for debug info (#118)

Signed-off-by: wpt967 <matt.aw@parity.io>
Signed-off-by: xermicus <cyrill@parity.io>

crates/solidity/src/yul/lexer/mod.rs

@@ -21,7 +21,7 @@ pub struct Lexer {
     /// The input source code.
     input: String,
     /// The number of characters processed so far.
-    offset: usize,
+    offset: u32,
     /// The current location.
     location: Location,
     /// The peeked lexeme, waiting to be fetched.
@@ -48,8 +48,17 @@ impl Lexer {
             return Ok(peeked);
         }
 
-        while self.offset < self.input.len() {
-            let input = &self.input[self.offset..];
+        while self.offset
+            < self
+                .input
+                .len()
+                .try_into()
+                .map_err(|_| Error::InvalidLexeme {
+                    location: self.location,
+                    sequence: Default::default(),
+                })?
+        {
+            let input = &self.input[(self.offset as usize)..];
 
             if input.starts_with(|character| char::is_ascii_whitespace(&character)) {
                 if input.starts_with('\n') {
@@ -101,12 +110,13 @@ impl Lexer {
                 return Ok(token);
             }
 
-            let end = self.input[self.offset..]
+            let end = self.input[(self.offset as usize)..]
                 .find(char::is_whitespace)
                 .unwrap_or(self.input.len());
             return Err(Error::InvalidLexeme {
                 location: self.location,
-                sequence: self.input[self.offset..self.offset + end].to_owned(),
+                sequence: self.input[(self.offset as usize)..(self.offset as usize) + end]
+                    .to_owned(),
             });
         }
 

crates/solidity/src/yul/lexer/token/lexeme/comment/multi_line.rs

@@ -19,12 +19,20 @@ impl Comment {
         let end_position = input.find(Self::END).unwrap_or(input.len());
         let input = &input[..end_position];
 
-        let length = end_position + Self::END.len();
-        let lines = input.matches('\n').count();
+        let length = (end_position + Self::END.len())
+            .try_into()
+            .expect("the YUL should be of reasonable size");
+        let lines = input
+            .matches('\n')
+            .count()
+            .try_into()
+            .expect("the YUL should be of reasonable size");
         let columns = match input.rfind('\n') {
             Some(new_line) => end_position - (new_line + 1),
             None => end_position,
-        };
+        }
+        .try_into()
+        .expect("the YUL should be of reasonable size");
 
         Token::new(Location::new(lines, columns), Lexeme::Comment, length)
     }

crates/solidity/src/yul/lexer/token/lexeme/comment/single_line.rs

@@ -17,7 +17,9 @@ impl Comment {
     /// Returns the comment's length, including the trimmed whitespace around it.
     pub fn parse(input: &str) -> Token {
         let end_position = input.find(Self::END).unwrap_or(input.len());
-        let length = end_position + Self::END.len();
+        let length = (end_position + Self::END.len())
+            .try_into()
+            .expect("the YUL should be of reasonable size");
 
         Token::new(Location::new(1, 1), Lexeme::Comment, length)
     }

crates/solidity/src/yul/lexer/token/lexeme/identifier.rs

@@ -26,7 +26,10 @@ impl Identifier {
         let end = input.find(Self::cannot_continue).unwrap_or(input.len());
 
         let inner = input[..end].to_string();
-        let length = inner.len();
+        let length = inner
+            .len()
+            .try_into()
+            .expect("the YUL should be of reasonable size");
 
         if let Some(token) = Keyword::parse(inner.as_str()) {
             return Some(token);

crates/solidity/src/yul/lexer/token/lexeme/keyword.rs

@@ -58,6 +58,9 @@ impl Keyword {
         if length != input.len() {
             return None;
         }
+        let length = length
+            .try_into()
+            .expect("the YUL should be of reasonable size");
 
         Some(Token::new(Location::new(0, length), lexeme, length))
     }

crates/solidity/src/yul/lexer/token/lexeme/literal/integer.rs

@@ -54,6 +54,10 @@ impl Integer {
             return None;
         };
 
+        let length = length
+            .try_into()
+            .expect("the YUL should be of reasonable size");
+
         let token = Token::new(
             Location::new(0, length),
             Lexeme::Literal(Literal::Integer(value)),

crates/solidity/src/yul/lexer/token/lexeme/literal/string.rs

@@ -69,6 +69,9 @@ impl String {
             .to_owned();
 
         let literal = Self::new(string, is_hex_string);
+        let length = length
+            .try_into()
+            .expect("the YUL should be of reasonable size");
 
         Some(Token::new(
             Location::new(0, length),

crates/solidity/src/yul/lexer/token/location.rs

@@ -7,9 +7,9 @@ use serde::Serialize;
 #[derive(Debug, Serialize, Deserialize, Clone, Copy, Eq)]
 pub struct Location {
     /// The line number, starting from 1.
-    pub line: usize,
+    pub line: u32,
     /// The column number, starting from 1.
-    pub column: usize,
+    pub column: u32,
 }
 
 impl Default for Location {
@@ -20,13 +20,13 @@ impl Default for Location {
 
 impl Location {
     /// Creates a default location.
-    pub fn new(line: usize, column: usize) -> Self {
+    pub fn new(line: u32, column: u32) -> Self {
         Self { line, column }
     }
 
     /// Mutates the location by shifting the original one down by `lines` and
     /// setting the column to `column`.
-    pub fn shift_down(&mut self, lines: usize, column: usize) {
+    pub fn shift_down(&mut self, lines: u32, column: u32) {
         if lines == 0 {
             self.shift_right(column);
             return;
@@ -37,7 +37,7 @@ impl Location {
     }
 
     /// Mutates the location by shifting the original one rightward by `columns`.
-    pub fn shift_right(&mut self, columns: usize) {
+    pub fn shift_right(&mut self, columns: u32) {
         self.column += columns;
     }
 }

crates/solidity/src/yul/lexer/token/mod.rs

@@ -15,12 +15,12 @@ pub struct Token {
     /// The lexeme.
     pub lexeme: Lexeme,
     /// The token length, including whitespaces.
-    pub length: usize,
+    pub length: u32,
 }
 
 impl Token {
     /// A shortcut constructor.
-    pub fn new(location: Location, lexeme: Lexeme, length: usize) -> Self {
+    pub fn new(location: Location, lexeme: Lexeme, length: u32) -> Self {
         Self {
             location,
             lexeme,