From ef1a527ef8b164e6a56fe3a34b34f0990297946a Mon Sep 17 00:00:00 2001 From: Rogier Reerink Date: Sun, 15 Nov 2026 12:32:51 +0100 Subject: [PATCH] Initial FnDef parsing. --- src/parser.rs | 154 +++++++++++++++++++++++++++++++++++++++++++++----- src/span.rs | 6 +- 2 files changed, 145 insertions(+), 15 deletions(-) diff --git a/src/parser.rs b/src/parser.rs index 8a0e8fc..3b95c6d 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -1,7 +1,9 @@ use std::iter::Peekable; use crate::{ - ast::{Assign, Block, Expr, FnCall, Ident, Let, LitNumber, LitString, Stmt}, + ast::{ + Assign, Block, Expr, FnCall, FnDef, FnParam, Ident, Let, LitNumber, LitString, Stmt, Type, + }, lexer::Token, span::{Span, Spanned}, }; @@ -114,22 +116,53 @@ where } .into()) } - Some(Token::CurlyBracketL) => { - let lbrace = self.next().unwrap(); - let mut stmts = Vec::new(); - while self.peek() != Some(&Token::CurlyBracketR) { - stmts.push(self.parse_stmt()?); + Some(Token::CurlyBracketL) => Ok(Stmt::Block(self.parse_block()?).into()), + Some(Token::Fn) => { + let r#fn = self.next().unwrap(); + let name = self.next_expected(Token::Ident)?; + let name = Ident { + name: self.slice(*name.span())?.to_string(), + span: *name.span(), + }; + self.next_expected(Token::ParenL)?; + let mut params = Vec::new(); + while self.peek() != Some(&Token::ParenR) { + let param_token = self.next_expected(Token::Ident)?; + let param_name = Ident { + name: self.slice(*param_token.span())?.to_string(), + span: *param_token.span(), + }; + self.next_expected(Token::Colon)?; + let param_type_token = self.next_expected(Token::Ident)?; + let param_type = match self.slice(*param_type_token.span())? { + "Number" => Type::Number, + "String" => Type::String, + other => { + return Err(ParseError { + span: *param_type_token.span(), + message: format!("Unknown type: {}", other), + }); + } + }; + params.push(FnParam { + name: param_name, + ty: param_type, + span: param_token.span_to(¶m_type_token), + }); + if self.next_if(Token::Comma).is_none() { + break; + } } - let rbrace = self.next_expected(Token::CurlyBracketR)?; - Ok(Block { - stmts, - span: lbrace.span_to(&rbrace), + self.next_expected(Token::ParenR)?; + let block = self.parse_block()?; + Ok(FnDef { + name, + params, + body: block.stmts, + span: r#fn.span().extend(&block.span), } .into()) } - Some(Token::Fn) => { - unimplemented!() - } Some(_) => Err(ParseError { span: self.current_span, message: "Unexpected token in statement".to_string(), @@ -206,6 +239,19 @@ where } } + fn parse_block(&mut self) -> Result { + let lbrace = self.next_expected(Token::CurlyBracketL)?; + let mut stmts = Vec::new(); + while self.peek() != Some(&Token::CurlyBracketR) { + stmts.push(self.parse_stmt()?); + } + let rbrace = self.next_expected(Token::CurlyBracketR)?; + Ok(Block { + stmts, + span: lbrace.span_to(&rbrace), + }) + } + fn unquote_string<'s>(s: &'s str, offset: usize) -> Result<&'s str, ParseError> { Ok(s.strip_prefix('"') .and_then(|s| s.strip_suffix('"')) @@ -411,7 +457,7 @@ mod tests { } #[test] - fn stmt_block() { + fn stmt_blocks() { let input = "{ x = 42; }"; let lexer = Lexer::new(input); let mut parser = Parser::new(input, lexer); @@ -438,6 +484,86 @@ mod tests { pretty_assertions::assert_eq!(parser.next(), None); } + #[test] + fn stmt_fns() { + let input = "fn foo() { x = 42; }"; + let lexer = Lexer::new(input); + let mut parser = Parser::new(input, lexer); + pretty_assertions::assert_eq!( + parser.parse_stmt(), + Ok(Stmt::Fn(FnDef { + name: Ident { + name: "foo".to_string(), + span: Span::new(3, 6), + }, + params: vec![], + body: vec![Stmt::Assign(Assign { + name: Ident { + name: "x".to_string(), + span: Span::new(11, 12), + }, + value: Expr::Literal( + LitNumber { + value: 42.0, + span: Span::new(15, 17) + } + .into() + ), + span: Span::new(11, 18), + })], + span: Span::new(0, 20), + })) + ); + pretty_assertions::assert_eq!(parser.next(), None); + + let input = "fn foo(p1: Number, p2: String) { x = 42; }"; + let lexer = Lexer::new(input); + let mut parser = Parser::new(input, lexer); + pretty_assertions::assert_eq!( + parser.parse_stmt(), + Ok(Stmt::Fn(FnDef { + name: Ident { + name: "foo".to_string(), + span: Span::new(3, 6), + }, + params: vec![ + FnParam { + name: Ident { + name: "p1".to_string(), + span: Span::new(7, 9), + }, + ty: Type::Number, + span: Span::new(7, 17), + }, + FnParam { + name: Ident { + name: "p2".to_string(), + span: Span::new(19, 21), + }, + ty: Type::String, + span: Span::new(19, 29), + }, + ], + body: vec![Stmt::Assign(Assign { + name: Ident { + name: "x".to_string(), + span: Span::new(33, 34), + }, + value: Expr::Literal( + LitNumber { + value: 42.0, + span: Span::new(37, 39) + } + .into() + ), + span: Span::new(33, 40), + })], + span: Span::new(0, 42), + })) + ); + pretty_assertions::assert_eq!(parser.next(), None); + } + #[test] fn expr_numbers() { let input = "500.0"; diff --git a/src/span.rs b/src/span.rs index 023cc92..f627dea 100644 --- a/src/span.rs +++ b/src/span.rs @@ -20,6 +20,10 @@ impl Span { pub fn len(&self) -> usize { self.end - self.start } + + pub fn extend(&self, other: &Span) -> Span { + Span::new(self.start, other.end) + } } impl Default for Span { @@ -48,6 +52,6 @@ impl Spanned { } pub fn span_to(&self, other: &Spanned) -> Span { - Span::new(self.span.start(), other.span.end()) + self.span.extend(&other.span) } }