From 842216729b31cac3950f82cc219ab364f146b499 Mon Sep 17 00:00:00 2001 From: Giulio Agostini Date: Mon, 6 Jul 2026 10:43:17 +0200 Subject: [PATCH] wip: Add type system and refator for having only epression --- README.md => .rules | 0 README.org | 36 ++ examples/test_closure.lox | 12 +- examples/test_example.lox | 6 +- examples/test_function_call.lox | 28 +- grammar.org | 57 +++ src/backend/interpreter.rs | 196 +++++----- src/common/ast.rs | 460 ++++++++--------------- src/common/base_value.rs | 45 ++- src/common/mod.rs | 1 + src/common/types.rs | 70 ++++ src/frontend/lexer.rs | 30 +- src/frontend/parser.rs | 534 +++++++++++++-------------- src/frontend/source_registry.rs | 8 + src/frontend/tokens.rs | 6 +- src/lib.rs | 1 + src/logging/display_ast.rs | 83 +---- src/logging/display_token.rs | 6 +- src/main.rs | 21 +- src/middleend/variable_resolution.rs | 95 +++-- src/middleend/visit_ast.rs | 160 ++++---- tests/frontend.rs | 56 ++- tests/resolution.rs | 8 +- 23 files changed, 940 insertions(+), 979 deletions(-) rename README.md => .rules (100%) mode change 100755 => 100644 create mode 100755 README.org create mode 100644 grammar.org create mode 100644 src/common/types.rs diff --git a/README.md b/.rules old mode 100755 new mode 100644 similarity index 100% rename from README.md rename to .rules diff --git a/README.org b/README.org new file mode 100755 index 0000000..4dce23c --- /dev/null +++ b/README.org @@ -0,0 +1,36 @@ +#+title: README + +* Syntax example: +#+begin_src +funzione :: fn(parametro1: Number, parametro2: String): String do + +end +#+end_src + +* Planning: +allora quello che devo fare è: +** TODO Controllare se ho finito la questione del retourn:labe +** TODO implement struct: +#+begin_src rlox +Cosa :: struct{ + field1: Number +} +#+end_src +*** TODO update lexert +*** TODO update ast +*** TODO update parser +** TODO implement partial function ... +#+begin_src rlox +cosa := make(Cosa, feld1: 42) +function :: fn(self:Cosa, b: Number) -> Number +res := function(cosa,44) +#+end_src +*** TODO ... to undericlty create method +#+begin_src rlox +res := cosa.function(44) +#+end_src +*** TODO ... to make pipeline +#+begin_src rlox +res := cosa |> function(44) +#+end_src +** TODO Understand what is a type system diff --git a/examples/test_closure.lox b/examples/test_closure.lox index 719f093..7b0586c 100755 --- a/examples/test_closure.lox +++ b/examples/test_closure.lox @@ -1,12 +1,12 @@ -closure :: fn() do +closure :: fn(): Any do value := "Closure"; - internal :: fn() do + internal :: fn(): String do print value; return value; - end + end; return internal; -end +end; internal := closure(); internal(); @@ -17,9 +17,9 @@ c := b; c = b = a; d := c = b = a; do - showA :: fn() do + showA :: fn(): Nil do print a; - end + end; showA(); a := "Local"; diff --git a/examples/test_example.lox b/examples/test_example.lox index a1e87e2..b439140 100755 --- a/examples/test_example.lox +++ b/examples/test_example.lox @@ -4,7 +4,7 @@ // address: String, // } //func_name :: fn(param: Number, param2: String) {param is Int} do -func_name :: fn(param: Int, param2: String) do +func_name :: fn(param: Int, param2: String): Any do print param; print param2; while param < param2 do @@ -26,6 +26,6 @@ func_name :: fn(param: Int, param2: String) do end return False or True; -end +end; -func_name(1,20) +func_name(1,20); diff --git a/examples/test_function_call.lox b/examples/test_function_call.lox index aa045ee..013d673 100755 --- a/examples/test_function_call.lox +++ b/examples/test_function_call.lox @@ -1,30 +1,30 @@ -function :: fn() do +function :: fn(): Nil do print "Function"; -end +end; -function_factory :: fn() do +function_factory :: fn(): Any do print "Function Factory"; - function -end + function; +end; -function_fatcoty_factory :: fn() do +function_fatcoty_factory :: fn(): Any do print "Function Factory Factory"; return function_factory; -end +end; //function(); //function_factory()(); //function_fatcoty_factory()()(); -clock() +clock(); -closure :: fn() do - value = "Closure"; - internal :: fn() do +closure :: fn(): Any do + value := "Closure"; + internal :: fn(): Nil do print value; - end + end; return internal; -end +end; -closure() +closure(); diff --git a/grammar.org b/grammar.org new file mode 100644 index 0000000..aecd0a5 --- /dev/null +++ b/grammar.org @@ -0,0 +1,57 @@ + +statement -> print_statement + | return_statement + | break_statement + | block_statement + | var_statement + | if_statement + | while_statement + | for_statement + | expression_statement + +print_statement -> "print" expression ";" +return_statement -> "return" expression? ";" +break_statement -> "break" ";" +block_statement -> "do" statement* "end" +expression_statement -> expression ";"? + +; leading "var" optional; the ":" is required +var_statement -> "var"? IDENTIFIER ":" IDENTIFIER? + ( variable_declaration + | function_declaration + | struct_declaration ) ; struct = WIP +variable_declaration -> ( "=" expression )? ";" +function_declaration -> ":" "fn" "(" parameters? ")" ( "{" expression "}" )? statement +parameters -> IDENTIFIER ( ":" IDENTIFIER )? + ( "," IDENTIFIER ( ":" IDENTIFIER )? )* + +if_statement -> "if" expression "then" statement + ( "elif" expression "then" statement )* + ( "else" statement )? +while_statement -> "while" expression statement +for_statement -> "for" var_statement expression ";" expression_statement statement + +; ---------- expressions (lowest -> highest precedence) ---------- +expression -> assignment +assignment -> IDENTIFIER "=" assignment ; right-associative + | pipe +pipe -> logic ( "|>" logic )* ; left-assoc; x |> f(a) == f(x, a) +logic -> is ( ( "or" | "and" ) is )* +is -> equality ( "is" equality )* +equality -> comparison ( ( "==" | "!=" ) comparison )* +comparison -> term ( ( ">" | ">=" | "<" | "<=" ) term )* +term -> factor ( ( "+" | "-" ) factor )* +factor -> unary ( ( "*" | "/" ) unary )* +unary -> ( "!" | "-" ) unary | call +call -> primary ( "(" arguments? ")" )* +arguments -> expression ( "," expression )* +primary -> NUMBER | STRING | "true" | "false" | "nil" + | "(" expression ")" | IDENTIFIER + | dictionary | list | ATOM ; WIP + +; ---------- work in progress (lexed; parser support being added) ---------- +struct_declaration -> "struct" "{" field* "}" +field -> IDENTIFIER ( ":" IDENTIFIER )? ";" +dictionary -> "dict" "(" IDENTIFIER ":" expression + ( "," IDENTIFIER ":" expression )* ")" +list -> "list" "(" expression ( "," expression )* ")" diff --git a/src/backend/interpreter.rs b/src/backend/interpreter.rs index e73f6c5..00969ef 100755 --- a/src/backend/interpreter.rs +++ b/src/backend/interpreter.rs @@ -1,7 +1,7 @@ use crate::{ backend::environment::EnvironmentStack, common::{ - ast::{AstNode, Expr, NodeId, Stmt}, + ast::{AstNode, Expr, NodeId}, base_value::{BaseValue, NativeFunction, Number, Truthy}, lox_result::{runtime_error, LoxError, LoxResult}, }, @@ -21,18 +21,9 @@ pub trait EvaluateInterpreter { fn evaluate(&mut self, stmt: T) -> LoxResult; } -impl EvaluateInterpreter> for Interpreter { - fn evaluate(&mut self, node: AstNode) -> LoxResult { - let stmt = node.node; - let result = self.interpret_stmt_inner(stmt); - match result { - Ok(value) => Ok(value), - Err(LoxError::RuntimeError { - message, - source_slice, - }) if source_slice.is_synthetic() => runtime_error(node.source_slice.clone(), message), - Err(err) => Err(err), - } +impl EvaluateInterpreter for Interpreter { + fn evaluate(&mut self, node: AstNode) -> LoxResult { + self.eval_expr(&node) } } @@ -63,9 +54,9 @@ impl Interpreter { /// Evaluate an expression node, threading its `NodeId` so resolved /// variables and assignments can use their precomputed scope distance. - fn eval_expr(&mut self, node: &AstNode) -> LoxResult { + fn eval_expr(&mut self, node: &AstNode) -> LoxResult { let result = match &node.node { - Expr::Literal { value } => match value { + Expr::Literal { value } => match &**value { BaseValue::Function(func) => { let mut func = func.clone(); func.closure = Some(self.enviorment.clone()); @@ -93,6 +84,67 @@ impl Interpreter { let value = self.eval_expr(value)?; self.assign_variable(name, node.id, value) } + Expr::Print { expression } => { + let value = self.eval_expr(expression)?; + println!("{}", value); + Ok(BaseValue::Nil) + } + Expr::VarDeclaration { + name, initializer, .. + } => { + let value = match initializer { + Some(expr_node) => self.eval_expr(expr_node)?, + None => BaseValue::Nil, + }; + self.enviorment.declare(name.clone(), value) + } + Expr::Return { expression, .. } => self.eval_expr(expression), + Expr::Block { statements, .. } => self.evaluate_block(statements), + Expr::If { + condition, + then_branch, + elif_branches, + else_branch, + } => self.evaluate_if(condition, then_branch, elif_branches, else_branch), + Expr::While { condition, body } => { + let mut ret = BaseValue::Nil; + while self.eval_expr(condition)?.is_truthy() { + match self.eval_expr(body) { + Ok(val) => ret = val, + Err(LoxError::Return { value, .. }) => { + ret = value; + break; + } + Err(err) => return Err(err), + }; + } + Ok(ret) + } + Expr::For { + variable, + condition, + increment, + body, + } => { + let source_slice = variable.source_slice.clone(); + let val = self.eval_expr(variable)?; + if !matches!(val, BaseValue::Number(..)) { + return runtime_error(source_slice, "Expected number literal"); + } + let mut ret = BaseValue::Nil; + while self.eval_expr(condition)?.is_truthy() { + match self.eval_expr(body) { + Ok(val) => ret = val, + Err(LoxError::Return { value, .. }) => { + ret = value; + break; + } + Err(err) => return Err(err), + }; + self.eval_expr(increment)?; + } + Ok(ret) + } }; // Give location-less runtime errors this node's span. match result { @@ -125,11 +177,7 @@ impl Interpreter { } } - fn evaluate_call( - &mut self, - callee: &AstNode, - arguments: &[AstNode], - ) -> LoxResult { + fn evaluate_call(&mut self, callee: &AstNode, arguments: &[AstNode]) -> LoxResult { let source_slice = callee.source_slice.clone(); // A bare identifier callee resolves through `locals`; anything else is @@ -167,7 +215,7 @@ impl Interpreter { } // Execute the function body - let result = match self.evaluate(func.body) { + let result = match self.eval_expr(&func.body) { Ok(value) => Ok(value), Err(LoxError::Return { value, .. }) => Ok(value), Err(err) => Err(err), @@ -228,94 +276,22 @@ impl Interpreter { } } - fn interpret_stmt_inner(&mut self, stmt: Stmt) -> LoxResult { - match stmt { - Stmt::Expression { expression, .. } => self.eval_expr(&expression), - Stmt::Print { expression, .. } => { - let value = self.eval_expr(&expression)?; - println!("{}", value); - Ok(BaseValue::Nil) - } - Stmt::Block { statements, .. } => self.evaluate_block(*statements), - Stmt::Return { expression, .. } => self.eval_expr(&expression), - Stmt::VarDeclaration { - name, initializer, .. - } => { - let value = match initializer { - Some(expr_node) => self.eval_expr(&expr_node)?, - None => BaseValue::Nil, - }; - self.enviorment.declare(name.clone(), value) - } - - Stmt::If { - condition, - then_branch, - elif_branch, - else_branch, - .. - } => self.evaluate_if(condition, then_branch, elif_branch, else_branch), - Stmt::While { - condition, body, .. - } => { - let mut ret = BaseValue::Nil; - while self.eval_expr(&condition)?.is_truthy() { - match self.evaluate(*body.clone()) { - Ok(val) => ret = val, - Err(LoxError::Return { value, .. }) => { - ret = value; - break; - } - Err(err) => return Err(err), - }; - } - Ok(ret) - } - Stmt::For { - variable, - condition, - increment, - body, - .. - } => { - let source_slice = variable.source_slice.clone(); - let val = self.evaluate(*variable)?; - if !matches!(val, BaseValue::Number(..)) { - return runtime_error(source_slice, "Expected number literal"); - } - let mut ret = BaseValue::Nil; - while self.eval_expr(&condition)?.is_truthy() { - match self.evaluate(*body.clone()) { - Ok(val) => ret = val, - Err(LoxError::Return { value, .. }) => { - ret = value; - break; - } - Err(err) => return Err(err), - }; - self.evaluate(*increment.clone())?; - } - - Ok(ret) - } - } - } fn evaluate_if( &mut self, - condition: Box>, - then_branch: Box>, - elif_branch: Vec<(Box>, Box>)>, - else_branch: Option>>, + condition: &AstNode, + then_branch: &AstNode, + elif_branch: &[(Box, Box)], + else_branch: &Option>, ) -> LoxResult { - let condition = self.eval_expr(&condition)?; + let condition = self.eval_expr(condition)?; match condition { - BaseValue::Boolean(true) => self.evaluate(*then_branch), + BaseValue::Boolean(true) => self.eval_expr(then_branch), BaseValue::Boolean(false) => { for (elif_condition, elif_then_branch) in elif_branch { - let condition = self.eval_expr(&elif_condition)?; + let condition = self.eval_expr(elif_condition)?; match condition { BaseValue::Boolean(true) => { - return self.evaluate(*elif_then_branch); + return self.eval_expr(elif_then_branch); } BaseValue::Boolean(false) => continue, _ => { @@ -328,7 +304,7 @@ impl Interpreter { }; } if let Some(else_block) = else_branch { - self.evaluate(*else_block) + self.eval_expr(else_block) } else { Ok(BaseValue::Nil) } @@ -341,25 +317,23 @@ impl Interpreter { } } - fn evaluate_block(&mut self, statements: Vec>) -> LoxResult { + fn evaluate_block(&mut self, statements: &[AstNode]) -> LoxResult { self.enviorment.push_new_scope(); - // Ora elements è sempre disponibile let mut result = Ok(BaseValue::Nil); for statement in statements.iter() { - let node = statement.node.clone(); - match node { - Stmt::Return { expression, .. } => { - let value = self.eval_expr(&expression)?; + match &statement.node { + Expr::Return { expression, .. } => { + let value = self.eval_expr(expression)?; result = Err(LoxError::Return { source_slice: statement.source_slice.clone(), - value: value, + value, return_label: "Hi".to_string(), }); break; } - _ => result = self.evaluate((*statement).clone()), + _ => result = self.eval_expr(statement), }; } self.enviorment.pop_scope(); @@ -482,7 +456,7 @@ mod tests { #[test] fn defines_and_calls_a_function() { - let src = "add :: fn (a, b) do return a + b; end add(2, 3);"; + let src = "add :: fn (a, b): Number do return a + b; end; add(2, 3);"; assert_eq!(eval(src).unwrap().to_string(), "5"); } diff --git a/src/common/ast.rs b/src/common/ast.rs index 48c6381..fdfab03 100755 --- a/src/common/ast.rs +++ b/src/common/ast.rs @@ -1,5 +1,5 @@ use crate::{ - common::base_value::BaseValue, + common::{base_value::BaseValue, types::Type}, frontend::{source_registry::SourceSlice, tokens::TokenType}, }; use std::fmt::{Debug, Display}; @@ -22,65 +22,66 @@ impl NodeId { NodeId(NEXT_NODE_ID.fetch_add(1, Ordering::Relaxed)) } } -/* - * grammar: - * program -> statement* EOF - * statement -> expression_statement - * | print_statement - * | var_statement - * | block_statement - * | if_statement - * - * expression_statement -> expression ";" - * print_statement -> "print" expression ";" - * var_statement -> ("var"|"dyn"|"mut")? IDENTIFIER (":" IDENTIFIER)? (("=" expression)? ";")| function_declaration - * function_declaration -> "::" "(" parameters? ")" ("->" IDENTIFIER)? block_statement - * parameters -> ( IDENTIFIER (":" IDENTIFIER)? ("," IDENTIFIER (":" IDENTIFIER)? )* ) - * block_statement -> "do" statement* "end" - * if_statement -> "if" expression "then" statement ("elif" expression "then" statement)* ("else" statement)? "end" - * while_statement -> "while" expression "do" statement "end" - * - * expression -> assignment - * assignment -> IDENTIFIER "=" assignment | logical_or - * logical_or -> logical_and (("or" logical_and)* - * logical_and -> logical_is (("and" logical_is)* - * logical_is -> equality (("is" equality)* - * equality -> comparison (("==" | "!=") comparison)* - * comparison -> term ((">" | ">=" | "<" | "<=") term)* - * term -> factor (("+" | "-") factor)* - * factor -> unary (("*" | "/") unary)* - * unary -> ("!" | "-") unary | call - * call -> primary ("(" arguments ")")* - * arguments -> expression ("," expression)* - * primary -> NUMBER | STRING | "true" | "false" | "nil" | "(" expression ")" | IDENTIFIER - */ + #[derive(Clone, PartialEq)] pub enum Expr { Literal { - value: BaseValue, + value: Box, }, Binary { - left: Box>, + left: Box, operator: TokenType, - right: Box>, + right: Box, }, Unary { operator: TokenType, - operand: Box>, + operand: Box, }, Grouping { - expression: Box>, + expression: Box, }, Identifier { name: String, }, Call { - callee: Box>, - arguments: Vec>, + callee: Box, + arguments: Vec, }, Assign { name: String, - value: Box>, + value: Box, + }, + Print { + expression: Box, + }, + VarDeclaration { + name: String, + var_type: Type, + initializer: Option>, + }, + Return { + expression: Box, + label: String, + }, + Block { + statements: Box>, + label: String, + }, + If { + condition: Box, + then_branch: Box, + elif_branches: Vec<(Box, Box)>, + else_branch: Option>, + }, + While { + condition: Box, + body: Box, + }, + For { + variable: Box, + condition: Box, + increment: Box, + body: Box, }, } @@ -95,8 +96,10 @@ impl std::fmt::Display for Expr { right, } => write!(f, "Binary ({} {} {})", left.node, operator, right.node), Expr::Unary { operator, operand } => write!(f, "Unary ({} {})", operator, operand.node), - Expr::Grouping { expression } => write!(f, "Grouping (group {})", expression.node), - Expr::Identifier { name } => write!(f, "Identifier (variable {})", name), + Expr::Grouping { expression } => write!(f, "Grouping (group {})", expression.node,), + Expr::Identifier { name } => { + write!(f, "Identifier (variable {})", name) + } Expr::Call { callee, arguments } => write!( f, "Call ({}({}))", @@ -108,6 +111,59 @@ impl std::fmt::Display for Expr { .join(", ") ), Expr::Assign { name, value } => write!(f, "Assign ({} = {})", name, value.node), + Expr::If { + condition, + then_branch, + elif_branches, + else_branch, + } => { + let mut result = format!("IF ({}) {{\n{}\n}}", condition.node, then_branch.node); + for (condition, branch) in elif_branches { + result.push_str(&format!( + " ELIF ({}) {{\n{}\n}}", + condition.node, branch.node, + )); + } + if let Some(else_branch) = else_branch { + result.push_str(&format!(" ELSE {{\n{}\n}}", else_branch.node)); + } + write!(f, "IfStmt {}", result) + } + Expr::Print { expression } => write!(f, "Print({})", expression.node), + Expr::VarDeclaration { + name, + initializer, + var_type, + } => match initializer { + Some(init) => write!(f, "Var({} : {:?} = {})", name, var_type, init.node), + None => write!(f, "Var({} : {:?})", name, var_type), + }, + Expr::Return { expression, label } => { + write!(f, "Return({}, {})", expression.node, label) + } + Expr::Block { statements, label } => write!( + f, + "Block [{}] ([\n{}\n])", + label, + statements + .iter() + .map(|stmt| format!("\t \t{}", stmt.node)) + .collect::>() + .join("\n"), + ), + Expr::While { condition, body } => { + write!(f, "While({}) {{\n{}\n}}", condition.node, body.node) + } + Expr::For { + variable, + condition, + increment, + body, + } => write!( + f, + "For({} = {} in {}) {{\n{}\n}}", + variable.node, condition.node, increment.node, body.node + ), } } } @@ -115,15 +171,21 @@ impl std::fmt::Display for Expr { impl Debug for Expr { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Expr::Literal { value } => write!(f, "{:?}", value), + Expr::Literal { value } => write!(f, "{:?} ", value,), Expr::Binary { left, operator, right, - } => write!(f, "({:?} {:?} {:?})", operator, left.node, right.node), - Expr::Unary { operator, operand } => write!(f, "({:?} {:?})", operator, operand.node), - Expr::Grouping { expression } => write!(f, "(group {:?})", expression.node), - Expr::Identifier { name } => write!(f, "(variable {:?})", name), + } => write!(f, "({:?} {:?} {:?}) ", operator, left.node, right.node,), + Expr::Unary { operator, operand } => { + write!(f, "(Unary {:?} {:?}) ", operator, operand.node,) + } + Expr::Grouping { expression } => { + write!(f, "(Grouping {:?})", expression.node,) + } + Expr::Identifier { name } => { + write!(f, "(variable {:?})", name,) + } Expr::Call { callee, arguments } => write!( f, "Call ({}({}))", @@ -132,306 +194,90 @@ impl Debug for Expr { .iter() .map(|arg| arg.node.to_string()) .collect::>() - .join(", ") + .join(", "), ), - Expr::Assign { name, value } => write!(f, "(assign {:?} {:?})", name, value.node), - } - } -} - -#[derive(Clone, PartialEq)] -pub enum Stmt { - Expression { - expression: Box>, - return_value: Box, - }, - Print { - expression: Box>, - return_value: Box, - }, - VarDeclaration { - name: String, - initializer: Option>>, - return_value: Box, - }, - Return { - expression: Box>, - label: String, - return_value: Box, - }, - Block { - statements: Box>>, - label: String, - return_value: Box, - }, - If { - condition: Box>, - then_branch: Box>, - elif_branch: Vec<(Box>, Box>)>, - else_branch: Option>>, - return_value: Box, - }, - While { - condition: Box>, - body: Box>, - return_value: Box, - }, - For { - variable: Box>, - condition: Box>, - increment: Box>, - body: Box>, - return_value: Box, - }, -} - -impl Display for Stmt { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Stmt::Expression { - expression, - return_value, - } => write!(f, "Expression ({}) -> {:?}", expression.node, return_value), - Stmt::If { + Expr::Assign { name, value } => { + write!(f, "(assign {:?} {:?})", name, value.node,) + } + Expr::If { condition, then_branch, - elif_branch, + elif_branches, else_branch, - return_value, } => { - let mut result = format!("IF ({}) {{\n{}\n}}", condition.node, then_branch.node); - for (condition, branch) in elif_branch { + let mut result = + format!("IF ({:?}) {{\n{:?}\n}}", condition.node, then_branch.node,); + for (condition, branch) in elif_branches { result.push_str(&format!( - " ELIF ({}) {{\n{}\n}} -> {:?}", - condition.node, branch.node, return_value + " ELIF ({:?}) {{\n{:?}\n}}", + condition.node, branch.node, )); } if let Some(else_branch) = else_branch { - result.push_str(&format!( - " ELSE {{\n{}\n}} -> {:?}", - else_branch.node, return_value - )); - } - write!(f, "IfStmt {}", result) - } - Stmt::Print { - expression, - return_value, - } => write!(f, "Print({}) -> {:?};", expression.node, return_value), - Stmt::VarDeclaration { - name, - initializer, - return_value, - } => match initializer { - Some(init) => write!(f, "Var({} = {}) -> {:?};", name, init.node, return_value), - None => write!(f, "Var({}) -> {:?};", name, return_value), - }, - Stmt::Return { - expression, - return_value, - label, - } => write!( - f, - "Return({}, {}) -> {:?};", - expression.node, label, return_value - ), - Stmt::Block { - statements, - label, - return_value, - } => write!( - f, - "Block [{}] ([\n{}\n]) -> {:?}", - label, - statements - .iter() - .map(|stmt| format!("\t \t{}", stmt.node)) - .collect::>() - .join("\n"), - return_value - ), - Stmt::While { - condition, - body, - return_value, - } => { - write!( - f, - "While({}) {{\n{}\n}} -> {:?}", - condition.node, body.node, return_value - ) - } - Stmt::For { - variable, - condition, - increment, - body, - return_value, - } => write!( - f, - "For({} = {} in {}) {{\n{}\n}} -> {:?}", - variable.node, condition.node, increment.node, body.node, return_value - ), - } - } -} - -impl Debug for Stmt { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Stmt::Expression { - expression, - return_value, - } => write!( - f, - " Expression ({:?}) -> {:?}", - expression.node, return_value - ), - Stmt::If { - condition, - then_branch, - elif_branch, - else_branch, - return_value, - } => { - let mut result = format!( - "IF ({:?}) {{\n{:?}\n}} -> {:?} ", - condition.node, then_branch.node, return_value - ); - for (condition, branch) in elif_branch { - result.push_str(&format!( - " ELIF ({:?}) {{\n{:?}\n}} -> {:?} ", - condition.node, branch.node, return_value - )); - } - if let Some(else_branch) = else_branch { - result.push_str(&format!( - " ELSE {{\n{:?}\n}} -> {:?}", - else_branch.node, return_value - )); + result.push_str(&format!(" ELSE {{\n{:?}\n}}", else_branch.node,)); } write!(f, "IfStmt {:?}", result) } - Stmt::Print { - expression, - return_value, - } => write!(f, "Print({:?}) -> {:?};", expression.node, return_value), - Stmt::VarDeclaration { + Expr::Print { expression } => { + write!(f, "Print({:?});", expression.node,) + } + Expr::VarDeclaration { name, initializer, - return_value, + var_type, } => match initializer { - Some(init) => write!( - f, - "Var({:?} = {:?}) -> {:?};", - name, init.node, return_value - ), - None => write!(f, "Var({:?}) -> {:?};", name, return_value), + Some(init) => write!(f, "Var({:?}: {:?} = {:?});", name, var_type, init.node,), + None => write!(f, "Var({:?}: {:?});", name, var_type,), }, - Stmt::Return { - expression, - return_value, - label, - } => write!( + Expr::Return { expression, label } => { + write!(f, "Return({:?}, {}) ;", expression.node, label,) + } + Expr::Block { label, statements } => write!( f, - "Return({:?}, {}) -> {:?};", - expression.node, label, return_value - ), - Stmt::Block { - label, - statements, - return_value, - } => write!( - f, - "Block [{}] ([\n{:?}\n]) -> {:?}", + "Block [{}] ([\n{:?}\n])", label, statements .iter() .map(|stmt| format!("{:?}", stmt.node)) .collect::>() .join("\t\t\n"), - return_value ), - Stmt::While { - condition, - body, - return_value, - } => { - write!( - f, - "While({:?}) {{\n{:?}\n}} -> {:?}", - condition.node, body.node, return_value - ) + Expr::While { condition, body } => { + write!(f, "While({:?}) {{\n{:?}\n}}", condition.node, body.node,) } - Stmt::For { + Expr::For { variable, condition, increment, body, - return_value, } => write!( f, - "For({:?} = {:?} in {:?}) {{\n{:?}\n}} -> {:?}", - variable.node, condition.node, increment.node, body.node, return_value + "For({:?} = {:?} in {:?}) {{\n{:?}\n}} ", + variable.node, condition.node, increment.node, body.node, ), } } } -pub trait AstNodeKind { - fn kind(&self) -> &'static str; -} - -impl AstNodeKind for Expr { - fn kind(&self) -> &'static str { - match self { - Expr::Literal { value: _ } => "literal", - Expr::Binary { - left: _, - operator: _, - right: _, - } => "binary expression", - Expr::Unary { .. } => "unary expression", - Expr::Grouping { .. } => "grouping expression", - Expr::Identifier { .. } => "variable expression", - Expr::Call { .. } => "call expression", - Expr::Assign { .. } => "assignment expression", - } - } -} - -impl AstNodeKind for Stmt { - fn kind(&self) -> &'static str { - match self { - Stmt::Expression { .. } => "expression", - Stmt::VarDeclaration { .. } => "variable declaration", - Stmt::Return { .. } => "return statement", - Stmt::Block { .. } => "block statement", - Stmt::If { .. } => "if statement", - Stmt::Print { .. } => "print statement", - Stmt::While { .. } => "while statement", - Stmt::For { .. } => "for statement", - } - } -} - #[derive(Clone)] -pub struct AstNode { +pub struct AstNode { /// Stable identity, assigned at construction and preserved across clones. pub id: NodeId, - pub node: T, + pub node: Expr, + pub is_statement: bool, pub source_slice: SourceSlice, + pub return_type: Type, } // Identity (`id`) deliberately does not participate in equality: two nodes are // equal when their content and location match, regardless of node id. -impl PartialEq for AstNode { +impl PartialEq for AstNode { fn eq(&self, other: &Self) -> bool { self.node == other.node && self.source_slice == other.source_slice } } -impl Display for AstNode { +impl Display for AstNode { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!( f, @@ -441,7 +287,7 @@ impl Display for AstNode { } } -impl Debug for AstNode { +impl Debug for AstNode { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!( f, @@ -451,12 +297,22 @@ impl Debug for AstNode { } } -impl AstNode { - pub fn new(node: T, source_slice: SourceSlice) -> Self { +impl AstNode { + fn new(node: Expr, source_slice: SourceSlice, type_name: String, is_statement: bool) -> Self { AstNode { id: NodeId::next(), node, + is_statement, source_slice, + return_type: Type::Unresolved(type_name), } } + + pub fn new_statement(node: Expr, source_slice: SourceSlice) -> Self { + Self::new(node, source_slice, "Nil".to_string(), true) + } + + pub fn new_expression(node: Expr, source_slice: SourceSlice, type_name: String) -> Self { + Self::new(node, source_slice, type_name, false) + } } diff --git a/src/common/base_value.rs b/src/common/base_value.rs index bc6ed9c..9d1862d 100755 --- a/src/common/base_value.rs +++ b/src/common/base_value.rs @@ -1,12 +1,12 @@ use core::fmt; +use std::collections::HashMap; use std::fmt::Display; use std::ops::{Add, Div, Mul, Not, Rem, Sub}; -use crate::backend::environment::Environment; use crate::common::lox_result::{runtime_error, LoxResult}; +use crate::common::types::Type; use crate::{ - backend::environment::EnvironmentStack, - common::ast::{AstNode, Expr, Stmt}, + backend::environment::EnvironmentStack, common::ast::AstNode, frontend::source_registry::SourceSlice, }; #[derive(Debug, Clone, PartialEq)] @@ -272,15 +272,20 @@ pub enum BaseValue { Nil, Function(LoxFunction), NativeFunction(NativeFunction), + Struct(Struct), +} + +struct Dict { + map: HashMap, } struct ReturnValue { label: Vec, - value: BaseValue, + value: Type, } impl ReturnValue { - pub fn new(label: Vec, value: BaseValue) -> Self { + pub fn new(label: Vec, value: Type) -> Self { Self { label, value } } } @@ -304,39 +309,40 @@ impl Display for BaseValue { BaseValue::Nil => write!(f, "nil"), BaseValue::Function(..) => write!(f, ""), BaseValue::NativeFunction(..) => write!(f, ""), + BaseValue::Struct(_) => write!(f, ""), } } } #[derive(Debug, Clone, PartialEq)] pub struct LoxFunction { - pub parameters: Vec<(String, String)>, - pub return_type: Option, - pub body: AstNode, + pub parameters: Vec<(String, Type)>, + pub return_type: Type, + pub body: AstNode, pub closure: Option>, - pub guard: Option>>, + pub guard: Option>, } impl LoxFunction { pub fn new( - parameters: Vec<(String, String)>, - body: AstNode, + parameters: Vec<(String, Type)>, + body: AstNode, closure: Option>, - guard: Option>>, + guard: Option>, ) -> Self { LoxFunction { parameters, - return_type: None, + return_type: Type::Any, body, closure, guard, } } - pub fn anonymous_function(parameters: Vec<(String, String)>, body: AstNode) -> Self { + pub fn anonymous_function(parameters: Vec<(String, Type)>, body: AstNode) -> Self { LoxFunction { parameters, - return_type: None, + return_type: Type::Any, body, closure: None, guard: None, @@ -346,12 +352,12 @@ impl LoxFunction { #[derive(Debug, Clone, PartialEq)] pub struct NativeFunction { - pub parameters: Vec<(String, String)>, + pub parameters: Vec<(String, Type)>, pub function: fn(&[BaseValue]) -> BaseValue, } impl NativeFunction { - pub fn new(parameters: Vec<(String, String)>, function: fn(&[BaseValue]) -> BaseValue) -> Self { + pub fn new(parameters: Vec<(String, Type)>, function: fn(&[BaseValue]) -> BaseValue) -> Self { NativeFunction { parameters, function, @@ -359,6 +365,11 @@ impl NativeFunction { } } +#[derive(Debug, Clone, PartialEq)] +pub struct Struct { + pub fields: Vec<(String, BaseValue)>, +} + // Trait implementations for BaseValue pub trait Truthy { diff --git a/src/common/mod.rs b/src/common/mod.rs index 736f74d..ccbfcd9 100755 --- a/src/common/mod.rs +++ b/src/common/mod.rs @@ -1,3 +1,4 @@ pub mod ast; pub mod base_value; pub mod lox_result; +pub mod types; diff --git a/src/common/types.rs b/src/common/types.rs new file mode 100644 index 0000000..d5a3dd7 --- /dev/null +++ b/src/common/types.rs @@ -0,0 +1,70 @@ +use std::{fmt::Display, rc::Rc}; + +#[derive(Debug, Clone, PartialEq)] +pub enum Type { + Any, + Number, + String, + Boolean, + Nil, + Function(FunctionType), + Struct(Rc), + Unresolved(String), +} + +impl Display for Type { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Type::Any => write!(f, "any"), + Type::Number => write!(f, "number"), + Type::String => write!(f, "string"), + Type::Boolean => write!(f, "boolean"), + Type::Nil => write!(f, "nil"), + Type::Function(fun) => write!(f, "{}", fun), + Type::Struct(struct_) => write!(f, "{}", struct_), + Type::Unresolved(name) => write!(f, "{}", name), + } + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct FunctionType { + pub params: Vec<(String, Box)>, + pub return_type: Box, +} + +impl Display for FunctionType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let rendered_params = self + .params + .iter() + .map(|(name, ty)| format!("{}: {}", name, ty)) + .collect::>() + .join(", "); + write!(f, "fn({}) -> {}", rendered_params, self.return_type) + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct StructType { + pub fields: Vec<(String, Box)>, + pub methods: Vec<(String, FunctionType)>, +} + +impl Display for StructType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let rendered_field = self + .fields + .iter() + .map(|(name, ty)| format!("{}: {}", name, ty)) + .collect::>() + .join(", "); + let rendered_method = self + .methods + .iter() + .map(|(name, ty)| format!("{}: {}", name, ty)) + .collect::>() + .join(", "); + write!(f, "struct {{ {}, {} }}", rendered_field, rendered_method) + } +} diff --git a/src/frontend/lexer.rs b/src/frontend/lexer.rs index 5c65137..5a61faf 100755 --- a/src/frontend/lexer.rs +++ b/src/frontend/lexer.rs @@ -16,7 +16,7 @@ pub struct Lexer { fn get_keyword_token(word: &str) -> Option { match word { "and" => Some(TokenType::And), - "class" => Some(TokenType::Class), + "struct" => Some(TokenType::Struct), "do" => Some(TokenType::StartBlock), "end" => Some(TokenType::EndBlock), "false" => Some(TokenType::False), @@ -514,4 +514,32 @@ mod tests { assert_eq!(tokens[1].source_slice.start_position.line, 1); assert_eq!(tokens[1].source_slice.start_position.column, 0); } + + #[test] + fn handle_struct() { + let tokens = lex("Cosa :: struct {field1: Number, field2: String}"); + let tokens_tyepe: Vec = tokens.iter().map(|x| x.token_type.clone()).collect(); + let tokent_for_check = vec![ + TokenType::Identifier, + TokenType::Colon, + TokenType::Colon, + TokenType::Struct, + TokenType::LeftBrace, + TokenType::Identifier, + TokenType::Colon, + TokenType::Identifier, + TokenType::Comma, + TokenType::Identifier, + TokenType::Colon, + TokenType::Identifier, + TokenType::RightBrace, + TokenType::Eof, + ]; + assert_eq!(tokens_tyepe, tokent_for_check); + assert_eq!(tokens[0].lexeme, "Cosa"); + assert_eq!(tokens[5].lexeme, "field1"); + assert_eq!(tokens[7].lexeme, "Number"); + assert_eq!(tokens[9].lexeme, "field2"); + assert_eq!(tokens[11].lexeme, "String"); + } } diff --git a/src/frontend/parser.rs b/src/frontend/parser.rs index 1a279c0..034bbb1 100755 --- a/src/frontend/parser.rs +++ b/src/frontend/parser.rs @@ -1,8 +1,11 @@ +use std::collections::hash_map::Values; + use crate::{ common::{ - ast::{AstNode, Expr, Stmt}, + ast::{AstNode, Expr}, base_value::{BaseValue, LoxFunction}, lox_result::{parse_error, runtime_error, LoxError, LoxResult}, + types::{FunctionType, Type}, }, frontend::{ source_registry::SourceSlice, @@ -20,11 +23,11 @@ impl Parser { Self { tokens, current: 0 } } - pub fn parse(&mut self) -> LoxResult>> { + pub fn parse(&mut self) -> LoxResult> { let mut statements = Vec::new(); let mut errors = Vec::new(); while !self.is_at_end() { - match self.statement(None) { + match self.statement() { Ok(stmt) => { statements.push(stmt.clone()); } @@ -42,12 +45,23 @@ impl Parser { Ok(statements) } - fn statement(&mut self, label: Option) -> LoxResult> { + fn statement(&mut self) -> LoxResult { match (&self.peek().token_type, &self.peek_next().token_type) { (TokenType::Print, _) => self.print_statement(), - (TokenType::Return, _) => self.return_statement(label), + (TokenType::Return, _) => { + let mut label = None; + if self.peek_next().token_type == TokenType::Colon { + self.advance(); + label = Some( + self.consume(TokenType::Identifier, "Expect label after return colon.")? + .lexeme + .clone(), + ); + } + self.return_statement(label) + } (TokenType::Break, _) => self.return_statement(Some("loop".to_string())), - (TokenType::StartBlock, _) => self.block_statement(label), + (TokenType::StartBlock, _) => self.block_statement(), (TokenType::Var, TokenType::Identifier) => { self.advance(); self.var_statement() @@ -60,7 +74,7 @@ impl Parser { } } - fn for_statement(&mut self) -> LoxResult> { + fn for_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); self.advance(); // consume 'for' @@ -68,7 +82,7 @@ impl Parser { let condition = self.expression()?; self.consume(TokenType::Semicolon, "Expected ';' after for condition")?; let increment = self.expression_statement()?; - let body = self.statement(Some("loop".to_string()))?; + let body = self.statement()?; let end_slice = self.previous().source_slice.clone(); let combined_slice = SourceSlice::from_positions( @@ -77,87 +91,43 @@ impl Parser { end_slice.end_position, ); - Ok(AstNode::new( - Stmt::For { + Ok(AstNode::new_statement( + Expr::For { variable: Box::new(variable), condition: Box::new(condition), increment: Box::new(increment), body: Box::new(body), - return_value: Box::new(BaseValue::Nil), }, combined_slice, )) } - // fn for_statement(&mut self) -> LoxResult> { - // let start_slice = self.peek().source_slice.clone(); - // self.advance(); - // let variable = if let Token { - // token_type: TokenType::Identifier, - // literal: Some(variable_name), - // source_slice, - // .. - // } = self.peek() - // { - // AstNode { - // node: Expr::Literal { - // value: variable_name.clone(), - // }, - // source_slice: source_slice.clone(), - // } - // } else { - // return parse_error( - // self.peek().source_slice.clone(), - // "Expect variable name after 'for' keyword.", - // ); - // }; - // self.advance(); - // self.consume(TokenType::In, "Expect 'in' after for variable.")?; - // let iterable = self.expression()?; - // let body = self.statement(None)?; - // let end_slice = body.source_slice.clone(); - // let combined_slice = SourceSlice::from_positions( - // start_slice.source_id, - // start_slice.start_position, - // end_slice.end_position, - // ); - // Ok(AstNode::new( - // Stmt::For { - // variable: Box::new(variable), - // iterable: Box::new(iterable), - // body: Box::new(body), - // }, - // combined_slice, - // )) - // } - - fn while_statement(&mut self) -> LoxResult> { + fn while_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); self.advance(); let condition = self.expression()?; - let body = self.statement(Some("loop".to_string()))?; + let body = self.statement()?; let end_slice = body.source_slice.clone(); let combined_slice = SourceSlice::from_positions( start_slice.source_id, start_slice.start_position, end_slice.end_position, ); - Ok(AstNode::new( - Stmt::While { + Ok(AstNode::new_statement( + Expr::While { condition: Box::new(condition), body: Box::new(body), - return_value: Box::new(BaseValue::Nil), }, combined_slice, )) } - fn if_statement(&mut self) -> LoxResult> { + fn if_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); self.advance(); // consume 'if' let condition = self.expression()?; self.consume(TokenType::Then, "Expect 'then' after if condition.")?; - let then_branch = self.statement(None)?; + let then_branch = self.statement()?; let mut elif_branches = Vec::new(); let mut last_slice = then_branch.source_slice.clone(); @@ -165,14 +135,14 @@ impl Parser { self.advance(); // consume 'elif' let elif_condition = self.expression()?; self.consume(TokenType::Then, "Expect 'then' after elif condition.")?; - let elif_branch = self.statement(None)?; + let elif_branch = self.statement()?; last_slice = elif_branch.source_slice.clone(); elif_branches.push((Box::new(elif_condition), Box::new(elif_branch))); } let else_branch = if self.peek().token_type == TokenType::Else { self.advance(); // consume 'else' - let else_stmt = self.statement(None)?; + let else_stmt = self.statement()?; last_slice = else_stmt.source_slice.clone(); Some(Box::new(else_stmt)) } else { @@ -185,59 +155,97 @@ impl Parser { last_slice.end_position, ); - Ok(AstNode::new( - Stmt::If { + Ok(AstNode::new_statement( + Expr::If { condition: Box::new(condition), then_branch: Box::new(then_branch), - elif_branch: elif_branches, - else_branch: else_branch, - return_value: Box::new(BaseValue::Nil), + elif_branches, + else_branch, }, combined_slice, )) } - fn var_statement(&mut self) -> LoxResult> { + fn var_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); - let name = self.consume(TokenType::Identifier, "Expect variable name.")?; - let name_lexeme = name.lexeme.clone(); + let name = self + .consume(TokenType::Identifier, "Expect variable name.")? + .lexeme + .clone(); + self.consume(TokenType::Colon, "Expected 'colon' after var identifier")?; + let start_slice_clone = start_slice.clone(); - let mut _type_annotation = BaseValue::Nil; - self.consume(TokenType::Colon, "Expect column")?; - if self.peek().token_type == TokenType::Identifier { - // TODO manage type annotation - self.consume(TokenType::Identifier, "Expect type name.")?; - } - - match self.peek().token_type { - TokenType::Equal | TokenType::Identifier => { - self.variable_declaration(start_slice, name_lexeme) + let mut var_type = Type::Any; + let var_content = match self.peek().token_type { + TokenType::Equal | TokenType::Identifier | TokenType::Nil => { + if self.peek_is_type_name() { + let tyepe_annotation = self.consume_type_name("Expected Identier")?; + var_type = Type::Unresolved(tyepe_annotation); + } + let mut value: Option> = None; + if self.peek().token_type == TokenType::Equal { + self.advance(); + value = Some(Box::new(self.expression()?)); + } + value } - TokenType::Colon => self.function_declaration(start_slice, name_lexeme), + + TokenType::Colon => { + self.consume(TokenType::Colon, "Expected 'colon' after var identifier")?; + var_type = Type::Unresolved("Function".to_string()); + let res = self.struct_or_function_declaration(start_slice)?; + Some(Box::new(res)) + } + _ => runtime_error(start_slice, "this is not supposed to be here")?, + }; + + let semicolon = self.consume( + TokenType::Semicolon, + "Expected 'semicolon' after var declaration", + )?; + + let slice = SourceSlice::from_source_slices( + start_slice_clone.clone(), + semicolon.source_slice.clone(), + ); + let variable = Expr::VarDeclaration { + name, + var_type, + initializer: var_content, + }; + + Ok(AstNode::new_statement(variable, slice)) + } + + fn struct_or_function_declaration(&mut self, start_slice: SourceSlice) -> LoxResult { + match self.peek().token_type { + TokenType::Fn => self.function_declaration(start_slice), + TokenType::Struct => self.struct_declaration(start_slice), _ => runtime_error(start_slice, "this is not supposed to be here"), } } - fn function_declaration( - &mut self, - start_slice: SourceSlice, - name_lexeme: String, - ) -> LoxResult> { - self.advance(); + fn struct_declaration(&mut self, start_slice: SourceSlice) -> LoxResult { + self.consume(TokenType::Struct, "Expect 'struct' after '::'")?; + self.consume(TokenType::LeftBrace, "Expect '{' after 'struct'")?; + + todo!() + } + + fn function_declaration(&mut self, start_slice: SourceSlice) -> LoxResult { self.consume(TokenType::Fn, "Expect 'fn' after '::'")?; self.consume(TokenType::LeftParen, "Expect '(' after 'fn' ")?; - let mut parameters: Vec<(String, String)> = vec![]; + let mut parameters: Vec<(String, Type)> = vec![]; while self.peek().token_type != TokenType::RightParen { - let expr = self + let parameter_name = self .consume(TokenType::Identifier, "Expect identifier after '('")? .clone(); if self.peek().token_type == TokenType::Colon { self.advance(); - let type_ = - self.consume(TokenType::Identifier, "Expected identifier after ':' ")?; - parameters.push((expr.lexeme, type_.lexeme.clone())); + let paramete_type = self.consume_type_name("Expected identifier after ':' ")?; + parameters.push((parameter_name.lexeme, Type::Unresolved(paramete_type))); } else { - parameters.push((expr.lexeme, "Any".to_string())); + parameters.push((parameter_name.lexeme, Type::Any)); } if self.peek().token_type == TokenType::Comma { self.advance(); @@ -251,79 +259,32 @@ impl Parser { end_position: end_position.end_position, }; - let mut guard: Option>> = None; + let mut guard: Option> = None; if self.peek().token_type == TokenType::LeftBrace { self.consume(TokenType::LeftBrace, "Expected '{' after guard expression")?; guard = Some(Box::new(self.expression()?)); self.consume(TokenType::RightBrace, "Expected '}' after guard expression")?; } + self.consume(TokenType::Colon, "Expected ':' after parameters")?; + let return_type = self.consume_type_name("Expected Type identifier after ':'")?; - let body = self.statement(None)?; - let node = AstNode::new( + let body = self.statement()?; + Ok(AstNode::new_expression( Expr::Literal { - value: BaseValue::Function(LoxFunction { + value: Box::new(BaseValue::Function(LoxFunction { parameters, - return_type: None, + return_type: Type::Unresolved(return_type.clone()), body, closure: None, guard, - }), - }, - combine_position.clone(), - ); - Ok(AstNode::new( - Stmt::VarDeclaration { - name: name_lexeme, - initializer: Some(Box::new(node)), - return_value: Box::new(BaseValue::Nil), + })), }, combine_position.clone(), + return_type.clone(), )) } - fn variable_declaration( - &mut self, - start_slice: SourceSlice, - name_lexeme: String, - ) -> LoxResult> { - if self.peek().token_type == TokenType::Identifier { - self.advance(); - if self.peek().token_type == TokenType::Identifier { - self.advance(); - } - // todo: make type annotation - } - let mut value = AstNode::new( - Expr::Literal { - value: BaseValue::Nil, - }, - start_slice.clone(), - ); - if self.peek().token_type == TokenType::Equal { - self.advance(); - value = self.expression()?; - } - let semicolon = self.consume( - TokenType::Semicolon, - "Expect ';' after variable declaration.", - )?; - let end_slice = semicolon.source_slice.clone(); - let combined_slice = SourceSlice::from_positions( - start_slice.source_id, - start_slice.start_position, - end_slice.end_position, - ); - Ok(AstNode::new( - Stmt::VarDeclaration { - name: name_lexeme, - initializer: Some(Box::new(value)), - return_value: Box::new(BaseValue::Nil), - }, - combined_slice, - )) - } - - fn print_statement(&mut self) -> LoxResult> { + fn print_statement(&mut self) -> LoxResult { // consume the print keyword let start_slice = self.peek().source_slice.clone(); self.advance(); @@ -335,22 +296,31 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - Ok(AstNode::new( - Stmt::Print { + Ok(AstNode::new_statement( + Expr::Print { expression: Box::new(expr), - return_value: Box::new(BaseValue::Nil), }, combined_slice, )) } - fn block_statement(&mut self, label: Option) -> LoxResult> { + fn block_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); self.advance(); + let mut label = None; + if self.peek().token_type == TokenType::Colon { + self.advance(); + label = Some( + self.consume(TokenType::Identifier, "Expect label after colon.")? + .lexeme + .clone(), + ); + } + let mut statements = Vec::new(); while self.peek().token_type != TokenType::EndBlock && !self.is_at_end() { - let stmt = self.statement(label.clone())?; + let stmt = self.statement()?; statements.push(stmt); } let end_token = self.consume(TokenType::EndBlock, "Expect 'end' after block.")?; @@ -365,98 +335,66 @@ impl Parser { } else { String::default() }; - Ok(AstNode::new( - Stmt::Block { + Ok(AstNode::new_statement( + Expr::Block { statements: Box::new(statements), label: label_str, - return_value: Box::new(BaseValue::Nil), }, combined_slice, )) } - fn expression_statement(&mut self) -> LoxResult> { + fn expression_statement(&mut self) -> LoxResult { let start_slice = self.peek().source_slice.clone(); - let expr = self.expression()?; - if self.peek().token_type == TokenType::Semicolon { - let semicolon = self.advance(); - let end_slice = semicolon.source_slice.clone(); - let combined_slice = SourceSlice::from_positions( - start_slice.source_id, - start_slice.start_position, - end_slice.end_position, - ); - return Ok(AstNode::new( - Stmt::Expression { - expression: Box::new(expr), - return_value: Box::new(BaseValue::Nil), - }, - combined_slice, - )); - } - // Use the expression's source slice for expression statements without semicolon - let expr_slice = expr.source_slice.clone(); - Ok(AstNode::new( - Stmt::Expression { - expression: Box::new(expr), - return_value: Box::new(BaseValue::Nil), - }, - expr_slice, - )) + let mut expr = self.expression()?; + let semicolon = + self.consume(TokenType::Semicolon, "Expected semicolon after expression")?; + let end_slice = semicolon.source_slice.clone(); + let combined_slice = SourceSlice::from_source_slices(start_slice, end_slice); + expr.is_statement = true; + expr.source_slice = combined_slice; + return Ok(expr); } - fn return_statement(&mut self, label: Option) -> LoxResult> { + fn return_statement(&mut self, label: Option) -> LoxResult { let start_slice = self.peek().source_slice.clone(); self.advance(); - let expr = match self.expression() { - Ok(expr) => expr, - Err(LoxError::ParseError { - message, - source_slice, - }) => { - if message == "Expect expression." { - AstNode::new( - Expr::Literal { - value: BaseValue::Nil, - }, - start_slice.clone(), - ) - } else { - return Err(LoxError::ParseError { - message, - source_slice, - }); - } - } - Err(err) => return Err(err), - }; + if self.peek().token_type == TokenType::Semicolon { + let semicolon = self.consume(TokenType::Semicolon, "Expect ';' after return value.")?; + let sorce_slice = + SourceSlice::from_source_slices(start_slice, semicolon.source_slice.clone()); + return Ok(AstNode::new_expression( + Expr::Literal { + value: Box::new(BaseValue::Nil), + }, + sorce_slice, + "Nil".to_string(), + )); + } + let expr = self.expression()?; + let semicolon = self.consume(TokenType::Semicolon, "Expect ';' after return value.")?; let end_slice = semicolon.source_slice.clone(); - let combined_slice = SourceSlice::from_positions( - start_slice.source_id, - start_slice.start_position, - end_slice.end_position, - ); + let combined_slice = SourceSlice::from_source_slices(start_slice, end_slice); let label_str = if let Some(label) = label { label } else { String::default() }; - Ok(AstNode::new( - Stmt::Return { + Ok(AstNode::new_statement( + Expr::Return { expression: Box::new(expr), - return_value: Box::new(BaseValue::Nil), label: label_str, }, combined_slice, )) } - fn expression(&mut self) -> LoxResult> { + fn expression(&mut self) -> LoxResult { self.assignment() } - fn assignment(&mut self) -> LoxResult> { + fn assignment(&mut self) -> LoxResult { let expr = self.or_and()?; if self.peek().token_type == TokenType::Equal { self.advance(); // consume '=' @@ -468,13 +406,15 @@ impl Parser { value.source_slice.end_position.clone(), ); let target_slice = expr.source_slice.clone(); + let var_type = value.return_type.to_string(); match expr.node { - Expr::Identifier { name } => Ok(AstNode::new( + Expr::Identifier { name } => Ok(AstNode::new_expression( Expr::Assign { name, value: Box::new(value), }, combined_slice, + var_type, )), _ => parse_error(target_slice, "Invalid assignment target."), } @@ -483,7 +423,7 @@ impl Parser { } } - fn or_and(&mut self) -> LoxResult> { + fn or_and(&mut self) -> LoxResult { let mut expr = self.logical_is()?; while [TokenType::Or, TokenType::And].contains(&self.peek().token_type) { @@ -497,20 +437,21 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + "bool".to_string(), ); } Ok(expr) } - fn logical_is(&mut self) -> LoxResult> { + fn logical_is(&mut self) -> LoxResult { let mut expr = self.equality()?; while self.peek().token_type == TokenType::Is { @@ -524,20 +465,21 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + "bool".to_string(), ); } Ok(expr) } - fn equality(&mut self) -> LoxResult> { + fn equality(&mut self) -> LoxResult { let mut expr = self.comparison()?; while [TokenType::BangEqual, TokenType::EqualEqual].contains(&self.peek().token_type) { @@ -551,20 +493,21 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + "bool".to_string(), ); } Ok(expr) } - fn comparison(&mut self) -> LoxResult> { + fn comparison(&mut self) -> LoxResult { let mut expr = self.term()?; while [ @@ -585,20 +528,21 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + "bool".to_string(), ); } Ok(expr) } - fn term(&mut self) -> LoxResult> { + fn term(&mut self) -> LoxResult { let mut expr = self.factor()?; while [TokenType::Plus, TokenType::Minus].contains(&self.peek().token_type) { @@ -612,20 +556,22 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + let expr_type = expr.return_type.clone().to_string(); + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + expr_type, ); } Ok(expr) } - fn factor(&mut self) -> LoxResult> { + fn factor(&mut self) -> LoxResult { let mut expr = self.unary()?; while [TokenType::Slash, TokenType::Star].contains(&self.peek().token_type) { @@ -639,38 +585,42 @@ impl Parser { start_slice.start_position, end_slice.end_position, ); - expr = AstNode::new( + let expr_type = expr.return_type.clone().to_string(); + expr = AstNode::new_expression( Expr::Binary { left: Box::new(expr), operator, right: Box::new(right), }, combined_slice, + expr_type, ); } Ok(expr) } - fn unary(&mut self) -> LoxResult> { + fn unary(&mut self) -> LoxResult { if [TokenType::Bang, TokenType::Minus].contains(&self.peek().token_type) { let operator = self.peek().token_type.clone(); let source_slice = self.peek().source_slice.clone(); self.advance(); let right = self.unary()?; - return Ok(AstNode::new( + let expr_type = right.return_type.clone().to_string(); + return Ok(AstNode::new_expression( Expr::Unary { operator, operand: Box::new(right), }, source_slice, + expr_type, )); } self.call() } - fn call(&mut self) -> LoxResult> { + fn call(&mut self) -> LoxResult { let mut expr = self.primary()?; loop { @@ -683,7 +633,7 @@ impl Parser { Ok(expr) } - fn finish_call(&mut self, callee: AstNode) -> LoxResult> { + fn finish_call(&mut self, callee: AstNode) -> LoxResult { let start_slice = callee.source_slice.start_position.clone(); self.advance(); // Consume '(' @@ -709,46 +659,50 @@ impl Parser { start_position: start_slice.clone(), end_position: end_slice.clone(), }; - - Ok(AstNode::new( + let expr_type = callee.return_type.clone().to_string(); + Ok(AstNode::new_expression( Expr::Call { callee: Box::new(callee), arguments, }, full_slice, + expr_type, )) } - fn primary(&mut self) -> LoxResult> { + fn primary(&mut self) -> LoxResult { match self.peek().token_type { TokenType::False => { let source_slice = self.peek().source_slice.clone(); self.advance(); - Ok(AstNode::new( + Ok(AstNode::new_expression( Expr::Literal { - value: BaseValue::Boolean(false), + value: Box::new(BaseValue::Boolean(false)), }, source_slice, + "bool".to_string(), )) } TokenType::True => { let source_slice = self.peek().source_slice.clone(); self.advance(); - Ok(AstNode::new( + Ok(AstNode::new_expression( Expr::Literal { - value: BaseValue::Boolean(true), + value: Box::new(BaseValue::Boolean(true)), }, source_slice, + "bool".to_string(), )) } TokenType::Nil => { let source_slice = self.peek().source_slice.clone(); self.advance(); - Ok(AstNode::new( + Ok(AstNode::new_expression( Expr::Literal { - value: BaseValue::Nil, + value: Box::new(BaseValue::Nil), }, source_slice, + "nil".to_string(), )) } TokenType::Number => { @@ -756,7 +710,13 @@ impl Parser { let literal = self.peek().literal.clone(); self.advance(); if let Some(literal) = literal { - Ok(AstNode::new(Expr::Literal { value: literal }, source_slice)) + Ok(AstNode::new_expression( + Expr::Literal { + value: Box::new(literal), + }, + source_slice, + "number".to_string(), + )) } else { parse_error(self.peek().source_slice.clone(), "Expected number literal") } @@ -766,7 +726,13 @@ impl Parser { let literal = self.peek().literal.clone(); self.advance(); if let Some(literal) = literal { - Ok(AstNode::new(Expr::Literal { value: literal }, source_slice)) + Ok(AstNode::new_expression( + Expr::Literal { + value: Box::new(literal), + }, + source_slice, + "string".to_string(), + )) } else { parse_error(self.peek().source_slice.clone(), "Expected string literal") } @@ -776,18 +742,23 @@ impl Parser { self.advance(); let expr = self.expression()?; self.consume(TokenType::RightParen, "Expect ')' after expression.")?; - Ok(AstNode::new( + Ok(AstNode::new_expression( Expr::Grouping { expression: Box::new(expr), }, source_slice, + "grouping".to_string(), )) } TokenType::Identifier => { let name = self.peek().lexeme.clone(); let source_slice = self.peek().source_slice.clone(); self.advance(); - Ok(AstNode::new(Expr::Identifier { name }, source_slice)) + Ok(AstNode::new_expression( + Expr::Identifier { name }, + source_slice, + "identifier".to_string(), + )) } _ => parse_error(self.peek().source_slice.clone(), "Expect expression."), } @@ -841,6 +812,25 @@ impl Parser { } } + /// Consume a type name and return its lexeme. + /// + /// A type name is an identifier (e.g. `Int`, `Number`, a struct name) or a + /// built-in type keyword such as `nil` that overlaps with a value keyword. + fn consume_type_name(&mut self, message: &str) -> LoxResult { + match self.peek().token_type { + TokenType::Identifier | TokenType::Nil => Ok(self.advance().lexeme.clone()), + _ => parse_error(self.peek().source_slice.clone(), message), + } + } + + /// Whether the current token can begin a type name. + fn peek_is_type_name(&self) -> bool { + matches!( + self.peek().token_type, + TokenType::Identifier | TokenType::Nil + ) + } + fn synchronize(&mut self) { self.advance(); @@ -850,7 +840,7 @@ impl Parser { } match self.peek().token_type { - TokenType::Class + TokenType::Struct | TokenType::Fun | TokenType::For | TokenType::If @@ -872,7 +862,7 @@ mod tests { use crate::frontend::lexer::Lexer; /// Lex and parse `src`, returning the parser's result. - fn parse_source(src: &str) -> LoxResult>> { + fn parse_source(src: &str) -> LoxResult> { let tokens = Lexer::new(src.to_string(), 0) .scans_tokens() .expect("source should lex without errors"); @@ -880,16 +870,18 @@ mod tests { } /// Parse `src`, panicking if parsing fails. - fn parse_ok(src: &str) -> Vec> { + fn parse_ok(src: &str) -> Vec { parse_source(src).expect("expected source to parse") } /// Extract the inner expression of an expression statement. - fn expression_of(stmt: &AstNode) -> &AstNode { - match &stmt.node { - Stmt::Expression { expression, .. } => expression, - other => panic!("expected expression statement, got {:?}", other), - } + /// + /// Expression statements aren't wrapped in a dedicated `Expr` variant; + /// the parser just marks the node's `is_statement` flag, so the node + /// itself already holds the expression. + fn expression_of(stmt: &AstNode) -> &AstNode { + assert!(stmt.is_statement, "expected an expression statement"); + stmt } #[test] @@ -898,7 +890,7 @@ mod tests { assert_eq!(stmts.len(), 1); match &expression_of(&stmts[0]).node { Expr::Literal { value } => { - assert_eq!(*value, BaseValue::Number(Number::I32(42))); + assert_eq!(**value, BaseValue::Number(Number::I32(42))); } other => panic!("expected literal, got {:?}", other), } @@ -946,6 +938,15 @@ mod tests { } } + #[test] + fn parses_identifier_expression() { + let stmts = parse_ok("x;"); + match &expression_of(&stmts[0]).node { + Expr::Identifier { name } => assert_eq!(name, "x"), + other => panic!("expected identifier expression, got {:?}", other), + } + } + #[test] fn parses_comparison_expression() { let stmts = parse_ok("1 < 2;"); @@ -958,14 +959,14 @@ mod tests { #[test] fn parses_print_statement() { let stmts = parse_ok("print 1;"); - assert!(matches!(stmts[0].node, Stmt::Print { .. })); + assert!(matches!(stmts[0].node, Expr::Print { .. })); } #[test] fn parses_var_declaration_with_initializer() { let stmts = parse_ok("var x: Int = 5;"); match &stmts[0].node { - Stmt::VarDeclaration { + Expr::VarDeclaration { name, initializer, .. } => { assert_eq!(name, "x"); @@ -978,12 +979,9 @@ mod tests { #[test] fn parses_assignment_statement() { let stmts = parse_ok("x = 5;"); - match &stmts[0].node { - Stmt::Expression { expression, .. } => match &expression.node { - Expr::Assign { name, .. } => assert_eq!(name, "x"), - other => panic!("expected assign expression, got {:?}", other), - }, - other => panic!("expected expression statement, got {:?}", other), + match &expression_of(&stmts[0]).node { + Expr::Assign { name, .. } => assert_eq!(name, "x"), + other => panic!("expected assign expression, got {:?}", other), } } @@ -991,7 +989,7 @@ mod tests { fn parses_block_statement() { let stmts = parse_ok("do print 1; print 2; end"); match &stmts[0].node { - Stmt::Block { statements, .. } => assert_eq!(statements.len(), 2), + Expr::Block { statements, .. } => assert_eq!(statements.len(), 2), other => panic!("expected block statement, got {:?}", other), } } @@ -999,13 +997,13 @@ mod tests { #[test] fn parses_if_statement() { let stmts = parse_ok("if true then print 1;"); - assert!(matches!(stmts[0].node, Stmt::If { .. })); + assert!(matches!(stmts[0].node, Expr::If { .. })); } #[test] fn parses_while_statement() { let stmts = parse_ok("while true do print 1; end"); - assert!(matches!(stmts[0].node, Stmt::While { .. })); + assert!(matches!(stmts[0].node, Expr::While { .. })); } #[test] diff --git a/src/frontend/source_registry.rs b/src/frontend/source_registry.rs index 7c245fa..9dc55ef 100755 --- a/src/frontend/source_registry.rs +++ b/src/frontend/source_registry.rs @@ -121,6 +121,14 @@ impl SourceSlice { end_position, } } + + pub fn from_source_slices(start_point: SourceSlice, end_point: SourceSlice) -> Self { + Self { + source_id: start_point.source_id, + start_position: start_point.start_position, + end_position: end_point.end_position, + } + } pub fn tree_point( source_id: SourceId, column_start: usize, diff --git a/src/frontend/tokens.rs b/src/frontend/tokens.rs index d822670..2701b7e 100755 --- a/src/frontend/tokens.rs +++ b/src/frontend/tokens.rs @@ -35,11 +35,12 @@ pub enum TokenType { Identifier, String, Number, + Atom, // Keywords Fn, And, - Class, + Struct, StartBlock, EndBlock, False, @@ -80,8 +81,9 @@ impl fmt::Display for TokenType { TokenType::Identifier => write!(f, "IDENTIFIER"), TokenType::String => write!(f, "STRING"), TokenType::Number => write!(f, "NUMBER"), + TokenType::Atom => write!(f, "ATOM"), TokenType::And => write!(f, "and"), - TokenType::Class => write!(f, "class"), + TokenType::Struct => write!(f, "struct"), TokenType::Else => write!(f, "else"), TokenType::False => write!(f, "false"), TokenType::True => write!(f, "true"), diff --git a/src/lib.rs b/src/lib.rs index f030b0c..5f4de5d 100755 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,5 @@ pub mod backend; pub mod common; pub mod frontend; +pub mod logging; pub mod middleend; diff --git a/src/logging/display_ast.rs b/src/logging/display_ast.rs index 04775c0..4055696 100755 --- a/src/logging/display_ast.rs +++ b/src/logging/display_ast.rs @@ -5,7 +5,7 @@ use std::fmt::{self, Write}; -use crate::common::ast::{AstNode, AstNodeKind, Expr, Stmt}; +use crate::common::ast::{AstNode, Expr}; /// Configuration for pretty printing output #[derive(Clone, Debug)] @@ -264,33 +264,7 @@ impl PrettyPrint for Expr { write!(f, "] }}") } } - } - } -} - -impl PrettyPrint for Stmt { - fn pretty_print(&self, ctx: &PrettyContext, f: &mut fmt::Formatter) -> fmt::Result { - if ctx.should_truncate() { - return write!(f, "{}...", ctx.indent()); - } - - let indent = ctx.indent(); - - match self { - Stmt::Expression { expression, .. } => { - if ctx.config.compact { - let expr_str = - pretty_print_with_config(expression.as_ref(), &PrettyConfig::compact()); - write!(f, "{};", expr_str) - } else { - writeln!(f, "{}Expression {{", indent)?; - write!(f, "{}expression: ", ctx.child_context(true).indent())?; - expression.pretty_print(&ctx.child_context(true), f)?; - writeln!(f)?; - write!(f, "{}}}", indent) - } - } - Stmt::Print { expression, .. } => { + Expr::Print { expression } => { if ctx.config.compact { let expr_str = pretty_print_with_config(expression.as_ref(), &PrettyConfig::compact()); @@ -303,7 +277,7 @@ impl PrettyPrint for Stmt { write!(f, "{}}}", indent) } } - Stmt::VarDeclaration { + Expr::VarDeclaration { name, initializer, .. } => { if ctx.config.compact { @@ -331,8 +305,7 @@ impl PrettyPrint for Stmt { write!(f, "{}}}", indent) } } - - Stmt::Return { expression, .. } => { + Expr::Return { expression, .. } => { if ctx.config.compact { let expr_str = pretty_print_with_config(expression.as_ref(), &PrettyConfig::compact()); @@ -345,9 +318,7 @@ impl PrettyPrint for Stmt { write!(f, "{}}}", indent) } } - Stmt::Block { - statements, label, .. - } => { + Expr::Block { statements, label } => { if ctx.config.compact { write!(f, "{{ ... [{}] ({} statements) }}", label, statements.len()) } else { @@ -366,12 +337,11 @@ impl PrettyPrint for Stmt { write!(f, "{}}}", indent) } } - Stmt::If { + Expr::If { condition, then_branch, - elif_branch, + elif_branches, else_branch, - .. } => { if ctx.config.compact { let cond_str = @@ -386,10 +356,10 @@ impl PrettyPrint for Stmt { then_branch.pretty_print(&ctx.child_context(false), f)?; writeln!(f, ",")?; - if !elif_branch.is_empty() { + if !elif_branches.is_empty() { writeln!(f, "{}elif_branches: [", ctx.child_context(false).indent())?; - for (i, (cond, branch)) in elif_branch.iter().enumerate() { - let is_last = i == elif_branch.len() - 1; + for (i, (cond, branch)) in elif_branches.iter().enumerate() { + let is_last = i == elif_branches.len() - 1; let child_ctx = ctx.child_context(false).child_context(is_last); writeln!(f, "{}(", child_ctx.indent())?; write!(f, "{}condition: ", child_ctx.child_context(false).indent())?; @@ -421,21 +391,18 @@ impl PrettyPrint for Stmt { write!(f, "{}}}", indent) } } - Stmt::While { - condition, body, .. - } => { + Expr::While { condition, body } => { write!(f, "{}while (", ctx.child_context(true).indent())?; condition.pretty_print(&ctx.child_context(true), f)?; writeln!(f, ") {{")?; body.pretty_print(&ctx.child_context(true), f)?; writeln!(f, "{}}}", ctx.child_context(true).indent()) } - Stmt::For { + Expr::For { variable, condition, increment, body, - .. } => { write!(f, "{}for (", ctx.child_context(true).indent())?; variable.pretty_print(&ctx.child_context(true), f)?; @@ -451,7 +418,7 @@ impl PrettyPrint for Stmt { } } -impl PrettyPrint for AstNode { +impl PrettyPrint for AstNode { fn pretty_print(&self, ctx: &PrettyContext, f: &mut fmt::Formatter) -> fmt::Result { let indent = ctx.indent(); @@ -463,9 +430,9 @@ impl PrettyPrint for A if ctx.config.show_types { writeln!( f, - "{}kind: {:?},", + "{}type: {},", ctx.child_context(false).indent(), - self.node.kind() + self.return_type )?; } @@ -519,25 +486,7 @@ impl PrettyPrintExt for Expr { } } -impl PrettyPrintExt for Stmt { - fn pretty(&self) -> String { - pretty_print(self) - } - - fn pretty_compact(&self) -> String { - pretty_print_with_config(self, &PrettyConfig::compact()) - } - - fn pretty_tree(&self) -> String { - pretty_print_with_config(self, &PrettyConfig::tree()) - } - - fn pretty_with_config(&self, config: &PrettyConfig) -> String { - pretty_print_with_config(self, config) - } -} - -impl PrettyPrintExt for AstNode { +impl PrettyPrintExt for AstNode { fn pretty(&self) -> String { pretty_print(self) } diff --git a/src/logging/display_token.rs b/src/logging/display_token.rs index 5ce6980..4910c95 100755 --- a/src/logging/display_token.rs +++ b/src/logging/display_token.rs @@ -174,7 +174,8 @@ impl Token { TokenType::String => "STR", TokenType::Number => "NUM", TokenType::And => "AND", - TokenType::Class => "CLASS", + TokenType::Struct => "STRUCT", + TokenType::Atom => "ATOM", TokenType::StartBlock => "DO", TokenType::EndBlock => "END", TokenType::False => "FALSE", @@ -219,7 +220,7 @@ impl Token { | TokenType::Less | TokenType::LessEqual => ("\x1b[31m", self.token_type_symbol()), TokenType::And - | TokenType::Class + | TokenType::Struct | TokenType::False | TokenType::True | TokenType::Fun @@ -239,6 +240,7 @@ impl Token { | TokenType::Var | TokenType::Fn | TokenType::Is + | TokenType::Atom | TokenType::Val => ("\x1b[34m", self.token_type_symbol()), TokenType::Identifier | TokenType::String | TokenType::Number => { ("\x1b[32m", self.token_type_symbol()) diff --git a/src/main.rs b/src/main.rs index e60e051..ff296d4 100755 --- a/src/main.rs +++ b/src/main.rs @@ -1,13 +1,12 @@ -mod backend; -mod common; -mod frontend; -mod logging; -mod middleend; - +pub mod backend; +pub mod common; +pub mod frontend; +pub mod logging; +pub mod middleend; use crate::{ backend::interpreter::{EvaluateInterpreter, Interpreter}, common::{ - ast::{AstNode, Stmt}, + ast::AstNode, lox_result::{LoxError, LoxResult}, }, frontend::{ @@ -175,7 +174,7 @@ impl LoxInterpreter { } // Funzione per parsare fino all'AST - fn parse_to_ast(&self, source_id: SourceId) -> LoxResult>> { + fn parse_to_ast(&self, source_id: SourceId) -> LoxResult> { let tokens = self.tokenize(source_id)?; Parser::new(tokens).parse().or_else(|err| { @@ -185,7 +184,7 @@ impl LoxInterpreter { } // Funzione per eseguire l'AST - fn execute_ast(&self, ast: Vec>, debug: bool) -> LoxResult { + fn execute_ast(&self, ast: Vec, debug: bool) -> LoxResult { // Static resolution pass: compute variable scope distances and report // any resolution errors before executing. let locals = self.resolve(&ast)?; @@ -212,7 +211,7 @@ impl LoxInterpreter { // Static variable resolution; prints and returns the first error, if any. fn resolve( &self, - ast: &[AstNode], + ast: &[AstNode], ) -> LoxResult> { Resolver::resolve_program(ast).map_err(|errors| { for err in &errors { @@ -295,7 +294,7 @@ fn format_tokens(tokens: &[crate::frontend::tokens::Token]) -> String { .join("\n") } -fn format_ast(ast: &[AstNode]) -> String { +fn format_ast(ast: &[AstNode]) -> String { use crate::logging::display_ast::{pretty_print_with_config, PrettyConfig}; let config = PrettyConfig { diff --git a/src/middleend/variable_resolution.rs b/src/middleend/variable_resolution.rs index c2be7e5..5827240 100755 --- a/src/middleend/variable_resolution.rs +++ b/src/middleend/variable_resolution.rs @@ -17,13 +17,13 @@ use std::collections::HashMap; use crate::{ common::{ - ast::{AstNode, Expr, NodeId, Stmt}, + ast::{AstNode, Expr, NodeId}, base_value::{BaseValue, LoxFunction}, lox_result::{ErrorSink, LoxError, LoxResult}, }, middleend::{ scope_stack::ScopeStack, - visit_ast::{walk_expr, walk_function, walk_stmt, Visitor}, + visit_ast::{walk_expr, walk_function, Visitor}, }, }; @@ -55,13 +55,13 @@ impl Resolver { /// Resolve a whole program, returning the per-reference scope distances or /// the accumulated resolution errors. pub fn resolve_program( - statements: &[AstNode], + statements: &[AstNode], ) -> Result, Vec> { let mut resolver = Resolver::new(); for statement in statements { // Visiting only fails for fatal/internal errors, which this pass // never produces; user-facing diagnostics go to `errors`. - let _ = resolver.visit_stmt(statement); + let _ = resolver.visit_expr(statement); } if resolver.errors.has_errors() { Err(resolver.errors.into_errors()) @@ -105,52 +105,7 @@ impl Default for Resolver { } impl Visitor for Resolver { - fn visit_stmt(&mut self, stmt: &AstNode) -> LoxResult<()> { - match &stmt.node { - Stmt::VarDeclaration { - name, initializer, .. - } => { - // A function declaration is a var bound to a function literal. - // Define its name *before* resolving the body so it can recurse; - // a plain variable is defined *after* its initializer so that - // `var a = a;` is caught. - let is_function = matches!( - initializer.as_deref().map(|node| &node.node), - Some(Expr::Literal { - value: BaseValue::Function(_) - }) - ); - self.declare(name, &stmt.source_slice); - if is_function { - self.define(name); - walk_stmt(self, stmt)?; - } else { - walk_stmt(self, stmt)?; // resolves the initializer, if any - self.define(name); - } - Ok(()) - } - Stmt::Block { .. } => { - self.scopes.begin_scope(); - walk_stmt(self, stmt)?; - self.scopes.end_scope(); - Ok(()) - } - Stmt::Return { .. } => { - if self.current_function == FunctionType::None { - self.errors.report(LoxError::ParseError { - source_slice: stmt.source_slice.clone(), - message: "Can't return from top-level code.".to_string(), - }); - } - walk_stmt(self, stmt) // resolve the returned expression - } - // Expression, Print, If, While, For: default traversal. - _ => walk_stmt(self, stmt), - } - } - - fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { + fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { match &expr.node { Expr::Identifier { name } => { if self.scopes.get_local(name) == Some(&false) { @@ -167,6 +122,42 @@ impl Visitor for Resolver { self.resolve_local(expr.id, name); Ok(()) } + Expr::VarDeclaration { + name, initializer, .. + } => { + // A function declaration is a var bound to a function literal. + // Define its name *before* resolving the body so it can recurse; + // a plain variable is defined *after* its initializer so that + // `var a = a;` is caught. + let is_function = matches!( + initializer.as_deref().map(|node| &node.node), + Some(Expr::Literal { value }) if matches!(**value, BaseValue::Function(_)) + ); + self.declare(name, &expr.source_slice); + if is_function { + self.define(name); + walk_expr(self, expr)?; + } else { + walk_expr(self, expr)?; // resolves the initializer, if any + self.define(name); + } + Ok(()) + } + Expr::Block { .. } => { + self.scopes.begin_scope(); + walk_expr(self, expr)?; + self.scopes.end_scope(); + Ok(()) + } + Expr::Return { .. } => { + if self.current_function == FunctionType::None { + self.errors.report(LoxError::ParseError { + source_slice: expr.source_slice.clone(), + message: "Can't return from top-level code.".to_string(), + }); + } + walk_expr(self, expr) // resolve the returned expression + } _ => walk_expr(self, expr), } } @@ -193,7 +184,7 @@ mod tests { use crate::frontend::lexer::Lexer; use crate::frontend::parser::Parser; - fn parse(src: &str) -> Vec> { + fn parse(src: &str) -> Vec { let tokens = Lexer::new(src.to_string(), 0) .scans_tokens() .expect("source should lex"); @@ -251,7 +242,7 @@ mod tests { #[test] fn return_inside_a_function_is_allowed() { - let locals = resolve("f :: fn (n) do return n; end").expect("should resolve"); + let locals = resolve("f :: fn (n): Number do return n; end;").expect("should resolve"); // `n` resolves from the body block up to the parameter scope. assert_eq!(locals.len(), 1); assert_eq!(*locals.values().next().unwrap(), 1); diff --git a/src/middleend/visit_ast.rs b/src/middleend/visit_ast.rs index 35471d6..75be11e 100644 --- a/src/middleend/visit_ast.rs +++ b/src/middleend/visit_ast.rs @@ -23,7 +23,7 @@ //! struct IdentifierCounter { count: usize } //! //! impl Visitor for IdentifierCounter { -//! fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { +//! fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { //! if let Expr::Identifier { .. } = &expr.node { //! self.count += 1; //! } @@ -33,7 +33,7 @@ //! ``` use crate::common::{ - ast::{AstNode, Expr, Stmt}, + ast::{AstNode, Expr}, base_value::{BaseValue, LoxFunction}, lox_result::LoxResult, }; @@ -43,13 +43,8 @@ use crate::common::{ /// Every hook has a default implementation that performs the standard /// recursive traversal, so implementors only override the cases they need. pub trait Visitor: Sized { - /// Visit a statement node. Defaults to [`walk_stmt`]. - fn visit_stmt(&mut self, stmt: &AstNode) -> LoxResult<()> { - walk_stmt(self, stmt) - } - /// Visit an expression node. Defaults to [`walk_expr`]. - fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { + fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { walk_expr(self, expr) } @@ -62,70 +57,13 @@ pub trait Visitor: Sized { } } -/// Recurse into the children of `stmt`, calling back into `visitor`. -pub fn walk_stmt(visitor: &mut V, stmt: &AstNode) -> LoxResult<()> { - match &stmt.node { - Stmt::Expression { expression, .. } => visitor.visit_expr(expression), - Stmt::Print { expression, .. } => visitor.visit_expr(expression), - Stmt::VarDeclaration { initializer, .. } => { - if let Some(initializer) = initializer { - visitor.visit_expr(initializer)?; - } - Ok(()) - } - Stmt::Return { expression, .. } => visitor.visit_expr(expression), - Stmt::Block { statements, .. } => { - for statement in statements.iter() { - visitor.visit_stmt(statement)?; - } - Ok(()) - } - Stmt::If { - condition, - then_branch, - elif_branch, - else_branch, - .. - } => { - visitor.visit_expr(condition)?; - visitor.visit_stmt(then_branch)?; - for (elif_condition, elif_body) in elif_branch.iter() { - visitor.visit_expr(elif_condition)?; - visitor.visit_stmt(elif_body)?; - } - if let Some(else_body) = else_branch { - visitor.visit_stmt(else_body)?; - } - Ok(()) - } - Stmt::While { - condition, body, .. - } => { - visitor.visit_expr(condition)?; - visitor.visit_stmt(body) - } - Stmt::For { - variable, - condition, - increment, - body, - .. - } => { - visitor.visit_stmt(variable)?; - visitor.visit_expr(condition)?; - visitor.visit_stmt(increment)?; - visitor.visit_stmt(body) - } - } -} - /// Recurse into the children of `expr`, calling back into `visitor`. -pub fn walk_expr(visitor: &mut V, expr: &AstNode) -> LoxResult<()> { +pub fn walk_expr(visitor: &mut V, expr: &AstNode) -> LoxResult<()> { match &expr.node { // A function literal carries an entire sub-tree (its body), so it is // not a leaf: hand it to the dedicated function hook. Expr::Literal { value } => { - if let BaseValue::Function(function) = value { + if let BaseValue::Function(function) = &**value { visitor.visit_function(function)?; } Ok(()) @@ -147,6 +85,57 @@ pub fn walk_expr(visitor: &mut V, expr: &AstNode) -> LoxResult } Ok(()) } + + Expr::Print { expression, .. } => visitor.visit_expr(expression), + Expr::VarDeclaration { initializer, .. } => { + if let Some(initializer) = initializer { + visitor.visit_expr(initializer)?; + } + Ok(()) + } + Expr::Return { expression, .. } => visitor.visit_expr(expression), + Expr::Block { statements, .. } => { + for statement in statements.iter() { + visitor.visit_expr(statement)?; + } + Ok(()) + } + Expr::If { + condition, + then_branch, + elif_branches, + else_branch, + .. + } => { + visitor.visit_expr(condition)?; + visitor.visit_expr(then_branch)?; + for (elif_condition, elif_body) in elif_branches.iter() { + visitor.visit_expr(elif_condition)?; + visitor.visit_expr(elif_body)?; + } + if let Some(else_body) = else_branch { + visitor.visit_expr(else_body)?; + } + Ok(()) + } + Expr::While { + condition, body, .. + } => { + visitor.visit_expr(condition)?; + visitor.visit_expr(body) + } + Expr::For { + variable, + condition, + increment, + body, + .. + } => { + visitor.visit_expr(variable)?; + visitor.visit_expr(condition)?; + visitor.visit_expr(increment)?; + visitor.visit_expr(body) + } } } @@ -155,7 +144,7 @@ pub fn walk_function(visitor: &mut V, function: &LoxFunction) -> Lox if let Some(guard) = &function.guard { visitor.visit_expr(guard)?; } - visitor.visit_stmt(&function.body) + visitor.visit_expr(&function.body) } #[cfg(test)] @@ -165,7 +154,7 @@ mod tests { use crate::frontend::lexer::Lexer; use crate::frontend::parser::Parser; - fn parse(src: &str) -> Vec> { + fn parse(src: &str) -> Vec { let tokens = Lexer::new(src.to_string(), 0) .scans_tokens() .expect("source should lex"); @@ -173,29 +162,23 @@ mod tests { } /// A visitor that relies entirely on the default traversal and just counts - /// how many statement and expression nodes it sees. + /// how many nodes it sees. #[derive(Default)] struct Counter { - stmts: usize, - exprs: usize, + nodes: usize, } impl Visitor for Counter { - fn visit_stmt(&mut self, stmt: &AstNode) -> LoxResult<()> { - self.stmts += 1; - walk_stmt(self, stmt) - } - - fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { - self.exprs += 1; - walk_expr(self, expr) + fn visit_expr(&mut self, node: &AstNode) -> LoxResult<()> { + self.nodes += 1; + walk_expr(self, node) } } fn count(src: &str) -> Counter { let mut counter = Counter::default(); for stmt in parse(src).iter() { - counter.visit_stmt(stmt).unwrap(); + counter.visit_expr(stmt).unwrap(); } counter } @@ -204,19 +187,16 @@ mod tests { fn counts_every_node_via_default_traversal() { // 1 + 2 * 3 => Binary(+){ Literal, Binary(*){ Literal, Literal } } let counter = count("1 + 2 * 3;"); - assert_eq!(counter.stmts, 1); - assert_eq!(counter.exprs, 5); + assert_eq!(counter.nodes, 5); } #[test] fn descends_into_function_bodies() { // The function body must be traversed through `visit_function`, so the // `return a;` inside it should contribute to the counts. - let counter = count("f :: fn (a) do return a; end"); - // VarDeclaration + Block + Return - assert_eq!(counter.stmts, 3); - // Function literal + identifier `a` - assert_eq!(counter.exprs, 2); + let counter = count("f :: fn (a): Number do return a; end;"); + // VarDeclaration + Function literal + Block + Return + identifier `a` + assert_eq!(counter.nodes, 5); } /// A visitor that aborts as soon as it sees an identifier, used to check @@ -224,7 +204,7 @@ mod tests { struct FailOnIdentifier; impl Visitor for FailOnIdentifier { - fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { + fn visit_expr(&mut self, expr: &AstNode) -> LoxResult<()> { if let Expr::Identifier { .. } = &expr.node { return runtime_error(expr.source_slice.clone(), "found an identifier"); } @@ -238,7 +218,7 @@ mod tests { let mut visitor = FailOnIdentifier; let mut result = Ok(()); for stmt in stmts.iter() { - result = visitor.visit_stmt(stmt); + result = visitor.visit_expr(stmt); if result.is_err() { break; } diff --git a/tests/frontend.rs b/tests/frontend.rs index 5ee5103..004e082 100644 --- a/tests/frontend.rs +++ b/tests/frontend.rs @@ -4,14 +4,14 @@ //! assert on the resulting AST, complementing the per-module unit tests inside //! `src/frontend/{lexer,parser}.rs`. -use rlox::common::ast::{AstNode, Expr, Stmt}; +use rlox::common::ast::{AstNode, Expr}; use rlox::common::base_value::{BaseValue, Number}; use rlox::frontend::lexer::Lexer; use rlox::frontend::parser::Parser; use rlox::frontend::tokens::TokenType; /// Run the full frontend pipeline on `src`. -fn parse(src: &str) -> Result>, String> { +fn parse(src: &str) -> Result, String> { let tokens = Lexer::new(src.to_string(), 0) .scans_tokens() .map_err(|e| format!("lex error: {e}"))?; @@ -21,23 +21,26 @@ fn parse(src: &str) -> Result>, String> { } /// Parse `src`, panicking if the frontend reports any error. -fn parse_ok(src: &str) -> Vec> { +fn parse_ok(src: &str) -> Vec { parse(src).expect("expected source to lex and parse") } -/// Parse `src` and return the single statement it should produce. -fn single_stmt(src: &str) -> Stmt { +/// Parse `src` and return the single node it should produce. +/// +/// Statements and expressions share the unified `Expr`/`AstNode` type, so this +/// simply returns the node of the sole top-level statement. +fn single_stmt(src: &str) -> Expr { let mut stmts = parse_ok(src); assert_eq!(stmts.len(), 1, "expected exactly one statement for {src:?}"); stmts.remove(0).node } -/// Parse `src` and return the expression of its single expression-statement. +/// Parse `src` and return its single expression-statement's expression. +/// +/// Expression statements aren't wrapped in a dedicated variant anymore; the +/// node itself is the expression. fn single_expr(src: &str) -> Expr { - match single_stmt(src) { - Stmt::Expression { expression, .. } => expression.node, - other => panic!("expected expression statement, got {other:?}"), - } + single_stmt(src) } // --------------------------------------------------------------------------- @@ -47,7 +50,7 @@ fn single_expr(src: &str) -> Expr { #[test] fn lexes_and_parses_number_literal() { match single_expr("42;") { - Expr::Literal { value } => assert_eq!(value, BaseValue::Number(Number::I32(42))), + Expr::Literal { value } => assert_eq!(*value, BaseValue::Number(Number::I32(42))), other => panic!("expected literal, got {other:?}"), } } @@ -194,7 +197,7 @@ fn assignment_to_non_identifier_is_an_error() { #[test] fn parses_var_declaration() { match single_stmt("x := 5;") { - Stmt::VarDeclaration { + Expr::VarDeclaration { name, initializer, .. } => { assert_eq!(name, "x"); @@ -206,13 +209,13 @@ fn parses_var_declaration() { #[test] fn parses_print_statement() { - assert!(matches!(single_stmt("print 1;"), Stmt::Print { .. })); + assert!(matches!(single_stmt("print 1;"), Expr::Print { .. })); } #[test] fn parses_block_with_multiple_statements() { match single_stmt("do print 1; print 2; end") { - Stmt::Block { statements, .. } => assert_eq!(statements.len(), 2), + Expr::Block { statements, .. } => assert_eq!(statements.len(), 2), other => panic!("expected block, got {other:?}"), } } @@ -220,7 +223,7 @@ fn parses_block_with_multiple_statements() { #[test] fn parses_if_else() { match single_stmt("if true then print 1; else print 2;") { - Stmt::If { + Expr::If { else_branch: Some(_), .. } => {} @@ -232,37 +235,32 @@ fn parses_if_else() { fn parses_while_loop() { assert!(matches!( single_stmt("while true do print 1; end"), - Stmt::While { .. } + Expr::While { .. } )); } #[test] fn parses_for_loop_with_assignment_increment() { match single_stmt("for i := 0; i <= 2; i = i + 1; do print i; end") { - Stmt::For { increment, .. } => match increment.node { - // The increment desugars to an expression statement holding an assignment. - Stmt::Expression { expression, .. } => { - assert!(matches!(expression.node, Expr::Assign { .. })) - } - other => panic!("expected expression-statement increment, got {other:?}"), - }, + Expr::For { increment, .. } => { + // The increment is an assignment expression. + assert!(matches!(increment.node, Expr::Assign { .. })) + } other => panic!("expected for loop, got {other:?}"), } } #[test] fn parses_function_declaration() { - match single_stmt("add :: fn (a, b) do return a + b; end") { - Stmt::VarDeclaration { + match single_stmt("add :: fn (a, b): Number do return a + b; end;") { + Expr::VarDeclaration { name, initializer, .. } => { assert_eq!(name, "add"); match initializer { Some(init) => assert!(matches!( - init.node, - Expr::Literal { - value: BaseValue::Function(_) - } + &init.node, + Expr::Literal { value } if matches!(&**value, BaseValue::Function(_)) )), None => panic!("expected a function initializer"), } diff --git a/tests/resolution.rs b/tests/resolution.rs index e099415..a897f83 100644 --- a/tests/resolution.rs +++ b/tests/resolution.rs @@ -37,13 +37,13 @@ fn resolved_nested_closure_reads_captured_local() { // `count` is read from inside a nested function, two scopes up; the // resolver records distance 2 and the interpreter uses `get_at(2, ..)`. let src = "\ -make :: fn () do +make :: fn (): Any do count := 10; - get :: fn () do + get :: fn (): Number do return count; - end + end; return get; -end +end; g := make(); g(); ";