diff --git a/src/semantic/mod.rs b/src/semantic/mod.rs index 783fea5..2b97797 100644 --- a/src/semantic/mod.rs +++ b/src/semantic/mod.rs @@ -20,7 +20,10 @@ use crate::{ AnyStringLiteral, }, transpile::{ - error::{AssignmentError, IllegalIndexing, MismatchedTypes, UnknownIdentifier}, + error::{ + AssignmentError, IllegalIndexing, IllegalIndexingReason, MismatchedTypes, + UnknownIdentifier, + }, expression::{ExpectedType, ValueType}, }, }; @@ -380,10 +383,7 @@ impl Assignment { if let Some(expected) = valid_index { let err = error::Error::IllegalIndexing(IllegalIndexing { expression: index.span(), - reason: - crate::transpile::error::IllegalIndexingReason::InvalidComptimeType { - expected, - }, + reason: IllegalIndexingReason::InvalidComptimeType { expected }, }); handler.receive(err.clone()); return Err(err); @@ -513,6 +513,7 @@ impl Expression { } impl Primary { + #[expect(clippy::too_many_lines)] fn analyze_semantics( &self, scope: &SemanticScope, @@ -545,9 +546,58 @@ impl Primary { } } Self::Indexed(indexed) => { - // TODO: check if target is indexable and can be indexed with given type - indexed.object().analyze_semantics(scope, handler)?; - indexed.index().analyze_semantics(scope, handler) + if let Self::Identifier(ident) = indexed.object().as_ref() { + let variable_type = scope.get_variable(ident.span.str()); + match variable_type { + Some(VariableType::BooleanStorageArray | VariableType::ScoreboardArray) => { + if !indexed + .index() + .can_yield_type_semantics(ValueType::Integer, scope) + { + let err = error::Error::IllegalIndexing(IllegalIndexing { + reason: IllegalIndexingReason::InvalidComptimeType { + expected: ExpectedType::Integer, + }, + expression: indexed.index().span(), + }); + handler.receive(err.clone()); + return Err(err); + } + } + Some(VariableType::Tag | VariableType::Scoreboard) => { + if !indexed + .index() + .can_yield_type_semantics(ValueType::String, scope) + { + let err = error::Error::IllegalIndexing(IllegalIndexing { + reason: IllegalIndexingReason::InvalidComptimeType { + expected: ExpectedType::String, + }, + expression: indexed.index().span(), + }); + handler.receive(err.clone()); + return Err(err); + } + } + _ => { + let err = error::Error::IllegalIndexing(IllegalIndexing { + reason: IllegalIndexingReason::NotIndexable, + expression: indexed.object().span(), + }); + handler.receive(err.clone()); + return Err(err); + } + } + indexed.object().analyze_semantics(scope, handler)?; + indexed.index().analyze_semantics(scope, handler) + } else { + let err = error::Error::IllegalIndexing(IllegalIndexing { + reason: IllegalIndexingReason::NotIdentifier, + expression: indexed.object().span(), + }); + handler.receive(err.clone()); + Err(err) + } } Self::Parenthesized(expr) => expr.analyze_semantics(scope, handler), Self::Prefix(prefixed) => match prefixed.operator() { @@ -730,10 +780,11 @@ impl Binary { impl LuaCode { #[expect(clippy::unused_self, clippy::unnecessary_wraps)] + #[cfg_attr(feature = "lua", expect(unused_variables))] fn analyze_semantics( &self, _scope: &SemanticScope, - _handler: &impl Handler, + handler: &impl Handler, ) -> Result<(), error::Error> { cfg_if::cfg_if! { if #[cfg(feature = "lua")] { diff --git a/src/transpile/expression.rs b/src/transpile/expression.rs index cf8cacc..72cdb7d 100644 --- a/src/transpile/expression.rs +++ b/src/transpile/expression.rs @@ -1,15 +1,8 @@ //! The expression transpiler. -use std::{fmt::Display, string::ToString, sync::Arc}; +use std::{fmt::Display, string::ToString}; -use super::{util::MacroString, Scope, VariableData}; -use crate::{ - base::{self, Handler, VoidHandler}, - lexical::token::MacroStringLiteralPart, - syntax::syntax_tree::expression::{ - Binary, BinaryOperator, Expression, PrefixOperator, Primary, - }, -}; +use super::util::MacroString; #[cfg(feature = "shulkerbox")] use enum_as_inner::EnumAsInner; @@ -20,16 +13,22 @@ use shulkerbox::prelude::{Command, Condition, Execute}; #[cfg(feature = "shulkerbox")] use super::{ error::{IllegalIndexing, IllegalIndexingReason, MismatchedTypes, UnknownIdentifier}, - TranspileResult, Transpiler, + Scope, TranspileResult, Transpiler, VariableData, }; #[cfg(feature = "shulkerbox")] use crate::{ - base::source_file::SourceElement, + base::{self, source_file::SourceElement, Handler, VoidHandler}, + lexical::token::MacroStringLiteralPart, + syntax::syntax_tree::expression::{ + Binary, BinaryOperator, Expression, PrefixOperator, Primary, + }, transpile::{ error::{FunctionArgumentsNotAllowed, MissingValue}, TranspileError, }, }; +#[cfg(feature = "shulkerbox")] +use std::sync::Arc; /// Compile-time evaluated value #[allow(missing_docs)] @@ -227,6 +226,7 @@ pub enum ExtendedCondition { Comptime(bool), } +#[cfg(feature = "shulkerbox")] impl Expression { /// Returns whether the expression can yield a certain type. #[must_use] @@ -251,6 +251,7 @@ impl Expression { } } +#[cfg(feature = "shulkerbox")] impl Primary { /// Returns whether the primary can yield a certain type. #[must_use] @@ -386,6 +387,7 @@ impl Primary { } } +#[cfg(feature = "shulkerbox")] impl Binary { /// Returns whether the binary can yield a certain type. #[must_use] diff --git a/src/transpile/lua.rs b/src/transpile/lua.rs index db99db7..bc792d0 100644 --- a/src/transpile/lua.rs +++ b/src/transpile/lua.rs @@ -1,6 +1,6 @@ //! Executes the Lua code and returns the resulting command. -#[cfg(feature = "lua")] +#[cfg(all(feature = "lua", feature = "shulkerbox"))] mod enabled { use std::sync::Arc; @@ -378,7 +378,7 @@ mod enabled { } } -#[cfg(not(feature = "lua"))] +#[cfg(all(not(feature = "lua"), feature = "shulkerbox"))] mod disabled { use std::sync::Arc; diff --git a/src/transpile/mod.rs b/src/transpile/mod.rs index e610707..ea9d503 100644 --- a/src/transpile/mod.rs +++ b/src/transpile/mod.rs @@ -38,9 +38,12 @@ pub mod internal_functions; #[doc(hidden)] #[cfg(feature = "shulkerbox")] pub mod function; +#[doc(inline)] +#[cfg(feature = "shulkerbox")] pub use function::TranspiledFunctionArguments; mod variables; +#[cfg(feature = "shulkerbox")] pub use variables::{Scope, VariableData}; pub mod util; diff --git a/src/transpile/variables.rs b/src/transpile/variables.rs index c7d78e3..dd88872 100644 --- a/src/transpile/variables.rs +++ b/src/transpile/variables.rs @@ -33,14 +33,14 @@ use super::{ MismatchedTypes, }, expression::{ComptimeValue, DataLocation, ExpectedType, StorageType}, - internal_functions::InternalFunction, FunctionData, TranspileAnnotationValue, TranspileError, TranspileResult, }; #[cfg(feature = "shulkerbox")] -use super::Transpiler; +use super::{internal_functions::InternalFunction, Transpiler}; /// Stores the data required to access a variable. +#[cfg(feature = "shulkerbox")] #[derive(Debug, Clone, EnumAsInner)] pub enum VariableData { /// A function. @@ -122,6 +122,7 @@ impl<'a> From<&'a AssignmentDestination> for TranspileAssignmentTarget<'a> { } /// A scope that stores variables. +#[cfg(feature = "shulkerbox")] #[derive(Default)] pub struct Scope<'a> { /// Parent scope where variables are inherited from. @@ -132,6 +133,7 @@ pub struct Scope<'a> { shadowed: RwLock>, } +#[cfg(feature = "shulkerbox")] impl<'a> Scope<'a> { /// Creates a new scope. #[must_use] @@ -226,6 +228,7 @@ impl<'a> Scope<'a> { } } +#[cfg(feature = "shulkerbox")] impl Debug for Scope<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { struct VariableWrapper<'a>(&'a RwLock>>); diff --git a/src/util.rs b/src/util.rs index 8ec9a87..af21380 100644 --- a/src/util.rs +++ b/src/util.rs @@ -107,7 +107,7 @@ pub fn identifier_to_scoreboard_target(ident: &str) -> std::borrow::Cow { let new_ident = ident .chars() .map(|c| { - if *c != '_' && !c.is_ascii_alphanumeric() { + if c != '_' && !c.is_ascii_alphanumeric() { '_' } else { c