moritz
/
shulkerscript-lang
mirror of https://github.com/moritz-hoelting/shulkerscript-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

implement dynamic (scoreboard, storages) values passed in as macro parameters 

- does not compile without the 'shulkerbox' feature enabled
This commit is contained in:
Moritz Hölting 2025-03-12 23:37:23 +01:00
parent 5740172ddb
commit cebe3e9cb0
6 changed files with 575 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.toml
View File

@ -22,10 +22,8 @@ serde = ["dep:serde", "dep:flexbuffers", "shulkerbox?/serde"]
shulkerbox = ["dep:shulkerbox", "dep:chksum-md5"] shulkerbox = ["dep:shulkerbox", "dep:chksum-md5"]
zip = ["shulkerbox?/zip"] zip = ["shulkerbox?/zip"]
[target.'cfg(target_arch = "wasm32")'.dependencies]
path-absolutize = { version = "3.1.1", features = ["use_unix_paths_on_wasm"] }
[dependencies] [dependencies]
cfg-if = "1.0.0"
chksum-md5 = { version = "0.1.0", optional = true } chksum-md5 = { version = "0.1.0", optional = true }
colored = "3.0.0" colored = "3.0.0"
derive_more = { version = "2.0.1", default-features = false, features = ["deref", "deref_mut", "from"] } derive_more = { version = "2.0.1", default-features = false, features = ["deref", "deref_mut", "from"] }
@ -34,7 +32,6 @@ flexbuffers = { version = "25.2.10", optional = true }
getset = "0.1.2" getset = "0.1.2"
itertools = "0.14.0" itertools = "0.14.0"
mlua = { version = "0.10.2", features = ["lua54", "vendored"], optional = true } mlua = { version = "0.10.2", features = ["lua54", "vendored"], optional = true }
path-absolutize = "3.1.1"
pathdiff = "0.2.3" pathdiff = "0.2.3"
serde = { version = "1.0.217", features = ["derive"], optional = true } serde = { version = "1.0.217", features = ["derive"], optional = true }
# shulkerbox = { version = "0.1.0", default-features = false, optional = true } # shulkerbox = { version = "0.1.0", default-features = false, optional = true }

33
src/transpile/error.rs
View File

@ -12,7 +12,7 @@ use crate::{
semantic::error::{ConflictingFunctionNames, InvalidFunctionArguments, UnexpectedExpression}, semantic::error::{ConflictingFunctionNames, InvalidFunctionArguments, UnexpectedExpression},
}; };
use super::{expression::ValueType, FunctionData}; use super::{expression::ExpectedType, FunctionData};
/// Errors that can occur during transpilation. /// Errors that can occur during transpilation.
#[allow(clippy::module_name_repetitions, missing_docs)] #[allow(clippy::module_name_repetitions, missing_docs)]
@ -40,6 +40,8 @@ pub enum TranspileError {
AssignmentError(#[from] AssignmentError), AssignmentError(#[from] AssignmentError),
#[error(transparent)] #[error(transparent)]
UnknownIdentifier(#[from] UnknownIdentifier), UnknownIdentifier(#[from] UnknownIdentifier),
#[error(transparent)]
MissingValue(#[from] MissingValue),
} }
/// The result of a transpilation operation. /// The result of a transpilation operation.
@ -193,7 +195,7 @@ impl std::error::Error for IllegalAnnotationContent {}
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct MismatchedTypes { pub struct MismatchedTypes {
pub expression: Span, pub expression: Span,
pub expected_type: ValueType, pub expected_type: ExpectedType,
} }
impl Display for MismatchedTypes { impl Display for MismatchedTypes {
@ -280,3 +282,30 @@ impl Display for UnknownIdentifier {
} }
impl std::error::Error for UnknownIdentifier {} impl std::error::Error for UnknownIdentifier {}
/// An error that occurs when there is a value expected but none provided.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MissingValue {
pub expression: Span,
}
impl Display for MissingValue {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"{}",
Message::new(
Severity::Error,
"The expression is expected to return a value, but no value is found."
)
)?;
write!(
f,
"\n{}",
SourceCodeDisplay::new(&self.expression, Option::<u8>::None)
)
}
}
impl std::error::Error for MissingValue {}

350
src/transpile/expression.rs
View File

