Remove warnings from parsing and casting

4 files changed, 37 insertions, 68 deletions

diff --git a/src/library/elements.rs b/src/library/elements.rs
index 6c6c66db..dd2da877 100644
--- a/src/library/elements.rs
+++ b/src/library/elements.rs
@@ -36,7 +36,7 @@ pub fn rect(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let width = args.named(ctx, "width");
     let height = args.named(ctx, "height");
     let fill = args.named(ctx, "fill");
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.eat().unwrap_or_default();
     rect_impl(width, height, None, fill, body)
 }
 
@@ -46,7 +46,7 @@ pub fn square(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let width = length.or_else(|| args.named(ctx, "width"));
     let height = width.is_none().then(|| args.named(ctx, "height")).flatten();
     let fill = args.named(ctx, "fill");
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.eat().unwrap_or_default();
     rect_impl(width, height, Some(N64::from(1.0)), fill, body)
 }
 
@@ -80,7 +80,7 @@ pub fn ellipse(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let width = args.named(ctx, "width");
     let height = args.named(ctx, "height");
     let fill = args.named(ctx, "fill");
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.eat().unwrap_or_default();
     ellipse_impl(width, height, None, fill, body)
 }
 
@@ -90,7 +90,7 @@ pub fn circle(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let width = radius.or_else(|| args.named(ctx, "width"));
     let height = width.is_none().then(|| args.named(ctx, "height")).flatten();
     let fill = args.named(ctx, "fill");
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.eat().unwrap_or_default();
     ellipse_impl(width, height, Some(N64::from(1.0)), fill, body)
 }
 
