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

fix variable declaration parsing

This commit is contained in:
Moritz Hölting 2025-02-25 20:40:54 +01:00
parent 0d0df920ee
commit 38f90e6491
4 changed files with 564 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
src/semantic/mod.rs
View File

@ -304,7 +304,9 @@ impl Semicolon {
Err(error)
}
},
SemicolonStatement::VariableDeclaration(decl) => decl.analyze_semantics(handler),
SemicolonStatement::VariableDeclaration(decl) => {
decl.analyze_semantics(function_names, macro_names, handler)
}
}
}
}
@ -521,61 +523,87 @@ impl VariableDeclaration {
/// Analyzes the semantics of a variable declaration.
pub fn analyze_semantics(
&self,
function_names: &HashSet<String>,
macro_names: &HashSet<String>,
handler: &impl Handler<base::Error>,
) -> Result<(), error::Error> {
match self.expression() {
Expression::Primary(Primary::Integer(num)) => {
if self.variable_type().keyword == KeywordKind::Bool {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
Expression::Primary(Primary::Integer(num.clone())),
));
handler.receive(err.clone());
Err(err)
match self {
Self::Array(array) => array.assignment().as_ref().map_or(Ok(()), |assignment| {
assignment
.expression()
.analyze_semantics(function_names, macro_names, handler)
}),
Self::Single(single) => {
if let Some(assignment) = single.assignment() {
let err = match single.variable_type().keyword {
KeywordKind::Int => !matches!(
assignment.expression(),
// TODO: also allow macro identifier but not macro string literal
Expression::Primary(
Primary::Integer(_) | Primary::Lua(_) | Primary::FunctionCall(_)
)
),
KeywordKind::Bool => !matches!(
assignment.expression(),
Expression::Primary(Primary::Boolean(_) | Primary::Lua(_))
),
_ => false,
};
if err {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
assignment.expression().clone(),
));
handler.receive(err.clone());
return Err(err);
}
assignment
.expression()
.analyze_semantics(function_names, macro_names, handler)
} else {
Ok(())
}
}
Expression::Primary(Primary::Boolean(bool)) => {
if self.variable_type().keyword == KeywordKind::Int {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
Expression::Primary(Primary::Boolean(bool.clone())),
));
handler.receive(err.clone());
Err(err)
Self::Score(score) => {
if let Some((_, assignment)) = score.target_assignment() {
// TODO: also allow macro identifier but not macro string literal
if !matches!(
assignment.expression(),
Expression::Primary(
Primary::Integer(_) | Primary::Lua(_) | Primary::FunctionCall(_)
)
) {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
assignment.expression().clone(),
));
handler.receive(err.clone());
return Err(err);
}
assignment
.expression()
.analyze_semantics(function_names, macro_names, handler)
} else {
Ok(())
}
}
Expression::Primary(Primary::StringLiteral(str)) => {
if matches!(
self.variable_type().keyword,
KeywordKind::Int | KeywordKind::Bool
) {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
Expression::Primary(Primary::StringLiteral(str.clone())),
));
handler.receive(err.clone());
Err(err)
Self::Tag(tag) => {
if let Some((_, assignment)) = tag.target_assignment() {
if !matches!(
assignment.expression(),
Expression::Primary(Primary::Boolean(_) | Primary::Lua(_))
) {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
assignment.expression().clone(),
));
handler.receive(err.clone());
return Err(err);
}
assignment
.expression()
.analyze_semantics(function_names, macro_names, handler)
} else {
Ok(())
}
}
Expression::Primary(Primary::MacroStringLiteral(str)) => {
if matches!(
self.variable_type().keyword,
KeywordKind::Int | KeywordKind::Bool
) {
let err = error::Error::UnexpectedExpression(UnexpectedExpression(
Expression::Primary(Primary::MacroStringLiteral(str.clone())),
));
handler.receive(err.clone());
Err(err)
} else {
Ok(())
}
}
Expression::Primary(_) => Ok(()),
}
}
}

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

