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 todos in scoreboard variable

This commit is contained in:
Moritz Hölting 2025-03-16 19:25:25 +01:00
parent 0885665baf
commit b119ca33c7
4 changed files with 358 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/transpile/error.rs
View File

@ -42,6 +42,8 @@ pub enum TranspileError {
UnknownIdentifier(#[from] UnknownIdentifier), UnknownIdentifier(#[from] UnknownIdentifier),
#[error(transparent)] #[error(transparent)]
MissingValue(#[from] MissingValue), MissingValue(#[from] MissingValue),
#[error(transparent)]
IllegalIndexing(#[from] IllegalIndexing),
} }
/// The result of a transpilation operation. /// The result of a transpilation operation.
@ -309,3 +311,54 @@ impl Display for MissingValue {
} }
impl std::error::Error for MissingValue {} impl std::error::Error for MissingValue {}
/// An error that occurs when an indexing operation is not permitted.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IllegalIndexing {
pub reason: IllegalIndexingReason,
pub expression: Span,
}
impl Display for IllegalIndexing {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", Message::new(Severity::Error, &self.reason))?;
write!(
f,
"\n{}",
SourceCodeDisplay::new(&self.expression, Option::<u8>::None)
)
}
}
impl std::error::Error for IllegalIndexing {}
/// The reason why an indexing operation is not permitted.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum IllegalIndexingReason {
NotIdentifier,
InvalidComptimeType { expected: ExpectedType },
IndexOutOfBounds { index: usize, length: usize },
}
impl Display for IllegalIndexingReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NotIdentifier => {
write!(f, "The expression is not an identifier.")
}
Self::InvalidComptimeType { expected } => {
write!(
f,
"The expression can only be indexed with type {expected} that can be evaluated at compile time."
)
}
Self::IndexOutOfBounds { index, length } => {
write!(
f,
"The index {index} is out of bounds for the expression with length {length}."
)
}
}
}
}

139
src/transpile/expression.rs
View File

