From ed9ccab5e1bf66e1b43ea349106c58e4b3e9de11 Mon Sep 17 00:00:00 2001 From: Araozu Date: Sat, 9 Mar 2024 12:33:11 -0500 Subject: [PATCH] Add lifetimes --- src/codegen/binding.rs | 4 ++-- src/codegen/block.rs | 2 +- src/codegen/expression.rs | 8 ++++---- src/codegen/function_call.rs | 2 +- src/codegen/module_ast.rs | 2 +- src/codegen/statement.rs | 2 +- src/semantic/impls.rs | 5 ++++- src/syntax/ast/functions.rs | 10 +++++----- src/syntax/ast/mod.rs | 28 ++++++++++++++-------------- src/syntax/ast/statement.rs | 6 +++--- src/syntax/ast/var_binding.rs | 4 ++-- src/syntax/expression/comparison.rs | 10 +++++----- src/syntax/expression/equality.rs | 10 +++++----- src/syntax/expression/factor.rs | 10 +++++----- src/syntax/expression/primary.rs | 17 +++++------------ src/syntax/expression/term.rs | 10 +++++----- src/syntax/expression/unary.rs | 2 +- src/syntax/functions/params_list.rs | 4 ++-- 18 files changed, 66 insertions(+), 70 deletions(-) diff --git a/src/codegen/binding.rs b/src/codegen/binding.rs index 039167f..d1233a8 100644 --- a/src/codegen/binding.rs +++ b/src/codegen/binding.rs @@ -1,7 +1,7 @@ use super::Transpilable; use crate::syntax::ast::var_binding::Binding; -impl Transpilable for Binding { +impl Transpilable for Binding<'_> { /// Transpiles val and var bindings into PHP. fn transpile(&self) -> String { let expression_str = self.expression.transpile(); @@ -22,7 +22,7 @@ mod tests { let binding = Binding { datatype: None, identifier: Box::new(id), - expression: Expression::Number(Box::new(value)), + expression: Expression::Number(&value), is_mutable: false, }; diff --git a/src/codegen/block.rs b/src/codegen/block.rs index bdd3759..64c1bfe 100644 --- a/src/codegen/block.rs +++ b/src/codegen/block.rs @@ -2,7 +2,7 @@ use crate::syntax::ast::Block; use super::Transpilable; -impl Transpilable for Block { +impl Transpilable for Block<'_> { fn transpile(&self) -> String { // TODO: Handle indentation self.statements diff --git a/src/codegen/expression.rs b/src/codegen/expression.rs index ef690c8..1bc9dc8 100644 --- a/src/codegen/expression.rs +++ b/src/codegen/expression.rs @@ -1,7 +1,7 @@ use super::Transpilable; use crate::syntax::ast::Expression; -impl Transpilable for Expression { +impl Transpilable for Expression<'_> { /// Transpiles an Expression to PHP /// /// Right now the expressions in the grammar are: @@ -41,7 +41,7 @@ mod tests { #[test] fn should_transpile_number() { let str = String::from("42"); - let exp = Expression::Number(Box::new(str)); + let exp = Expression::Number(&str); let result = exp.transpile(); assert_eq!("42", result); @@ -50,7 +50,7 @@ mod tests { #[test] fn should_transpile_string() { let str = String::from("\"Hello world\""); - let exp = Expression::String(Box::new(str)); + let exp = Expression::String(&str); let result = exp.transpile(); assert_eq!("\"Hello world\"", result); @@ -67,7 +67,7 @@ mod tests { #[test] fn should_transpile_identifier() { let s = String::from("newValue"); - let exp = Expression::Identifier(Box::new(s)); + let exp = Expression::Identifier(&s); let result = exp.transpile(); assert_eq!("newValue", result); diff --git a/src/codegen/function_call.rs b/src/codegen/function_call.rs index dd01692..3a8ab85 100644 --- a/src/codegen/function_call.rs +++ b/src/codegen/function_call.rs @@ -2,7 +2,7 @@ use crate::syntax::ast::functions::FunctionCall; use super::Transpilable; -impl Transpilable for FunctionCall { +impl Transpilable for FunctionCall<'_> { fn transpile(&self) -> String { let parameters = &self .arguments diff --git a/src/codegen/module_ast.rs b/src/codegen/module_ast.rs index 0c56af6..caba1b9 100644 --- a/src/codegen/module_ast.rs +++ b/src/codegen/module_ast.rs @@ -27,7 +27,7 @@ mod tests { let binding = Binding { datatype: None, identifier: Box::new(id), - expression: Expression::Number(Box::new(value)), + expression: Expression::Number(&value), is_mutable: false, }; diff --git a/src/codegen/statement.rs b/src/codegen/statement.rs index 198b69c..a48d448 100644 --- a/src/codegen/statement.rs +++ b/src/codegen/statement.rs @@ -2,7 +2,7 @@ use crate::syntax::ast::statement::Statement; use super::Transpilable; -impl Transpilable for Statement { +impl Transpilable for Statement<'_> { fn transpile(&self) -> String { let stmt = match self { Statement::FunctionCall(f) => f.transpile(), diff --git a/src/semantic/impls.rs b/src/semantic/impls.rs index d8600f9..71e17e7 100644 --- a/src/semantic/impls.rs +++ b/src/semantic/impls.rs @@ -40,7 +40,10 @@ impl SemanticCheck for TopLevelDeclaration<'_> { let error = SemanticError { error_start: function.identifier.position, error_end: function.identifier.get_end_position(), - reason: format!("Duplicated function: A function with name {} was already defined", function_name), + reason: format!( + "Duplicated function: A function with name {} was already defined", + function_name + ), }; return Err(MistiError::Semantic(error)); diff --git a/src/syntax/ast/functions.rs b/src/syntax/ast/functions.rs index 43477bc..9eaf229 100644 --- a/src/syntax/ast/functions.rs +++ b/src/syntax/ast/functions.rs @@ -1,12 +1,12 @@ use super::Expression; #[derive(Debug)] -pub struct FunctionCall { - pub function: Box, - pub arguments: Box, +pub struct FunctionCall<'a> { + pub function: Box>, + pub arguments: Box>, } #[derive(Debug)] -pub struct ArgumentsList { - pub arguments: Vec, +pub struct ArgumentsList<'a> { + pub arguments: Vec>, } diff --git a/src/syntax/ast/mod.rs b/src/syntax/ast/mod.rs index 5b2cdd8..fefc7b5 100644 --- a/src/syntax/ast/mod.rs +++ b/src/syntax/ast/mod.rs @@ -12,7 +12,7 @@ pub struct ModuleAST<'a> { #[derive(Debug)] pub enum TopLevelDeclaration<'a> { - Binding(var_binding::Binding), + Binding(var_binding::Binding<'a>), FunctionDeclaration(FunctionDeclaration<'a>), } @@ -20,29 +20,29 @@ pub enum TopLevelDeclaration<'a> { pub struct FunctionDeclaration<'a> { pub identifier: &'a Token, pub params_list: Box, - pub block: Box, + pub block: Box>, } #[derive(Debug)] -pub struct Block { - pub statements: Vec, +pub struct Block<'a> { + pub statements: Vec>, } #[derive(Debug)] pub struct ParamsList {} -pub struct Parameter { - pub identifier: Box, - pub datatype: Box, +pub struct Parameter<'a> { + pub identifier: &'a String, + pub datatype: &'a String, } #[derive(Debug)] -pub enum Expression { - Number(Box), - String(Box), +pub enum Expression<'a> { + Number(&'a String), + String(&'a String), Boolean(bool), - Identifier(Box), - FunctionCall(FunctionCall), - UnaryOperator(Box, Box), - BinaryOperator(Box, Box, Box), + Identifier(&'a String), + FunctionCall(FunctionCall<'a>), + UnaryOperator(&'a String, Box>), + BinaryOperator(Box>, Box>, &'a String), } diff --git a/src/syntax/ast/statement.rs b/src/syntax/ast/statement.rs index 7e0bc69..d72386a 100644 --- a/src/syntax/ast/statement.rs +++ b/src/syntax/ast/statement.rs @@ -1,7 +1,7 @@ use super::{functions::FunctionCall, var_binding::Binding}; #[derive(Debug)] -pub enum Statement { - FunctionCall(FunctionCall), - Binding(Binding), +pub enum Statement<'a> { + FunctionCall(FunctionCall<'a>), + Binding(Binding<'a>), } diff --git a/src/syntax/ast/var_binding.rs b/src/syntax/ast/var_binding.rs index eef1fc6..1bf41d5 100644 --- a/src/syntax/ast/var_binding.rs +++ b/src/syntax/ast/var_binding.rs @@ -1,9 +1,9 @@ use super::Expression; #[derive(Debug)] -pub struct Binding { +pub struct Binding<'a> { pub datatype: Option, pub identifier: Box, - pub expression: Expression, + pub expression: Expression<'a>, pub is_mutable: bool, } diff --git a/src/syntax/expression/comparison.rs b/src/syntax/expression/comparison.rs index 42f10a9..729026b 100644 --- a/src/syntax/expression/comparison.rs +++ b/src/syntax/expression/comparison.rs @@ -17,11 +17,11 @@ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult parse_many(tokens, next_pos, term) } -fn parse_many( - tokens: &Vec, +fn parse_many<'a>( + tokens: &'a Vec, pos: usize, - prev_expr: Expression, -) -> ParseResult { + prev_expr: Expression<'a>, +) -> ParseResult, ()> { // comparison = term, ((">" | ">=" | "<" | "<="), term)*; match tokens.get(pos) { @@ -36,7 +36,7 @@ fn parse_many( let expr = Expression::BinaryOperator( Box::new(prev_expr), Box::new(expr), - Box::new(token.value.clone()), + &token.value, ); parse_many(tokens, next_pos, expr) diff --git a/src/syntax/expression/equality.rs b/src/syntax/expression/equality.rs index ebae488..dd34929 100644 --- a/src/syntax/expression/equality.rs +++ b/src/syntax/expression/equality.rs @@ -17,11 +17,11 @@ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult parse_many(tokens, next_pos, comparison) } -fn parse_many( - tokens: &Vec, +fn parse_many<'a>( + tokens: &'a Vec, pos: usize, - prev_expr: Expression, -) -> ParseResult { + prev_expr: Expression<'a>, +) -> ParseResult, ()> { // equality = comparison, (("==" | "!="), comparison )*; match tokens.get(pos) { @@ -31,7 +31,7 @@ fn parse_many( let expr = Expression::BinaryOperator( Box::new(prev_expr), Box::new(expr), - Box::new(token.value.clone()), + &token.value, ); parse_many(tokens, next_pos, expr) diff --git a/src/syntax/expression/factor.rs b/src/syntax/expression/factor.rs index e486de8..1c4f568 100644 --- a/src/syntax/expression/factor.rs +++ b/src/syntax/expression/factor.rs @@ -17,11 +17,11 @@ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult parse_many(tokens, next_pos, unary) } -fn parse_many( - tokens: &Vec, +fn parse_many<'a>( + tokens: &'a Vec, pos: usize, - prev_expr: Expression, -) -> ParseResult { + prev_expr: Expression<'a>, +) -> ParseResult, ()> { // (("/" | "*"), unary)* match tokens.get(pos) { @@ -31,7 +31,7 @@ fn parse_many( let expr = Expression::BinaryOperator( Box::new(prev_expr), Box::new(expr), - Box::new(token.value.clone()), + &token.value, ); parse_many(tokens, next_pos, expr) diff --git a/src/syntax/expression/primary.rs b/src/syntax/expression/primary.rs index bfa567f..78d5272 100644 --- a/src/syntax/expression/primary.rs +++ b/src/syntax/expression/primary.rs @@ -12,21 +12,14 @@ use crate::{ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult { match tokens.get_significant(pos) { Some((token, token_pos)) => match token.token_type { - TokenType::Number => ParseResult::Ok( - Expression::Number(Box::new(token.value.clone())), - token_pos + 1, - ), - TokenType::String => ParseResult::Ok( - Expression::String(Box::new(token.value.clone())), - token_pos + 1, - ), + TokenType::Number => ParseResult::Ok(Expression::Number(&token.value), token_pos + 1), + TokenType::String => ParseResult::Ok(Expression::String(&token.value), token_pos + 1), TokenType::Identifier if token.value == "true" || token.value == "false" => { ParseResult::Ok(Expression::Boolean(token.value == "true"), token_pos + 1) } - TokenType::Identifier => ParseResult::Ok( - Expression::Identifier(Box::new(token.value.clone())), - token_pos + 1, - ), + TokenType::Identifier => { + ParseResult::Ok(Expression::Identifier(&token.value), token_pos + 1) + } TokenType::LeftParen => parse_parenthesized_expression(tokens, token_pos), _ => ParseResult::Unmatched, }, diff --git a/src/syntax/expression/term.rs b/src/syntax/expression/term.rs index 22b15ad..6a1fe71 100644 --- a/src/syntax/expression/term.rs +++ b/src/syntax/expression/term.rs @@ -17,11 +17,11 @@ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult parse_many(tokens, next_pos, factor) } -fn parse_many( - tokens: &Vec, +fn parse_many<'a>( + tokens: &'a Vec, pos: usize, - prev_expr: Expression, -) -> ParseResult { + prev_expr: Expression<'a>, +) -> ParseResult, ()> { // term = factor, (("-" | "+"), factor)*; match tokens.get(pos) { @@ -31,7 +31,7 @@ fn parse_many( let expr = Expression::BinaryOperator( Box::new(prev_expr), Box::new(expr), - Box::new(token.value.clone()), + &token.value, ); parse_many(tokens, next_pos, expr) diff --git a/src/syntax/expression/unary.rs b/src/syntax/expression/unary.rs index 2db44c8..808a58e 100644 --- a/src/syntax/expression/unary.rs +++ b/src/syntax/expression/unary.rs @@ -16,7 +16,7 @@ pub fn try_parse(tokens: &Vec, pos: usize) -> ParseResult Some(token) if token.value == "!" || token.value == "-" => { match super::try_parse(tokens, pos + 1) { ParseResult::Ok(expression, next_pos) => ParseResult::Ok( - Expression::UnaryOperator(Box::new(token.value.clone()), Box::new(expression)), + Expression::UnaryOperator(&token.value, Box::new(expression)), next_pos, ), _ => ParseResult::Unmatched, diff --git a/src/syntax/functions/params_list.rs b/src/syntax/functions/params_list.rs index a565cba..47f4017 100644 --- a/src/syntax/functions/params_list.rs +++ b/src/syntax/functions/params_list.rs @@ -129,8 +129,8 @@ fn parse_param_definition<'a>( ParseResult::Ok( Parameter { - identifier: Box::new(identifier.value.clone()), - datatype: Box::new(datatype.value.clone()), + identifier: &identifier.value, + datatype: &datatype.value, }, next_pos, )