Rename errors to problems and make error! macro more ergonomic 🧼

Also adds a `warning!` macro.

3 files changed, 58 insertions, 56 deletions

diff --git a/src/syntax/func/maps.rs b/src/syntax/func/maps.rs
index 8143d0a5..44d8e1aa 100644
--- a/src/syntax/func/maps.rs
+++ b/src/syntax/func/maps.rs
@@ -1,6 +1,6 @@
 //! Deduplicating maps and keys for argument parsing.
 
-use crate::error::Errors;
+use crate::problem::Problems;
 use crate::layout::prelude::*;
 use crate::size::{PSize, ValueBox};
 use crate::syntax::span::Spanned;
@@ -12,7 +12,7 @@ use super::*;
 /// A map which deduplicates redundant arguments.
 ///
 /// Whenever a duplicate argument is inserted into the map, through the
-/// functions `from_iter`, `insert` or `extend` an errors is added to the error
+/// functions `from_iter`, `insert` or `extend` an problems is added to the error
 /// list that needs to be passed to those functions.
 ///
 /// All entries need to have span information to enable the error reporting.
@@ -28,27 +28,27 @@ impl<K, V> DedupMap<K, V> where K: Eq {
     }
 
     /// Create a new map from an iterator of spanned keys and values.
-    pub fn from_iter<I>(errors: &mut Errors, iter: I) -> DedupMap<K, V>
+    pub fn from_iter<I>(problems: &mut Problems, iter: I) -> DedupMap<K, V>
     where I: IntoIterator<Item=Spanned<(K, V)>> {
         let mut map = DedupMap::new();
-        map.extend(errors, iter);
+        map.extend(problems, iter);
         map
     }
 
     /// Add a spanned key-value pair.