@ -19,7 +19,7 @@ use shulkerbox::prelude::{Command, Condition, Execute};
#[cfg(feature = "shulkerbox")] #[cfg(feature = "shulkerbox")]
use super::{ use super::{
error::{MismatchedTypes, UnknownIdentifier}, error::{IllegalIndexing, IllegalIndexingReason, MismatchedTypes, UnknownIdentifier},
TranspileResult, Transpiler, TranspileResult, Transpiler,
}; };
#[cfg(feature = "shulkerbox")] #[cfg(feature = "shulkerbox")]
@ -31,7 +31,6 @@ use crate::{
}, },
}; };
// TODO: fix this leading to compile errors without 'shulkerbox' feature
/// Compile-time evaluated value /// Compile-time evaluated value
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
@ -287,27 +286,29 @@ impl Primary {
} }
}, },
Self::Indexed(indexed) => { Self::Indexed(indexed) => {
let Self::Identifier(ident) = indexed.object().as_ref() else { if let Self::Identifier(ident) = indexed.object().as_ref() {
todo!("throw error: cannot index anything except identifiers") scope
}; .get_variable(ident.span.str())
scope .map_or(false, |variable| match r#type {
.get_variable(ident.span.str()) ValueType::Boolean => {
.map_or(false, |variable| match r#type { matches!(
ValueType::Boolean => { variable.as_ref(),
matches!( VariableData::Tag { .. }
variable.as_ref(), | VariableData::BooleanStorageArray { .. }
VariableData::Tag { .. } | VariableData::BooleanStorageArray { .. } )
) }
} ValueType::Integer => {
ValueType::Integer => { matches!(
matches!( variable.as_ref(),
variable.as_ref(), VariableData::Scoreboard { .. }
VariableData::Scoreboard { .. } | VariableData::ScoreboardArray { .. }
| VariableData::ScoreboardArray { .. } )
) }
} ValueType::String => false,
ValueType::String => false, })
}) } else {
false
}
} }
#[cfg_attr(not(feature = "lua"), expect(unused_variables))] #[cfg_attr(not(feature = "lua"), expect(unused_variables))]
Self::Lua(lua) => { Self::Lua(lua) => {
@ -785,9 +786,16 @@ impl Transpiler {
} }
} }
Primary::Indexed(indexed) => { Primary::Indexed(indexed) => {
let Primary::Identifier(ident) = indexed.object().as_ref() else { let ident = if let Primary::Identifier(ident) = indexed.object().as_ref() {
todo!("can only index identifier") Ok(ident)
}; } else {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::NotIdentifier,
expression: indexed.object().span(),
});
handler.receive(err.clone());
Err(err)
}?;
let variable = scope.get_variable(ident.span.str()); let variable = scope.get_variable(ident.span.str());
#[expect(clippy::option_if_let_else)] #[expect(clippy::option_if_let_else)]
if let Some(variable) = variable.as_deref() { if let Some(variable) = variable.as_deref() {
@ -801,7 +809,14 @@ impl Transpiler {
target, target,
}) })
} else { } else {
todo!("can only index scoreboard with comptime string") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::String,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} }
VariableData::ScoreboardArray { objective, targets } => { VariableData::ScoreboardArray { objective, targets } => {
@ -818,10 +833,25 @@ impl Transpiler {
target, target,
}) })
} else { } else {
todo!("index out of bounds") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: targets.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} else { } else {
todo!("can only index array with comptime integer") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} }
VariableData::BooleanStorageArray { VariableData::BooleanStorageArray {
@ -842,10 +872,25 @@ impl Transpiler {
r#type: StorageType::Boolean, r#type: StorageType::Boolean,
}) })
} else { } else {
todo!("index out of bounds") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: paths.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} else { } else {
todo!("can only index array with comptime integer") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} }
_ => { _ => {
@ -1022,9 +1067,16 @@ impl Transpiler {
self.transpile_expression_as_condition(parenthesized.expression(), scope, handler) self.transpile_expression_as_condition(parenthesized.expression(), scope, handler)
} }
Primary::Indexed(indexed) => { Primary::Indexed(indexed) => {
let Primary::Identifier(ident) = indexed.object().as_ref() else { let ident = if let Primary::Identifier(ident) = indexed.object().as_ref() {
todo!("can only index identifier") Ok(ident)
}; } else {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::NotIdentifier,
expression: indexed.object().span(),
});
handler.receive(err.clone());
Err(err)
}?;
#[expect(clippy::option_if_let_else)] #[expect(clippy::option_if_let_else)]
if let Some(variable) = scope.get_variable(ident.span.str()).as_deref() { if let Some(variable) = scope.get_variable(ident.span.str()).as_deref() {
#[expect(clippy::single_match_else)] #[expect(clippy::single_match_else)]
@ -1049,10 +1101,25 @@ impl Transpiler {
)), )),
)) ))
} else { } else {
todo!("index out of bounds") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::IndexOutOfBounds {
length: paths.len(),
index: usize::try_from(index).unwrap_or(usize::MAX),
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} else { } else {
todo!("can only index array with comptime integer") let err = TranspileError::IllegalIndexing(IllegalIndexing {
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::Integer,
},
expression: indexed.index().span(),
});
handler.receive(err.clone());
Err(err)
} }
} }
_ => { _ => {

283
src/transpile/lua.rs
View File

@ -4,13 +4,17 @@
mod enabled { mod enabled {
use std::sync::Arc; use std::sync::Arc;
use mlua::{Lua, Value}; use mlua::{Lua, Table, Value};
use crate::{ use crate::{
base::{self, source_file::SourceElement, Handler}, base::{self, source_file::SourceElement, Handler},
lexical::token::Identifier,
syntax::syntax_tree::expression::LuaCode, syntax::syntax_tree::expression::LuaCode,
transpile::{ transpile::{
error::{LuaRuntimeError, MismatchedTypes, TranspileError, TranspileResult}, error::{
LuaRuntimeError, MismatchedTypes, TranspileError, TranspileResult,
UnknownIdentifier,
},
expression::{ComptimeValue, ExpectedType}, expression::{ComptimeValue, ExpectedType},
Scope, VariableData, Scope, VariableData,
}, },
@ -53,14 +57,8 @@ mod enabled {
) )
}; };
if let Err(err) = self.add_globals(&lua, scope) { self.add_globals(&lua, scope)
let err = TranspileError::LuaRuntimeError(LuaRuntimeError::from_lua_err( .inspect_err(|err| handler.receive(err.clone()))?;
&err,
self.span(),
));
handler.receive(crate::Error::from(err.clone()));
return Err(err);
}
let res = lua let res = lua
.load(self.code()) .load(self.code())
@ -95,111 +93,188 @@ mod enabled {
self.handle_lua_result(lua_result, handler) self.handle_lua_result(lua_result, handler)
} }
fn add_globals(&self, lua: &Lua, scope: &Arc<Scope>) -> mlua::Result<()> { fn add_globals(&self, lua: &Lua, scope: &Arc<Scope>) -> TranspileResult<()> {
let globals = lua.globals(); let globals = lua.globals();
let shulkerscript_globals = { let shulkerscript_globals = self
let table = lua.create_table()?; .get_std_library(lua)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
let (location_path, location_start, location_end) = {
let span = self.span();
let file = span.source_file();
let path = file.path().to_owned();
let start_location = span.start_location();
let end_location = span.end_location().unwrap_or_else(|| {
let line_amount = file.line_amount();
let column = file.get_line(line_amount).expect("line amount used").len();
crate::base::source_file::Location {
line: line_amount,
column,
}
});
(path, start_location, end_location)
};
table.set("file_path", location_path.to_string_lossy())?;
table.set("start_line", location_start.line)?;
table.set("start_column", location_start.column)?;
table.set("end_line", location_end.line)?;
table.set("end_column", location_end.column)?;
table.set("version", crate::VERSION)?;
table
};
if let Some(inputs) = self.inputs() { if let Some(inputs) = self.inputs() {
for x in inputs.elements() { for identifier in inputs.elements() {
let name = x.span.str(); let (name, value) = self.add_input_to_globals(identifier, lua, scope)?;
let value = match scope.get_variable(name).as_deref() { globals
Some(VariableData::MacroParameter { macro_name, .. }) => { .set(name, value)
Value::String(lua.create_string(format!("$({macro_name})"))?) .map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
}
Some(VariableData::Scoreboard { objective }) => {
let table = lua.create_table()?;
table.set("objective", objective.as_str())?;
Value::Table(table)
}
Some(VariableData::ScoreboardValue { objective, target }) => {
let table = lua.create_table()?;
table.set("objective", lua.create_string(objective)?)?;
table.set("target", lua.create_string(target)?)?;
Value::Table(table)
}
Some(VariableData::ScoreboardArray { objective, targets }) => {
let table = lua.create_table()?;
table.set("objective", objective.as_str())?;
let values = lua.create_table_from(
targets
.iter()
.enumerate()
.map(|(i, target)| (i + 1, target.as_str())),
)?;
table.set("targets", values)?;
Value::Table(table)
}
Some(VariableData::BooleanStorage { storage_name, path }) => {
let table = lua.create_table()?;
table.set("storage", lua.create_string(storage_name)?)?;
table.set("path", lua.create_string(path)?)?;
Value::Table(table)
}
Some(VariableData::BooleanStorageArray {
storage_name,
paths,
}) => {
let table = lua.create_table()?;
table.set("storage", storage_name.as_str())?;
let values = lua.create_table_from(
paths
.iter()
.enumerate()
.map(|(i, path)| (i + 1, path.as_str())),
)?;
table.set("paths", values)?;
Value::Table(table)
}
Some(VariableData::Tag { tag_name }) => {
let table = lua.create_table()?;
table.set("name", tag_name.as_str())?;
Value::Table(table)
}
Some(VariableData::Function { .. }) => {
todo!("allow function variable type")
}
None => todo!("throw correct error"),
};
globals.set(name, value)?;
} }
} }
globals.set("shulkerscript", shulkerscript_globals)?; globals
.set("shulkerscript", shulkerscript_globals)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Ok(()) Ok(())
} }
fn get_std_library(&self, lua: &Lua) -> mlua::Result<Table> {
let table = lua.create_table()?;
let (location_path, location_start, location_end) = {
let span = self.span();
let file = span.source_file();
let path = file.path().to_owned();
let start_location = span.start_location();
let end_location = span.end_location().unwrap_or_else(|| {
let line_amount = file.line_amount();
let column = file.get_line(line_amount).expect("line amount used").len();
crate::base::source_file::Location {
line: line_amount,
column,
}
});
(path, start_location, end_location)
};
table.set("file_path", location_path.to_string_lossy())?;
table.set("start_line", location_start.line)?;
table.set("start_column", location_start.column)?;
table.set("end_line", location_end.line)?;
table.set("end_column", location_end.column)?;
table.set("version", crate::VERSION)?;
Ok(table)
}
#[expect(clippy::too_many_lines)]
fn add_input_to_globals<'a>(
&self,
identifier: &'a Identifier,
lua: &Lua,
scope: &Arc<Scope>,
) -> TranspileResult<(&'a str, Value)> {
let name = identifier.span.str();
let value = match scope.get_variable(name).as_deref() {
Some(VariableData::MacroParameter { macro_name, .. }) => Value::String(
lua.create_string(format!("$({macro_name})"))
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
),
Some(VariableData::Scoreboard { objective }) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("objective", objective.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::ScoreboardValue { objective, target }) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"objective",
lua.create_string(objective)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"target",
lua.create_string(target)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::ScoreboardArray { objective, targets }) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("objective", objective.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
let values = lua
.create_table_from(
targets
.iter()
.enumerate()
.map(|(i, target)| (i + 1, target.as_str())),
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("targets", values)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::BooleanStorage { storage_name, path }) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"storage",
lua.create_string(storage_name)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set(
"path",
lua.create_string(path)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?,
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::BooleanStorageArray {
storage_name,
paths,
}) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("storage", storage_name.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
let values = lua
.create_table_from(
paths
.iter()
.enumerate()
.map(|(i, path)| (i + 1, path.as_str())),
)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("paths", values)
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::Tag { tag_name }) => {
let table = lua
.create_table()
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
table
.set("name", tag_name.as_str())
.map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?;
Value::Table(table)
}
Some(VariableData::Function { .. }) => {
todo!("functions are not supported yet");
}
None => {
return Err(TranspileError::UnknownIdentifier(UnknownIdentifier {
identifier: identifier.span(),
}));
}
};
Ok((name, value))
}
fn handle_lua_result( fn handle_lua_result(
&self, &self,
value: Value, value: Value,

27
src/transpile/variables.rs
View File

@ -27,7 +27,10 @@ use crate::{
}; };
use super::{ use super::{
error::{AssignmentError, IllegalAnnotationContent, MismatchedTypes}, error::{
AssignmentError, IllegalAnnotationContent, IllegalIndexing, IllegalIndexingReason,
MismatchedTypes,
},
expression::{ComptimeValue, DataLocation, ExpectedType, StorageType}, expression::{ComptimeValue, DataLocation, ExpectedType, StorageType},
FunctionData, TranspileAnnotationValue, TranspileError, TranspileResult, FunctionData, TranspileAnnotationValue, TranspileError, TranspileResult,
}; };
@ -244,7 +247,9 @@ impl Transpiler {
scope, scope,
handler, handler,
), ),
_ => todo!("declarations other than single not supported yet: {declaration:?}"), _ => todo!(
"declarations other than single and scoreboard not supported yet: {declaration:?}"
),
} }
} }
@ -388,9 +393,23 @@ impl Transpiler {
Some(ComptimeValue::MacroString(s)) => { Some(ComptimeValue::MacroString(s)) => {
todo!("indexing scoreboard with macro string: {s}") todo!("indexing scoreboard with macro string: {s}")
} }
Some(_) => todo!("invalid indexing value"), Some(_) => {
let err = TranspileError::IllegalIndexing(IllegalIndexing {
expression: expression.span(),
reason: IllegalIndexingReason::InvalidComptimeType {
expected: ExpectedType::String,
},
});
handler.receive(err.clone());
return Err(err);
}
None => { None => {
todo!("cannot assign to scoreboard without indexing") let err = TranspileError::AssignmentError(AssignmentError {
identifier: identifier.span(),
message: "Cannot assign to a scoreboard without indexing".to_string(),
});
handler.receive(err.clone());
return Err(err);
} }
}, },
VariableData::Function { .. } | VariableData::MacroParameter { .. } => { VariableData::Function { .. } | VariableData::MacroParameter { .. } => {