fix binop with function

game.ayin

@@ -1,17 +1,21 @@
 let setup = fn() {
   return {
-    .player: { .position: { .x: 10, .y: 20 }, },
+    .color: {
+	  .r: 0,
+	  .g: 0,
+	  .b: 0,
+	}
   };
 };
 
 let update = fn(state, input) {
-  let new = random_u8();
+  state.color.g = state.color.g + (random_u8() % 3) % 50;
-  state.player.position.x = new;
+  state.color.b = (state.color.b + 1) % 255;
   return state;
 };
 
 let draw = fn(state) {
-  frame_clear(0,90,state.player.position.x);
+  frame_clear(state.color.r, state.color.g, state.color.b);
 };
 
 let migrate = fn(state) {

src/parser/parser.rs

@@ -107,16 +107,9 @@ fn parse_definition(tokens: &mut Tokens) -> ParseResult<ast::Definition> {
 }
 
 fn parse_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
-    if let Some(expr1) = parse_simple_expr(tokens)? {
+    if let Some(expr1) = parse_expr2(tokens)? {
         let expr1 = parse_dot(tokens, expr1)?;
-        if let Some(args) = tokens.between(&Token::OpenParen, &Token::CloseParen, |ts| {
+        if let Some((expr2, op)) = parse_op(tokens)? {
-            ts.many_sep_by(&Token::Comma, parse_expr)
-        })? {
-            Ok(Some(ast::Expr::FunCall {
-                func: Box::new(expr1),
-                args,
-            }))
-        } else if let Some((expr2, op)) = parse_op(tokens)? {
             let op = match op {
                 Op::Eq => ast::Op::Compare(ast::Cmp::Eq),
                 Op::NotEq => ast::Op::Compare(ast::Cmp::NotEq),
@@ -139,6 +132,23 @@ fn parse_expr(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
                 lhs: Box::new(expr1.clone()),
                 rhs: Box::new(expr2),
             }))
+        } else {
+            Ok(Some(expr1))
+        }
+    } else {
+        Ok(None)
+    }
+}
+fn parse_expr2(tokens: &mut Tokens) -> ParseResult<ast::Expr> {
+    if let Some(expr1) = parse_simple_expr(tokens)? {
+        let expr1 = parse_dot(tokens, expr1)?;
+        if let Some(args) = tokens.between(&Token::OpenParen, &Token::CloseParen, |ts| {
+            ts.many_sep_by(&Token::Comma, parse_expr)
+        })? {
+            Ok(Some(ast::Expr::FunCall {
+                func: Box::new(expr1),
+                args,
+            }))
         } else {
             Ok(parse_set(tokens)?
                 .map(|expr2| ast::Expr::Op {
@@ -437,6 +447,12 @@ mod tests {
         insta::assert_debug_snapshot!(result);
     }
     #[test]
+    fn paren_fncall_binop() {
+        let program = "random_u8() % 10".to_string();
+        let result = parse(&mut scan(program), parse_expr);
+        insta::assert_debug_snapshot!(result);
+    }
+    #[test]
     fn let_number() {
         let program = "let x = 108;".to_string();
         let result = parse(&mut scan(program), parse_definition);

src/parser/snapshots/ayin__parser__parser__tests__paren_fncall_binop.snap

@@ -0,0 +1,24 @@
+---
+source: src/parser/parser.rs
+expression: result
+---
+Ok(
+    Op {
+        lhs: FunCall {
+            func: Var(
+                Name(
+                    "random_u8",
+                ),
+            ),
+            args: [],
+        },
+        op: Calc(
+            Mod,
+        ),
+        rhs: Value(
+            Int(
+                10,
+            ),
+        ),
+    },
+)