refactor(error_report): remove dead code

src/command.rs

@@ -1,5 +1,5 @@
-use crate::meta_commands::{MetaCommand, MetaCommandExecuteResult, MetaCommandParseError};
-use crate::statements::{Statement, StatementExecuteResult, StatementParseError};
+use crate::meta_commands::{MetaCommand, MetaCommandExecuteResult};
+use crate::statements::{Statement, StatementExecuteResult};
 use crate::tokens::ScanError;
 
 #[derive(Debug)]
@@ -49,45 +49,21 @@ impl Command {
 
 #[derive(Debug)]
 pub enum CommandParseError {
-    MetaCommand(MetaCommandParseError),
-    Statement(StatementParseError),
     Scan(ScanError),
 }
 
-impl CommandParseError {
-    pub(crate) fn message(&self) -> String {
-        match self {
-            CommandParseError::MetaCommand(x) => format!("{x}"),
-            CommandParseError::Statement(x) => format!("{x}"),
-            CommandParseError::Scan(x) => format!("{x}"),
-        }
-    }
-}
-
 impl From<MetaCommand> for Command {
     fn from(value: MetaCommand) -> Self {
         Command::MetaCommand(value)
     }
 }
 
-impl From<MetaCommandParseError> for CommandParseError {
-    fn from(value: MetaCommandParseError) -> Self {
-        CommandParseError::MetaCommand(value)
-    }
-}
-
 impl From<Statement> for Command {
     fn from(value: Statement) -> Self {
         Command::Statement(value)
     }
 }
 
-impl From<StatementParseError> for CommandParseError {
-    fn from(value: StatementParseError) -> Self {
-        CommandParseError::Statement(value)
-    }
-}
-
 impl From<ScanError> for CommandParseError {
     fn from(value: ScanError) -> Self {
         CommandParseError::Scan(value)

src/error_display.rs

@@ -7,20 +7,8 @@ pub trait OSDBError {
 
 impl OSDBError for CommandParseError {
     fn display(&self, file: &str, input: &str) {
-        if let CommandParseError::Scan(x) = self {
-            x.display(file, input);
-        } else {
-            Report::build(ReportKind::Error, (file, 0..input.len() - 1))
-                .with_message(self.message())
-                .with_label(
-                    Label::new((file, 0..input.len() - 1))
-                        .with_color(Color::Red)
-                        .with_message(self.message()),
-                )
-                .finish()
-                .print((file, Source::from(input)))
-                .unwrap();
-        }
+        let CommandParseError::Scan(x) = self;
+        x.display(file, input);
     }
 }
 
@@ -34,6 +22,7 @@ impl OSDBError for ScanError {
                     .with_color(Color::Red)
                     .with_message(format!("{self}")),
             )
+            .with_help("Make sure you don't have any typos or unexpected characters.")
             .finish()
             .print((file, Source::from(input)))
             .unwrap();

src/meta_commands.rs

@@ -14,18 +14,3 @@ impl MetaCommand {
         }
     }
 }
-
-#[derive(Debug)]
-pub enum MetaCommandParseError {
-    Unrecognized { cmd: String },
-}
-
-impl std::fmt::Display for MetaCommandParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            MetaCommandParseError::Unrecognized { cmd } => {
-                write!(f, "unrecognized meta-command {cmd:?}")
-            }
-        }
-    }
-}

src/statements.rs

@@ -4,21 +4,6 @@ pub enum Statement {
     Select,
 }
 
-#[derive(Debug)]
-pub enum StatementParseError {
-    Unrecognized { stmt: String },
-}
-
-impl std::fmt::Display for StatementParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            StatementParseError::Unrecognized { stmt } => {
-                write!(f, "unrecognized statement {stmt:?}")
-            }
-        }
-    }
-}
-
 pub struct StatementExecuteResult {
     pub msg: String,
 }