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

Compare commits

base: moritz:d9f2d99c3a5e09488fc85ad792501a209387a89d
Branches Tags
moritz:main
moritz:feature/variables
moritz:develop
moritz:v0.1.0
..
compare: moritz:b7d50f822276a7465833d0b187614086fa64f319
Branches Tags
moritz:feature/variables
moritz:develop
moritz:main
moritz:v0.1.0

No commits in common. "d9f2d99c3a5e09488fc85ad792501a209387a89d" and "b7d50f822276a7465833d0b187614086fa64f319" have entirely different histories.
d9f2d99c3a ... b7d50f8222

6 changed files with 118 additions and 181 deletions
Show Stats Expand all files Collapse all files

17
src/semantic/mod.rs
View File

@ -967,10 +967,20 @@ impl TemplateStringLiteral {
for part in self.parts() { for part in self.parts() {
match part { match part {
TemplateStringLiteralPart::Expression { expression, .. } => { TemplateStringLiteralPart::Expression { expression, .. } => {
expression.analyze_semantics(scope, handler)?;
match expression.as_ref() { match expression.as_ref() {
Expression::Primary(Primary::Identifier(identifier)) => { Expression::Primary(Primary::Identifier(identifier)) => {
if scope.get_variable(identifier.span.str()).is_none() { if let Some(variable_type) = scope.get_variable(identifier.span.str()) {
// TODO: template string correct checks
// if variable_type != VariableType::MacroParameter {
// let err = error::Error::UnexpectedExpression(UnexpectedExpression(
// Box::new(Expression::Primary(Primary::Identifier(
// identifier.clone(),
// ))),
// ));
// handler.receive(err.clone());
// errs.push(err);
// }
} else {
let err = error::Error::UnknownIdentifier(UnknownIdentifier { let err = error::Error::UnknownIdentifier(UnknownIdentifier {
identifier: identifier.span.clone(), identifier: identifier.span.clone(),
}); });
@ -1016,9 +1026,6 @@ impl TemplateStringLiteral {
errs.push(err); errs.push(err);
} }
} }
Expression::Primary(Primary::MemberAccess(member_access)) => {
member_access.parent().analyze_semantics(scope, handler)?;
}
_ => { _ => {
let err = error::Error::UnexpectedExpression(UnexpectedExpression( let err = error::Error::UnexpectedExpression(UnexpectedExpression(
expression.clone(), expression.clone(),

1
src/syntax/syntax_tree/declaration.rs
View File

@ -344,7 +344,6 @@ impl Parser<'_> {
/// ///
/// # Errors /// # Errors
/// - cannot parse declaration from current position /// - cannot parse declaration from current position
#[expect(clippy::too_many_lines)]
#[tracing::instrument(level = "trace", skip_all)] #[tracing::instrument(level = "trace", skip_all)]
pub fn parse_declaration( pub fn parse_declaration(
&mut self, &mut self,

1
src/syntax/syntax_tree/statement.rs
View File

@ -1010,7 +1010,6 @@ impl Parser<'_> {
/// ///
/// # Errors /// # Errors
/// - cannot parse variable declaration from current position /// - cannot parse variable declaration from current position
#[expect(clippy::too_many_lines)]
#[tracing::instrument(level = "trace", skip_all)] #[tracing::instrument(level = "trace", skip_all)]
pub fn parse_variable_declaration( pub fn parse_variable_declaration(
&mut self, &mut self,

164
src/transpile/function.rs
View File

@ -412,7 +412,7 @@ impl Transpiler {
}, },
} }
let mut compiled_args = Vec::<(Parameter, Span)>::new(); let mut compiled_args = Vec::<Parameter>::new();
let mut errs = Vec::new(); let mut errs = Vec::new();
for (expression, is_comptime) in arguments for (expression, is_comptime) in arguments
@ -571,13 +571,11 @@ impl Transpiler {
match value { match value {
Ok(value) => { Ok(value) => {
compiled_args.push((value, expression.span())); compiled_args.push(value);
} }
Err(err) => { Err(err) => {
compiled_args.push(( compiled_args
Parameter::Static(MacroString::String(String::new())), .push(Parameter::Static(MacroString::String(String::new())));
expression.span(),
));
errs.push(err.clone()); errs.push(err.clone());
} }
} }
@ -586,164 +584,111 @@ impl Transpiler {
return Err(err.clone()); return Err(err.clone());
} }
if compiled_args.iter().any(|(arg, _)| !arg.is_static()) { if compiled_args.iter().any(|arg| !arg.is_static()) {
let mut require_dyn_params = false; let (require_dyn_params, mut setup_cmds, move_cmds, static_params) = parameters.clone().into_iter().zip(compiled_args).fold(
let mut setup_cmds = Vec::new(); (false, Vec::new(), Vec::new(), BTreeMap::new()),
let mut move_cmds = Vec::new(); |(mut require_dyn_params, mut acc_setup, mut acc_move, mut statics), (param, data)| {
let mut statics = BTreeMap::new();
for (param, (data, span)) in parameters.clone().into_iter().zip(compiled_args) {
match param.variable_type() { match param.variable_type() {
FunctionVariableType::Macro(_) => { FunctionVariableType::Macro(_) => {
let arg_name = let arg_name = crate::util::identifier_to_macro(param.identifier().span.str());
crate::util::identifier_to_macro(param.identifier().span.str());
match data { match data {
Parameter::Comptime => {} Parameter::Comptime => {}
Parameter::Static(s) => { Parameter::Static(s) => {
match s { match s {
MacroString::String(value) => statics.insert( MacroString::String(value) => statics.insert(
arg_name.to_string(), arg_name.to_string(),
MacroString::String( MacroString::String(crate::util::escape_str(&value).to_string())
crate::util::escape_str(&value).to_string(),
),
), ),
MacroString::MacroString(parts) => { MacroString::MacroString(parts) => {
let parts = parts let parts = parts.into_iter().map(|part| {
.into_iter() match part {
.map(|part| match part { MacroStringPart::String(s) => MacroStringPart::String(crate::util::escape_str(&s).to_string()),
MacroStringPart::String(s) => { MacroStringPart::MacroUsage(m) => MacroStringPart::MacroUsage(m),
MacroStringPart::String(
crate::util::escape_str(&s)
.to_string(),
)
} }
MacroStringPart::MacroUsage(m) => { }).collect();
MacroStringPart::MacroUsage(m) statics.insert(arg_name.to_string(), MacroString::MacroString(parts))
}
})
.collect();
statics.insert(
arg_name.to_string(),
MacroString::MacroString(parts),
)
} }
}; };
} }
Parameter::Storage { Parameter::Storage { prepare_cmds, storage_name, path } => {
prepare_cmds,
storage_name,
path,
} => {
require_dyn_params = true; require_dyn_params = true;
setup_cmds.extend(prepare_cmds); acc_setup.extend(prepare_cmds);
move_cmds.push(Command::Raw( acc_move.push(Command::Raw(
format!(r"data modify storage shulkerscript:function_arguments {arg_name} set from storage {storage_name} {path}") format!(r"data modify storage shulkerscript:function_arguments {arg_name} set from storage {storage_name} {path}")
)); ));
} }
} }
} }
FunctionVariableType::Integer(_) => { FunctionVariableType::Integer(_) => {
let objective = format!( let objective = format!("shu_arguments_{}", function_location.replace(['/', ':'], "_"));
"shu_arguments_{}",
function_location.replace(['/', ':'], "_")
);
let param_str = param.identifier().span.str(); let param_str = param.identifier().span.str();
let target = let target = crate::util::identifier_to_scoreboard_target(param_str);
crate::util::identifier_to_scoreboard_target(param_str);
match data { match data {
Parameter::Comptime => {} Parameter::Comptime => {}
Parameter::Static(s) => match s.as_str() { Parameter::Static(s) => {
match s.as_str() {
Ok(s) => { Ok(s) => {
if s.parse::<i32>().is_ok() { if s.parse::<i32>().is_ok() {
move_cmds.push(Command::Raw(format!(r"scoreboard players set {target} {objective} {s}"))); acc_move.push(Command::Raw(format!(r"scoreboard players set {target} {objective} {s}")));
} else { } else {
let err = TranspileError::MismatchedTypes( panic!("non-integer static argument")
MismatchedTypes {
expression: span,
expected_type: ExpectedType::Integer,
},
);
handler.receive(Box::new(err.clone()));
return Err(err);
} }
} }
Err(parts) => { Err(parts) => {
move_cmds.push(Command::UsesMacro(MacroString::MacroString( acc_move.push(Command::UsesMacro(MacroString::MacroString(
std::iter::once(MacroStringPart::String(format!("scoreboard players set {target} {objective} "))) std::iter::once(MacroStringPart::String(format!("scoreboard players set {target} {objective} ")))
.chain(parts.iter().cloned()).collect() .chain(parts.iter().cloned()).collect()
).into())); ).into()));
} }
}, }
Parameter::Storage { }
prepare_cmds, Parameter::Storage { prepare_cmds, storage_name, path } => {
storage_name, acc_setup.extend(prepare_cmds);
path, acc_move.push(Command::Execute(Execute::Store(
} => {
setup_cmds.extend(prepare_cmds);
move_cmds.push(Command::Execute(Execute::Store(
format!("result score {target} {objective}").into(), format!("result score {target} {objective}").into(),
Box::new(Execute::Run(Box::new(Command::Raw( Box::new(Execute::Run(Box::new(Command::Raw(format!("data get storage {storage_name} {path}")))))
format!("data get storage {storage_name} {path}"),
)))),
))); )));
} }
} }
} },
FunctionVariableType::Boolean(_) => { FunctionVariableType::Boolean(_) => {
require_dyn_params = true; require_dyn_params = true;
let target_storage_name = format!( let target_storage_name = format!("shulkerscript:arguments_{}", function_location.replace(['/', ':'], "_"));
"shulkerscript:arguments_{}",
function_location.replace(['/', ':'], "_")
);
let param_str = param.identifier().span.str(); let param_str = param.identifier().span.str();
let target_path = let target_path = crate::util::identifier_to_scoreboard_target(param_str);
crate::util::identifier_to_scoreboard_target(param_str);
match data { match data {
Parameter::Comptime => {} Parameter::Comptime => {}
Parameter::Static(s) => match s.as_str() { Parameter::Static(s) => {
match s.as_str() {
Ok(s) => { Ok(s) => {
if let Ok(b) = s.parse::<bool>() { if let Ok(b) = s.parse::<bool>() {
move_cmds.push(Command::Raw(format!("data modify storage {target_storage_name} {target_path} set value {}", if b { "1b" } else { "0b" }))); acc_move.push(Command::Raw(format!("data modify storage {target_storage_name} {target_path} set value {}", if b { "1b" } else { "0b" })));
} else { } else {
let err = TranspileError::MismatchedTypes( panic!("non-integer static argument")
MismatchedTypes {
expression: span,
expected_type: ExpectedType::Boolean,
},
);
handler.receive(Box::new(err.clone()));
return Err(err);
} }
} }
Err(parts) => { Err(parts) => {
move_cmds.push(Command::UsesMacro(MacroString::MacroString( acc_move.push(Command::UsesMacro(MacroString::MacroString(
std::iter::once(MacroStringPart::String(format!("data modify storage {target_storage_name} {target_path} set value "))) std::iter::once(MacroStringPart::String(format!("data modify storage {target_storage_name} {target_path} set value ")))
.chain(parts.iter().cloned()).collect() .chain(parts.iter().cloned()).collect()
).into())); ).into()));
} }
}
}
Parameter::Storage { prepare_cmds, storage_name, path } => {
acc_setup.extend(prepare_cmds);
acc_move.push(Command::Raw(format!("data modify storage {target_storage_name} {target_path} set from storage {storage_name} {path}")));
}
}
}, },
Parameter::Storage {
prepare_cmds,
storage_name,
path,
} => {
setup_cmds.extend(prepare_cmds);
move_cmds.push(Command::Raw(format!("data modify storage {target_storage_name} {target_path} set from storage {storage_name} {path}")));
}
}
}
FunctionVariableType::Value(_) => { FunctionVariableType::Value(_) => {
// handled before in `transpile_comptime_function_arguments` // handled before in `transpile_comptime_function_arguments`
} }
} }
} (require_dyn_params, acc_setup, acc_move, statics)},
);
let require_dyn_params = require_dyn_params;
let move_cmds = move_cmds;
let static_params = statics;
if require_dyn_params { if require_dyn_params {
let statics_len = static_params.len(); let statics_len = static_params.len();
let joined_statics = super::util::join_macro_strings( let joined_statics = super::util::join_macro_strings(
@ -804,13 +749,14 @@ impl Transpiler {
)) ))
} }
} else { } else {
let function_args = let function_args = parameters
parameters
.clone() .clone()
.into_iter() .into_iter()
.zip(compiled_args.into_iter().map(|(arg, _)| { .zip(
arg.into_static().expect("checked in if condition") compiled_args
})) .into_iter()
.map(|arg| arg.into_static().expect("checked in if condition")),
)
.map(|(k, v)| (k.identifier().span.str().to_string(), v)) .map(|(k, v)| (k.identifier().span.str().to_string(), v))
.collect(); .collect();
Ok(TranspiledFunctionArguments::Static( Ok(TranspiledFunctionArguments::Static(

1
src/transpile/transpiler.rs
View File

@ -69,7 +69,6 @@ impl Transpiler {
/// ///
/// # Errors /// # Errors
/// - [`TranspileError::MissingFunctionDeclaration`] If a called function is missing /// - [`TranspileError::MissingFunctionDeclaration`] If a called function is missing
#[expect(clippy::too_many_lines)]
#[tracing::instrument(level = "trace", skip_all)] #[tracing::instrument(level = "trace", skip_all)]
pub fn transpile( pub fn transpile(
mut self, mut self,

21
src/transpile/util.rs
View File

@ -1,8 +1,7 @@
//! Utility methods for transpiling //! Utility methods for transpiling
use std::{fmt::Display, str::FromStr}; use std::{fmt::Display, str::FromStr, sync::Arc};
#[cfg(feature = "shulkerbox")]
use crate::{ use crate::{
base::{self, source_file::SourceElement as _, Handler}, base::{self, source_file::SourceElement as _, Handler},
syntax::syntax_tree::{ syntax::syntax_tree::{
@ -11,12 +10,11 @@ use crate::{
}, },
transpile::{ transpile::{
error::{TranspileError, UnknownIdentifier}, error::{TranspileError, UnknownIdentifier},
expression::ComptimeValue,
Scope, TranspileResult, VariableData, Scope, TranspileResult, VariableData,
}, },
}; };
#[cfg(feature = "shulkerbox")]
use std::sync::Arc; use super::expression::ComptimeValue;
/// String that can contain macros /// String that can contain macros
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@ -258,7 +256,6 @@ where
} }
} }
#[cfg(feature = "shulkerbox")]
impl AnyStringLiteral { impl AnyStringLiteral {
/// Convert the any string literal to a macro string, using the provided scope to resolve variables /// Convert the any string literal to a macro string, using the provided scope to resolve variables
/// ///
@ -276,7 +273,6 @@ impl AnyStringLiteral {
} }
} }
#[cfg(feature = "shulkerbox")]
impl TemplateStringLiteral { impl TemplateStringLiteral {
/// Convert the template string literal to a macro string, using the provided scope to resolve variables /// Convert the template string literal to a macro string, using the provided scope to resolve variables
/// ///
@ -333,13 +329,6 @@ impl TemplateStringLiteral {
Err(err) Err(err)
} }
} }
Expression::Primary(Primary::MemberAccess(member_access)) => {
let value = member_access.parent().comptime_member_access(member_access, scope, handler).inspect_err(|err| {
handler.receive(Box::new(TranspileError::NotComptime(err.clone())));
})?.to_macro_string();
value.as_str().map_or_else(|_| todo!("comptime value resulting in macro string with macros"), |s| Ok(MacroStringPart::String(s.into_owned())))
}
_ => todo!("other expressions in template strings"), _ => todo!("other expressions in template strings"),
} }
} }
@ -349,9 +338,7 @@ impl TemplateStringLiteral {
Ok(macro_string) Ok(macro_string)
} else { } else {
Ok(MacroString::String( Ok(MacroString::String(self.as_str(scope, handler)?.into_owned()))
self.as_str(scope, handler)?.into_owned(),
))
} }
} }
} }