Add tests for inline functions

examples/greeter.sb

@@ -1,7 +1,5 @@
+fn greet(name: string) = "Hello " + name
+
 fn main() {
     println(greet("World"))
 }
-
-fn greet(name: string): string {
-    return "Hello " + name
-}

src/parser/parser.rs

@@ -141,7 +141,7 @@ impl Parser {
 
     pub(super) fn make_hint_msg(&mut self, msg: String) -> String {
         let new_lines = "\n".repeat(3);
-        format!("{new_lines}Hint: {}\n",msg)
+        format!("{new_lines}Hint: {}\n", msg)
     }
 
     pub(super) fn prev(&mut self) -> Option<Token> {

src/parser/rules.rs

@@ -405,16 +405,17 @@ impl Parser {
         };
 
         // Check if the parsed expression continues
-        if self.peek_token(TokenKind::Dot).is_ok() {
-            // foo.bar
-            self.parse_field_access(expr)
-        } else if BinOp::try_from(self.peek()?.kind).is_ok() {
-            // 1 + 2
-            self.parse_bin_op(Some(expr))
-        } else {
-            // Nope, the expression was fully parsed
-            Ok(expr)
+        if let Ok(next) = self.peek() {
+            if next.kind == TokenKind::Dot {
+                // foo.bar
+                return self.parse_field_access(expr);
+            } else if BinOp::try_from(next.kind).is_ok() {
+                // 1 + 2
+                return self.parse_bin_op(Some(expr));
+            }
         }
+        // Nope, the expression was fully parsed
+        Ok(expr)
     }
 
     fn parse_field_access(&mut self, lhs: Expression) -> Result<Expression, String> {

src/parser/tests.rs

@@ -37,6 +37,36 @@ fn test_parse_function_with_return() {
     assert!(tree.is_ok())
 }
 
+#[test]
+fn test_parse_inline_function() {
+    let raw = "
+    fn greet(name: string) = \"Hello \" + name
+    fn main() {
+        println(greet(\"World\"))
+    }
+    ";
+    let tokens = tokenize(raw).unwrap();
+    let tree = parse(tokens, Some(raw.to_string()), "".into());
+    assert!(tree.is_ok())
+}
+
+#[test]
+#[ignore]
+// I don't know how this fails yet. It seems to have something to do with how
+// `parse_expression` peeks tokens. It tries to peek a token after the
+// expression body but it's empty, so it errors out.
+fn test_parse_inline_function_as_last_statement() {
+    let raw = "
+    fn main() {
+        println(greet(\"World\"))
+    }
+    fn greet(name: string) = \"Hello \" + name
+    ";
+    let tokens = tokenize(raw).unwrap();
+    let tree = parse(tokens, Some(raw.to_string()), "".into());
+    assert!(tree.is_ok())
+}
+
 #[test]
 fn test_parse_redundant_semicolon() {
     let raw = "