diff --git a/src/library/layout.rs b/src/library/layout.rs
index d7ada806..19352062 100644
--- a/src/library/layout.rs
+++ b/src/library/layout.rs
@@ -5,7 +5,7 @@ use crate::paper::{Paper, PaperClass};
 /// `page`: Configure pages.
 pub fn page(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let span = args.span;
-    let paper = args.eat::<Spanned<EcoString>>(ctx).and_then(|name| {
+    let paper = args.eat::<Spanned<EcoString>>().and_then(|name| {
         Paper::from_name(&name.v).or_else(|| {
             ctx.diag(error!(name.span, "invalid paper name"));
             None
@@ -104,8 +104,8 @@ fn spacing_impl(ctx: &mut EvalContext, args: &mut FuncArgs, axis: GenAxis) -> Va
 
 /// `align`: Configure the alignment along the layouting axes.
 pub fn align(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let first = args.eat::<AlignValue>(ctx);
-    let second = args.eat::<AlignValue>(ctx);
+    let first = args.eat::<AlignValue>();
+    let second = args.eat::<AlignValue>();
     let mut horizontal = args.named::<AlignValue>(ctx, "horizontal");
     let mut vertical = args.named::<AlignValue>(ctx, "vertical");
     let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
@@ -207,7 +207,7 @@ castable! {
 pub fn boxed(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let width = args.named(ctx, "width");
     let height = args.named(ctx, "height");
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.eat().unwrap_or_default();
     Value::template(move |ctx| {
         let child = ctx.exec_template_stack(&body).into();
         ctx.push_into_par(FixedNode { width, height, child });
@@ -216,7 +216,7 @@ pub fn boxed(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 
 /// `block`: Place content in a block.
 pub fn block(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let body = args.eat(ctx).unwrap_or_default();
+    let body = args.expect(ctx, "body").unwrap_or_default();
     Value::template(move |ctx| {
         let block = ctx.exec_template_stack(&body);
         ctx.push_into_stack(block);
@@ -225,7 +225,7 @@ pub fn block(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 
 /// `pad`: Pad content at the sides.
 pub fn pad(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let all = args.eat(ctx);
+    let all = args.eat();
     let left = args.named(ctx, "left");
     let top = args.named(ctx, "top");
     let right = args.named(ctx, "right");
@@ -248,7 +248,7 @@ pub fn pad(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 /// `stack`: Stack children along an axis.
 pub fn stack(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let dir = args.named::<Dir>(ctx, "dir").unwrap_or(Dir::TTB);
-    let children = args.all(ctx);
+    let children: Vec<_> = args.all().collect();
 
     Value::template(move |ctx| {
         let children = children
@@ -271,15 +271,18 @@ pub fn stack(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 pub fn grid(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     let columns = args.named::<Tracks>(ctx, "columns").unwrap_or_default();
     let rows = args.named::<Tracks>(ctx, "rows").unwrap_or_default();
+
+    let gutter_columns = args.named::<Tracks>(ctx, "gutter-columns");
+    let gutter_rows = args.named::<Tracks>(ctx, "gutter-rows");
     let gutter = args
         .named::<Linear>(ctx, "gutter")
         .map(|v| vec![TrackSizing::Linear(v)])
         .unwrap_or_default();
-    let gutter_columns = args.named::<Tracks>(ctx, "gutter-columns");
-    let gutter_rows = args.named::<Tracks>(ctx, "gutter-rows");
+
     let column_dir = args.named(ctx, "column-dir");
     let row_dir = args.named(ctx, "row-dir");
-    let children = args.all(ctx);
+
+    let children: Vec<_> = args.all().collect();
 
     Value::template(move |ctx| {
         let children = children
diff --git a/src/library/text.rs b/src/library/text.rs
index e6de04a1..0f6f3ec1 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -1,3 +1,5 @@
+use std::convert::TryFrom;
+
 use crate::exec::{FontState, LineState};
 use crate::font::{FontStretch, FontStyle, FontWeight};
 use crate::layout::Paint;
@@ -6,14 +8,14 @@ use super::*;
 
 /// `font`: Configure the font.
 pub fn font(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let families = args.all(ctx);
+    let families: Vec<_> = args.all().collect();
     let list = if families.is_empty() {
         args.named(ctx, "family")
     } else {
         Some(FontDef(families))
     };
 
-    let size = args.eat(ctx).or_else(|| args.named::<Linear>(ctx, "size"));
+    let size = args.eat().or_else(|| args.named::<Linear>(ctx, "size"));
     let style = args.named(ctx, "style");
     let weight = args.named(ctx, "weight");
     let stretch = args.named(ctx, "stretch");
@@ -116,42 +118,13 @@ castable! {
 castable! {
     FontWeight: "font weight",
     Value::Int(number) => {
-        let [min, max] = [Self::THIN, Self::BLACK];
-        let message = || format!(
-            "should be between {} and {}",
-            min.to_number(),
-            max.to_number(),
-        );
-
-        return if number < i64::from(min.to_number()) {
-            CastResult::Warn(min, message())
-        } else if number > i64::from(max.to_number()) {
-            CastResult::Warn(max, message())
-        } else {
-            CastResult::Ok(Self::from_number(number as u16))
-        };
-    },
+        u16::try_from(number).map_or(Self::BLACK, Self::from_number)
+    }
 }
 
 castable! {
     FontStretch: "font stretch",
-    Value::Relative(relative) => {
-        let [min, max] = [Self::ULTRA_CONDENSED, Self::ULTRA_EXPANDED];
-        let message = || format!(
-            "should be between {} and {}",
-            Relative::new(min.to_ratio() as f64),
-            Relative::new(max.to_ratio() as f64),
-        );
-
-        let ratio = relative.get() as f32;
-        let value = Self::from_ratio(ratio);
-
-        return if ratio < min.to_ratio() || ratio > max.to_ratio() {
-            CastResult::Warn(value, message())
-        } else {
-            CastResult::Ok(value)
-        };
-    },
+    Value::Relative(relative) => Self::from_ratio(relative.get() as f32),
 }
 
 castable! {
@@ -185,7 +158,7 @@ pub fn par(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 
 /// `lang`: Configure the language.
 pub fn lang(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
-    let iso = args.eat::<EcoString>(ctx).map(|s| lang_dir(&s));
+    let iso = args.eat::<EcoString>().map(|s| lang_dir(&s));
     let dir = match args.named::<Spanned<Dir>>(ctx, "dir") {
         Some(dir) if dir.v.axis() == SpecAxis::Horizontal => Some(dir.v),
         Some(dir) => {
@@ -235,8 +208,8 @@ fn line_impl(
     args: &mut FuncArgs,
     substate: fn(&mut FontState) -> &mut Option<Rc<LineState>>,
 ) -> Value {
-    let stroke = args.eat(ctx).or_else(|| args.named(ctx, "stroke"));
-    let thickness = args.eat(ctx).or_else(|| args.named::<Linear>(ctx, "thickness"));
+    let stroke = args.eat().or_else(|| args.named(ctx, "stroke"));
+    let thickness = args.eat().or_else(|| args.named::<Linear>(ctx, "thickness"));
     let offset = args.named(ctx, "offset");
     let extent = args.named(ctx, "extent").unwrap_or_default();
     let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
diff --git a/src/library/utility.rs b/src/library/utility.rs
index eaa6146d..ce45aae7 100644
--- a/src/library/utility.rs
+++ b/src/library/utility.rs
@@ -39,7 +39,7 @@ pub fn len(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 /// `rgb`: Create an RGB(A) color.
 pub fn rgb(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
     Value::Color(Color::Rgba(
-        if let Some(string) = args.eat::<Spanned<EcoString>>(ctx) {
+        if let Some(string) = args.eat::<Spanned<EcoString>>() {
             match RgbaColor::from_str(&string.v) {
                 Ok(color) => color,
                 Err(_) => {
@@ -48,20 +48,12 @@ pub fn rgb(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
                 }
             }
         } else {
-            let r = args.expect(ctx, "red component");
-            let g = args.expect(ctx, "green component");
-            let b = args.expect(ctx, "blue component");
-            let a = args.eat(ctx);
-            let mut clamp = |component: Option<Spanned<f64>>, default| {
-                component.map_or(default, |c| {
-                    if c.v < 0.0 || c.v > 1.0 {
-                        ctx.diag(warning!(c.span, "should be between 0.0 and 1.0"));
-                    }
-                    (c.v.max(0.0).min(1.0) * 255.0).round() as u8
-                })
-            };
-
-            RgbaColor::new(clamp(r, 0), clamp(g, 0), clamp(b, 0), clamp(a, 255))
+            let r = args.expect(ctx, "red component").unwrap_or(0.0);
+            let g = args.expect(ctx, "green component").unwrap_or(0.0);
+            let b = args.expect(ctx, "blue component").unwrap_or(0.0);
+            let a = args.eat().unwrap_or(1.0);
+            let f = |v: f64| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
+            RgbaColor::new(f(r), f(g), f(b), f(a))
         },
     ))
 }
@@ -78,16 +70,17 @@ pub fn max(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
 
 /// Find the minimum or maximum of a sequence of values.
 fn minmax(ctx: &mut EvalContext, args: &mut FuncArgs, goal: Ordering) -> Value {
+    let span = args.span;
     let mut extremum = None;
 
-    while let Some(value) = args.eat::<Value>(ctx) {
+    for value in args.all::<Value>() {
         if let Some(prev) = &extremum {
             match value.partial_cmp(&prev) {
                 Some(ordering) if ordering == goal => extremum = Some(value),
                 Some(_) => {}
                 None => {
                     ctx.diag(error!(
-                        args.span,
+                        span,
                         "cannot compare {} with {}",
                         prev.type_name(),
                         value.type_name(),