Improved error casting system

parser/src/error.rs

@@ -46,34 +46,13 @@ impl<'a, F> AstError<'a, F> {
     }
 }
 
-pub trait GetParseError<'a, F> {
-    fn get<T>(self) -> AstResult<'a, F, T>;
+pub trait IntoErr<T> {
+    fn get(self) -> T;
 }
 
-impl<'a, F> GetParseError<'a, F> for AstResult<'a, F> {
-    fn get<T>(self) -> AstResult<'a, F, T> {
-        match self {
-            Ok(v) => Ok(v),
-            Err(e) => Err(e.get()),
-        }
-    }
-}
-
-impl<'a, F> GetParseError<'a, Option<F>> for Result<Option<F>, AstError<'a, F>> {
-    fn get<T>(self) -> AstResult<'a, Option<F>, T> {
-        match self {
-            Ok(v) => Ok(v),
-            Err(e) => Err(e.get()),
-        }
-    }
-}
-
-impl<'a, F> GetParseError<'a, Option<Vec<F>>> for Result<Option<Vec<F>>, AstError<'a, F>> {
-    fn get<T>(self) -> AstResult<'a, Option<Vec<F>>, T> {
-        match self {
-            Ok(v) => Ok(v),
-            Err(e) => Err(e.get()),
-        }
+impl<'a, T, TE, TE2> IntoErr<AstResult<'a, T, TE2>> for AstResult<'a, T, TE> {
+    fn get(self) -> AstResult<'a, T, TE2> {
+        self.map_err(AstError::get)
     }
 }
 

parser/src/lib.rs

@@ -7,7 +7,7 @@ pub mod parser;
 
 use ast::*;
 
-use crate::error::{GetParseError, ParseError};
+use crate::error::{IntoErr, ParseError};
 
 #[derive(Parser)]
 #[grammar = "./src/grammar.pest"]

parser/src/parser/common/decl.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError},
+    error::{AstError, IntoErr},
     parser::listen_rule,
 };
 

parser/src/parser/common/expr.rs

@@ -1,7 +1,8 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, AstResult, GetParseError, collect_recovered, collect_recovered_map},
+    ast_expr,
+    error::{AstError, IntoErr, collect_recovered, collect_recovered_map},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
@@ -15,26 +16,19 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
             Rule::expr => {
                 let prefixes = inner
                     .next()
-                    .map(|p| {
-                        p.into_inner()
-                            .into_iter()
-                            .map(Prefix::try_from)
-                            .collect::<AstResult<'a, Vec<_>, _>>()
-                    })
-                    .transpose()
-                    .get()?
-                    .unwrap_or_default();
+                    .map(|p| collect_recovered::<Prefix, Prefix>(p.into_inner()))
+                    .unwrap_or_else(|| Ok(Vec::new()));
 
-                let exp = Expression::try_from(inner.next().unwrap())?;
+                let exp = Expression::try_from(inner.next().unwrap());
 
-                if inner.len() > 0 || prefixes.len() > 0 {
-                    Ok(Expression::Fix {
-                        initial: Box::new(exp),
-                        prefixes,
-                        postfixes: collect_recovered(inner).get()?,
+                if inner.len() > 0 {
+                    ast_expr!(Expression::Fix {
+                        initial: exp.map(Box::new),
+                        prefixes: prefixes,
+                        postfixes: collect_recovered(inner),
                     })
                 } else {
-                    Ok(exp)
+                    Ok(exp?)
                 }
             }
             Rule::primary => Expression::try_from(inner.next().unwrap()),

parser/src/parser/common/mod.rs

@@ -6,7 +6,7 @@ pub mod types;
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
     parser::consume_rule,
 };
 

parser/src/parser/common/statement.rs

@@ -2,7 +2,7 @@ use crate::{
     Rule,
     ast::*,
     ast_expr,
-    error::{AstError, AstResult, ErrorCode, GetParseError, collect_recovered},
+    error::{AstError, AstResult, ErrorCode, IntoErr, collect_recovered},
     parser::listen_rule,
 };
 

parser/src/parser/common/types.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
     parser::{consume_rule, listen_rule},
 };
 

parser/src/parser/items/attribute.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Attribute {

parser/src/parser/items/class.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError},
+    error::{AstError, IntoErr},
     parser::consume_rule,
 };
 

parser/src/parser/items/enums.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for EnumItem {
@@ -25,7 +25,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for EnumItem {
                     .next()
                     .map(|pair| collect_recovered::<FieldDecl, FieldDecl>(pair.into_inner()))
                     .transpose()
-                    .get::<Self>()?
+                    .get()?
                     .unwrap_or_default(),
             )),
 

parser/src/parser/items/function.rs

@@ -2,7 +2,7 @@ use crate::{
     Rule,
     ast::*,
     ast_expr,
-    error::{AstError, AstResult, GetParseError, collect_recovered},
+    error::{AstError, AstResult, IntoErr, collect_recovered},
     parser::{consume_rule, listen_rule},
 };
 

parser/src/parser/items/impl_decl.rs

@@ -1,7 +1,7 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
     parser::consume_rule,
 };
 

parser/src/parser/items/mod.rs

@@ -8,7 +8,7 @@ use crate::{
     Rule,
     ast::*,
     ast_expr,
-    error::{AstError, GetParseError, collect_recovered},
+    error::{AstError, IntoErr, collect_recovered},
     parser::consume_rule,
 };