Add arguments value 🏓

2 files changed, 20 insertions, 20 deletions

diff --git a/src/parse/collection.rs b/src/parse/collection.rs
index 162a8bd5..7ffc4539 100644
--- a/src/parse/collection.rs
+++ b/src/parse/collection.rs
@@ -51,29 +51,29 @@ fn collection<T: Collection>(p: &mut Parser, mut collection: T) -> T {
 }
 
 /// Parse an expression or a named pair.
-fn argument(p: &mut Parser) -> Option<Argument> {
+fn argument(p: &mut Parser) -> Option<ExprArg> {
     let first = expr(p)?;
     if p.eat_if(Token::Colon) {
         if let Expr::Ident(name) = first {
-            Some(Argument::Named(Named { name, expr: expr(p)? }))
+            Some(ExprArg::Named(Named { name, expr: expr(p)? }))
         } else {
             p.diag(error!(first.span(), "expected identifier"));
             expr(p);
             None
         }
     } else {
-        Some(Argument::Pos(first))
+        Some(ExprArg::Pos(first))
     }
 }
 
 /// Abstraction for comma-separated list of expression / named pairs.
 trait Collection {
-    fn push_arg(&mut self, p: &mut Parser, arg: Argument);
+    fn push_arg(&mut self, p: &mut Parser, arg: ExprArg);
     fn push_comma(&mut self) {}
 }
 
-impl Collection for Vec<Argument> {
-    fn push_arg(&mut self, _: &mut Parser, arg: Argument) {
+impl Collection for Vec<ExprArg> {
+    fn push_arg(&mut self, _: &mut Parser, arg: ExprArg) {
         self.push(arg);
     }
 }
@@ -99,23 +99,23 @@ impl State {
 }
 
 impl Collection for State {
-    fn push_arg(&mut self, p: &mut Parser, arg: Argument) {
+    fn push_arg(&mut self, p: &mut Parser, arg: ExprArg) {
         match self {
             Self::Unknown => match arg {
-                Argument::Pos(expr) => *self = Self::Expr(expr),
-                Argument::Named(named) => *self = Self::Dict(vec![named]),
+                ExprArg::Pos(expr) => *self = Self::Expr(expr),
+                ExprArg::Named(named) => *self = Self::Dict(vec![named]),
             },
             Self::Expr(prev) => match arg {
-                Argument::Pos(expr) => *self = Self::Array(vec![take(prev), expr]),
-                Argument::Named(_) => diag(p, arg),
+                ExprArg::Pos(expr) => *self = Self::Array(vec![take(prev), expr]),
+                ExprArg::Named(_) => diag(p, arg),
             },
             Self::Array(array) => match arg {
-                Argument::Pos(expr) => array.push(expr),
-                Argument::Named(_) => diag(p, arg),
+                ExprArg::Pos(expr) => array.push(expr),
+                ExprArg::Named(_) => diag(p, arg),
             },
             Self::Dict(dict) => match arg {
-                Argument::Pos(_) => diag(p, arg),
-                Argument::Named(named) => dict.push(named),
+                ExprArg::Pos(_) => diag(p, arg),
+                ExprArg::Named(named) => dict.push(named),
             },
         }
     }
@@ -135,9 +135,9 @@ fn take(expr: &mut Expr) -> Expr {
     )
 }
 
-fn diag(p: &mut Parser, arg: Argument) {
+fn diag(p: &mut Parser, arg: ExprArg) {
     p.diag(error!(arg.span(), "{}", match arg {
-        Argument::Pos(_) => "expected named pair, found expression",
-        Argument::Named(_) => "expected expression, found named pair",
+        ExprArg::Pos(_) => "expected named pair, found expression",
+        ExprArg::Named(_) => "expected expression, found named pair",
     }));
 }
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 2c34d7b8..e7e25a1d 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -198,11 +198,11 @@ fn bracket_call(p: &mut Parser) -> Option<Expr> {
     let mut inner = inner?;
     if let Some(body) = body {
         inner.span.expand(body.span());
-        inner.args.items.push(Argument::Pos(body));
+        inner.args.items.push(ExprArg::Pos(body));
     }
 
     while let Some(mut top) = outer.pop() {
-        top.args.items.push(Argument::Pos(Expr::Call(inner)));
+        top.args.items.push(ExprArg::Pos(Expr::Call(inner)));
         inner = top;
     }