Refactor ParserError into opaque struct (#71)

Author: jeparlefrancais

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+* refactor ParserError into an opaque struct (instead of an enum) ([#71](https://github.com/seaofvoices/darklua/pull/71))
 * refactor darklua frontend ([#69](https://github.com/seaofvoices/darklua/pull/69)):
   * the `--config-path` argument of the `minify` command was removed
   * the configuration file does not accept the `column_span` field anymore (use the [`generator` field](https://darklua.com/docs/generators/) instead)

src/frontend/error.rs

@@ -53,14 +53,14 @@ pub type DarkluaResult<T> = Result<T, DarkluaError>;
 
 #[derive(Debug, Clone)]
 pub struct DarkluaError {
-    kind: ErrorKind,
+    kind: Box<ErrorKind>,
     context: Option<Cow<'static, str>>,
 }
 
 impl DarkluaError {
     fn new(kind: ErrorKind) -> Self {
         Self {
-            kind,
+            kind: kind.into(),
             context: None,
         }
     }
@@ -184,7 +184,7 @@ impl From<ResourceError> for DarkluaError {
 
 impl Display for DarkluaError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.kind {
+        match &*self.kind {
             ErrorKind::Parser { path, error } => {
                 write!(f, "unable to parse `{}`: {}", path.display(), error)?;
             }

src/frontend/mod.rs

@@ -83,9 +83,10 @@ fn private_process(
             )
         }
     } else {
+        let input = options.input().to_path_buf();
         worker.process(
             resources
-                .collect_work(options.input().to_path_buf())
+                .collect_work(input)
                 .map(|source| Ok(WorkItem::new_in_place(source))),
             options,
         )

src/generator/token_based.rs

@@ -724,7 +724,7 @@ impl<'a> TokenBasedLuaGenerator<'a> {
             end: Token::from_content("end"),
             parameter_commas: intersect_with_token(
                 comma_token(),
-                function.parameters_count() + if function.is_variadic() { 1 } else { 0 },
+                function.parameters_count() + usize::from(function.is_variadic()),
             ),
             variable_arguments: if function.is_variadic() {
                 Some(Token::from_content("..."))
@@ -776,7 +776,7 @@ impl<'a> TokenBasedLuaGenerator<'a> {
             end: Token::from_content("end"),
             parameter_commas: intersect_with_token(
                 comma_token(),
-                function.parameters_count() + if function.is_variadic() { 1 } else { 0 },
+                function.parameters_count() + usize::from(function.is_variadic()),
             ),
             variable_arguments: if function.is_variadic() {
                 Some(Token::from_content("..."))
@@ -820,7 +820,7 @@ impl<'a> TokenBasedLuaGenerator<'a> {
             end: Token::from_content("end"),
             parameter_commas: intersect_with_token(
                 comma_token(),
-                function.parameters_count() + if function.is_variadic() { 1 } else { 0 },
+                function.parameters_count() + usize::from(function.is_variadic()),
             ),
             variable_arguments: if function.is_variadic() {
                 Some(Token::from_content("..."))

src/generator/utils.rs

@@ -266,7 +266,7 @@ pub fn write_string(string: &StringExpression) -> String {
 }
 
 fn write_long_bracket(value: &str) -> String {
-    let mut i = if value.ends_with(']') { 1 } else { 0 };
+    let mut i: usize = value.ends_with(']').into();
     let mut equals = "=".repeat(i);
     loop {
         if !value.contains(&format!("]{}]", equals)) {

src/nodes/expressions/string.rs

@@ -246,7 +246,7 @@ fn read_number(
     let mut amount = first_digit
         .map(|char| char.to_digit(radix).unwrap())
         .unwrap_or(0);
-    let mut iteration_count = if first_digit.is_some() { 1 } else { 0 };
+    let mut iteration_count: usize = first_digit.is_some().into();
 
     while let Some(next_digit) = chars.peek().cloned().filter(filter) {
         chars.next();

src/parser.rs

@@ -83,8 +83,8 @@ pub struct Parser {
 impl Parser {
     pub fn parse(&self, code: &str) -> Result<Block, ParserError> {
         full_moon::parse(code)
-            .map_err(ParserError::Parsing)
-            .and_then(|ast| self.convert_ast(ast).map_err(ParserError::Converting))
+            .map_err(ParserError::parsing)
+            .and_then(|ast| self.convert_ast(ast).map_err(ParserError::converting))
     }
 
     pub fn preserve_tokens(mut self) -> Self {
@@ -1048,7 +1048,7 @@ impl Parser {
 }
 
 #[derive(Clone, Debug)]
-pub enum ConvertError {
+enum ConvertError {
     Statement {
         statement: String,
     },
@@ -1134,16 +1134,35 @@ impl fmt::Display for ConvertError {
 }
 
 #[derive(Clone, Debug)]
-pub enum ParserError {
+enum ParserErrorKind {
     Parsing(full_moon::Error),
     Converting(ConvertError),
 }
 
+#[derive(Clone, Debug)]
+pub struct ParserError {
+    kind: Box<ParserErrorKind>,
+}
+
+impl ParserError {
+    fn parsing(err: full_moon::Error) -> Self {
+        Self {
+            kind: ParserErrorKind::Parsing(err).into(),
+        }
+    }
+
+    fn converting(err: ConvertError) -> Self {
+        Self {
+            kind: ParserErrorKind::Converting(err).into(),
+        }
+    }
+}
+
 impl fmt::Display for ParserError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Parsing(err) => write!(f, "{}", err),
-            Self::Converting(err) => write!(f, "{}", err),
+        match &*self.kind {
+            ParserErrorKind::Parsing(err) => write!(f, "{}", err),
+            ParserErrorKind::Converting(err) => write!(f, "{}", err),
         }
     }
 }

src/rules/filter_early_return.rs

@@ -10,7 +10,7 @@ use super::verify_no_rule_properties;
 struct Processor {}
 
 impl Processor {
-    fn search_remove_after(&self, block: &Block) -> Option<usize> {
+    fn search_remove_after(block: &Block) -> Option<usize> {
         block
             .iter_statements()
             .enumerate()
@@ -24,7 +24,7 @@ impl Processor {
                             LastStatement::Return(_) => Some(i),
                         }
                     } else {
-                        self.search_remove_after(inner_block).map(|_| i)
+                        Self::search_remove_after(inner_block).map(|_| i)
                     }
                 }
                 Statement::Assign(_)
@@ -44,7 +44,7 @@ impl Processor {
 
 impl NodeProcessor for Processor {
     fn process_block(&mut self, block: &mut Block) {
-        if let Some(remove_after) = self.search_remove_after(block) {
+        if let Some(remove_after) = Self::search_remove_after(block) {
             block.take_last_statement();
             block.truncate(remove_after + 1);
         }

tests/cli.rs

@@ -44,7 +44,7 @@ impl Context {
     pub fn expect_file<P: AsRef<Path>>(&self, file_path: P) -> &Self {
         let file_path = file_path.as_ref();
         if !file_path.exists() || !file_path.is_file() {
-            self.debug_working_directory(self.working_directory.path());
+            Self::debug_working_directory(self.working_directory.path());
         }
         assert!(
             file_path.exists(),
@@ -138,12 +138,12 @@ impl Context {
         string
     }
 
-    fn debug_working_directory(&self, root: &Path) {
+    fn debug_working_directory(root: &Path) {
         eprintln!("{}", root.display());
         for entry in root.read_dir().unwrap() {
             let entry = entry.unwrap().path();
             if entry.is_dir() {
-                self.debug_working_directory(&entry);
+                Self::debug_working_directory(&entry);
             } else {
                 eprintln!("{}", entry.display());
             }