FIX: Removes unused code

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 {