@ -3,16 +3,20 @@
pub mod execute_block;
use derive_more::From;
use enum_as_inner::EnumAsInner;
use getset::Getters;
use crate::{
base::{
self,
source_file::{SourceElement, Span},
Handler,
Handler, VoidHandler,
},
lexical::{
token::{CommandLiteral, DocComment, Identifier, Keyword, KeywordKind, Punctuation, Token},
token::{
CommandLiteral, DocComment, Identifier, Integer, Keyword, KeywordKind, Punctuation,
Token,
},
token_stream::Delimiter,
},
syntax::{
@ -23,7 +27,7 @@ use crate::{
use self::execute_block::ExecuteBlock;
use super::expression::Expression;
use super::{expression::Expression, AnyStringLiteral};
/// Represents a statement in the syntax tree.
///
@ -230,7 +234,7 @@ impl Semicolon {
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, From, EnumAsInner)]
pub enum SemicolonStatement {
/// An expression that ends with a semicolon.
Expression(Expression),
@ -252,18 +256,69 @@ impl SourceElement for SemicolonStatement {
/// Syntax Synopsis:
///
/// ```ebnf
/// LuaCode:
/// ('int' | 'bool') identifier '=' Expression ';'
/// VariableDeclaration:
/// SingleVariableDeclaration
/// | ArrayVariableDeclaration
/// | ScoreVariableDeclaration
/// | TagVariableDeclaration
/// ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, From, EnumAsInner)]
#[allow(missing_docs)]
pub enum VariableDeclaration {
Single(SingleVariableDeclaration),
Array(ArrayVariableDeclaration),
Score(ScoreVariableDeclaration),
Tag(TagVariableDeclaration),
}
impl SourceElement for VariableDeclaration {
fn span(&self) -> Span {
match self {
Self::Single(declaration) => declaration.span(),
Self::Array(declaration) => declaration.span(),
Self::Score(declaration) => declaration.span(),
Self::Tag(declaration) => declaration.span(),
}
}
}
impl VariableDeclaration {
/// Get the identifier of the variable declaration
#[must_use]
pub fn identifier(&self) -> &Identifier {
match self {
Self::Single(declaration) => &declaration.identifier,
Self::Array(declaration) => &declaration.identifier,
Self::Score(declaration) => &declaration.identifier,
Self::Tag(declaration) => &declaration.identifier,
}
}
/// Get the type of the variable declaration
#[must_use]
pub fn variable_type(&self) -> &Keyword {
match self {
Self::Single(declaration) => &declaration.variable_type,
Self::Array(declaration) => &declaration.variable_type,
Self::Score(declaration) => &declaration.int_keyword,
Self::Tag(declaration) => &declaration.bool_keyword,
}
}
}
/// Represents a variable assignment.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// VariableDeclarationAssignment:
/// '=' Expression
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct VariableDeclaration {
/// The type of the variable.
#[get = "pub"]
variable_type: Keyword,
/// The identifier of the variable.
#[get = "pub"]
identifier: Identifier,
pub struct VariableDeclarationAssignment {
/// The equals sign of the variable declaration.
#[get = "pub"]
equals: Punctuation,
@ -272,12 +327,265 @@ pub struct VariableDeclaration {
expression: Expression,
}
impl SourceElement for VariableDeclaration {
impl SourceElement for VariableDeclarationAssignment {
fn span(&self) -> Span {
self.equals
.span()
.join(&self.expression.span())
.expect("The span of the variable declaration assignment is invalid.")
}
}
impl VariableDeclarationAssignment {
/// Dissolves the [`VariableDeclarationAssignment`] into its components.
#[must_use]
pub fn dissolve(self) -> (Punctuation, Expression) {
(self.equals, self.expression)
}
}
/// Represents a single variable declaration in the syntax tree.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// SingleVariableDeclaration:
/// ('int' | 'bool') identifier VariableDeclarationAssignment?
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct SingleVariableDeclaration {
/// The type of the variable.
#[get = "pub"]
variable_type: Keyword,
/// The identifier of the variable.
#[get = "pub"]
identifier: Identifier,
/// The optional assignment of the variable.
#[get = "pub"]
assignment: Option<VariableDeclarationAssignment>,
}
impl SourceElement for SingleVariableDeclaration {
fn span(&self) -> Span {
self.variable_type
.span()
.join(&self.expression.span())
.expect("The span of the variable declaration is invalid.")
.join(
&self
.assignment
.as_ref()
.map_or_else(|| self.identifier.span(), SourceElement::span),
)
.expect("The span of the single variable declaration is invalid.")
}
}
impl SingleVariableDeclaration {
/// Dissolves the [`SingleVariableDeclaration`] into its components.
#[must_use]
pub fn dissolve(self) -> (Keyword, Identifier, Option<VariableDeclarationAssignment>) {
(self.variable_type, self.identifier, self.assignment)
}
}
/// Represents an array variable declaration in the syntax tree.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// ArrayVariableDeclaration:
/// ('int' | 'bool') identifier '[' integer ']' VariableDeclarationAssignment?
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct ArrayVariableDeclaration {
/// The type of the variable.
#[get = "pub"]
variable_type: Keyword,
/// The identifier of the variable.
#[get = "pub"]
identifier: Identifier,
/// The opening bracket of the array.
#[get = "pub"]
open_bracket: Punctuation,
/// The array size
#[get = "pub"]
size: Integer,
/// The closing bracket of the array.
#[get = "pub"]
close_bracket: Punctuation,
/// The optional assignment of the variable.
#[get = "pub"]
assignment: Option<VariableDeclarationAssignment>,
}
impl SourceElement for ArrayVariableDeclaration {
fn span(&self) -> Span {
self.variable_type
.span()
.join(
&self
.assignment
.as_ref()
.map_or_else(|| self.close_bracket.span(), SourceElement::span),
)
.expect("The span of the array variable declaration is invalid.")
}
}
impl ArrayVariableDeclaration {
/// Dissolves the [`ArrayVariableDeclaration`] into its components.
#[must_use]
pub fn dissolve(
self,
) -> (
Keyword,
Identifier,
Punctuation,
Integer,
Punctuation,
Option<VariableDeclarationAssignment>,
) {
(
self.variable_type,
self.identifier,
self.open_bracket,
self.size,
self.close_bracket,
self.assignment,
)
}
}
type CriteriaSelection = (Punctuation, AnyStringLiteral, Punctuation);
/// Represents a scoreboard variable declaration in the syntax tree.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// ScoreVariableDeclaration:
/// 'int' ('<' AnyStringLiteral '>')? identifier '[' AnyStringLiteral? ']' VariableDeclarationAssignment?
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct ScoreVariableDeclaration {
/// `int` keyword
#[get = "pub"]
int_keyword: Keyword,
/// The scoreboard criteria
#[get = "pub"]
criteria: Option<CriteriaSelection>,
/// The identifier of the variable.
#[get = "pub"]
identifier: Identifier,
/// Opening bracket of the score variable
#[get = "pub"]
open_bracket: Punctuation,
/// Closing bracket of the score variable
#[get = "pub"]
close_bracket: Punctuation,
/// The optional assignment of the variable.
#[get = "pub"]
target_assignment: Option<(AnyStringLiteral, VariableDeclarationAssignment)>,
}
impl SourceElement for ScoreVariableDeclaration {
fn span(&self) -> Span {
self.int_keyword
.span()
.join(&self.target_assignment.as_ref().map_or_else(
|| self.close_bracket.span(),
|(_, assignment)| assignment.span(),
))
.expect("The span of the score variable declaration is invalid.")
}
}
impl ScoreVariableDeclaration {
/// Dissolves the [`ScoreVariableDeclaration`] into its components.
#[expect(clippy::type_complexity)]
#[must_use]
pub fn dissolve(
self,
) -> (
Keyword,
Option<CriteriaSelection>,
Identifier,
Punctuation,
Punctuation,
Option<(AnyStringLiteral, VariableDeclarationAssignment)>,
) {
(
self.int_keyword,
self.criteria,
self.identifier,
self.open_bracket,
self.close_bracket,
self.target_assignment,
)
}
}
/// Represents a tag variable declaration in the syntax tree.
///
/// Syntax Synopsis:
///
/// ```ebnf
/// TagVariableDeclaration:
/// 'bool' identifier '[' AnyStringLiteral? ']' VariableDeclarationAssignment?
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Getters)]
pub struct TagVariableDeclaration {
/// `bool` keyword
#[get = "pub"]
bool_keyword: Keyword,
/// The identifier of the variable.
#[get = "pub"]
identifier: Identifier,
/// Opening bracket of the score variable
#[get = "pub"]
open_bracket: Punctuation,
/// Closing bracket of the score variable
#[get = "pub"]
close_bracket: Punctuation,
/// The optional assignment of the variable.
#[get = "pub"]
target_assignment: Option<(AnyStringLiteral, VariableDeclarationAssignment)>,
}
impl SourceElement for TagVariableDeclaration {
fn span(&self) -> Span {
self.bool_keyword
.span()
.join(&self.target_assignment.as_ref().map_or_else(
|| self.close_bracket.span(),
|(_, assignment)| assignment.span(),
))
.expect("The span of the tag variable declaration is invalid.")
}
}
impl TagVariableDeclaration {
/// Dissolves the [`TagVariableDeclaration`] into its components.
#[must_use]
pub fn dissolve(
self,
) -> (
Keyword,
Identifier,
Punctuation,
Punctuation,
Option<(AnyStringLiteral, VariableDeclarationAssignment)>,
) {
(
self.bool_keyword,
self.identifier,
self.open_bracket,
self.close_bracket,
self.target_assignment,
)
}
}
@ -430,6 +738,12 @@ impl<'a> Parser<'a> {
&mut self,
handler: &impl Handler<base::Error>,
) -> ParseResult<VariableDeclaration> {
enum IndexingType {
IntegerSize(Integer),
AnyString(AnyStringLiteral),
None,
}
let variable_type = match self.stop_at_significant() {
Reading::Atomic(Token::Keyword(keyword))
if matches!(keyword.keyword, KeywordKind::Int | KeywordKind::Bool) =>
@ -450,21 +764,163 @@ impl<'a> Parser<'a> {
}
};
let criteria_selection = if variable_type.keyword == KeywordKind::Int {
self.try_parse(|p| {
let open = p.parse_punctuation('<', true, &VoidHandler)?;
let criteria = p.parse_any_string_literal(&VoidHandler)?;
let close = p.parse_punctuation('>', true, &VoidHandler)?;
Ok((open, criteria, close))
})
.ok()
} else {
None
};
// read identifier
self.stop_at_significant();
let identifier = self.parse_identifier(handler)?;
// read equals sign
let equals = self.parse_punctuation('=', true, handler)?;
match self.stop_at_significant() {
Reading::IntoDelimited(punc) if punc.punctuation == '[' => {
let tree = self.step_into(
Delimiter::Bracket,
|p| {
let res = match p.stop_at_significant() {
Reading::Atomic(Token::Integer(int)) => {
p.forward();
IndexingType::IntegerSize(int)
}
// read expression
let expression = self.parse_expression(handler)?;
Reading::Atomic(Token::StringLiteral(s)) => {
let selector = AnyStringLiteral::from(s);
p.forward();
IndexingType::AnyString(selector)
}
Reading::Atomic(Token::MacroStringLiteral(s)) => {
let selector = AnyStringLiteral::from(s);
p.forward();
IndexingType::AnyString(selector)
}
Ok(VariableDeclaration {
variable_type,
identifier,
equals,
expression,
})
Reading::DelimitedEnd(punc) if punc.punctuation == ']' => {
IndexingType::None
}
unexpected => {
let err = Error::UnexpectedSyntax(UnexpectedSyntax {
expected: SyntaxKind::Either(&[
SyntaxKind::Integer,
SyntaxKind::AnyStringLiteral,
]),
found: unexpected.into_token(),
});
handler.receive(err.clone());
return Err(err);
}
};
Ok(res)
},
handler,
)?;
let open_bracket = tree.open;
let close_bracket = tree.close;
let inner = tree.tree?;
match inner {
IndexingType::IntegerSize(size) => {
let assignment = self
.try_parse(|p| {
// read equals sign
let equals = p.parse_punctuation('=', true, handler)?;
// read expression
let expression = p.parse_expression(handler)?;
Ok(VariableDeclarationAssignment { equals, expression })
})
.ok();
Ok(VariableDeclaration::Array(ArrayVariableDeclaration {
variable_type,
identifier,
open_bracket,
size,
close_bracket,
assignment,
}))
}
IndexingType::AnyString(selector) => {
let equals = self.parse_punctuation('=', true, handler)?;
let expression = self.parse_expression(handler)?;
let assignment = VariableDeclarationAssignment { equals, expression };
match variable_type.keyword {
KeywordKind::Int => {
Ok(VariableDeclaration::Score(ScoreVariableDeclaration {
int_keyword: variable_type,
criteria: criteria_selection,
identifier,
open_bracket,
close_bracket,
target_assignment: Some((selector, assignment)),
}))
}
KeywordKind::Bool => {
Ok(VariableDeclaration::Tag(TagVariableDeclaration {
bool_keyword: variable_type,
identifier,
open_bracket,
close_bracket,
target_assignment: Some((selector, assignment)),
}))
}
_ => unreachable!(),
}
}
IndexingType::None => match variable_type.keyword {
KeywordKind::Int => {
Ok(VariableDeclaration::Score(ScoreVariableDeclaration {
int_keyword: variable_type,
criteria: criteria_selection,
identifier,
open_bracket,
close_bracket,
target_assignment: None,
}))
}
KeywordKind::Bool => Ok(VariableDeclaration::Tag(TagVariableDeclaration {
bool_keyword: variable_type,
identifier,
open_bracket,
close_bracket,
target_assignment: None,
})),
_ => unreachable!(),
},
}
}
// SingleVariableDeclaration with Assignment
Reading::Atomic(Token::Punctuation(punc)) if punc.punctuation == '=' => {
self.forward();
let equals = punc;
let expression = self.parse_expression(handler)?;
let assignment = VariableDeclarationAssignment { equals, expression };
Ok(VariableDeclaration::Single(SingleVariableDeclaration {
variable_type,
identifier,
assignment: Some(assignment),
}))
}
// SingleVariableDeclaration without Assignment
_ => Ok(VariableDeclaration::Single(SingleVariableDeclaration {
variable_type,
identifier,
assignment: None,
})),
}
}
}

20
src/transpile/transpiler.rs
View File

@ -21,7 +21,7 @@ use crate::{
program::{Namespace, ProgramFile},
statement::{
execute_block::{Conditional, Else, ExecuteBlock, ExecuteBlockHead, ExecuteBlockTail},
Statement,
SemicolonStatement, Statement,
},
},
transpile::error::MissingFunctionDeclaration,
@ -520,15 +520,15 @@ impl Transpiler {
Statement::Semicolon(semi) => match semi.statement() {
#[expect(clippy::match_wildcard_for_single_variants)]
SemicolonStatement::Expression(expr) => match expr {
Expression::Primary(Primary::FunctionCall(func)) => {
self.transpile_function_call(func, handler).map(Some)
}
unexpected => {
let error = TranspileError::UnexpectedExpression(UnexpectedExpression(
unexpected.clone(),
));
handler.receive(error.clone());
Err(error)
Expression::Primary(Primary::FunctionCall(func)) => {
self.transpile_function_call(func, handler).map(Some)
}
unexpected => {
let error = TranspileError::UnexpectedExpression(UnexpectedExpression(
unexpected.clone(),
));
handler.receive(error.clone());
Err(error)
}
},
SemicolonStatement::VariableDeclaration(_) => {

4
src/transpile/util.rs
View File

@ -47,11 +47,11 @@ pub fn identifier_to_macro(ident: &str) -> std::borrow::Cow<str> {
if ident.contains("__")
|| ident
.chars()
.any(|c| !(c == '_' && c.is_ascii_alphanumeric()))
.any(|c| c == '_' || !c.is_ascii_alphanumeric())
{
let new_ident = ident
.chars()
.filter(|c| *c == '_' || c.is_ascii_alphanumeric())
.filter(|c| *c != '_' && c.is_ascii_alphanumeric())
.collect::<String>();
let chksum = md5::hash(ident).to_hex_lowercase();