Desugar function calls with argument

src/ast/basic.rs

@@ -45,6 +45,15 @@ pub struct Ident {
     pub span: Span,
 }
 
+impl Ident {
+    pub fn new<S: ToString>(name: S, span: Span) -> Self {
+        Self {
+            name: name.to_string(),
+            span,
+        }
+    }
+}
+
 impl fmt::Debug for Ident {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "i#{}", self.name)

src/desugar/call.rs

@@ -1,8 +1,8 @@
-use chumsky::Span;
+use crate::ast::{Call, Expr, Ident, Lit, Separated, Space, TableLit, TableLitElem};
-
-use crate::ast::{Call, Expr, Lit, Space};
 use crate::span::HasSpan;
 
+// TODO Add span for just the parentheses to ast, or limit span to parentheses
+
 impl Call {
     pub fn desugar(self) -> (Expr, bool) {
         match self {
@@ -14,15 +14,59 @@ impl Call {
                 s2,
                 span,
             } => {
-                let new = Expr::Call(Self::Arg {
+                let (expr, desugared) = expr.desugar();
-                    expr,
+                if desugared {
-                    s0,
+                    let new = Expr::Call(Self::Arg {
-                    s1,
+                        expr: Box::new(expr),
-                    arg,
+                        s0,
-                    s2,
+                        s1,
+                        arg,
+                        s2,
+                        span,
+                    });
+                    return (new, true);
+                }
+
+                let (arg, desugared) = arg.desugar();
+                if desugared {
+                    let new = Expr::Call(Self::Arg {
+                        expr: Box::new(expr),
+                        s0,
+                        s1,
+                        arg: Box::new(arg),
+                        s2,
+                        span,
+                    });
+                    return (new, true);
+                }
+
+                let call = TableLitElem::Named {
+                    name: Ident::new("call", span),
+                    s0: Space::empty(span),
+                    s1: Space::empty(span),
+                    value: Box::new(expr),
                     span,
-                });
+                };
-                (new, false) // TODO Implement
+                let arg = TableLitElem::Named {
+                    name: Ident::new("arg", span),
+                    s0: Space::empty(span),
+                    s1: Space::empty(span),
+                    value: Box::new(arg),
+                    span,
+                };
+                let elems = Separated::NonEmpty {
+                    first_elem: call,
+                    last_elems: vec![((Space::empty(span), Space::empty(span)), arg)],
+                    trailing: None,
+                    span,
+                };
+                let new = Expr::Lit(Lit::Table(TableLit {
+                    s0: Space::empty(span),
+                    elems,
+                    s1: Space::empty(span),
+                    span,
+                }));
+                (new, true)
             }
 
             Self::NoArg { expr, s0, s1, span } => {