FIX: Removes unused code

base/src/expressions/lexer/mod.rs

@@ -140,7 +140,7 @@ impl Lexer {
     pub fn expect(&mut self, tk: TokenType) -> Result<()> {
         let nt = self.next_token();
         if index(&nt) != index(&tk) {
-            return Err(self.set_error(&format!("Error, expected {}", tk), self.position));
+            return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
         }
         Ok(())
     }

base/src/expressions/lexer/util.rs

@@ -80,8 +80,3 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
     tokens
 }
 
-impl fmt::Display for MarkedToken {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{}", self.token)
-    }
-}

base/src/expressions/mod.rs

@@ -1,8 +1,6 @@
 // public modules
 pub mod lexer;
 pub mod parser;
-#[cfg(test)]
-mod test_tokens_serde;
 pub mod token;
 pub mod types;
 pub mod utils;

base/src/expressions/parser/mod.rs

@@ -648,7 +648,7 @@ impl Parser {
             | TokenType::Percent => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
                 position: 0,
-                message: format!("Unexpected token: '{}'", next_token),
+                message: format!("Unexpected token: '{:?}'", next_token),
             },
             TokenType::LeftBracket => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),

base/src/expressions/test_tokens_serde.rs

@@ -1,12 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use super::lexer::util::{get_tokens, MarkedToken};
-
-#[test]
-fn test_simple_formula() {
-    let formula = "123+23";
-    let tokens = get_tokens(formula);
-    let tokens_str = serde_json::to_string(&tokens).unwrap();
-    let tokens_json: Vec<MarkedToken> = serde_json::from_str(&tokens_str).unwrap();
-    assert_eq!(tokens_json.len(), 3);
-}

base/src/expressions/token.rs

@@ -260,102 +260,6 @@ pub enum TokenType {
     },
 }
 
-impl fmt::Display for TokenType {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        use self::TokenType::*;
-        match self {
-            Illegal(_) => write!(fmt, "Illegal"),
-            EOF => write!(fmt, ""),
-            Ident(value) => write!(fmt, "{}", value),
-            String(value) => write!(fmt, "\"{}\"", value),
-            Number(value) => write!(fmt, "{}", value),
-            Boolean(value) => write!(fmt, "{}", value),
-            Error(value) => write!(fmt, "{}", value),
-            Compare(value) => write!(fmt, "{}", value),
-            Addition(value) => write!(fmt, "{}", value),
-            Product(value) => write!(fmt, "{}", value),
-            Power => write!(fmt, "^"),
-            LeftParenthesis => write!(fmt, "("),
-            RightParenthesis => write!(fmt, ")"),
-            Colon => write!(fmt, ":"),
-            Semicolon => write!(fmt, ";"),
-            LeftBracket => write!(fmt, "["),
-            RightBracket => write!(fmt, "]"),
-            LeftBrace => write!(fmt, "{{"),
-            RightBrace => write!(fmt, "}}"),
-            Comma => write!(fmt, ","),
-            Bang => write!(fmt, "!"),
-            Percent => write!(fmt, "%"),
-            And => write!(fmt, "&"),
-            Reference {
-                sheet,
-                row,
-                column,
-                absolute_column,
-                absolute_row,
-            } => {
-                let row_data = if *absolute_row {
-                    format!("{}", row)
-                } else {
-                    format!("${}", row)
-                };
-                let column_data = if *absolute_column {
-                    format!("{}", column)
-                } else {
-                    format!("${}", column)
-                };
-                match sheet {
-                    Some(name) => write!(fmt, "{}!{}{}", name, column_data, row_data),
-                    None => write!(fmt, "{}{}", column, row),
-                }
-            }
-            Range { sheet, left, right } => {
-                let row_left_data = if left.absolute_row {
-                    format!("{}", left.row)
-                } else {
-                    format!("${}", left.row)
-                };
-                let column_left_data = if left.absolute_column {
-                    format!("{}", left.column)
-                } else {
-                    format!("${}", left.column)
-                };
-
-                let row_right_data = if right.absolute_row {
-                    format!("{}", right.row)
-                } else {
-                    format!("${}", right.row)
-                };
-                let column_right_data = if right.absolute_column {
-                    format!("{}", right.column)
-                } else {
-                    format!("${}", right.column)
-                };
-                match sheet {
-                    Some(name) => write!(
-                        fmt,
-                        "{}!{}{}:{}{}",
-                        name, column_left_data, row_left_data, column_right_data, row_right_data
-                    ),
-                    None => write!(
-                        fmt,
-                        "{}{}:{}{}",
-                        left.column, left.row, right.column, right.row
-                    ),
-                }
-            }
-            StructuredReference {
-                table_name: _,
-                specifier: _,
-                table_reference: _,
-            } => {
-                // This should never happen
-                write!(fmt, "-----ERROR-----")
-            }
-        }
-    }
-}
-
 pub fn index(token: &TokenType) -> u32 {
     use self::TokenType::*;
     match token {