fix(parser): issue in function declaration.

crates/fuse-parser/src/cursor.rs

@@ -14,10 +14,6 @@ impl<'a> Parser<'a> {
         self.cur_token().kind
     }
 
-    pub(crate) fn peek_token(&self) -> Option<&TokenReference> {
-        self.lexer.peek()
-    }
-
     pub(crate) fn consume(&mut self) -> TokenReference {
         let token = self.lexer.consume();
         self.prev_token = token.clone();

crates/fuse-parser/src/lexer/mod.rs

@@ -50,10 +50,6 @@ impl<'a> Lexer<'a> {
         &self.current_token
     }
 
-    pub fn peek(&self) -> Option<&TokenReference> {
-        self.lookahead.front().map(|next| &next.token)
-    }
-
     pub fn lookahead(&mut self, n: u8) -> &TokenReference {
         // Cache the new lookahead if it dosn't exists.
         self.ensure_lookahead(n);
@@ -108,14 +104,12 @@ impl<'a> Lexer<'a> {
             unsafe { self.source.set_position(lookahead.position) };
         }
 
-        let mut n = 0;
         for _ in self.lookahead.len()..n {
             let next = self.next_with_trivia();
             self.lookahead.push_back(Lookahead {
                 position: self.source.position(),
                 token: next,
             });
-            n += 1;
         }
 
         // SAFETY: Position is created at the begining of the function,

crates/fuse-parser/src/parsers/statements.rs

@@ -43,16 +43,17 @@ impl<'a> Parser<'a> {
                 .parse_expression()
                 .map(|expr| self.ast.expression_statement(expr)),
 
-            TokenKind::Function | TokenKind::Fn => match self.peek_token() {
-                // function declaration
-                Some(peek) if peek.kind() == TokenKind::Identifier => self
-                    .parse_function_declaration()
-                    .map(|func| self.ast.function_declaration_statement(func)),
-                // function expression
-                _ => self
-                    .parse_function_expression()
-                    .map(|expr| self.ast.expression_statement(expr)),
-            },
+            TokenKind::Function | TokenKind::Fn => {
+                if self.nth_kind(1) == TokenKind::Identifier {
+                    // function declaration
+                    self.parse_function_declaration()
+                        .map(|func| self.ast.function_declaration_statement(func))
+                } else {
+                    // function expression
+                    self.parse_function_expression()
+                        .map(|expr| self.ast.expression_statement(expr))
+                }
+            }
 
             kind if kind.is_trivial() => {
                 unreachable!("All trivial tokens should be eaten by a `TokenReference`.")

crates/fuse-parser/tests/cases/pass/function-declaration-01/ast.snap

@@ -0,0 +1,40 @@
+---
+source: crates/fuse-parser/tests/cases/mod.rs
+expression: parsed.chunk
+input_file: crates/fuse-parser/tests/cases/pass/function-declaration-01/case.fuse
+---
+Some(Chunk(
+  span: Span(
+    start: 0,
+    end: 20,
+  ),
+  body: Block(
+    statements: [
+      FunctionDeclaration(Function(
+        span: Span(
+          start: 0,
+          end: 15,
+        ),
+        identifier: Some(Identifier(
+          span: Span(
+            start: 9,
+            end: 13,
+          ),
+          name: Atom("test"),
+        )),
+        params: FunctionParameters(
+          span: Span(
+            start: 13,
+            end: 15,
+          ),
+          items: [],
+          rest: None,
+        ),
+        return_type: None,
+        body: Block(Block(
+          statements: [],
+        )),
+      )),
+    ],
+  ),
+))

crates/fuse-parser/tests/cases/pass/function-declaration-01/case.fuse

@@ -0,0 +1,2 @@
+function test()
+end

crates/fuse-parser/tests/cases/pass/function-declaration-01/tokens.snap

@@ -0,0 +1,86 @@
+---
+source: crates/fuse-parser/tests/cases/mod.rs
+expression: tokens
+input_file: crates/fuse-parser/tests/cases/pass/function-declaration-01/case.fuse
+---
+[
+  TokenReference(
+    token: Token(
+      span: Span(
+        start: 0,
+        end: 8,
+      ),
+      kind: Function,
+    ),
+    leading_trivia: [],
+    trailing_trivia: [
+      Token(
+        span: Span(
+          start: 8,
+          end: 9,
+        ),
+        kind: Whitespace,
+      ),
+    ],
+  ),
+  TokenReference(
+    token: Token(
+      span: Span(
+        start: 9,
+        end: 13,
+      ),
+      kind: Identifier,
+    ),
+    leading_trivia: [],
+    trailing_trivia: [],
+  ),
+  TokenReference(
+    token: Token(
+      span: Span(
+        start: 13,
+        end: 14,
+      ),
+      kind: LParen,
+    ),
+    leading_trivia: [],
+    trailing_trivia: [],
+  ),
+  TokenReference(
+    token: Token(
+      span: Span(
+        start: 14,
+        end: 15,
+      ),
+      kind: RParen,
+    ),
+    leading_trivia: [],
+    trailing_trivia: [
+      Token(
+        span: Span(
+          start: 15,
+          end: 16,
+        ),
+        kind: Whitespace,
+      ),
+    ],
+  ),
+  TokenReference(
+    token: Token(
+      span: Span(
+        start: 16,
+        end: 19,
+      ),
+      kind: End,
+    ),
+    leading_trivia: [],
+    trailing_trivia: [
+      Token(
+        span: Span(
+          start: 19,
+          end: 20,
+        ),
+        kind: Whitespace,
+      ),
+    ],
+  ),
+]