jeff/dust
1
0
Fork 0
Code Issues

Remove return statement; Add StatementInner

Browse Source
This commit is contained in:
Jeff 2024-02-16 10:36:16 -05:00
parent 51869f04b6
commit 172a6fa860
4 changed files with 88 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/abstract_tree/block.rs
View File

@ -75,15 +75,8 @@ impl AbstractTree for Block {
.find_map_first(|(index, statement)| { .find_map_first(|(index, statement)| {
let result = statement.run(_source, _context); let result = statement.run(_source, _context);
let is_last_statement = index == statements.len() - 1; let is_last_statement = index == statements.len() - 1;
let is_return_statement = if let Statement::Return(_) = statement {
true
} else {
false
};
if is_return_statement || result.is_err() { if is_last_statement {
Some(result)
} else if is_last_statement {
let get_write_lock = final_result.write(); let get_write_lock = final_result.write();
match get_write_lock { match get_write_lock {
@ -102,10 +95,6 @@ impl AbstractTree for Block {
let mut prev_result = None; let mut prev_result = None;
for statement in &self.statements { for statement in &self.statements {
if let Statement::Return(inner_statement) = statement {
return inner_statement.run(_source, _context);
}
prev_result = Some(statement.run(_source, _context)); prev_result = Some(statement.run(_source, _context));
} }
@ -114,15 +103,7 @@ impl AbstractTree for Block {
} }
fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> { fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> {
if let Some(statement) = self.statements.iter().find(|statement| { if let Some(statement) = self.statements.last() {
if let Statement::Return(_) = statement {
true
} else {
false
}
}) {
statement.expected_type(_context)
} else if let Some(statement) = self.statements.last() {
statement.expected_type(_context) statement.expected_type(_context)
} else { } else {
Ok(Type::None) Ok(Type::None)

6
src/abstract_tree/mod.rs
View File

@ -105,11 +105,7 @@ impl AbstractTree for Root {
fn validate(&self, _source: &str, _context: &Context) -> Result<(), ValidationError> { fn validate(&self, _source: &str, _context: &Context) -> Result<(), ValidationError> {
for statement in &self.statements { for statement in &self.statements {
if let Statement::Return(inner_statement) = statement { statement.validate(_source, _context)?;
return inner_statement.validate(_source, _context);
} else {
statement.validate(_source, _context)?;
}
} }
Ok(()) Ok(())

0
src/abstract_tree/return.rs
View File

144
src/abstract_tree/statement.rs
View File

@ -6,58 +6,82 @@ use crate::{
Match, SyntaxNode, Type, TypeDefinition, Value, While, Match, SyntaxNode, Type, TypeDefinition, Value, While,
}; };
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
pub struct Statement {
is_return: bool,
statement_inner: StatementInner,
}
impl AbstractTree for Statement {
fn from_syntax(node: SyntaxNode, source: &str, context: &Context) -> Result<Self, SyntaxError> {
todo!()
}
fn expected_type(&self, context: &Context) -> Result<Type, ValidationError> {
todo!()
}
fn validate(&self, source: &str, context: &Context) -> Result<(), ValidationError> {
todo!()
}
fn run(&self, source: &str, context: &Context) -> Result<Value, RuntimeError> {
todo!()
}
}
impl Format for Statement {
fn format(&self, output: &mut String, indent_level: u8) {
todo!()
}
}
/// Abstract representation of a statement. /// Abstract representation of a statement.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)] #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
pub enum Statement { pub enum StatementInner {
Assignment(Box<Assignment>), Assignment(Box<Assignment>),
Expression(Expression), Expression(Expression),
IfElse(Box<IfElse>), IfElse(Box<IfElse>),
Match(Match), Match(Match),
While(Box<While>), While(Box<While>),
Block(Box<Block>), Block(Box<Block>),
Return(Box<Statement>),
For(Box<For>), For(Box<For>),
IndexAssignment(Box<IndexAssignment>), IndexAssignment(Box<IndexAssignment>),
TypeDefinition(TypeDefinition), TypeDefinition(TypeDefinition),
} }
impl AbstractTree for Statement { impl AbstractTree for StatementInner {
fn from_syntax(node: SyntaxNode, source: &str, context: &Context) -> Result<Self, SyntaxError> { fn from_syntax(node: SyntaxNode, source: &str, context: &Context) -> Result<Self, SyntaxError> {
SyntaxError::expect_syntax_node(source, "statement", node)?; SyntaxError::expect_syntax_node(source, "statement", node)?;
let child = node.child(0).unwrap(); let child = node.child(0).unwrap();
match child.kind() { match child.kind() {
"assignment" => Ok(Statement::Assignment(Box::new( "assignment" => Ok(StatementInner::Assignment(Box::new(
Assignment::from_syntax(child, source, context)?, Assignment::from_syntax(child, source, context)?,
))), ))),
"expression" => Ok(Statement::Expression(Expression::from_syntax( "expression" => Ok(StatementInner::Expression(Expression::from_syntax(
child, source, context, child, source, context,
)?)), )?)),
"if_else" => Ok(Statement::IfElse(Box::new(IfElse::from_syntax( "if_else" => Ok(StatementInner::IfElse(Box::new(IfElse::from_syntax(
child, source, context, child, source, context,
)?))), )?))),
"while" => Ok(Statement::While(Box::new(While::from_syntax( "while" => Ok(StatementInner::While(Box::new(While::from_syntax(
child, source, context, child, source, context,
)?))), )?))),
"block" => Ok(Statement::Block(Box::new(Block::from_syntax( "block" => Ok(StatementInner::Block(Box::new(Block::from_syntax(
child, source, context, child, source, context,
)?))), )?))),
"for" => Ok(Statement::For(Box::new(For::from_syntax( "for" => Ok(StatementInner::For(Box::new(For::from_syntax(
child, source, context, child, source, context,
)?))), )?))),
"index_assignment" => Ok(Statement::IndexAssignment(Box::new( "index_assignment" => Ok(StatementInner::IndexAssignment(Box::new(
IndexAssignment::from_syntax(child, source, context)?, IndexAssignment::from_syntax(child, source, context)?,
))), ))),
"match" => Ok(Statement::Match(Match::from_syntax( "match" => Ok(StatementInner::Match(Match::from_syntax(
child, source, context, child, source, context,
)?)), )?)),
"return" => { "type_definition" => Ok(StatementInner::TypeDefinition(TypeDefinition::from_syntax(
let statement_node = child.child(1).unwrap();
Ok(Statement::Return(Box::new(Statement::from_syntax(statement_node, source, context)?)))
},
"type_definition" => Ok(Statement::TypeDefinition(TypeDefinition::from_syntax(
child, source, context child, source, context
)?)), )?)),
_ => Err(SyntaxError::UnexpectedSyntaxNode { _ => Err(SyntaxError::UnexpectedSyntaxNode {
@ -72,35 +96,35 @@ impl AbstractTree for Statement {
fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> { fn expected_type(&self, _context: &Context) -> Result<Type, ValidationError> {
match self { match self {
Statement::Assignment(assignment) => assignment.expected_type(_context), StatementInner::Assignment(assignment) => assignment.expected_type(_context),
Statement::Expression(expression) => expression.expected_type(_context), StatementInner::Expression(expression) => expression.expected_type(_context),
Statement::IfElse(if_else) => if_else.expected_type(_context), StatementInner::IfElse(if_else) => if_else.expected_type(_context),
Statement::Match(r#match) => r#match.expected_type(_context), StatementInner::Match(r#match) => r#match.expected_type(_context),
Statement::While(r#while) => r#while.expected_type(_context), StatementInner::While(r#while) => r#while.expected_type(_context),
Statement::Block(block) => block.expected_type(_context), StatementInner::Block(block) => block.expected_type(_context),
Statement::For(r#for) => r#for.expected_type(_context), StatementInner::For(r#for) => r#for.expected_type(_context),
Statement::IndexAssignment(index_assignment) => { StatementInner::IndexAssignment(index_assignment) => {
index_assignment.expected_type(_context) index_assignment.expected_type(_context)
} }
Statement::Return(statement) => statement.expected_type(_context), StatementInner::TypeDefinition(type_definition) => {
Statement::TypeDefinition(type_definition) => type_definition.expected_type(_context), type_definition.expected_type(_context)
}
} }
} }
fn validate(&self, _source: &str, _context: &Context) -> Result<(), ValidationError> { fn validate(&self, _source: &str, _context: &Context) -> Result<(), ValidationError> {
match self { match self {
Statement::Assignment(assignment) => assignment.validate(_source, _context), StatementInner::Assignment(assignment) => assignment.validate(_source, _context),
Statement::Expression(expression) => expression.validate(_source, _context), StatementInner::Expression(expression) => expression.validate(_source, _context),
Statement::IfElse(if_else) => if_else.validate(_source, _context), StatementInner::IfElse(if_else) => if_else.validate(_source, _context),
Statement::Match(r#match) => r#match.validate(_source, _context), StatementInner::Match(r#match) => r#match.validate(_source, _context),
Statement::While(r#while) => r#while.validate(_source, _context), StatementInner::While(r#while) => r#while.validate(_source, _context),
Statement::Block(block) => block.validate(_source, _context), StatementInner::Block(block) => block.validate(_source, _context),
Statement::For(r#for) => r#for.validate(_source, _context), StatementInner::For(r#for) => r#for.validate(_source, _context),
Statement::IndexAssignment(index_assignment) => { StatementInner::IndexAssignment(index_assignment) => {
index_assignment.validate(_source, _context) index_assignment.validate(_source, _context)
} }
Statement::Return(statement) => statement.validate(_source, _context), StatementInner::TypeDefinition(type_definition) => {
Statement::TypeDefinition(type_definition) => {
type_definition.validate(_source, _context) type_definition.validate(_source, _context)
} }
} }
@ -108,37 +132,39 @@ impl AbstractTree for Statement {
fn run(&self, _source: &str, _context: &Context) -> Result<Value, RuntimeError> { fn run(&self, _source: &str, _context: &Context) -> Result<Value, RuntimeError> {
match self { match self {
Statement::Assignment(assignment) => assignment.run(_source, _context), StatementInner::Assignment(assignment) => assignment.run(_source, _context),
Statement::Expression(expression) => expression.run(_source, _context), StatementInner::Expression(expression) => expression.run(_source, _context),
Statement::IfElse(if_else) => if_else.run(_source, _context), StatementInner::IfElse(if_else) => if_else.run(_source, _context),
Statement::Match(r#match) => r#match.run(_source, _context), StatementInner::Match(r#match) => r#match.run(_source, _context),
Statement::While(r#while) => r#while.run(_source, _context), StatementInner::While(r#while) => r#while.run(_source, _context),
Statement::Block(block) => block.run(_source, _context), StatementInner::Block(block) => block.run(_source, _context),
Statement::For(r#for) => r#for.run(_source, _context), StatementInner::For(r#for) => r#for.run(_source, _context),
Statement::IndexAssignment(index_assignment) => index_assignment.run(_source, _context), StatementInner::IndexAssignment(index_assignment) => {
Statement::Return(statement) => statement.run(_source, _context), index_assignment.run(_source, _context)
Statement::TypeDefinition(type_definition) => type_definition.run(_source, _context), }
StatementInner::TypeDefinition(type_definition) => {
type_definition.run(_source, _context)
}
} }
} }
} }
impl Format for Statement { impl Format for StatementInner {
fn format(&self, output: &mut String, indent_level: u8) { fn format(&self, output: &mut String, indent_level: u8) {
Statement::indent(output, indent_level); StatementInner::indent(output, indent_level);
match self { match self {
Statement::Assignment(assignment) => assignment.format(output, indent_level), StatementInner::Assignment(assignment) => assignment.format(output, indent_level),
Statement::Expression(expression) => expression.format(output, indent_level), StatementInner::Expression(expression) => expression.format(output, indent_level),
Statement::IfElse(if_else) => if_else.format(output, indent_level), StatementInner::IfElse(if_else) => if_else.format(output, indent_level),
Statement::Match(r#match) => r#match.format(output, indent_level), StatementInner::Match(r#match) => r#match.format(output, indent_level),
Statement::While(r#while) => r#while.format(output, indent_level), StatementInner::While(r#while) => r#while.format(output, indent_level),
Statement::Block(block) => block.format(output, indent_level), StatementInner::Block(block) => block.format(output, indent_level),
Statement::For(r#for) => r#for.format(output, indent_level), StatementInner::For(r#for) => r#for.format(output, indent_level),
Statement::IndexAssignment(index_assignment) => { StatementInner::IndexAssignment(index_assignment) => {
index_assignment.format(output, indent_level) index_assignment.format(output, indent_level)
} }
Statement::Return(statement) => statement.format(output, indent_level), StatementInner::TypeDefinition(type_definition) => {
Statement::TypeDefinition(type_definition) => {
type_definition.format(output, indent_level) type_definition.format(output, indent_level)
} }
} }