From 09dd19508d6846c6d4cb8f3d2bea1bd10c8ec469 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Moritz=20H=C3=B6lting?= <87192362+moritz-hoelting@users.noreply.github.com> Date: Tue, 11 Mar 2025 19:43:26 +0100 Subject: [PATCH] change conditional to use expression instead of individual condition --- src/semantic/mod.rs | 83 +--- src/syntax/syntax_tree/condition.rs | 451 ------------------ src/syntax/syntax_tree/expression.rs | 2 +- src/syntax/syntax_tree/mod.rs | 1 - .../syntax_tree/statement/execute_block.rs | 10 +- src/transpile/conversions.rs | 50 +- src/transpile/expression.rs | 205 ++++---- src/transpile/transpiler.rs | 161 ++++--- 8 files changed, 218 insertions(+), 745 deletions(-) delete mode 100644 src/syntax/syntax_tree/condition.rs diff --git a/src/semantic/mod.rs b/src/semantic/mod.rs index b16e1e3..99aedf6 100644 --- a/src/semantic/mod.rs +++ b/src/semantic/mod.rs @@ -13,11 +13,8 @@ use crate::{ base::{self, source_file::SourceElement as _, Handler}, lexical::token::{MacroStringLiteral, MacroStringLiteralPart}, syntax::syntax_tree::{ - condition::{ - BinaryCondition, Condition, ParenthesizedCondition, PrimaryCondition, UnaryCondition, - }, declaration::{Declaration, Function, ImportItems}, - expression::{Expression, FunctionCall, Primary}, + expression::{Expression, FunctionCall, Parenthesized, Primary}, program::{Namespace, ProgramFile}, statement::{ execute_block::{ @@ -360,7 +357,7 @@ impl Conditional { } } -impl ParenthesizedCondition { +impl Parenthesized { /// Analyzes the semantics of the parenthesized condition. pub fn analyze_semantics( &self, @@ -368,26 +365,11 @@ impl ParenthesizedCondition { macro_names: &HashSet, handler: &impl Handler, ) -> Result<(), error::Error> { - self.condition + self.expression() .analyze_semantics(function_names, macro_names, handler) } } -impl Condition { - /// Analyzes the semantics of the condition. - pub fn analyze_semantics( - &self, - function_names: &HashSet, - macro_names: &HashSet, - handler: &impl Handler, - ) -> Result<(), error::Error> { - match self { - Self::Primary(prim) => prim.analyze_semantics(function_names, macro_names, handler), - Self::Binary(bin) => bin.analyze_semantics(function_names, macro_names, handler), - } - } -} - impl Else { /// Analyzes the semantics of the else block. pub fn analyze_semantics( @@ -618,62 +600,3 @@ impl VariableDeclaration { Ok(()) } } - -impl PrimaryCondition { - /// Analyzes the semantics of a primary condition. - pub fn analyze_semantics( - &self, - function_names: &HashSet, - macro_names: &HashSet, - handler: &impl Handler, - ) -> Result<(), error::Error> { - match self { - Self::Parenthesized(paren) => { - paren.analyze_semantics(function_names, macro_names, handler) - } - Self::StringLiteral(_) => Ok(()), - Self::Unary(unary) => unary.analyze_semantics(function_names, macro_names, handler), - } - } -} - -impl UnaryCondition { - /// Analyzes the semantics of an unary condition. - pub fn analyze_semantics( - &self, - function_names: &HashSet, - macro_names: &HashSet, - handler: &impl Handler, - ) -> Result<(), error::Error> { - self.operand() - .analyze_semantics(function_names, macro_names, handler) - } -} - -impl BinaryCondition { - /// Analyzes the semantics of a binary condition. - pub fn analyze_semantics( - &self, - function_names: &HashSet, - macro_names: &HashSet, - handler: &impl Handler, - ) -> Result<(), error::Error> { - let a = self - .left_operand() - .analyze_semantics(function_names, macro_names, handler) - .inspect_err(|err| { - handler.receive(err.clone()); - }); - let b = self - .right_operand() - .analyze_semantics(function_names, macro_names, handler) - .inspect_err(|err| { - handler.receive(err.clone()); - }); - if a.is_err() { - a - } else { - b - } - } -} diff --git a/src/syntax/syntax_tree/condition.rs b/src/syntax/syntax_tree/condition.rs deleted file mode 100644 index ebdba7a..0000000 --- a/src/syntax/syntax_tree/condition.rs +++ /dev/null @@ -1,451 +0,0 @@ -//! Syntax tree nodes for conditions. - -#![allow(clippy::missing_errors_doc)] - -use std::{cmp::Ordering, collections::VecDeque}; - -use enum_as_inner::EnumAsInner; -use getset::Getters; - -use crate::{ - base::{ - self, - source_file::{SourceElement, Span}, - Handler, VoidHandler, - }, - lexical::{ - token::{Punctuation, Token}, - token_stream::Delimiter, - }, - syntax::{ - error::{Error, ParseResult, SyntaxKind, UnexpectedSyntax}, - parser::{Parser, Reading}, - }, -}; - -use super::AnyStringLiteral; - -/// Condition that is viewed as a single entity during precedence parsing. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// PrimaryCondition: -/// UnaryCondition -/// | ParenthesizedCondition -/// | AnyStringLiteral -/// ``` -#[allow(missing_docs)] -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)] -pub enum PrimaryCondition { - Unary(UnaryCondition), - Parenthesized(ParenthesizedCondition), - StringLiteral(AnyStringLiteral), -} - -impl SourceElement for PrimaryCondition { - fn span(&self) -> Span { - match self { - Self::Unary(unary) => unary.span(), - Self::Parenthesized(parenthesized) => parenthesized.span(), - Self::StringLiteral(literal) => literal.span(), - } - } -} - -/// Condition that is composed of two conditions and a binary operator. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// BinaryCondition: -/// Condition ConditionalBinaryOperator Condition -/// ; -/// ``` -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)] -pub struct BinaryCondition { - /// The left operand of the binary condition. - #[get = "pub"] - left_operand: Box, - /// The operator of the binary condition. - #[get = "pub"] - operator: ConditionalBinaryOperator, - /// The right operand of the binary condition. - #[get = "pub"] - right_operand: Box, -} - -impl SourceElement for BinaryCondition { - fn span(&self) -> Span { - self.left_operand - .span() - .join(&self.right_operand.span()) - .unwrap() - } -} - -impl BinaryCondition { - /// Dissolves the binary condition into its components - #[must_use] - pub fn dissolve(self) -> (Condition, ConditionalBinaryOperator, Condition) { - (*self.left_operand, self.operator, *self.right_operand) - } -} - -/// Operator that is used to combine two conditions. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// ConditionalBinaryOperator: -/// '&&' -/// | '||' -/// ; -/// ``` -#[allow(missing_docs)] -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)] -pub enum ConditionalBinaryOperator { - LogicalAnd(Punctuation, Punctuation), - LogicalOr(Punctuation, Punctuation), -} - -impl ConditionalBinaryOperator { - /// Gets the precedence of the operator (the higher the number, the first it will be evaluated) - /// - /// The least operator has precedence 1. - #[must_use] - pub fn get_precedence(&self) -> u8 { - match self { - Self::LogicalOr(..) => 1, - Self::LogicalAnd(..) => 2, - } - } -} - -impl SourceElement for ConditionalBinaryOperator { - fn span(&self) -> Span { - match self { - Self::LogicalAnd(a, b) | Self::LogicalOr(a, b) => a - .span - .join(&b.span) - .expect("Invalid tokens for ConditionalBinaryOperator"), - } - } -} - -/// Condition that is enclosed in parentheses. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// ParenthesizedCondition: -/// '(' Condition ')'; -/// ``` -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)] -pub struct ParenthesizedCondition { - /// The opening parenthesis. - #[get = "pub"] - pub open_paren: Punctuation, - /// The condition within the parenthesis. - #[get = "pub"] - pub condition: Box, - /// The closing parenthesis. - #[get = "pub"] - pub close_paren: Punctuation, -} - -impl ParenthesizedCondition { - /// Dissolves the parenthesized condition into its components - #[must_use] - pub fn dissolve(self) -> (Punctuation, Condition, Punctuation) { - (self.open_paren, *self.condition, self.close_paren) - } -} - -impl SourceElement for ParenthesizedCondition { - fn span(&self) -> Span { - self.open_paren - .span() - .join(&self.close_paren.span()) - .expect("The span of the parenthesis is invalid.") - } -} - -/// Operator that is used to prefix a condition. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// ConditionalPrefixOperator: '!'; -/// ``` -#[allow(missing_docs)] -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)] -pub enum ConditionalPrefixOperator { - LogicalNot(Punctuation), -} - -impl SourceElement for ConditionalPrefixOperator { - fn span(&self) -> Span { - match self { - Self::LogicalNot(token) => token.span.clone(), - } - } -} - -/// Condition that is prefixed by an operator. -/// -/// Syntax Synopsis: -/// -/// ```ebnf -/// UnaryCondition: -/// ConditionalPrefixOperator PrimaryCondition -/// ; -/// ``` -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)] -pub struct UnaryCondition { - /// The operator of the prefix. - #[get = "pub"] - operator: ConditionalPrefixOperator, - /// The operand of the prefix. - #[get = "pub"] - operand: Box, -} - -impl SourceElement for UnaryCondition { - fn span(&self) -> Span { - self.operator.span().join(&self.operand.span()).unwrap() - } -} -impl UnaryCondition { - /// Dissolves the conditional prefix into its components - #[must_use] - pub fn dissolve(self) -> (ConditionalPrefixOperator, PrimaryCondition) { - (self.operator, *self.operand) - } -} - -/// Represents a condition in the syntax tree. -/// -/// Syntax Synopsis: -/// -/// ``` ebnf -/// Condition: -/// PrimaryCondition -/// | BinaryCondition -/// ; -/// ``` -#[allow(missing_docs)] -#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, EnumAsInner)] -pub enum Condition { - Primary(PrimaryCondition), - Binary(BinaryCondition), -} - -impl SourceElement for Condition { - fn span(&self) -> Span { - match self { - Self::Primary(primary) => primary.span(), - Self::Binary(binary) => binary.span(), - } - } -} - -impl<'a> Parser<'a> { - /// Parses a [`Condition`]. - /// - /// # Precedence of the operators - /// 1. `!` - /// 2. `&&` - /// 3. `||` - pub fn parse_condition( - &mut self, - handler: &impl Handler, - ) -> ParseResult { - let mut lhs = Condition::Primary(self.parse_primary_condition(handler)?); - let mut expressions = VecDeque::new(); - - // Parses a list of binary operators and expressions - while let Ok(binary_operator) = self.try_parse_conditional_binary_operator() { - expressions.push_back(( - binary_operator, - Some(Condition::Primary(self.parse_primary_condition(handler)?)), - )); - } - - let mut candidate_index = 0; - let mut current_precedence; - - while !expressions.is_empty() { - // reset precedence - current_precedence = 0; - - for (index, (binary_op, _)) in expressions.iter().enumerate() { - let new_precedence = binary_op.get_precedence(); - match new_precedence.cmp(¤t_precedence) { - // Clear the candidate indices and set the current precedence to the - // precedence of the current binary operator. - Ordering::Greater => { - current_precedence = new_precedence; - candidate_index = index; - } - - Ordering::Less | Ordering::Equal => (), - } - } - - // ASSUMPTION: The assignments have 1 precedence and are right associative. - assert!(current_precedence > 0); - - if candidate_index == 0 { - let (binary_op, rhs) = expressions.pop_front().expect("No binary operator found"); - - // fold the first expression - lhs = Condition::Binary(BinaryCondition { - left_operand: Box::new(lhs), - operator: binary_op, - right_operand: Box::new(rhs.unwrap()), - }); - } else { - let (binary_op, rhs) = expressions - .remove(candidate_index) - .expect("No binary operator found"); - - // fold the expression at candidate_index - expressions[candidate_index - 1].1 = Some(Condition::Binary(BinaryCondition { - left_operand: Box::new(expressions[candidate_index - 1].1.take().unwrap()), - operator: binary_op, - right_operand: Box::new(rhs.unwrap()), - })); - } - } - - Ok(lhs) - } - - /// Parses a [`PrimaryCondition`]. - pub fn parse_primary_condition( - &mut self, - handler: &impl Handler, - ) -> ParseResult { - match self.stop_at_significant() { - // prefixed expression - Reading::Atomic(Token::Punctuation(punc)) if punc.punctuation == '!' => { - // eat prefix operator - self.forward(); - - let operator = match punc.punctuation { - '!' => ConditionalPrefixOperator::LogicalNot(punc), - _ => unreachable!(), - }; - - let operand = Box::new(self.parse_primary_condition(handler)?); - - Ok(PrimaryCondition::Unary(UnaryCondition { - operator, - operand, - })) - } - - // string literal - Reading::Atomic(Token::StringLiteral(literal)) => { - self.forward(); - Ok(PrimaryCondition::StringLiteral(literal.into())) - } - - // macro string literal - Reading::Atomic(Token::MacroStringLiteral(literal)) => { - self.forward(); - Ok(PrimaryCondition::StringLiteral(literal.into())) - } - - // parenthesized condition - Reading::IntoDelimited(punc) if punc.punctuation == '(' => self - .parse_parenthesized_condition(handler) - .map(PrimaryCondition::Parenthesized), - - unexpected => { - // make progress - self.forward(); - - let err = Error::UnexpectedSyntax(UnexpectedSyntax { - expected: SyntaxKind::Either(&[ - SyntaxKind::Punctuation('!'), - SyntaxKind::StringLiteral, - SyntaxKind::Punctuation('('), - ]), - found: unexpected.into_token(), - }); - handler.receive(err.clone()); - - Err(err) - } - } - } - - /// Parses a [`ParenthesizedCondition`]. - pub fn parse_parenthesized_condition( - &mut self, - handler: &impl Handler, - ) -> ParseResult { - let token_tree = self.step_into( - Delimiter::Parenthesis, - |parser| { - let cond = parser.parse_condition(handler)?; - parser.stop_at_significant(); - Ok(cond) - }, - handler, - )?; - - Ok(ParenthesizedCondition { - open_paren: token_tree.open, - condition: Box::new(token_tree.tree?), - close_paren: token_tree.close, - }) - } - - fn try_parse_conditional_binary_operator(&mut self) -> ParseResult { - self.try_parse(|parser| match parser.next_significant_token() { - Reading::Atomic(token) => match token.clone() { - Token::Punctuation(punc) => match punc.punctuation { - '&' => { - let b = parser.parse_punctuation('&', false, &VoidHandler)?; - Ok(ConditionalBinaryOperator::LogicalAnd(punc, b)) - } - '|' => { - let b = parser.parse_punctuation('|', false, &VoidHandler)?; - Ok(ConditionalBinaryOperator::LogicalOr(punc, b)) - } - _ => Err(Error::UnexpectedSyntax(UnexpectedSyntax { - expected: SyntaxKind::Either(&[ - SyntaxKind::Punctuation('&'), - SyntaxKind::Punctuation('|'), - ]), - found: Some(token), - })), - }, - unexpected => Err(Error::UnexpectedSyntax(UnexpectedSyntax { - expected: SyntaxKind::Either(&[ - SyntaxKind::Punctuation('&'), - SyntaxKind::Punctuation('|'), - ]), - found: Some(unexpected), - })), - }, - unexpected => Err(Error::UnexpectedSyntax(UnexpectedSyntax { - expected: SyntaxKind::Either(&[ - SyntaxKind::Punctuation('&'), - SyntaxKind::Punctuation('|'), - ]), - found: unexpected.into_token(), - })), - }) - } -} diff --git a/src/syntax/syntax_tree/expression.rs b/src/syntax/syntax_tree/expression.rs index 957919d..e53a7e5 100644 --- a/src/syntax/syntax_tree/expression.rs +++ b/src/syntax/syntax_tree/expression.rs @@ -620,7 +620,7 @@ impl<'a> Parser<'a> { } } - fn parse_parenthesized( + pub(super) fn parse_parenthesized( &mut self, handler: &impl Handler, ) -> ParseResult { diff --git a/src/syntax/syntax_tree/mod.rs b/src/syntax/syntax_tree/mod.rs index 84c87af..5287c9f 100644 --- a/src/syntax/syntax_tree/mod.rs +++ b/src/syntax/syntax_tree/mod.rs @@ -23,7 +23,6 @@ use super::{ parser::Parser, }; -pub mod condition; pub mod declaration; pub mod expression; pub mod program; diff --git a/src/syntax/syntax_tree/statement/execute_block.rs b/src/syntax/syntax_tree/statement/execute_block.rs index ef19b7f..6e0d516 100644 --- a/src/syntax/syntax_tree/statement/execute_block.rs +++ b/src/syntax/syntax_tree/statement/execute_block.rs @@ -19,7 +19,7 @@ use crate::{ syntax::{ error::{Error, ParseResult, SyntaxKind, UnexpectedSyntax}, parser::{DelimitedTree, Parser, Reading}, - syntax_tree::{condition::ParenthesizedCondition, AnyStringLiteral}, + syntax_tree::{expression::Parenthesized, AnyStringLiteral}, }, }; @@ -148,7 +148,7 @@ impl SourceElement for ExecuteBlockTail { /// /// ``` ebnf /// Conditional: -/// 'if' ParenthizedCondition +/// 'if' Parenthized /// ; /// ``` #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] @@ -159,13 +159,13 @@ pub struct Conditional { if_keyword: Keyword, /// The condition of the conditional. #[get = "pub"] - condition: ParenthesizedCondition, + condition: Parenthesized, } impl Conditional { /// Dissolves the [`Conditional`] into its components. #[must_use] - pub fn dissolve(self) -> (Keyword, ParenthesizedCondition) { + pub fn dissolve(self) -> (Keyword, Parenthesized) { (self.if_keyword, self.condition) } } @@ -773,7 +773,7 @@ impl<'a> Parser<'a> { // eat the if keyword self.forward(); - let condition = self.parse_parenthesized_condition(handler)?; + let condition = self.parse_parenthesized(handler)?; let conditional = Conditional { if_keyword, diff --git a/src/transpile/conversions.rs b/src/transpile/conversions.rs index c58d608..dbfdfdf 100644 --- a/src/transpile/conversions.rs +++ b/src/transpile/conversions.rs @@ -1,44 +1,12 @@ //! Conversion functions for converting between tokens/ast-nodes and [`shulkerbox`] types -use shulkerbox::{ - datapack::Condition as DpCondition, - util::{MacroString, MacroStringPart}, -}; +use shulkerbox::util::{MacroString, MacroStringPart}; use crate::{ lexical::token::{MacroStringLiteral, MacroStringLiteralPart}, - syntax::syntax_tree::{ - condition::{ - BinaryCondition, Condition, ConditionalBinaryOperator, ConditionalPrefixOperator, - PrimaryCondition, - }, - AnyStringLiteral, - }, + syntax::syntax_tree::AnyStringLiteral, }; -impl From for DpCondition { - fn from(value: Condition) -> Self { - match value { - Condition::Primary(primary) => primary.into(), - Condition::Binary(binary) => binary.into(), - } - } -} - -impl From for DpCondition { - fn from(value: PrimaryCondition) -> Self { - match value { - PrimaryCondition::StringLiteral(literal) => Self::Atom(literal.into()), - PrimaryCondition::Parenthesized(cond) => cond.dissolve().1.into(), - PrimaryCondition::Unary(prefix) => match prefix.operator() { - ConditionalPrefixOperator::LogicalNot(_) => { - Self::Not(Box::new(prefix.dissolve().1.into())) - } - }, - } - } -} - impl From<&AnyStringLiteral> for MacroString { fn from(value: &AnyStringLiteral) -> Self { match value { @@ -88,17 +56,3 @@ impl From for MacroString { Self::from(&value) } } - -impl From for DpCondition { - fn from(value: BinaryCondition) -> Self { - let (lhs, op, rhs) = value.dissolve(); - match op { - ConditionalBinaryOperator::LogicalAnd(_, _) => { - Self::And(Box::new(lhs.into()), Box::new(rhs.into())) - } - ConditionalBinaryOperator::LogicalOr(_, _) => { - Self::Or(Box::new(lhs.into()), Box::new(rhs.into())) - } - } - } -} diff --git a/src/transpile/expression.rs b/src/transpile/expression.rs index cef622e..1b896b8 100644 --- a/src/transpile/expression.rs +++ b/src/transpile/expression.rs @@ -266,6 +266,26 @@ impl Binary { let right = self.right_operand().comptime_eval(scope)?; match (left, right) { + (ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) if matches!(self.operator(), BinaryOperator::LogicalOr(..)) + // TODO: re-enable if can_yield_type works properly + /*&& self + .left_operand() + .can_yield_type(ValueType::Boolean, scope) + && self + .right_operand() + .can_yield_type(ValueType::Boolean, scope)*/ => { + Some(ComptimeValue::Boolean(true)) + } + (ComptimeValue::Boolean(false), _) | (_, ComptimeValue::Boolean(false)) if matches!(self.operator(), BinaryOperator::LogicalAnd(..)) + // TODO: re-enable if can_yield_type works properly + /*&& self + .left_operand() + .can_yield_type(ValueType::Boolean, scope) + && self + .right_operand() + .can_yield_type(ValueType::Boolean, scope)*/ => { + Some(ComptimeValue::Boolean(false)) + } (ComptimeValue::Boolean(left), ComptimeValue::Boolean(right)) => { match self.operator() { BinaryOperator::Equal(..) => Some(ComptimeValue::Boolean(left == right)), @@ -275,27 +295,6 @@ impl Binary { _ => None, } } - (ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) => { - if matches!(self.operator(), BinaryOperator::LogicalOr(..)) - && self - .left_operand() - .can_yield_type(ValueType::Boolean, scope) - && self - .right_operand() - .can_yield_type(ValueType::Boolean, scope) - { - Some(ComptimeValue::Boolean(true)) - } else { - None - } - } - (ComptimeValue::Boolean(false), _) | (_, ComptimeValue::Boolean(false)) => { - if matches!(self.operator(), BinaryOperator::LogicalAnd(..)) { - Some(ComptimeValue::Boolean(false)) - } else { - None - } - } (ComptimeValue::Integer(left), ComptimeValue::Integer(right)) => { match self.operator() { BinaryOperator::Add(..) => left.checked_add(right).map(ComptimeValue::Integer), @@ -703,11 +702,11 @@ impl Transpiler { format!("scoreboard players set {target} {objective} 1"), format!("scoreboard players set {target} {objective} 0"), ), - DataLocation::Storage { - storage_name, - path, - r#type, - } => { + DataLocation::Storage { + storage_name, + path, + r#type, + } => { if matches!(r#type, StorageType::Boolean) { ( format!( @@ -717,15 +716,15 @@ impl Transpiler { "data modify storage {storage_name} {path} set value 0b" ), ) - } else { + } else { let err = TranspileError::MismatchedTypes(MismatchedTypes { expected_type: ValueType::Boolean, - expression: binary.span(), + expression: binary.span(), }); handler.receive(err.clone()); return Err(err); - } - } + } + } DataLocation::Tag { tag_name, entity } => ( format!("tag {entity} add {tag_name}"), format!("tag {entity} remove {tag_name}"), @@ -744,7 +743,7 @@ impl Transpiler { } } - fn transpile_expression_as_condition( + pub(super) fn transpile_expression_as_condition( &mut self, expression: &Expression, scope: &Arc, @@ -767,7 +766,7 @@ impl Transpiler { handler: &impl Handler, ) -> TranspileResult<(Vec, Condition)> { match primary { - Primary::Boolean(_) => unreachable!("boolean literal would have been catched in comptime evaluation of binary expression"), + Primary::Boolean(_) => todo!("handle boolean literal if not catched by comptime eval"), Primary::Integer(_) => { let err = TranspileError::MismatchedTypes(MismatchedTypes { expected_type: ValueType::Boolean, @@ -797,7 +796,7 @@ impl Transpiler { }); handler.receive(err.clone()); Err(err) - } else { + } else { let (func_location, _) = self.get_or_transpile_function( &func.identifier().span, None, @@ -906,35 +905,35 @@ impl Transpiler { scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { - let left = binary.left_operand(); - let right = binary.right_operand(); - let operator = binary.operator(); + let left = binary.left_operand(); + let right = binary.right_operand(); + let operator = binary.operator(); - let (temp_objective, temp_locations) = self.get_temp_scoreboard_locations(2); + let (temp_objective, temp_locations) = self.get_temp_scoreboard_locations(2); - let score_target_location = match target { - DataLocation::ScoreboardValue { objective, target } => (objective, target), - _ => (&temp_objective, &temp_locations[0]), - }; + let score_target_location = match target { + DataLocation::ScoreboardValue { objective, target } => (objective, target), + _ => (&temp_objective, &temp_locations[0]), + }; - let left_cmds = self.transpile_expression( - left, - &DataLocation::ScoreboardValue { - objective: score_target_location.0.clone(), - target: score_target_location.1.clone(), - }, - scope, - handler, - )?; - let right_cmds = self.transpile_expression( - right, - &DataLocation::ScoreboardValue { - objective: temp_objective.clone(), - target: temp_locations[1].clone(), - }, - scope, - handler, - )?; + let left_cmds = self.transpile_expression( + left, + &DataLocation::ScoreboardValue { + objective: score_target_location.0.clone(), + target: score_target_location.1.clone(), + }, + scope, + handler, + )?; + let right_cmds = self.transpile_expression( + right, + &DataLocation::ScoreboardValue { + objective: temp_objective.clone(), + target: temp_locations[1].clone(), + }, + scope, + handler, + )?; let calc_cmds = { let (target_objective, target) = score_target_location; @@ -950,58 +949,58 @@ impl Transpiler { _ => unreachable!("This operator should not be handled here."), }; - vec![Command::Raw(format!( + vec![Command::Raw(format!( "scoreboard players operation {target} {target_objective} {operation} {source} {source_objective}" ))] - }; + }; - let transfer_cmd = match target { - DataLocation::ScoreboardValue { .. } => None, - DataLocation::Tag { .. } => { - let err = TranspileError::MismatchedTypes(MismatchedTypes { - expected_type: ValueType::Boolean, - expression: binary.span(), - }); - handler.receive(err.clone()); - return Err(err); - } - DataLocation::Storage { - storage_name, - path, - r#type, - } => match r#type { + let transfer_cmd = match target { + DataLocation::ScoreboardValue { .. } => None, + DataLocation::Tag { .. } => { + let err = TranspileError::MismatchedTypes(MismatchedTypes { + expected_type: ValueType::Boolean, + expression: binary.span(), + }); + handler.receive(err.clone()); + return Err(err); + } + DataLocation::Storage { + storage_name, + path, + r#type, + } => match r#type { StorageType::Byte | StorageType::Double | StorageType::Int | StorageType::Long => { Some(Command::Execute(Execute::Store( - format!( - "result storage {storage_name} {path} {t} 1", - t = r#type.as_str() - ) - .into(), - Box::new(Execute::Run(Box::new(Command::Raw(format!( - "scoreboard players get {target} {objective}", - objective = score_target_location.0, - target = score_target_location.1 - ))))), + format!( + "result storage {storage_name} {path} {t} 1", + t = r#type.as_str() + ) + .into(), + Box::new(Execute::Run(Box::new(Command::Raw(format!( + "scoreboard players get {target} {objective}", + objective = score_target_location.0, + target = score_target_location.1 + ))))), ))) } - StorageType::Boolean => { - let err = TranspileError::MismatchedTypes(MismatchedTypes { - expected_type: ValueType::Boolean, - expression: binary.span(), - }); - handler.receive(err.clone()); - return Err(err); - } - }, - }; + StorageType::Boolean => { + let err = TranspileError::MismatchedTypes(MismatchedTypes { + expected_type: ValueType::Boolean, + expression: binary.span(), + }); + handler.receive(err.clone()); + return Err(err); + } + }, + }; - Ok(left_cmds - .into_iter() - .chain(right_cmds) - .chain(calc_cmds) - .chain(transfer_cmd) - .collect()) - } + Ok(left_cmds + .into_iter() + .chain(right_cmds) + .chain(calc_cmds) + .chain(transfer_cmd) + .collect()) + } fn transpile_comparison_operator( &mut self, diff --git a/src/transpile/transpiler.rs b/src/transpile/transpiler.rs index 6717f91..3d350bb 100644 --- a/src/transpile/transpiler.rs +++ b/src/transpile/transpiler.rs @@ -31,6 +31,7 @@ use crate::{ use super::{ error::{TranspileError, TranspileResult}, + expression::ComptimeValue, variables::{Scope, VariableData}, FunctionData, TranspileAnnotationValue, }; @@ -508,9 +509,12 @@ impl Transpiler { } Statement::ExecuteBlock(execute) => { let child_scope = Scope::with_parent(scope); - Ok(self - .transpile_execute_block(execute, program_identifier, &child_scope, handler)? - .map_or_else(Vec::new, |cmd| vec![cmd])) + Ok(self.transpile_execute_block( + execute, + program_identifier, + &child_scope, + handler, + )?) } Statement::DocComment(doccomment) => { let content = doccomment.content(); @@ -654,9 +658,15 @@ impl Transpiler { program_identifier: &str, scope: &Arc, handler: &impl Handler, - ) -> TranspileResult> { + ) -> TranspileResult> { self.transpile_execute_block_internal(execute, program_identifier, scope, handler) - .map(|ex| ex.map(Command::Execute)) + .map(|ex| { + ex.map(|(mut pre_cmds, exec)| { + pre_cmds.push(exec.into()); + pre_cmds + }) + .unwrap_or_default() + }) } fn transpile_execute_block_internal( @@ -665,7 +675,7 @@ impl Transpiler { program_identifier: &str, scope: &Arc, handler: &impl Handler, - ) -> TranspileResult> { + ) -> TranspileResult, Execute)>> { match execute { ExecuteBlock::HeadTail(head, tail) => { let tail = match tail { @@ -689,7 +699,7 @@ impl Transpiler { if commands.is_empty() { Ok(None) } else { - Ok(Some(Execute::Runs(commands))) + Ok(Some((Vec::new(), Execute::Runs(commands)))) } } ExecuteBlockTail::ExecuteBlock(_, execute_block) => self @@ -764,58 +774,66 @@ impl Transpiler { program_identifier: &str, scope: &Arc, handler: &impl Handler, - ) -> TranspileResult> { - let (_, cond) = cond.clone().dissolve(); - let (_, cond, _) = cond.dissolve(); + ) -> TranspileResult, Execute)>> { + let cond_expression = cond.condition().expression().as_ref(); + let mut errors = Vec::new(); - let el = el - .and_then(|el| { - let (_, block) = el.clone().dissolve(); - let statements = block.statements(); - let cmds = statements - .iter() - .flat_map(|statement| { - self.transpile_statement(statement, program_identifier, scope, handler) - .unwrap_or_else(|err| { - errors.push(err); - Vec::new() - }) - }) - .collect::>(); + let el = el.and_then(|el| { + let (_, block) = el.clone().dissolve(); + let statements = block.statements(); + let cmds = statements + .iter() + .flat_map(|statement| { + self.transpile_statement(statement, program_identifier, scope, handler) + .unwrap_or_else(|err| { + errors.push(err); + Vec::new() + }) + }) + .collect::>(); - match cmds.len() { - 0 => None, - 1 => Some(Execute::Run(Box::new( - cmds.into_iter().next().expect("length is 1"), - ))), - _ => Some(Execute::Runs(cmds)), - } - }) - .map(Box::new); + match cmds.len() { + 0 => None, + 1 => Some(Execute::Run(Box::new( + cmds.into_iter().next().expect("length is 1"), + ))), + _ => Some(Execute::Runs(cmds)), + } + }); - if !errors.is_empty() { - return Err(errors.remove(0)); + if let Some(ComptimeValue::Boolean(value)) = cond_expression.comptime_eval(scope) { + if value { + Ok(Some((Vec::new(), then))) + } else { + Ok(el.map(|el| (Vec::new(), el))) + } + } else { + if !errors.is_empty() { + return Err(errors.remove(0)); + } + + let (pre_cond_cmds, cond) = + self.transpile_expression_as_condition(cond_expression, scope, handler)?; + + Ok(Some(( + pre_cond_cmds, + Execute::If(cond, Box::new(then), el.map(Box::new)), + ))) } - - Ok(Some(Execute::If( - datapack::Condition::from(cond), - Box::new(then), - el, - ))) } fn combine_execute_head_tail( &mut self, head: &ExecuteBlockHead, - tail: Option, + tail: Option<(Vec, Execute)>, program_identifier: &str, scope: &Arc, handler: &impl Handler, - ) -> TranspileResult> { + ) -> TranspileResult, Execute)>> { Ok(match head { ExecuteBlockHead::Conditional(cond) => { - if let Some(tail) = tail { + if let Some((mut pre_cmds, tail)) = tail { self.transpile_conditional( cond, tail, @@ -824,57 +842,88 @@ impl Transpiler { scope, handler, )? + .map(|(pre_cond_cmds, cond)| { + pre_cmds.extend(pre_cond_cmds); + (pre_cmds, cond) + }) } else { None } } ExecuteBlockHead::As(r#as) => { let selector = r#as.as_selector(); - tail.map(|tail| Execute::As(selector.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::As(selector.into(), Box::new(tail))) + }) } ExecuteBlockHead::At(at) => { let selector = at.at_selector(); - tail.map(|tail| Execute::At(selector.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::At(selector.into(), Box::new(tail))) + }) } ExecuteBlockHead::Align(align) => { let align = align.align_selector(); - tail.map(|tail| Execute::Align(align.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Align(align.into(), Box::new(tail))) + }) } ExecuteBlockHead::Anchored(anchored) => { let anchor = anchored.anchored_selector(); - tail.map(|tail| Execute::Anchored(anchor.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Anchored(anchor.into(), Box::new(tail))) + }) } ExecuteBlockHead::In(r#in) => { let dimension = r#in.in_selector(); - tail.map(|tail| Execute::In(dimension.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::In(dimension.into(), Box::new(tail))) + }) } ExecuteBlockHead::Positioned(positioned) => { let position = positioned.positioned_selector(); - tail.map(|tail| Execute::Positioned(position.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + ( + pre_cmds, + Execute::Positioned(position.into(), Box::new(tail)), + ) + }) } ExecuteBlockHead::Rotated(rotated) => { let rotation = rotated.rotated_selector(); - tail.map(|tail| Execute::Rotated(rotation.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Rotated(rotation.into(), Box::new(tail))) + }) } ExecuteBlockHead::Facing(facing) => { let facing = facing.facing_selector(); - tail.map(|tail| Execute::Facing(facing.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Facing(facing.into(), Box::new(tail))) + }) } ExecuteBlockHead::AsAt(as_at) => { let selector = as_at.asat_selector(); - tail.map(|tail| Execute::AsAt(selector.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::AsAt(selector.into(), Box::new(tail))) + }) } ExecuteBlockHead::On(on) => { let dimension = on.on_selector(); - tail.map(|tail| Execute::On(dimension.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::On(dimension.into(), Box::new(tail))) + }) } ExecuteBlockHead::Store(store) => { let store = store.store_selector(); - tail.map(|tail| Execute::Store(store.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Store(store.into(), Box::new(tail))) + }) } ExecuteBlockHead::Summon(summon) => { let entity = summon.summon_selector(); - tail.map(|tail| Execute::Summon(entity.into(), Box::new(tail))) + tail.map(|(pre_cmds, tail)| { + (pre_cmds, Execute::Summon(entity.into(), Box::new(tail))) + }) } }) }