-    pub fn insert(&mut self, errors: &mut Errors, entry: Spanned<(K, V)>) {
+    pub fn insert(&mut self, problems: &mut Problems, entry: Spanned<(K, V)>) {
         if self.map.iter().any(|e| e.v.0 == entry.v.0) {
-            errors.push(err!(entry.span; "duplicate argument"));
+            problems.push(error!(entry.span, "duplicate argument"));
         } else {
             self.map.push(entry);
         }
     }
 
     /// Add multiple spanned key-value pairs.
-    pub fn extend<I>(&mut self, errors: &mut Errors, items: I)
+    pub fn extend<I>(&mut self, problems: &mut Problems, items: I)
     where I: IntoIterator<Item=Spanned<(K, V)>> {
         for item in items.into_iter() {
-            self.insert(errors, item);
+            self.insert(problems, item);
         }
     }
 
@@ -71,15 +71,15 @@ impl<K, V> DedupMap<K, V> where K: Eq {
     }
 
     /// Create a new map where keys and values are mapped to new keys and
-    /// values. When the mapping introduces new duplicates, errors are
+    /// values. When the mapping introduces new duplicates, problems are
     /// generated.
-    pub fn dedup<F, K2, V2>(&self, errors: &mut Errors, mut f: F) -> DedupMap<K2, V2>
+    pub fn dedup<F, K2, V2>(&self, problems: &mut Problems, mut f: F) -> DedupMap<K2, V2>
     where F: FnMut(&K, &V) -> (K2, V2), K2: Eq {
         let mut map = DedupMap::new();
 
         for Spanned { v: (key, value), span } in self.map.iter() {
             let (key, value) = f(key, value);
-            map.insert(errors, Spanned { v: (key, value), span: *span });
+            map.insert(problems, Spanned { v: (key, value), span: *span });
         }
 
         map
@@ -98,21 +98,21 @@ pub struct AxisMap<V>(DedupMap<AxisKey, V>);
 impl<V: Value> AxisMap<V> {
     /// Parse an axis map from the object.
     pub fn parse<K>(
-        errors: &mut Errors,
+        problems: &mut Problems,
         object: &mut Object,
     ) -> AxisMap<V> where K: Key + Into<AxisKey> {
         let values: Vec<_> = object
-            .get_all_spanned::<K, V>(errors)
+            .get_all_spanned::<K, V>(problems)
             .map(|s| s.map(|(k, v)| (k.into(), v)))
             .collect();
 
-        AxisMap(DedupMap::from_iter(errors, values))
+        AxisMap(DedupMap::from_iter(problems, values))
     }
 
     /// Deduplicate from specific or generic to just specific axes.
-    pub fn dedup(&self, errors: &mut Errors, axes: LayoutAxes) -> DedupMap<SpecificAxis, V>
+    pub fn dedup(&self, problems: &mut Problems, axes: LayoutAxes) -> DedupMap<SpecificAxis, V>
     where V: Clone {
-        self.0.dedup(errors, |key, val| (key.to_specific(axes), val.clone()))
+        self.0.dedup(problems, |key, val| (key.to_specific(axes), val.clone()))
     }
 }
 
@@ -124,23 +124,23 @@ pub struct PosAxisMap<V>(DedupMap<PosAxisKey, V>);
 impl<V: Value> PosAxisMap<V> {
     /// Parse a positional/axis map from the function arguments.
     pub fn parse<K>(
-        errors: &mut Errors,
+        problems: &mut Problems,
         args: &mut FuncArgs,
     ) -> PosAxisMap<V> where K: Key + Into<AxisKey> {
         let mut map = DedupMap::new();
 
         for &key in &[PosAxisKey::First, PosAxisKey::Second] {
-            if let Some(Spanned { v, span }) = args.pos.get::<Spanned<V>>(errors) {
-                map.insert(errors, Spanned { v: (key, v), span })
+            if let Some(Spanned { v, span }) = args.pos.get::<Spanned<V>>(problems) {
+                map.insert(problems, Spanned { v: (key, v), span })
             }
         }
 
         let keywords: Vec<_> = args.key
-            .get_all_spanned::<K, V>(errors)
+            .get_all_spanned::<K, V>(problems)
             .map(|s| s.map(|(k, v)| (PosAxisKey::Keyword(k.into()), v)))
             .collect();
 
-        map.extend(errors, keywords);
+        map.extend(problems, keywords);
 
         PosAxisMap(map)
     }
@@ -149,7 +149,7 @@ impl<V: Value> PosAxisMap<V> {
     /// or specific axes to just generic axes.
     pub fn dedup<F>(
         &self,
-        errors: &mut Errors,
+        problems: &mut Problems,
         axes: LayoutAxes,
         mut f: F,
     ) -> DedupMap<GenericAxis, V>
@@ -157,7 +157,7 @@ impl<V: Value> PosAxisMap<V> {
         F: FnMut(&V) -> Option<GenericAxis>,
         V: Clone,
     {
-        self.0.dedup(errors, |key, val| {
+        self.0.dedup(problems, |key, val| {
             (match key {
                 PosAxisKey::First => f(val).unwrap_or(GenericAxis::Primary),
                 PosAxisKey::Second => f(val).unwrap_or(GenericAxis::Secondary),
@@ -175,20 +175,20 @@ pub struct PaddingMap(DedupMap<PaddingKey<AxisKey>, Option<PSize>>);
 
 impl PaddingMap {
     /// Parse a padding map from the function arguments.
-    pub fn parse(errors: &mut Errors, args: &mut FuncArgs) -> PaddingMap {
+    pub fn parse(problems: &mut Problems, args: &mut FuncArgs) -> PaddingMap {
         let mut map = DedupMap::new();
 
-        let all = args.pos.get::<Spanned<Defaultable<PSize>>>(errors);
+        let all = args.pos.get::<Spanned<Defaultable<PSize>>>(problems);
         if let Some(Spanned { v, span }) = all {
-            map.insert(errors, Spanned { v: (PaddingKey::All, v.into()), span });
+            map.insert(problems, Spanned { v: (PaddingKey::All, v.into()), span });
         }
 
         let paddings: Vec<_> = args.key
-            .get_all_spanned::<PaddingKey<AxisKey>, Defaultable<PSize>>(errors)
+            .get_all_spanned::<PaddingKey<AxisKey>, Defaultable<PSize>>(problems)
             .map(|s| s.map(|(k, v)| (k, v.into())))
             .collect();
 
-        map.extend(errors, paddings);
+        map.extend(problems, paddings);
 
         PaddingMap(map)
     }
@@ -196,13 +196,13 @@ impl PaddingMap {
     /// Apply the specified padding on a value box of optional, scalable sizes.
     pub fn apply(
         &self,
-        errors: &mut Errors,
+        problems: &mut Problems,
         axes: LayoutAxes,
         padding: &mut ValueBox<Option<PSize>>
     ) {
         use PaddingKey::*;
 
-        let map = self.0.dedup(errors, |key, &val| {
+        let map = self.0.dedup(problems, |key, &val| {
             (match key {
                 All => All,
                 Both(axis) => Both(axis.to_specific(axes)),
diff --git a/src/syntax/func/mod.rs b/src/syntax/func/mod.rs
index fd516208..d379b407 100644
--- a/src/syntax/func/mod.rs
+++ b/src/syntax/func/mod.rs
@@ -1,7 +1,7 @@
 //! Primitives for argument parsing in library functions.
 
 use std::iter::FromIterator;
-use crate::error::{Error, Errors};
+use crate::problem::{Problem, Problems};
 use super::expr::{Expr, Ident, Tuple, Object, Pair};
 use super::span::{Span, Spanned};
 
@@ -84,13 +84,13 @@ pub enum FuncArg {
 pub trait OptionExt: Sized {
     /// Add an error about a missing argument `arg` with the given span if the
     /// option is `None`.
-    fn or_missing(self, errors: &mut Errors, span: Span, arg: &str) -> Self;
+    fn or_missing(self, problems: &mut Problems, span: Span, arg: &str) -> Self;
 }
 
 impl<T> OptionExt for Option<T> {
-    fn or_missing(self, errors: &mut Errors, span: Span, arg: &str) -> Self {
+    fn or_missing(self, problems: &mut Problems, span: Span, arg: &str) -> Self {
         if self.is_none() {
-            errors.push(err!(span; "missing argument: {}", arg));
+            problems.push(error!(span, "missing argument: {}", arg));
         }
         self
     }
diff --git a/src/syntax/func/values.rs b/src/syntax/func/values.rs
index 8e0c24b4..7a1aa912 100644
--- a/src/syntax/func/values.rs
+++ b/src/syntax/func/values.rs
@@ -23,20 +23,20 @@ use self::AlignmentValue::*;
 /// # Example implementation
 /// An implementation for `bool` might look as follows:
 /// ```
-/// # use typstc::err;
-/// # use typstc::error::Error;
+/// # use typstc::error;
+/// # use typstc::problem::Problem;
 /// # use typstc::syntax::expr::Expr;
 /// # use typstc::syntax::func::Value;
 /// # use typstc::syntax::span::Spanned;
 /// # struct Bool; /*
 /// impl Value for bool {
 /// # */ impl Value for Bool {
-///     fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+///     fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
 ///         match expr.v {
 ///             # /*
 ///             Expr::Bool(b) => Ok(b),
 ///             # */ Expr::Bool(_) => Ok(Bool),
-///             other => Err(err!("expected bool, found {}", other.name())),
+///             other => Err(error!("expected bool, found {}", other.name())),
 ///         }
 ///     }
 /// }
@@ -44,11 +44,11 @@ use self::AlignmentValue::*;
 pub trait Value: Sized {
     /// Parse an expression into this value or return an error if the expression
     /// is valid for this value type.
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error>;
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem>;
 }
 
 impl<V: Value> Value for Spanned<V> {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         let span = expr.span;
         V::parse(expr).map(|v| Spanned { v, span })
     }
@@ -58,12 +58,13 @@ impl<V: Value> Value for Spanned<V> {
 macro_rules! value {
     ($type:ty, $name:expr, $($p:pat => $r:expr),* $(,)?) => {
         impl Value for $type {
-            fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+            fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
                 #[allow(unreachable_patterns)]
                 match expr.v {
                     $($p => Ok($r)),*,
-                    other => Err(err!("expected {}, found {}",
-                                      $name, other.name())),
+                    other => Err(
+                        error!("expected {}, found {}", $name, other.name())
+                    ),
                 }
             }
         }
@@ -120,7 +121,7 @@ impl From<StringLike> for String {
 pub struct Defaultable<V>(pub Option<V>);
 
 impl<V: Value> Value for Defaultable<V> {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         Ok(Defaultable(match expr.v {
             Expr::Ident(ident) if ident.as_str() == "default" => None,
             _ => Some(V::parse(expr)?)
@@ -135,16 +136,16 @@ impl<V> From<Defaultable<V>> for Option<V> {
 }
 
 impl Value for FontStyle {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         FontStyle::from_name(Ident::parse(expr)?.as_str())
-            .ok_or_else(|| err!("invalid font style"))
+            .ok_or_else(|| error!("invalid font style"))
     }
 }
 
 /// The additional boolean specifies whether a number was clamped into the range
 /// 100 - 900 to make it a valid font weight.
 impl Value for (FontWeight, bool) {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         match expr.v {
             Expr::Number(weight) => {
                 let weight = weight.round();
@@ -158,30 +159,31 @@ impl Value for (FontWeight, bool) {
             }
             Expr::Ident(id) => {
                 FontWeight::from_name(id.as_str())
-                    .ok_or_else(|| err!("invalid font weight"))
+                    .ok_or_else(|| error!("invalid font weight"))
                     .map(|weight| (weight, false))
             }
-            other => Err(err!("expected identifier or number, \
-                               found {}", other.name())),
+            other => Err(
+                error!("expected identifier or number, found {}", other.name())
+            ),
         }
     }
 }
 
 impl Value for Paper {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         Paper::from_name(Ident::parse(expr)?.as_str())
-            .ok_or_else(|| err!("invalid paper type"))
+            .ok_or_else(|| error!("invalid paper type"))
     }
 }
 
 impl Value for Direction {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         Ok(match Ident::parse(expr)?.as_str() {
             "left-to-right" | "ltr" | "LTR" => LeftToRight,
             "right-to-left" | "rtl" | "RTL" => RightToLeft,
             "top-to-bottom" | "ttb" | "TTB" => TopToBottom,
             "bottom-to-top" | "btt" | "BTT" => BottomToTop,
-            _ => return Err(err!("invalid direction"))
+            _ => return Err(error!("invalid direction"))
         })
     }
 }
@@ -248,7 +250,7 @@ impl AlignmentValue {
 }
 
 impl Value for AlignmentValue {
-    fn parse(expr: Spanned<Expr>) -> Result<Self, Error> {
+    fn parse(expr: Spanned<Expr>) -> Result<Self, Problem> {
         Ok(match Ident::parse(expr)?.as_str() {
             "origin" => Align(Origin),
             "center" => Align(Center),
@@ -257,7 +259,7 @@ impl Value for AlignmentValue {
             "top"    => Top,
             "right"  => Right,
             "bottom" => Bottom,
-            _ => return Err(err!("invalid alignment"))
+            _ => return Err(error!("invalid alignment"))
         })
     }
 }