cargo fmt

Signed-off-by: Alek Ratzloff <alekratz@gmail.com>

src/syn/parser.rs

@@ -174,11 +174,7 @@ impl<'t> Parser<'t> {
         next_dot_expr
     );
     // .
-    bin_expr!(
+    bin_expr!(next_dot_expr, &[TokenKind::Dot], next_un_expr);
-        next_dot_expr,
-        &[TokenKind::Dot],
-        next_un_expr
-    );
 
     fn next_un_expr(&mut self) -> Result<Expr> {
         if let Some(un_op) = self.match_any_token_kind(&UN_EXPR_START)? {
@@ -296,29 +292,19 @@ impl<'t> Parser<'t> {
             let end_token =
                 self.expect_token_kind(TokenKind::RParen, "end of function call (right paren)")?;
             let span = expr.span().union(end_token.span());
-            let fun_call = Expr::FunCall(
+            let fun_call = Expr::FunCall(FunCallExpr { expr, args, span }.into());
-                FunCallExpr {
-                    expr,
-                    args,
-                    span,
-                }.into()
-            );
             self.next_suffix_expr(fun_call)
         } else if self.match_token_kind(TokenKind::LBracket)?.is_some() {
             // indexing
             let prev_skip = self.set_skip_newlines(true)?;
             let index = self.next_expr()?;
             self.set_skip_newlines(prev_skip)?;
-            let end_token =
+            let end_token = self.expect_token_kind(
-                self.expect_token_kind(TokenKind::RBracket, "end of index expression (right square bracket)")?;
+                TokenKind::RBracket,
+                "end of index expression (right square bracket)",
+            )?;
             let span = expr.span().union(end_token.span());
-            let index_expr = Expr::Index(
+            let index_expr = Expr::Index(IndexExpr { expr, index, span }.into());
-                IndexExpr {
-                    expr,
-                    index,
-                    span,
-                }.into()
-            );
             self.next_suffix_expr(index_expr)
         } else {
             Ok(expr)
@@ -617,19 +603,25 @@ mod test {
     }
 
     fn fun_call_expr(expr: Expr, args: Vec<Expr>) -> Expr {
-        Expr::FunCall(FunCallExpr {
+        Expr::FunCall(
+            FunCallExpr {
                 expr,
                 args,
                 span: Default::default(),
-        }.into())
+            }
+            .into(),
+        )
     }
 
     fn index_expr(expr: Expr, index: Expr) -> Expr {
-        Expr::Index(IndexExpr {
+        Expr::Index(
+            IndexExpr {
                 expr,
                 index,
                 span: Default::default(),
-        }.into())
+            }
+            .into(),
+        )
     }
 
     #[test]
@@ -861,7 +853,10 @@ mod test {
                 bin_expr(
                     fun_call_expr(base_expr(BaseExprKind::Ident), vec![]),
                     BinOp::Dot,
-                    fun_call_expr(base_expr(BaseExprKind::Ident), vec![base_expr(BaseExprKind::Ident)]),
+                    fun_call_expr(
+                        base_expr(BaseExprKind::Ident),
+                        vec![base_expr(BaseExprKind::Ident)]
+                    ),
                 )
             )
         );
@@ -975,10 +970,7 @@ mod test {
         test_parser!(
             Parser::try_from(r"foo()").unwrap(),
             next_expr,
-            fun_call_expr(
+            fun_call_expr(base_expr(BaseExprKind::Ident), vec![])
-                base_expr(BaseExprKind::Ident),
-                vec![]
-            )
         );
 
         test_parser!(
@@ -986,9 +978,7 @@ mod test {
             next_expr,
             fun_call_expr(
                 base_expr(BaseExprKind::Ident),
-                vec![
+                vec![base_expr(BaseExprKind::Ident)]
-                    base_expr(BaseExprKind::Ident)
-                ]
             )
         );
 
@@ -1006,11 +996,14 @@ mod test {
         );
 
         test_parser!(
-            Parser::try_from(r"foo(
+            Parser::try_from(
+                r"foo(
                     bar,
                     1,
                     :sym
-            )").unwrap(),
+            )"
+            )
+            .unwrap(),
             next_expr,
             fun_call_expr(
                 base_expr(BaseExprKind::Ident),
@@ -1026,10 +1019,7 @@ mod test {
             Parser::try_from(r"foo()[0]").unwrap(),
             next_expr,
             index_expr(
-                fun_call_expr(
+                fun_call_expr(base_expr(BaseExprKind::Ident), vec![]),
-                    base_expr(BaseExprKind::Ident),
-                    vec![]
-                ),
                 base_expr(BaseExprKind::Num),
             )
         );
@@ -1038,13 +1028,8 @@ mod test {
             Parser::try_from(r"foo[0](bar)").unwrap(),
             next_expr,
             fun_call_expr(
-                index_expr(
+                index_expr(base_expr(BaseExprKind::Ident), base_expr(BaseExprKind::Num),),
-                    base_expr(BaseExprKind::Ident),
+                vec![base_expr(BaseExprKind::Ident)]
-                    base_expr(BaseExprKind::Num),
-                ),
-                vec![
-                    base_expr(BaseExprKind::Ident)
-                ]
             )
         );
     }