adjust errors to be more standard compliant

src/machine/preprocessor.rs

@@ -16,37 +16,47 @@ pub(crate) fn to_op_decl(prec: u16, spec: OpDeclSpec, name: Atom) -> OpDecl {
 }
 
 pub(crate) fn to_op_decl_spec(spec: Atom) -> Result<OpDeclSpec, CompilationError> {
-    OpDeclSpec::try_from(spec).map_err(|_err| CompilationError::InvalidOpDeclSpecValue(spec))
+    OpDeclSpec::try_from(spec).map_err(|_err| {
+        CompilationError::InvalidDecl(DeclarationError::InvalidOpDeclSpecValue(spec))
+    })
 }
 
 fn setup_op_decl(mut terms: Vec<Term>, atom_tbl: &AtomTable) -> Result<OpDecl, CompilationError> {
+    // should allow non-partial lists?
     let name = match terms.pop().unwrap() {
         Term::Literal(_, Literal::Atom(name)) => name,
         Term::Literal(_, Literal::Char(c)) => AtomTable::build_with(atom_tbl, &c.to_string()),
         other => {
-            return Err(CompilationError::InvalidOpDeclName(other));
+            return Err(CompilationError::InvalidDecl(
+                DeclarationError::InvalidOpDeclNameType(other),
+            ));
         }
     };
 
     let spec = match terms.pop().unwrap() {
         Term::Literal(_, Literal::Atom(name)) => name,
         other => {
-            return Err(CompilationError::InvalidOpDeclSpecTerm(other));
+            return Err(CompilationError::InvalidDecl(
+                DeclarationError::InvalidOpDeclSpecDomain(other),
+            ))
         }
     };
 
     let spec = to_op_decl_spec(spec)?;
 
     let prec = match terms.pop().unwrap() {
-        // once msrv is >= 1.78 we can remove the ref and the clone of term below
-        ref term @ Term::Literal(_, Literal::Fixnum(bi)) => match u16::try_from(bi.get_num()) {
+        Term::Literal(_, Literal::Fixnum(bi)) => match u16::try_from(bi.get_num()) {
             Ok(n) if n <= 1200 => n,
             _ => {
-                return Err(CompilationError::InvalidOpDeclPrec(term.clone()));
+                return Err(CompilationError::InvalidDecl(
+                    DeclarationError::InvalidOpDeclPrecDomain(bi),
+                ));
             }
         },
         other => {
-            return Err(CompilationError::InvalidOpDeclPrec(other));
+            return Err(CompilationError::InvalidDecl(
+                DeclarationError::InvalidOpDeclPrecType(other),
+            ));
         }
     };
 
@@ -335,9 +345,13 @@ pub(super) fn setup_declaration<'a, LS: LoadState<'a>>(
                 let (module_name, name, meta_specs) = setup_meta_predicate(terms, loader)?;
                 Ok(Declaration::MetaPredicate(module_name, name, meta_specs))
             }
-            _ => Err(CompilationError::InvalidDecl(name, terms.len())),
+            _ => Err(CompilationError::InvalidDecl(
+                DeclarationError::InvalidDecl(name, terms.len()),
+            )),
         },
-        other => Err(CompilationError::ExpectedDecl(other)),
+        other => Err(CompilationError::InvalidDecl(
+            DeclarationError::ExpectedDecl(other),
+        )),
     }
 }