@ -4,17 +4,21 @@ use std::{fmt::Display, sync::Arc};
use super::{Scope, VariableData}; use super::{Scope, VariableData};
use crate::{ use crate::{
base::VoidHandler, base::{self, Handler, VoidHandler},
lexical::token::MacroStringLiteralPart, lexical::token::MacroStringLiteralPart,
syntax::syntax_tree::expression::{ syntax::syntax_tree::expression::{
Binary, BinaryOperator, Expression, PrefixOperator, Primary, Binary, BinaryOperator, Expression, PrefixOperator, Primary,
}, },
}; };
#[cfg(feature = "shulkerbox")]
use enum_as_inner::EnumAsInner; use enum_as_inner::EnumAsInner;
#[cfg(feature = "shulkerbox")] #[cfg(feature = "shulkerbox")]
use shulkerbox::prelude::{Command, Condition, Execute}; use shulkerbox::{
prelude::{Command, Condition, Execute},
util::MacroString,
};
#[cfg(feature = "shulkerbox")] #[cfg(feature = "shulkerbox")]
use super::{ use super::{
@ -23,8 +27,11 @@ use super::{
}; };
#[cfg(feature = "shulkerbox")] #[cfg(feature = "shulkerbox")]
use crate::{ use crate::{
base::{self, source_file::SourceElement, Handler}, base::source_file::SourceElement,
transpile::{error::FunctionArgumentsNotAllowed, TranspileError}, transpile::{
error::{FunctionArgumentsNotAllowed, MissingValue},
TranspileError,
},
}; };
/// Compile-time evaluated value /// Compile-time evaluated value
@ -34,7 +41,7 @@ pub enum ComptimeValue {
Boolean(bool), Boolean(bool),
Integer(i64), Integer(i64),
String(String), String(String),
MacroString(String), MacroString(MacroString),
} }
impl Display for ComptimeValue { impl Display for ComptimeValue {
@ -43,7 +50,7 @@ impl Display for ComptimeValue {
Self::Boolean(boolean) => write!(f, "{boolean}"), Self::Boolean(boolean) => write!(f, "{boolean}"),
Self::Integer(int) => write!(f, "{int}"), Self::Integer(int) => write!(f, "{int}"),
Self::String(string) => write!(f, "{string}"), Self::String(string) => write!(f, "{string}"),
Self::MacroString(macro_string) => write!(f, "{macro_string}"), Self::MacroString(macro_string) => write!(f, "{}", macro_string.compile()),
} }
} }
} }
@ -80,6 +87,69 @@ impl Display for ValueType {
} }
} }
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExpectedType {
Boolean,
Integer,
String,
Any,
AnyOf(Vec<ExpectedType>),
}
impl ExpectedType {
/// Add another expected type to the list of expected types.
#[must_use]
pub fn or(self, or: Self) -> Self {
match self {
Self::Boolean | Self::Integer | Self::String => match or {
Self::Boolean | Self::Integer | Self::String => Self::AnyOf(vec![self, or]),
Self::Any => Self::Any,
Self::AnyOf(mut types) => {
types.push(self);
Self::AnyOf(types)
}
},
Self::Any => Self::Any,
Self::AnyOf(mut types) => {
types.push(or);
Self::AnyOf(types)
}
}
}
}
impl Display for ExpectedType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Boolean => write!(f, "boolean"),
Self::Integer => write!(f, "integer"),
Self::String => write!(f, "string"),
Self::Any => write!(f, "any"),
Self::AnyOf(types) => {
write!(f, "any of [")?;
for (i, r#type) in types.iter().enumerate() {
if i != 0 {
write!(f, ", ")?;
}
write!(f, "{type}")?;
}
write!(f, "]")
}
}
}
}
impl From<ValueType> for ExpectedType {
fn from(value: ValueType) -> Self {
match value {
ValueType::Boolean => Self::Boolean,
ValueType::Integer => Self::Integer,
ValueType::String => Self::String,
}
}
}
/// Location of data /// Location of data
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
@ -151,6 +221,7 @@ impl StorageType {
} }
/// Condition /// Condition
#[cfg(feature = "shulkerbox")]
#[derive(Debug, Clone, PartialEq, Eq, EnumAsInner)] #[derive(Debug, Clone, PartialEq, Eq, EnumAsInner)]
pub enum ExtendedCondition { pub enum ExtendedCondition {
/// Runtime condition /// Runtime condition
@ -171,10 +242,14 @@ impl Expression {
/// Evaluate at compile-time. /// Evaluate at compile-time.
#[must_use] #[must_use]
pub fn comptime_eval(&self, scope: &Arc<Scope>) -> Option<ComptimeValue> { pub fn comptime_eval(
&self,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> Option<ComptimeValue> {
match self { match self {
Self::Primary(primary) => primary.comptime_eval(scope), Self::Primary(primary) => primary.comptime_eval(scope, handler),
Self::Binary(binary) => binary.comptime_eval(scope), Self::Binary(binary) => binary.comptime_eval(scope, handler),
} }
} }
} }
@ -216,16 +291,19 @@ impl Primary {
&& prefix.operand().can_yield_type(r#type, scope) && prefix.operand().can_yield_type(r#type, scope)
} }
}, },
#[cfg_attr(not(feature = "lua"), expect(unused_variables))]
Self::Lua(lua) => { Self::Lua(lua) => {
if let Ok(value) = lua.eval(&VoidHandler) { cfg_if::cfg_if! {
match value { if #[cfg(feature = "lua")] {
mlua::Value::Boolean(_) => matches!(r#type, ValueType::Boolean), lua.eval(&VoidHandler).map_or(false, |value| match value {
mlua::Value::Integer(_) => matches!(r#type, ValueType::Integer), mlua::Value::Boolean(_) => matches!(r#type, ValueType::Boolean),
mlua::Value::String(_) => matches!(r#type, ValueType::String), mlua::Value::Integer(_) => matches!(r#type, ValueType::Integer),
_ => false, mlua::Value::String(_) => matches!(r#type, ValueType::String),
_ => false,
})
} else {
false
} }
} else {
false
} }
} }
Self::StringLiteral(_) | Self::MacroStringLiteral(_) => { Self::StringLiteral(_) | Self::MacroStringLiteral(_) => {
@ -236,7 +314,11 @@ impl Primary {
/// Evaluate at compile-time. /// Evaluate at compile-time.
#[must_use] #[must_use]
pub fn comptime_eval(&self, scope: &Arc<Scope>) -> Option<ComptimeValue> { pub fn comptime_eval(
&self,
scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> Option<ComptimeValue> {
match self { match self {
Self::Boolean(boolean) => Some(ComptimeValue::Boolean(boolean.value())), Self::Boolean(boolean) => Some(ComptimeValue::Boolean(boolean.value())),
Self::Integer(int) => Some(ComptimeValue::Integer(int.as_i64())), Self::Integer(int) => Some(ComptimeValue::Integer(int.as_i64())),
@ -244,20 +326,30 @@ impl Primary {
string_literal.str_content().to_string(), string_literal.str_content().to_string(),
)), )),
Self::Identifier(_) | Self::FunctionCall(_) => None, Self::Identifier(_) | Self::FunctionCall(_) => None,
Self::Parenthesized(parenthesized) => parenthesized.expression().comptime_eval(scope), Self::Parenthesized(parenthesized) => {
Self::Prefix(prefix) => prefix.operand().comptime_eval(scope).and_then(|val| { parenthesized.expression().comptime_eval(scope, handler)
match (prefix.operator(), val) { }
(PrefixOperator::LogicalNot(_), ComptimeValue::Boolean(boolean)) => { Self::Prefix(prefix) => {
Some(ComptimeValue::Boolean(!boolean)) prefix
} .operand()
(PrefixOperator::Negate(_), ComptimeValue::Integer(int)) => { .comptime_eval(scope, handler)
Some(ComptimeValue::Integer(-int)) .and_then(|val| match (prefix.operator(), val) {
} (PrefixOperator::LogicalNot(_), ComptimeValue::Boolean(boolean)) => {
_ => None, Some(ComptimeValue::Boolean(!boolean))
} }
}), (PrefixOperator::Negate(_), ComptimeValue::Integer(int)) => {
// TODO: throw error Some(ComptimeValue::Integer(-int))
Self::Lua(lua) => lua.eval_comptime(&VoidHandler).ok().flatten(), }
_ => None,
})
}
Self::Lua(lua) => lua
.eval_comptime(&VoidHandler)
.inspect_err(|err| {
handler.receive(err.clone());
})
.ok()
.flatten(),
Self::MacroStringLiteral(macro_string_literal) => { Self::MacroStringLiteral(macro_string_literal) => {
if macro_string_literal if macro_string_literal
.parts() .parts()
@ -265,7 +357,7 @@ impl Primary {
.any(|part| matches!(part, MacroStringLiteralPart::MacroUsage { .. })) .any(|part| matches!(part, MacroStringLiteralPart::MacroUsage { .. }))
{ {
Some(ComptimeValue::MacroString( Some(ComptimeValue::MacroString(
macro_string_literal.str_content(), macro_string_literal.clone().into(),
)) ))
} else { } else {
Some(ComptimeValue::String(macro_string_literal.str_content())) Some(ComptimeValue::String(macro_string_literal.str_content()))
@ -318,9 +410,13 @@ impl Binary {
/// Evaluate at compile-time. /// Evaluate at compile-time.
#[must_use] #[must_use]
pub fn comptime_eval(&self, scope: &Arc<Scope>) -> Option<ComptimeValue> { pub fn comptime_eval(
let left = self.left_operand().comptime_eval(scope)?; &self,
let right = self.right_operand().comptime_eval(scope)?; scope: &Arc<Scope>,
handler: &impl Handler<base::Error>,
) -> Option<ComptimeValue> {
let left = self.left_operand().comptime_eval(scope, handler)?;
let right = self.right_operand().comptime_eval(scope, handler)?;
match (left, right) { match (left, right) {
(ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) if matches!(self.operator(), BinaryOperator::LogicalOr(..)) (ComptimeValue::Boolean(true), _) | (_, ComptimeValue::Boolean(true)) if matches!(self.operator(), BinaryOperator::LogicalOr(..))
@ -426,7 +522,7 @@ impl Transpiler {
} }
#[expect(clippy::too_many_lines)] #[expect(clippy::too_many_lines)]
fn transpile_primary_expression( pub(super) fn transpile_primary_expression(
&mut self, &mut self,
primary: &Primary, primary: &Primary,
target: &DataLocation, target: &DataLocation,
@ -442,31 +538,39 @@ impl Transpiler {
), ),
Primary::FunctionCall(func) => match target { Primary::FunctionCall(func) => match target {
DataLocation::ScoreboardValue { objective, target } => { DataLocation::ScoreboardValue { objective, target } => {
let call_cmd = self.transpile_function_call(func, scope, handler)?; let mut cmds = self.transpile_function_call(func, scope, handler)?;
Ok(vec![Command::Execute(Execute::Store( if let Some(call_cmd) = cmds.pop() {
format!("result score {target} {objective}").into(), let modified = Command::Execute(Execute::Store(
Box::new(Execute::Run(Box::new(call_cmd))), format!("result score {target} {objective}").into(),
))]) Box::new(Execute::Run(Box::new(call_cmd))),
));
cmds.push(modified);
}
Ok(cmds)
} }
DataLocation::Storage { DataLocation::Storage {
storage_name, storage_name,
path, path,
r#type, r#type,
} => { } => {
let call_cmd = self.transpile_function_call(func, scope, handler)?; let mut cmds = self.transpile_function_call(func, scope, handler)?;
let result_success = if matches!(r#type, StorageType::Boolean) { if let Some(call_cmd) = cmds.pop() {
"success" let result_success = if matches!(r#type, StorageType::Boolean) {
} else { "success"
"result" } else {
}; "result"
Ok(vec![Command::Execute(Execute::Store( };
format!( let modified = Command::Execute(Execute::Store(
"{result_success} storage {storage_name} {path} {type} 1.0d", format!(
r#type = r#type.as_str() "{result_success} storage {storage_name} {path} {type} 1.0d",
) r#type = r#type.as_str()
.into(), )
Box::new(Execute::Run(Box::new(call_cmd))), .into(),
))]) Box::new(Execute::Run(Box::new(call_cmd))),
));
cmds.push(modified);
}
Ok(cmds)
} }
DataLocation::Tag { tag_name, entity } => { DataLocation::Tag { tag_name, entity } => {
if func if func
@ -511,11 +615,17 @@ impl Transpiler {
Primary::Parenthesized(parenthesized) => { Primary::Parenthesized(parenthesized) => {
self.transpile_expression(parenthesized.expression(), target, scope, handler) self.transpile_expression(parenthesized.expression(), target, scope, handler)
} }
Primary::Lua(lua) => { Primary::Lua(lua) =>
{
#[expect(clippy::option_if_let_else)]
if let Some(value) = lua.eval_comptime(handler)? { if let Some(value) = lua.eval_comptime(handler)? {
self.store_comptime_value(&value, target, lua, handler) self.store_comptime_value(&value, target, lua, handler)
} else { } else {
todo!("handle no return value from lua") let err = TranspileError::MissingValue(MissingValue {
expression: lua.span(),
});
handler.receive(err.clone());
Err(err)
} }
} }
Primary::StringLiteral(_) | Primary::MacroStringLiteral(_) => { Primary::StringLiteral(_) | Primary::MacroStringLiteral(_) => {
@ -536,7 +646,7 @@ impl Transpiler {
Ok(cmds) Ok(cmds)
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: target.value_type(), expected_type: target.value_type().into(),
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -601,7 +711,7 @@ impl Transpiler {
_ => { _ => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: prefix.span(), expression: prefix.span(),
expected_type: ValueType::Integer, expected_type: ExpectedType::Integer,
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -665,7 +775,7 @@ impl Transpiler {
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: primary.span(), expression: primary.span(),
expected_type: target.value_type(), expected_type: target.value_type().into(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -697,16 +807,21 @@ impl Transpiler {
| StorageType::Int | StorageType::Int
| StorageType::Long | StorageType::Long
) { ) {
let cmd = Command::Raw(format!( let cmd = Command::Execute(Execute::Store(
"data modify storage {storage_name} {path} set value {value}{suffix}", format!(
value = score_target, "result storage {storage_name} {path} {t} 1.0",
suffix = r#type.suffix() t = r#type.as_str()
)
.into(),
Box::new(Execute::Run(Box::new(Command::Raw(format!(
"scoreboard players get {score_target} {objective}"
))))),
)); ));
Ok(vec![cmd]) Ok(vec![cmd])
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: primary.span(), expression: primary.span(),
expected_type: target.value_type(), expected_type: target.value_type().into(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -714,7 +829,7 @@ impl Transpiler {
} }
DataLocation::Tag { .. } => { DataLocation::Tag { .. } => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -723,7 +838,7 @@ impl Transpiler {
}, },
_ => { _ => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: target.value_type(), expected_type: target.value_type().into(),
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -748,7 +863,7 @@ impl Transpiler {
scope: &Arc<super::Scope>, scope: &Arc<super::Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Vec<Command>> { ) -> TranspileResult<Vec<Command>> {
if let Some(value) = binary.comptime_eval(scope) { if let Some(value) = binary.comptime_eval(scope, handler) {
self.transpile_comptime_value(&value, binary, target, scope, handler) self.transpile_comptime_value(&value, binary, target, scope, handler)
} else { } else {
match binary.operator() { match binary.operator() {
@ -808,7 +923,7 @@ impl Transpiler {
} }
Primary::Integer(_) => { Primary::Integer(_) => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -874,7 +989,7 @@ impl Transpiler {
)), )),
_ => { _ => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -911,28 +1026,34 @@ impl Transpiler {
} }
PrefixOperator::Negate(_) => { PrefixOperator::Negate(_) => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: primary.span(), expression: primary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
} }
}, },
Primary::Lua(lua) => { Primary::Lua(lua) => match lua.eval_comptime(handler)? {
match lua.eval_comptime(handler)? { Some(ComptimeValue::String(value)) => Ok((
Some(ComptimeValue::String(value) | ComptimeValue::MacroString(value)) => { Vec::new(),
// TODO: mark condition as containing macro if so ExtendedCondition::Runtime(Condition::Atom(value.into())),
Ok(( )),
Vec::new(), Some(ComptimeValue::MacroString(value)) => Ok((
ExtendedCondition::Runtime(Condition::Atom(value.into())), Vec::new(),
)) ExtendedCondition::Runtime(Condition::Atom(value)),
} )),
Some(ComptimeValue::Boolean(boolean)) => { Some(ComptimeValue::Boolean(boolean)) => {
Ok((Vec::new(), ExtendedCondition::Comptime(boolean))) Ok((Vec::new(), ExtendedCondition::Comptime(boolean)))
}
_ => todo!("invalid or none lua return value"),
} }
} _ => {
let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ExpectedType::Boolean,
expression: primary.span(),
});
handler.receive(err.clone());
Err(err)
}
},
} }
} }
@ -956,7 +1077,7 @@ impl Transpiler {
} }
_ => { _ => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: binary.span(), expression: binary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1025,7 +1146,7 @@ impl Transpiler {
DataLocation::ScoreboardValue { .. } => None, DataLocation::ScoreboardValue { .. } => None,
DataLocation::Tag { .. } => { DataLocation::Tag { .. } => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: binary.span(), expression: binary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1052,7 +1173,7 @@ impl Transpiler {
} }
StorageType::Boolean => { StorageType::Boolean => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: binary.span(), expression: binary.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1201,7 +1322,7 @@ impl Transpiler {
)]), )]),
DataLocation::Tag { .. } => { DataLocation::Tag { .. } => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: original.span(), expression: original.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1226,7 +1347,7 @@ impl Transpiler {
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: original.span(), expression: original.span(),
expected_type: target.value_type(), expected_type: target.value_type().into(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -1258,7 +1379,7 @@ impl Transpiler {
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: original.span(), expression: original.span(),
expected_type: target.value_type(), expected_type: target.value_type().into(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -1267,7 +1388,7 @@ impl Transpiler {
}, },
ComptimeValue::String(_) | ComptimeValue::MacroString(_) => { ComptimeValue::String(_) | ComptimeValue::MacroString(_) => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: target.value_type(), expected_type: target.value_type().into(),
expression: original.span(), expression: original.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1276,6 +1397,7 @@ impl Transpiler {
} }
} }
#[expect(clippy::needless_pass_by_ref_mut)]
fn store_comptime_value( fn store_comptime_value(
&mut self, &mut self,
value: &ComptimeValue, value: &ComptimeValue,
@ -1285,17 +1407,12 @@ impl Transpiler {
) -> TranspileResult<Vec<Command>> { ) -> TranspileResult<Vec<Command>> {
match value { match value {
ComptimeValue::Integer(int) => match target { ComptimeValue::Integer(int) => match target {
DataLocation::ScoreboardValue { objective, target } => { DataLocation::ScoreboardValue { objective, target } => Ok(vec![Command::Raw(
Ok(vec![Command::Raw(format!( format!("scoreboard players set {target} {objective} {int}"),
"scoreboard players set {target} {objective} {value}", )]),
target = target,
objective = objective,
value = int
))])
}
DataLocation::Tag { .. } => { DataLocation::Tag { .. } => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: source.span(), expression: source.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1323,7 +1440,7 @@ impl Transpiler {
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: source.span(), expression: source.span(),
expected_type: ValueType::Integer, expected_type: ExpectedType::Integer,
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
@ -1370,6 +1487,7 @@ impl Transpiler {
} }
} }
#[expect(clippy::unused_self, clippy::needless_pass_by_ref_mut)]
fn store_condition_success( fn store_condition_success(
&mut self, &mut self,
cond: ExtendedCondition, cond: ExtendedCondition,
@ -1394,7 +1512,7 @@ impl Transpiler {
) )
} else { } else {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::Boolean, expected_type: ExpectedType::Boolean,
expression: source.span(), expression: source.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -1426,7 +1544,7 @@ impl Transpiler {
} }
/// Get temporary scoreboard locations. /// Get temporary scoreboard locations.
fn get_temp_scoreboard_locations(&mut self, amount: usize) -> (String, Vec<String>) { pub(super) fn get_temp_scoreboard_locations(&mut self, amount: usize) -> (String, Vec<String>) {
let objective = "shu_temp_".to_string() let objective = "shu_temp_".to_string()
+ &chksum_md5::hash(&self.main_namespace_name).to_hex_lowercase(); + &chksum_md5::hash(&self.main_namespace_name).to_hex_lowercase();
@ -1449,4 +1567,26 @@ impl Transpiler {
(objective, targets) (objective, targets)
} }
/// Get temporary storage locations.
pub(super) fn get_temp_storage_locations(&mut self, amount: usize) -> (String, Vec<String>) {
let storage_name = "shulkerscript:temp_".to_string()
+ &chksum_md5::hash(&self.main_namespace_name).to_hex_lowercase();
let paths = (0..amount)
.map(|i| {
chksum_md5::hash(format!(
"{namespace}\0{j}",
namespace = self.main_namespace_name,
j = i + self.temp_counter
))
.to_hex_lowercase()
.split_off(16)
})
.collect();
self.temp_counter = self.temp_counter.wrapping_add(amount);
(storage_name, paths)
}
} }

35
src/transpile/lua.rs
View File

@ -70,9 +70,10 @@ mod enabled {
) -> TranspileResult<Option<ComptimeValue>> { ) -> TranspileResult<Option<ComptimeValue>> {
let lua_result = self.eval(handler)?; let lua_result = self.eval(handler)?;
self.handle_lua_result(lua_result).inspect_err(|err| { self.handle_lua_result(lua_result, handler)
handler.receive(err.clone()); .inspect_err(|err| {
}) handler.receive(err.clone());
})
} }
fn add_globals(&self, lua: &Lua) -> mlua::Result<()> { fn add_globals(&self, lua: &Lua) -> mlua::Result<()> {
@ -88,19 +89,26 @@ mod enabled {
Ok(()) Ok(())
} }
fn handle_lua_result(&self, value: Value) -> TranspileResult<Option<ComptimeValue>> { fn handle_lua_result(
&self,
value: Value,
handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<ComptimeValue>> {
match value { match value {
Value::Nil => Ok(None), Value::Nil => Ok(None),
Value::String(s) => Ok(Some(ComptimeValue::String(s.to_string_lossy()))), Value::String(s) => Ok(Some(ComptimeValue::String(s.to_string_lossy()))),
Value::Integer(i) => Ok(Some(ComptimeValue::Integer(i))), Value::Integer(i) => Ok(Some(ComptimeValue::Integer(i))),
// TODO: change when floating point comptime numbers are supported // TODO: change when floating point comptime numbers are supported
Value::Number(n) => Ok(Some(ComptimeValue::String(n.to_string()))), Value::Number(n) => Ok(Some(ComptimeValue::String(n.to_string()))),
Value::Function(f) => self.handle_lua_result(f.call(()).map_err(|err| { Value::Function(f) => self.handle_lua_result(
TranspileError::LuaRuntimeError(LuaRuntimeError::from_lua_err( f.call(()).map_err(|err| {
&err, TranspileError::LuaRuntimeError(LuaRuntimeError::from_lua_err(
self.span(), &err,
)) self.span(),
})?), ))
})?,
handler,
),
Value::Boolean(boolean) => Ok(Some(ComptimeValue::Boolean(boolean))), Value::Boolean(boolean) => Ok(Some(ComptimeValue::Boolean(boolean))),
Value::Error(_) Value::Error(_)
| Value::Table(_) | Value::Table(_)
@ -112,7 +120,8 @@ mod enabled {
code_block: self.span(), code_block: self.span(),
error_message: format!("invalid return type {}", value.type_name()), error_message: format!("invalid return type {}", value.type_name()),
}); });
todo!("pass error to handler: {err}") handler.receive(err.clone());
Err(err)
} }
} }
} }
@ -127,7 +136,7 @@ mod disabled {
transpile::error::{TranspileError, TranspileResult}, transpile::error::{TranspileError, TranspileResult},
}; };
use super::expression::ComptimeValue; use crate::transpile::expression::ComptimeValue;
impl LuaCode { impl LuaCode {
/// Will always return an error because Lua code evaluation is disabled. /// Will always return an error because Lua code evaluation is disabled.
@ -136,7 +145,7 @@ mod disabled {
/// # Errors /// # Errors
/// - Always, as the lua feature is disabled /// - Always, as the lua feature is disabled
#[tracing::instrument(level = "debug", name = "eval_lua", skip_all, ret)] #[tracing::instrument(level = "debug", name = "eval_lua", skip_all, ret)]
pub fn eval(&self, handler: &impl Handler<base::Error>) -> TranspileResult<mlua::Value> { pub fn eval(&self, handler: &impl Handler<base::Error>) -> TranspileResult<()> {
handler.receive(TranspileError::LuaDisabled); handler.receive(TranspileError::LuaDisabled);
tracing::error!("Lua code evaluation is disabled"); tracing::error!("Lua code evaluation is disabled");
Err(TranspileError::LuaDisabled) Err(TranspileError::LuaDisabled)

368
src/transpile/transpiler.rs
View File

@ -1,13 +1,17 @@
//! Transpiler for `Shulkerscript` //! Transpiler for `Shulkerscript`
use chksum_md5 as md5; use chksum_md5 as md5;
use enum_as_inner::EnumAsInner;
use std::{ use std::{
collections::{BTreeMap, HashMap, HashSet}, collections::{BTreeMap, HashMap, HashSet},
ops::Deref, ops::Deref,
sync::{Arc, OnceLock}, sync::{Arc, OnceLock},
}; };
use shulkerbox::datapack::{self, Command, Datapack, Execute}; use shulkerbox::{
datapack::{self, Command, Datapack, Execute},
util::{MacroString, MacroStringPart},
};
use crate::{ use crate::{
base::{ base::{
@ -30,8 +34,8 @@ use crate::{
}; };
use super::{ use super::{
error::{MismatchedTypes, TranspileError, TranspileResult}, error::{MismatchedTypes, TranspileError, TranspileResult, UnknownIdentifier},
expression::{ComptimeValue, ExtendedCondition, ValueType}, expression::{ComptimeValue, ExpectedType, ExtendedCondition, StorageType},
variables::{Scope, VariableData}, variables::{Scope, VariableData},
FunctionData, TranspileAnnotationValue, FunctionData, TranspileAnnotationValue,
}; };
@ -52,6 +56,13 @@ pub struct Transpiler {
aliases: HashMap<(String, String), (String, String)>, aliases: HashMap<(String, String), (String, String)>,
} }
#[derive(Debug, Clone)]
pub enum TranspiledFunctionArguments {
None,
Static(BTreeMap<String, MacroString>),
Dynamic(Vec<Command>),
}
impl Transpiler { impl Transpiler {
/// Creates a new transpiler. /// Creates a new transpiler.
#[must_use] #[must_use]
@ -265,22 +276,20 @@ impl Transpiler {
arguments: Option<&[&Expression]>, arguments: Option<&[&Expression]>,
scope: &Arc<Scope>, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<(String, Option<BTreeMap<String, String>>)> { ) -> TranspileResult<(String, TranspiledFunctionArguments)> {
let program_identifier = identifier_span.source_file().identifier(); let program_identifier = identifier_span.source_file().identifier();
let program_query = ( let program_query = (
program_identifier.to_string(), program_identifier.to_string(),
identifier_span.str().to_string(), identifier_span.str().to_string(),
); );
let alias_query = self.aliases.get(&program_query).cloned(); let alias_query = self.aliases.get(&program_query).cloned();
let already_transpiled = match scope let already_transpiled = scope
.get_variable(identifier_span.str()) .get_variable(identifier_span.str())
.expect("called function should be in scope") .expect("called function should be in scope")
.as_ref() .as_ref()
{ .as_function()
VariableData::Function { path, .. } => Some(path.get().is_some()), .map(|(_, path)| path.get().is_some())
_ => None, .expect("called variable should be of type function");
}
.expect("called variable should be of type function");
let function_data = scope let function_data = scope
.get_variable(identifier_span.str()) .get_variable(identifier_span.str())
@ -331,7 +340,7 @@ impl Transpiler {
|val| match val { |val| match val {
TranspileAnnotationValue::None => Ok(identifier_span.str().to_string()), TranspileAnnotationValue::None => Ok(identifier_span.str().to_string()),
TranspileAnnotationValue::Expression(expr) => expr TranspileAnnotationValue::Expression(expr) => expr
.comptime_eval(scope) .comptime_eval(scope, handler)
.and_then(|val| val.to_string_no_macro()) .and_then(|val| val.to_string_no_macro())
.ok_or_else(|| { .ok_or_else(|| {
let err = TranspileError::IllegalAnnotationContent( let err = TranspileError::IllegalAnnotationContent(
@ -385,7 +394,7 @@ impl Transpiler {
function_path.set(function_location.clone()).unwrap(); function_path.set(function_location.clone()).unwrap();
} }
let parameters = function_data.parameters.clone(); let parameters = &function_data.parameters;
let function_location = function_path let function_location = function_path
.get() .get()
@ -402,71 +411,185 @@ impl Transpiler {
if arg_count.is_some_and(|arg_count| arg_count != parameters.len()) { if arg_count.is_some_and(|arg_count| arg_count != parameters.len()) {
let err = TranspileError::InvalidFunctionArguments(InvalidFunctionArguments { let err = TranspileError::InvalidFunctionArguments(InvalidFunctionArguments {
expected: parameters.len(), expected: parameters.len(),
actual: arg_count.expect("checked in if condition"), actual: arg_count.unwrap_or_default(),
span: identifier_span.clone(), span: identifier_span.clone(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
} else if arg_count.is_some_and(|arg_count| arg_count > 0) { } else if arg_count.is_some_and(|arg_count| arg_count > 0) {
let mut compiled_args = Vec::new(); {
let mut errs = Vec::new(); #[derive(Debug, Clone, EnumAsInner)]
for expression in arguments.iter().flat_map(|x| x.iter()) { enum Parameter {
let value = match expression { Static(MacroString),
Expression::Primary(Primary::FunctionCall(func)) => self Dynamic {
.transpile_function_call(func, scope, handler) prepare_cmds: Vec<Command>,
.map(|cmd| match cmd { storage_name: String,
Command::Raw(s) => s, path: String,
_ => unreachable!("Function call should always return a raw command"), },
}), }
Expression::Primary(Primary::Lua(lua)) => {
lua.eval_comptime(handler).and_then(|opt| { let mut compiled_args = Vec::new();
opt.map_or_else( let mut errs = Vec::new();
|| {
for expression in arguments.iter().flat_map(|x| x.iter()) {
let value = match expression {
Expression::Primary(Primary::Lua(lua)) => {
lua.eval_comptime(handler).and_then(|val| match val {
Some(ComptimeValue::MacroString(s)) => Ok(Parameter::Static(s)),
Some(val) => Ok(Parameter::Static(val.to_string().into())),
None => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expression: expression.span(), expression: expression.span(),
expected_type: ValueType::String, expected_type: ExpectedType::String,
}); });
handler.receive(err.clone()); handler.receive(err.clone());
Err(err) Err(err)
}
})
}
Expression::Primary(Primary::Integer(num)) => {
Ok(Parameter::Static(num.span.str().to_string().into()))
}
Expression::Primary(Primary::Boolean(bool)) => {
Ok(Parameter::Static(bool.span.str().to_string().into()))
}
Expression::Primary(Primary::StringLiteral(string)) => {
Ok(Parameter::Static(string.str_content().to_string().into()))
}
Expression::Primary(Primary::MacroStringLiteral(literal)) => {
Ok(Parameter::Static(literal.into()))
}
Expression::Primary(primary @ Primary::Identifier(ident)) => {
let var = scope.get_variable(ident.span.str()).ok_or_else(|| {
let err = TranspileError::UnknownIdentifier(UnknownIdentifier {
identifier: ident.span(),
});
handler.receive(err.clone());
err
})?;
match var.as_ref() {
VariableData::FunctionArgument { .. } => {
Ok(Parameter::Static(MacroString::MacroString(vec![
MacroStringPart::MacroUsage(
crate::util::identifier_to_macro(ident.span.str())
.to_string(),
),
])))
}
VariableData::BooleanStorage { .. }
| VariableData::ScoreboardValue { .. } => {
let (temp_storage, mut temp_path) =
self.get_temp_storage_locations(1);
let prepare_cmds = self.transpile_primary_expression(
primary,
&super::expression::DataLocation::Storage {
storage_name: temp_storage.clone(),
path: temp_path[0].clone(),
r#type: StorageType::Int,
},
scope,
handler,
)?;
Ok(Parameter::Dynamic {
prepare_cmds: dbg!(prepare_cmds),
storage_name: temp_storage,
path: std::mem::take(&mut temp_path[0]),
})
}
_ => todo!("other variable types"),
}
}
Expression::Primary(
Primary::Parenthesized(_)
| Primary::Prefix(_)
| Primary::FunctionCall(_),
)
| Expression::Binary(_) => {
let (temp_storage, mut temp_path) = self.get_temp_storage_locations(1);
let prepare_cmds = self.transpile_expression(
expression,
&super::expression::DataLocation::Storage {
storage_name: temp_storage.clone(),
path: temp_path[0].clone(),
r#type: StorageType::Int,
}, },
|val| Ok(val.to_string()), scope,
) handler,
}) )?;
}
Expression::Primary(Primary::Integer(num)) => Ok(num.span.str().to_string()),
Expression::Primary(Primary::Boolean(bool)) => Ok(bool.span.str().to_string()),
Expression::Primary(Primary::StringLiteral(string)) => {
Ok(string.str_content().to_string())
}
Expression::Primary(Primary::MacroStringLiteral(literal)) => {
Ok(literal.str_content())
}
Expression::Primary(
Primary::Identifier(_) | Primary::Parenthesized(_) | Primary::Prefix(_),
) => {
todo!("allow identifiers, parenthesized & prefix expressions as arguments")
}
Expression::Binary(_) => todo!("allow binary expressions as arguments"), Ok(Parameter::Dynamic {
}; prepare_cmds,
storage_name: temp_storage,
path: std::mem::take(&mut temp_path[0]),
})
}
};
match value { match value {
Ok(value) => { Ok(value) => {
compiled_args.push(value); compiled_args.push(value);
} }
Err(err) => { Err(err) => {
compiled_args.push(String::new()); compiled_args
errs.push(err.clone()); .push(Parameter::Static(MacroString::String(String::new())));
errs.push(err.clone());
}
} }
} }
if let Some(err) = errs.first() {
return Err(err.clone());
}
if compiled_args.iter().any(|arg| !arg.is_static()) {
let (mut setup_cmds, move_cmds) = parameters.clone().into_iter().zip(compiled_args).fold(
(Vec::new(), Vec::new()),
|(mut acc_setup, mut acc_move), (arg_name, data)| {
let arg_name = crate::util::identifier_to_macro(&arg_name);
match data {
Parameter::Static(s) => {
// TODO: optimize by combining into single `data merge` command
let move_cmd = match s {
MacroString::String(value) => Command::Raw(format!(r#"data modify storage shulkerscript:function_arguments {arg_name} set value "{value}""#, value = crate::util::escape_str(&value))),
MacroString::MacroString(mut parts) => {
parts.insert(0, MacroStringPart::String(format!(r#"data modify storage shulkerscript:function_arguments {arg_name} set value ""#)));
parts.push(MacroStringPart::String('"'.to_string()));
Command::UsesMacro(MacroString::MacroString(parts))
}
};
acc_move.push(move_cmd);
}
Parameter::Dynamic { prepare_cmds, storage_name, path } => {
acc_setup.extend(prepare_cmds);
acc_move.push(Command::Raw(format!(r#"data modify storage shulkerscript:function_arguments {arg_name} set from storage {storage_name} {path}"#)));
}
}
(acc_setup, acc_move)},
);
setup_cmds.extend(move_cmds);
Ok((
function_location,
TranspiledFunctionArguments::Dynamic(setup_cmds),
))
} else {
let function_args = parameters
.clone()
.into_iter()
.zip(
compiled_args
.into_iter()
.map(|arg| arg.into_static().expect("checked in if condition")),
)
.collect();
Ok((
function_location,
TranspiledFunctionArguments::Static(function_args),
))
}
} }
if let Some(err) = errs.first() {
return Err(err.clone());
}
let function_args = parameters.into_iter().zip(compiled_args).collect();
Ok((function_location, Some(function_args)))
} else { } else {
Ok((function_location, None)) Ok((function_location, TranspiledFunctionArguments::None))
} }
} }
@ -556,9 +679,9 @@ impl Transpiler {
} }
Statement::Semicolon(semi) => match semi.statement() { Statement::Semicolon(semi) => match semi.statement() {
SemicolonStatement::Expression(expr) => match expr { SemicolonStatement::Expression(expr) => match expr {
Expression::Primary(Primary::FunctionCall(func)) => self Expression::Primary(Primary::FunctionCall(func)) => {
.transpile_function_call(func, scope, handler) self.transpile_function_call(func, scope, handler)
.map(|cmd| vec![cmd]), }
unexpected => { unexpected => {
let error = TranspileError::UnexpectedExpression(UnexpectedExpression( let error = TranspileError::UnexpectedExpression(UnexpectedExpression(
unexpected.clone(), unexpected.clone(),
@ -589,9 +712,9 @@ impl Transpiler {
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Vec<Command>> { ) -> TranspileResult<Vec<Command>> {
match expression { match expression {
Expression::Primary(Primary::FunctionCall(func)) => self Expression::Primary(Primary::FunctionCall(func)) => {
.transpile_function_call(func, scope, handler) self.transpile_function_call(func, scope, handler)
.map(|cmd| vec![cmd]), }
expression @ Expression::Primary( expression @ Expression::Primary(
Primary::Integer(_) Primary::Integer(_)
| Primary::Boolean(_) | Primary::Boolean(_)
@ -610,13 +733,11 @@ impl Transpiler {
Ok(vec![Command::UsesMacro(string.into())]) Ok(vec![Command::UsesMacro(string.into())])
} }
Expression::Primary(Primary::Lua(code)) => match code.eval_comptime(handler)? { Expression::Primary(Primary::Lua(code)) => match code.eval_comptime(handler)? {
Some(ComptimeValue::String(cmd) | ComptimeValue::MacroString(cmd)) => { Some(ComptimeValue::String(cmd)) => Ok(vec![Command::Raw(cmd)]),
// TODO: mark command as containing macro if so Some(ComptimeValue::MacroString(cmd)) => Ok(vec![Command::UsesMacro(cmd)]),
Ok(vec![Command::Raw(cmd)])
}
Some(ComptimeValue::Boolean(_) | ComptimeValue::Integer(_)) => { Some(ComptimeValue::Boolean(_) | ComptimeValue::Integer(_)) => {
let err = TranspileError::MismatchedTypes(MismatchedTypes { let err = TranspileError::MismatchedTypes(MismatchedTypes {
expected_type: ValueType::String, expected_type: ExpectedType::String,
expression: code.span(), expression: code.span(),
}); });
handler.receive(err.clone()); handler.receive(err.clone());
@ -632,16 +753,11 @@ impl Transpiler {
scope, scope,
handler, handler,
), ),
Expression::Binary(bin) => { Expression::Binary(bin) => match bin.comptime_eval(scope, handler) {
if let Some(ComptimeValue::String(cmd) | ComptimeValue::MacroString(cmd)) = Some(ComptimeValue::String(cmd)) => Ok(vec![Command::Raw(cmd)]),
bin.comptime_eval(scope) Some(ComptimeValue::MacroString(cmd)) => Ok(vec![Command::UsesMacro(cmd)]),
{ _ => todo!("run binary expression"),
// TODO: mark as containing macro if so },
Ok(vec![Command::Raw(cmd)])
} else {
todo!("run binary expression")
}
}
} }
} }
@ -650,7 +766,7 @@ impl Transpiler {
func: &FunctionCall, func: &FunctionCall,
scope: &Arc<Scope>, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Command> { ) -> TranspileResult<Vec<Command>> {
let arguments = func let arguments = func
.arguments() .arguments()
.as_ref() .as_ref()
@ -662,22 +778,78 @@ impl Transpiler {
handler, handler,
)?; )?;
let mut function_call = format!("function {location}"); let mut function_call = format!("function {location}");
if let Some(arguments) = arguments { match arguments {
use std::fmt::Write; TranspiledFunctionArguments::Static(arguments) => {
let arguments = arguments use std::fmt::Write;
.iter() let arguments = arguments
.map(|(ident, v)| { .iter()
format!( .map(|(ident, v)| match v {
r#"{macro_name}:"{escaped}""#, MacroString::String(s) => MacroString::String(format!(
macro_name = crate::util::identifier_to_macro(ident), r#"{macro_name}:"{escaped}""#,
escaped = crate::util::escape_str(v) macro_name = crate::util::identifier_to_macro(ident),
) escaped = crate::util::escape_str(s)
}) )),
.collect::<Vec<_>>() MacroString::MacroString(parts) => MacroString::MacroString(
.join(","); std::iter::once(MacroStringPart::String(format!(
write!(function_call, " {{{arguments}}}").unwrap(); r#"{macro_name}:""#,
macro_name = crate::util::identifier_to_macro(ident)
)))
.chain(parts.clone().into_iter().map(|part| match part {
MacroStringPart::String(s) => {
MacroStringPart::String(crate::util::escape_str(&s).to_string())
}
macro_usage @ MacroStringPart::MacroUsage(_) => macro_usage,
}))
.chain(std::iter::once(MacroStringPart::String('"'.to_string())))
.collect(),
),
})
.fold(MacroString::String(String::new()), |acc, cur| match acc {
MacroString::String(mut s) => match cur {
MacroString::String(cur) => {
s.push_str(&cur);
MacroString::String(s)
}
MacroString::MacroString(cur) => {
let mut parts = vec![MacroStringPart::String(s)];
parts.extend(cur);
MacroString::MacroString(parts)
}
},
MacroString::MacroString(mut parts) => match cur {
MacroString::String(cur) => {
parts.push(MacroStringPart::String(cur));
MacroString::MacroString(parts)
}
MacroString::MacroString(cur) => {
parts.extend(cur);
MacroString::MacroString(parts)
}
},
});
let cmd = match arguments {
MacroString::String(arguments) => {
write!(function_call, " {{{arguments}}}").unwrap();
Command::Raw(function_call)
}
MacroString::MacroString(mut parts) => {
function_call.push_str(" {");
parts.insert(0, MacroStringPart::String(function_call));
parts.push(MacroStringPart::String('}'.to_string()));
Command::UsesMacro(MacroString::MacroString(parts))
}
};
Ok(vec![cmd])
}
TranspiledFunctionArguments::Dynamic(mut cmds) => {
function_call.push_str(" with storage shulkerscript:function_arguments");
cmds.push(Command::Raw(function_call));
Ok(cmds)
}
TranspiledFunctionArguments::None => Ok(vec![Command::Raw(function_call)]),
} }
Ok(Command::Raw(function_call))
} }
fn transpile_execute_block( fn transpile_execute_block(
@ -830,7 +1002,7 @@ impl Transpiler {
} }
}); });
if let Some(ComptimeValue::Boolean(value)) = cond_expression.comptime_eval(scope) { if let Some(ComptimeValue::Boolean(value)) = cond_expression.comptime_eval(scope, handler) {
if value { if value {
Ok(Some((Vec::new(), then))) Ok(Some((Vec::new(), then)))
} else { } else {

8
src/transpile/variables.rs
View File

@ -380,8 +380,12 @@ fn get_single_data_location_identifiers(
) = (name, target) ) = (name, target)
{ {
if let (Some(name_eval), Some(target_eval)) = ( if let (Some(name_eval), Some(target_eval)) = (
objective.comptime_eval(scope).map(|val| val.to_string()), objective
target.comptime_eval(scope).map(|val| val.to_string()), .comptime_eval(scope, handler)
.map(|val| val.to_string()),
target
.comptime_eval(scope, handler)
.map(|val| val.to_string()),
) { ) {
// TODO: change invalid criteria if boolean // TODO: change invalid criteria if boolean
if !crate::util::is_valid_scoreboard_objective_name(&name_eval) { if !crate::util::is_valid_scoreboard_objective_name(&name_eval) {