ProjectValkay/rlox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip:

Browse Source 
Add type system and refator for having only epression
This commit is contained in:
Giulio Agostini
2026-07-06 10:43:17 +02:00
parent 9f15a00b98
commit 842216729b
23 changed files with 940 additions and 979 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/backend/interpreter.rs
+85 -111
View File
@@ -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<T> {
fn evaluate(&mut self, stmt: T) -> LoxResult<BaseValue>;
}
impl EvaluateInterpreter<AstNode<Stmt>> for Interpreter {
fn evaluate(&mut self, node: AstNode<Stmt>) -> LoxResult<BaseValue> {
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<AstNode> for Interpreter {
fn evaluate(&mut self, node: AstNode) -> LoxResult<BaseValue> {
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<Expr>) -> LoxResult<BaseValue> {
fn eval_expr(&mut self, node: &AstNode) -> LoxResult<BaseValue> {
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<Expr>,
arguments: &[AstNode<Expr>],
) -> LoxResult<BaseValue> {
fn evaluate_call(&mut self, callee: &AstNode, arguments: &[AstNode]) -> LoxResult<BaseValue> {
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<BaseValue> {
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<AstNode<Expr>>,
then_branch: Box<AstNode<Stmt>>,
elif_branch: Vec<(Box<AstNode<Expr>>, Box<AstNode<Stmt>>)>,
else_branch: Option<Box<AstNode<Stmt>>>,
condition: &AstNode,
then_branch: &AstNode,
elif_branch: &[(Box<AstNode>, Box<AstNode>)],
else_branch: &Option<Box<AstNode>>,
) -> LoxResult<BaseValue> {
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<AstNode<Stmt>>) -> LoxResult<BaseValue> {
fn evaluate_block(&mut self, statements: &[AstNode]) -> LoxResult<BaseValue> {
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");
}
src/common/ast.rs
+158 -302
View File
@@ -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<BaseValue>,
},
Binary {
left: Box<AstNode<Expr>>,
left: Box<AstNode>,
operator: TokenType,
right: Box<AstNode<Expr>>,
right: Box<AstNode>,
},
Unary {
operator: TokenType,
operand: Box<AstNode<Expr>>,
operand: Box<AstNode>,
},
Grouping {
expression: Box<AstNode<Expr>>,
expression: Box<AstNode>,
},
Identifier {
name: String,
},
Call {
callee: Box<AstNode<Expr>>,
arguments: Vec<AstNode<Expr>>,
callee: Box<AstNode>,
arguments: Vec<AstNode>,
},
Assign {
name: String,
value: Box<AstNode<Expr>>,
value: Box<AstNode>,
},
Print {
expression: Box<AstNode>,
},
VarDeclaration {
name: String,
var_type: Type,
initializer: Option<Box<AstNode>>,
},
Return {
expression: Box<AstNode>,
label: String,
},
Block {
statements: Box<Vec<AstNode>>,
label: String,
},
If {
condition: Box<AstNode>,
then_branch: Box<AstNode>,
elif_branches: Vec<(Box<AstNode>, Box<AstNode>)>,
else_branch: Option<Box<AstNode>>,
},
While {
condition: Box<AstNode>,
body: Box<AstNode>,
},
For {
variable: Box<AstNode>,
condition: Box<AstNode>,
increment: Box<AstNode>,
body: Box<AstNode>,
},
}
@@ -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::<Vec<_>>()
.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::<Vec<String>>()
.join(", ")
.join(", "),
),
Expr::Assign { name, value } => write!(f, "(assign {:?} {:?})", name, value.node),
}
}
}
#[derive(Clone, PartialEq)]
pub enum Stmt {
Expression {
expression: Box<AstNode<Expr>>,
return_value: Box<BaseValue>,
},
Print {
expression: Box<AstNode<Expr>>,
return_value: Box<BaseValue>,
},
VarDeclaration {
name: String,
initializer: Option<Box<AstNode<Expr>>>,
return_value: Box<BaseValue>,
},
Return {
expression: Box<AstNode<Expr>>,
label: String,
return_value: Box<BaseValue>,
},
Block {
statements: Box<Vec<AstNode<Stmt>>>,
label: String,
return_value: Box<BaseValue>,
},
If {
condition: Box<AstNode<Expr>>,
then_branch: Box<AstNode<Stmt>>,
elif_branch: Vec<(Box<AstNode<Expr>>, Box<AstNode<Stmt>>)>,
else_branch: Option<Box<AstNode<Stmt>>>,
return_value: Box<BaseValue>,
},
While {
condition: Box<AstNode<Expr>>,
body: Box<AstNode<Stmt>>,
return_value: Box<BaseValue>,
},
For {
variable: Box<AstNode<Stmt>>,
condition: Box<AstNode<Expr>>,
increment: Box<AstNode<Stmt>>,
body: Box<AstNode<Stmt>>,
return_value: Box<BaseValue>,
},
}
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::<Vec<_>>()
.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::<Vec<_>>()
.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<T: AstNodeKind + Debug + Display> {
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<T: AstNodeKind + Debug + Display + PartialEq> PartialEq for AstNode<T> {
impl PartialEq for AstNode {
fn eq(&self, other: &Self) -> bool {
self.node == other.node && self.source_slice == other.source_slice
}
}
impl<T: AstNodeKind + Debug + Display> Display for AstNode<T> {
impl Display for AstNode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
@@ -441,7 +287,7 @@ impl<T: AstNodeKind + Debug + Display> Display for AstNode<T> {
}
}
impl<T: AstNodeKind + Debug + Display> Debug for AstNode<T> {
impl Debug for AstNode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
@@ -451,12 +297,22 @@ impl<T: AstNodeKind + Debug + Display> Debug for AstNode<T> {
}
}
impl<T: AstNodeKind + Debug + Display> AstNode<T> {
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)
}
}
src/common/base_value.rs
+28 -17
View File
@@ -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<String, BaseValue>,
}
struct ReturnValue {
label: Vec<String>,
value: BaseValue,
value: Type,
}
impl ReturnValue {
pub fn new(label: Vec<String>, value: BaseValue) -> Self {
pub fn new(label: Vec<String>, value: Type) -> Self {
Self { label, value }
}
}
@@ -304,39 +309,40 @@ impl Display for BaseValue {
BaseValue::Nil => write!(f, "nil"),
BaseValue::Function(..) => write!(f, "<fn lox function>"),
BaseValue::NativeFunction(..) => write!(f, "<native native function>"),
BaseValue::Struct(_) => write!(f, "<struct>"),
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct LoxFunction {
pub parameters: Vec<(String, String)>,
pub return_type: Option<String>,
pub body: AstNode<Stmt>,
pub parameters: Vec<(String, Type)>,
pub return_type: Type,
pub body: AstNode,
pub closure: Option<EnvironmentStack<BaseValue>>,
pub guard: Option<Box<AstNode<Expr>>>,
pub guard: Option<Box<AstNode>>,
}
impl LoxFunction {
pub fn new(
parameters: Vec<(String, String)>,
body: AstNode<Stmt>,
parameters: Vec<(String, Type)>,
body: AstNode,
closure: Option<EnvironmentStack<BaseValue>>,
guard: Option<Box<AstNode<Expr>>>,
guard: Option<Box<AstNode>>,
) -> Self {
LoxFunction {
parameters,
return_type: None,
return_type: Type::Any,
body,
closure,
guard,
}
}
pub fn anonymous_function(parameters: Vec<(String, String)>, body: AstNode<Stmt>) -> 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 {
src/common/mod.rs
+1
View File
@@ -1,3 +1,4 @@
pub mod ast;
pub mod base_value;
pub mod lox_result;
pub mod types;
src/common/types.rs
+70
View File
@@ -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<StructType>),
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<Type>)>,
pub return_type: Box<Type>,
}
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::<Vec<_>>()
.join(", ");
write!(f, "fn({}) -> {}", rendered_params, self.return_type)
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct StructType {
pub fields: Vec<(String, Box<Type>)>,
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::<Vec<_>>()
.join(", ");
let rendered_method = self
.methods
.iter()
.map(|(name, ty)| format!("{}: {}", name, ty))
.collect::<Vec<_>>()
.join(", ");
write!(f, "struct {{ {}, {} }}", rendered_field, rendered_method)
}
}
src/frontend/lexer.rs
+29 -1
View File
@@ -16,7 +16,7 @@ pub struct Lexer {
fn get_keyword_token(word: &str) -> Option<TokenType> {
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<TokenType> = 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");
}
}
src/frontend/parser.rs
+266 -268
View File
File diff suppressed because it is too large Load Diff
src/frontend/source_registry.rs
+8
View File
@@ -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,
src/frontend/tokens.rs
+4 -2
View File
@@ -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"),
src/lib.rs
+1
View File
@@ -1,4 +1,5 @@
pub mod backend;
pub mod common;
pub mod frontend;
pub mod logging;
pub mod middleend;
src/logging/display_ast.rs
+16 -67
View File
@@ -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<T: AstNodeKind + fmt::Debug + fmt::Display + PrettyPrint> PrettyPrint for AstNode<T> {
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<T: AstNodeKind + fmt::Debug + fmt::Display + PrettyPrint> 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<T: AstNodeKind + fmt::Debug + fmt::Display + PrettyPrint> PrettyPrintExt for AstNode<T> {
impl PrettyPrintExt for AstNode {
fn pretty(&self) -> String {
pretty_print(self)
}
src/logging/display_token.rs
+4 -2
View File
@@ -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())
src/main.rs
+10 -11
View File
@@ -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<Vec<AstNode<Stmt>>> {
fn parse_to_ast(&self, source_id: SourceId) -> LoxResult<Vec<AstNode>> {
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<AstNode<Stmt>>, debug: bool) -> LoxResult<String> {
fn execute_ast(&self, ast: Vec<AstNode>, debug: bool) -> LoxResult<String> {
// 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<Stmt>],
ast: &[AstNode],
) -> LoxResult<std::collections::HashMap<crate::common::ast::NodeId, usize>> {
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<Stmt>]) -> String {
fn format_ast(ast: &[AstNode]) -> String {
use crate::logging::display_ast::{pretty_print_with_config, PrettyConfig};
let config = PrettyConfig {
src/middleend/variable_resolution.rs
+43 -52
View File
@@ -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<Stmt>],
statements: &[AstNode],
) -> Result<HashMap<NodeId, usize>, Vec<LoxError>> {
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<Stmt>) -> 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<Expr>) -> 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<AstNode<Stmt>> {
fn parse(src: &str) -> Vec<AstNode> {
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);
src/middleend/visit_ast.rs
+70 -90
View File
@@ -23,7 +23,7 @@
//! struct IdentifierCounter { count: usize }
//!
//! impl Visitor for IdentifierCounter {
//! fn visit_expr(&mut self, expr: &AstNode<Expr>) -> 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<Stmt>) -> LoxResult<()> {
walk_stmt(self, stmt)
}
/// Visit an expression node. Defaults to [`walk_expr`].
fn visit_expr(&mut self, expr: &AstNode<Expr>) -> 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<V: Visitor>(visitor: &mut V, stmt: &AstNode<Stmt>) -> 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<V: Visitor>(visitor: &mut V, expr: &AstNode<Expr>) -> LoxResult<()> {
pub fn walk_expr<V: Visitor>(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<V: Visitor>(visitor: &mut V, expr: &AstNode<Expr>) -> 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<V: Visitor>(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<AstNode<Stmt>> {
fn parse(src: &str) -> Vec<AstNode> {
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<Stmt>) -> LoxResult<()> {
self.stmts += 1;
walk_stmt(self, stmt)
}
fn visit_expr(&mut self, expr: &AstNode<Expr>) -> 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<Expr>) -> 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;
}