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

change function transpilation to use scope instead of separate map

This commit is contained in:
Moritz Hölting 2025-02-26 13:05:59 +01:00
parent a07f16f283
commit 9279e52c00
3 changed files with 188 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/transpile/error.rs
View File

@ -1,6 +1,6 @@
//! Errors that can occur during transpilation. //! Errors that can occur during transpilation.
use std::{collections::BTreeMap, fmt::Display}; use std::{fmt::Display, sync::Arc};
use getset::Getters; use getset::Getters;
use itertools::Itertools; use itertools::Itertools;
@ -13,7 +13,10 @@ use crate::{
semantic::error::{ConflictingFunctionNames, InvalidFunctionArguments, UnexpectedExpression}, semantic::error::{ConflictingFunctionNames, InvalidFunctionArguments, UnexpectedExpression},
}; };
use super::FunctionData; use super::{
variables::{Scope, VariableType},
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)]
@ -47,20 +50,21 @@ pub struct MissingFunctionDeclaration {
impl MissingFunctionDeclaration { impl MissingFunctionDeclaration {
#[cfg_attr(not(feature = "shulkerbox"), expect(unused))] #[cfg_attr(not(feature = "shulkerbox"), expect(unused))]
pub(super) fn from_context( pub(super) fn from_scope(identifier_span: Span, scope: &Arc<Scope>) -> Self {
identifier_span: Span,
functions: &BTreeMap<(String, String), FunctionData>,
) -> Self {
let own_name = identifier_span.str(); let own_name = identifier_span.str();
let own_program_identifier = identifier_span.source_file().identifier(); let alternatives = scope
let alternatives = functions .get_variables()
.read()
.unwrap()
.iter() .iter()
.filter_map(|((program_identifier, function_name), data)| { .filter_map(|(name, value)| {
let normalized_distance = let data = match value.as_ref() {
strsim::normalized_damerau_levenshtein(own_name, function_name); VariableType::Function { function_data, .. } => function_data,
(program_identifier == own_program_identifier _ => return None,
&& (normalized_distance > 0.8 };
|| strsim::damerau_levenshtein(own_name, function_name) < 3))
let normalized_distance = strsim::normalized_damerau_levenshtein(own_name, name);
(normalized_distance > 0.8 || strsim::damerau_levenshtein(own_name, name) < 3)
.then_some((normalized_distance, data)) .then_some((normalized_distance, data))
}) })
.sorted_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal)) .sorted_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal))

241
src/transpile/transpiler.rs
View File

@ -4,6 +4,7 @@ use chksum_md5 as md5;
use std::{ use std::{
collections::{BTreeMap, HashMap}, collections::{BTreeMap, HashMap},
ops::Deref, ops::Deref,
sync::{Arc, OnceLock},
}; };
use shulkerbox::datapack::{self, Command, Datapack, Execute}; use shulkerbox::datapack::{self, Command, Datapack, Execute};
@ -37,10 +38,10 @@ use super::{
#[derive(Debug)] #[derive(Debug)]
pub struct Transpiler { pub struct Transpiler {
datapack: shulkerbox::datapack::Datapack, datapack: shulkerbox::datapack::Datapack,
/// Top-level [`Scope`] for each program identifier
scopes: BTreeMap<String, Arc<Scope<'static>>>,
/// Key: (program identifier, function name) /// Key: (program identifier, function name)
functions: BTreeMap<(String, String), FunctionData>, functions: BTreeMap<(String, String), FunctionData>,
/// Key: (program identifier, function name), Value: (function location, public)
function_locations: HashMap<(String, String), (String, bool)>,
/// Key: alias, Value: target /// Key: alias, Value: target
aliases: HashMap<(String, String), (String, String)>, aliases: HashMap<(String, String), (String, String)>,
} }
@ -51,8 +52,8 @@ impl Transpiler {
pub fn new(pack_format: u8) -> Self { pub fn new(pack_format: u8) -> Self {
Self { Self {
datapack: shulkerbox::datapack::Datapack::new(pack_format), datapack: shulkerbox::datapack::Datapack::new(pack_format),
scopes: BTreeMap::new(),
functions: BTreeMap::new(), functions: BTreeMap::new(),
function_locations: HashMap::new(),
aliases: HashMap::new(), aliases: HashMap::new(),
} }
} }
@ -74,10 +75,18 @@ impl Transpiler {
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> Result<(), TranspileError> { ) -> Result<(), TranspileError> {
tracing::trace!("Transpiling program declarations"); tracing::trace!("Transpiling program declarations");
let scope = Scope::new();
for program in programs { for program in programs {
let program_identifier = program
.namespace()
.span()
.source_file()
.identifier()
.clone();
let scope = self
.scopes
.entry(program_identifier)
.or_insert_with(Scope::new)
.to_owned();
self.transpile_program_declarations(program, &scope, handler); self.transpile_program_declarations(program, &scope, handler);
} }
@ -101,6 +110,11 @@ impl Transpiler {
); );
for identifier_span in always_transpile_functions { for identifier_span in always_transpile_functions {
let scope = self
.scopes
.entry(identifier_span.source_file().identifier().to_owned())
.or_insert_with(Scope::new)
.to_owned();
self.get_or_transpile_function(&identifier_span, None, &scope, handler)?; self.get_or_transpile_function(&identifier_span, None, &scope, handler)?;
} }
@ -111,7 +125,7 @@ impl Transpiler {
fn transpile_program_declarations( fn transpile_program_declarations(
&mut self, &mut self,
program: &ProgramFile, program: &ProgramFile,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) { ) {
let namespace = program.namespace(); let namespace = program.namespace();
@ -127,7 +141,7 @@ impl Transpiler {
&mut self, &mut self,
declaration: &Declaration, declaration: &Declaration,
namespace: &Namespace, namespace: &Namespace,
_scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) { ) {
let program_identifier = declaration.span().source_file().identifier().clone(); let program_identifier = declaration.span().source_file().identifier().clone();
@ -148,25 +162,31 @@ impl Transpiler {
) )
}) })
.collect(); .collect();
self.functions.insert( let function_data = FunctionData {
(program_identifier, name), namespace: namespace.namespace_name().str_content().to_string(),
FunctionData { identifier_span: identifier_span.clone(),
namespace: namespace.namespace_name().str_content().to_string(), parameters: function
identifier_span: identifier_span.clone(), .parameters()
parameters: function .as_ref()
.parameters() .map(|l| {
.as_ref() l.elements()
.map(|l| { .map(|i| i.span.str().to_string())
l.elements() .collect::<Vec<_>>()
.map(|i| i.span.str().to_string()) })
.collect::<Vec<_>>() .unwrap_or_default(),
}) statements,
.unwrap_or_default(), public: function.is_public(),
statements, annotations,
public: function.is_public(), };
annotations, scope.set_variable(
&name,
VariableType::Function {
function_data: function_data.clone(),
path: OnceLock::new(),
}, },
); );
self.functions
.insert((program_identifier, name), function_data);
} }
Declaration::Import(import) => { Declaration::Import(import) => {
let path = import.module().str_content(); let path = import.module().str_content();
@ -220,7 +240,7 @@ impl Transpiler {
&mut self, &mut self,
identifier_span: &Span, identifier_span: &Span,
arguments: Option<&[&Expression]>, arguments: Option<&[&Expression]>,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<(String, Option<BTreeMap<String, String>>)> { ) -> TranspileResult<(String, Option<BTreeMap<String, String>>)> {
let program_identifier = identifier_span.source_file().identifier(); let program_identifier = identifier_span.source_file().identifier();
@ -229,71 +249,57 @@ impl Transpiler {
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 = { let already_transpiled = match scope
let locations = &self.function_locations; .get_variable(identifier_span.str())
locations .expect("called function should be in scope")
.get(&program_query) .as_ref()
.or_else(|| { {
alias_query VariableType::Function { path, .. } => Some(path.get().is_some()),
.clone() _ => None,
.and_then(|q| locations.get(&q).filter(|(_, p)| *p)) }
}) .expect("called variable should be of type function");
.is_some()
let function_data = scope
.get_variable(identifier_span.str())
.or_else(|| {
alias_query
.clone()
.and_then(|(alias_program_identifier, alias_function_name)| {
self.scopes
.get(&alias_program_identifier)
.and_then(|s| s.get_variable(&alias_function_name))
})
})
.ok_or_else(|| {
let error = TranspileError::MissingFunctionDeclaration(
MissingFunctionDeclaration::from_scope(identifier_span.clone(), scope),
);
handler.receive(error.clone());
error
})?;
let (function_data, function_path) = match function_data.as_ref() {
VariableType::Function {
function_data,
path,
} => (function_data, path),
_ => todo!("correctly throw error on wrong type"),
}; };
if !already_transpiled { if !already_transpiled {
tracing::trace!("Function not transpiled yet, transpiling."); tracing::trace!("Function not transpiled yet, transpiling.");
let function_scope = scope.new_child(); let function_scope = Scope::with_parent(scope);
let statements = { for (i, param) in function_data.parameters.iter().enumerate() {
let functions = &self.functions; function_scope.set_variable(param, VariableType::FunctionArgument { index: i });
let function_data = functions }
.get(&program_query)
.or_else(|| {
alias_query
.clone()
.and_then(|q| functions.get(&q).filter(|f| f.public))
})
.ok_or_else(|| {
let error = TranspileError::MissingFunctionDeclaration(
MissingFunctionDeclaration::from_context(
identifier_span.clone(),
functions,
),
);
handler.receive(error.clone());
error
})?;
for (i, param) in function_data.parameters.iter().enumerate() { let statements = function_data.statements.clone();
function_scope.set_variable(param, VariableType::FunctionArgument { index: i });
}
function_data.statements.clone()
};
let commands = let commands =
self.transpile_function(&statements, program_identifier, &function_scope, handler)?; self.transpile_function(&statements, program_identifier, &function_scope, handler)?;
let functions = &self.functions;
let function_data = functions
.get(&program_query)
.or_else(|| {
alias_query
.clone()
.and_then(|q| functions.get(&q).filter(|f| f.public))
})
.ok_or_else(|| {
let error = TranspileError::MissingFunctionDeclaration(
MissingFunctionDeclaration::from_context(
identifier_span.clone(),
functions,
),
);
handler.receive(error.clone());
error
})?;
let modified_name = function_data let modified_name = function_data
.annotations .annotations
.get("deobfuscate") .get("deobfuscate")
@ -333,55 +339,30 @@ impl Transpiler {
self.datapack.add_load(&function_location); self.datapack.add_load(&function_location);
} }
self.function_locations.insert( match scope
( .get_variable(identifier_span.str())
program_identifier.to_string(), .expect("variable should be in scope if called")
identifier_span.str().to_string(), .as_ref()
), {
(function_location, function_data.public), VariableType::Function { path, .. } => {
); path.set(function_location.clone()).unwrap();
}
_ => todo!("implement error handling")
}
} }
let parameters = { let parameters = function_data.parameters.clone();
let function_data = self
.functions
.get(&program_query)
.or_else(|| {
alias_query
.clone()
.and_then(|q| self.functions.get(&q).filter(|f| f.public))
})
.ok_or_else(|| {
let error = TranspileError::MissingFunctionDeclaration(
MissingFunctionDeclaration::from_context(
identifier_span.clone(),
&self.functions,
),
);
handler.receive(error.clone());
error
})?;
function_data.parameters.clone() let function_location = function_path
}; .get()
let function_location = self
.function_locations
.get(&program_query)
.or_else(|| {
alias_query.and_then(|q| self.function_locations.get(&q).filter(|(_, p)| *p))
})
.ok_or_else(|| { .ok_or_else(|| {
let error = TranspileError::MissingFunctionDeclaration( let error = TranspileError::MissingFunctionDeclaration(
MissingFunctionDeclaration::from_context( MissingFunctionDeclaration::from_scope(identifier_span.clone(), scope),
identifier_span.clone(),
&self.functions,
),
); );
handler.receive(error.clone()); handler.receive(error.clone());
error error
}) })
.map(|(s, _)| s.to_owned())?; .map(|s| s.to_owned())?;
let arg_count = arguments.map(<[&Expression]>::len); let arg_count = arguments.map(<[&Expression]>::len);
if arg_count.is_some_and(|arg_count| arg_count != parameters.len()) { if arg_count.is_some_and(|arg_count| arg_count != parameters.len()) {
@ -440,7 +421,7 @@ impl Transpiler {
&mut self, &mut self,
statements: &[Statement], statements: &[Statement],
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Vec<Command>> { ) -> TranspileResult<Vec<Command>> {
let mut errors = Vec::new(); let mut errors = Vec::new();
@ -466,7 +447,7 @@ impl Transpiler {
&mut self, &mut self,
statement: &Statement, statement: &Statement,
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Command>> { ) -> TranspileResult<Option<Command>> {
match statement { match statement {
@ -505,7 +486,7 @@ impl Transpiler {
unreachable!("Only literal commands are allowed in functions at this time.") unreachable!("Only literal commands are allowed in functions at this time.")
} }
Statement::ExecuteBlock(execute) => { Statement::ExecuteBlock(execute) => {
let child_scope = scope.new_child(); let child_scope = Scope::with_parent(scope);
self.transpile_execute_block(execute, program_identifier, &child_scope, handler) self.transpile_execute_block(execute, program_identifier, &child_scope, handler)
} }
Statement::DocComment(doccomment) => { Statement::DocComment(doccomment) => {
@ -513,7 +494,7 @@ impl Transpiler {
Ok(Some(Command::Comment(content.to_string()))) Ok(Some(Command::Comment(content.to_string())))
} }
Statement::Grouping(group) => { Statement::Grouping(group) => {
let child_scope = scope.new_child(); let child_scope = Scope::with_parent(scope);
let statements = group.block().statements(); let statements = group.block().statements();
let mut errors = Vec::new(); let mut errors = Vec::new();
let commands = statements let commands = statements
@ -580,7 +561,7 @@ impl Transpiler {
fn transpile_function_call( fn transpile_function_call(
&mut self, &mut self,
func: &FunctionCall, func: &FunctionCall,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Command> { ) -> TranspileResult<Command> {
let arguments = func let arguments = func
@ -616,7 +597,7 @@ impl Transpiler {
&mut self, &mut self,
execute: &ExecuteBlock, execute: &ExecuteBlock,
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Command>> { ) -> TranspileResult<Option<Command>> {
self.transpile_execute_block_internal(execute, program_identifier, scope, handler) self.transpile_execute_block_internal(execute, program_identifier, scope, handler)
@ -627,7 +608,7 @@ impl Transpiler {
&mut self, &mut self,
execute: &ExecuteBlock, execute: &ExecuteBlock,
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> { ) -> TranspileResult<Option<Execute>> {
match execute { match execute {
@ -715,7 +696,7 @@ impl Transpiler {
then: Execute, then: Execute,
el: Option<&Else>, el: Option<&Else>,
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> { ) -> TranspileResult<Option<Execute>> {
let (_, cond) = cond.clone().dissolve(); let (_, cond) = cond.clone().dissolve();
@ -767,7 +748,7 @@ impl Transpiler {
head: &ExecuteBlockHead, head: &ExecuteBlockHead,
tail: Option<Execute>, tail: Option<Execute>,
program_identifier: &str, program_identifier: &str,
scope: &Scope, scope: &Arc<Scope>,
handler: &impl Handler<base::Error>, handler: &impl Handler<base::Error>,
) -> TranspileResult<Option<Execute>> { ) -> TranspileResult<Option<Execute>> {
Ok(match head { Ok(match head {

101
src/transpile/variables.rs
View File

@ -1,11 +1,20 @@
#![expect(unused)] #![expect(unused)]
use std::{collections::HashMap, sync::RwLock}; use std::{
collections::HashMap,
sync::{Arc, OnceLock, RwLock},
};
use super::Transpiler; use strum::EnumIs;
#[derive(Debug, Clone)] use super::{FunctionData, Transpiler};
#[derive(Debug, Clone, EnumIs)]
pub enum VariableType { pub enum VariableType {
Function {
function_data: FunctionData,
path: OnceLock<String>,
},
FunctionArgument { FunctionArgument {
index: usize, index: usize,
}, },
@ -35,28 +44,30 @@ pub enum VariableType {
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub struct Scope<'a> { pub struct Scope<'a> {
parent: Option<&'a Scope<'a>>, parent: Option<&'a Arc<Self>>,
variables: RwLock<HashMap<String, VariableType>>, variables: RwLock<HashMap<String, Arc<VariableType>>>,
} }
impl<'a> Scope<'a> { impl<'a> Scope<'a> {
pub fn new() -> Self { pub fn new() -> Arc<Self> {
Self::default() Arc::new(Self::default())
} }
pub fn new_child(&'a self) -> Self { pub fn with_parent(parent: &'a Arc<Self>) -> Arc<Self> {
Self { Arc::new(Self {
parent: Some(self), parent: Some(parent),
variables: RwLock::new(HashMap::new()), ..Default::default()
} })
} }
pub fn get_variable(&self, name: &str) -> Option<VariableType> { pub fn get_variable(&self, name: &str) -> Option<Arc<VariableType>> {
let var = self.variables.read().unwrap().get(name).cloned(); let var = self.variables.read().unwrap().get(name).cloned();
if var.is_some() { if var.is_some() {
var var
} else { } else {
self.parent.and_then(|parent| parent.get_variable(name)) self.parent
.as_ref()
.and_then(|parent| parent.get_variable(name))
} }
} }
@ -64,11 +75,15 @@ impl<'a> Scope<'a> {
self.variables self.variables
.write() .write()
.unwrap() .unwrap()
.insert(name.to_string(), var); .insert(name.to_string(), Arc::new(var));
} }
pub fn get_parent(&self) -> Option<&'a Self> { pub fn get_variables(&self) -> &RwLock<HashMap<String, Arc<VariableType>>> {
self.parent &self.variables
}
pub fn get_parent(&self) -> Option<Arc<Self>> {
self.parent.map(|v| v.clone())
} }
} }
@ -81,37 +96,39 @@ mod tests {
#[test] #[test]
fn test_scope() { fn test_scope() {
let scope = Scope::new(); let scope = Scope::new();
{ scope.set_variable(
let mut variables = scope.variables.write().unwrap(); "test",
variables.insert( VariableType::Scoreboard {
"test".to_string(), objective: "test".to_string(),
VariableType::Scoreboard { },
objective: "test".to_string(), );
}, if let Some(var) = scope.get_variable("test") {
); match var.as_ref() {
} VariableType::Scoreboard { objective } => assert_eq!(objective, "test"),
match scope.get_variable("test") { _ => panic!("Incorrect Variable"),
Some(VariableType::Scoreboard { objective }) => assert_eq!(objective, "test"), }
_ => panic!("Incorrect Variable"), } else {
panic!("Variable missing")
} }
} }
#[test] #[test]
fn test_parent() { fn test_parent() {
let scope = Scope::new(); let scope = Scope::new();
{ scope.set_variable(
let mut variables = scope.variables.write().unwrap(); "test",
variables.insert( VariableType::Scoreboard {
"test".to_string(), objective: "test".to_string(),
VariableType::Scoreboard { },
objective: "test".to_string(), );
}, let child = Scope::with_parent(&scope);
); if let Some(var) = child.get_variable("test") {
} match var.as_ref() {
let child = scope.new_child(); VariableType::Scoreboard { objective } => assert_eq!(objective, "test"),
match child.get_variable("test") { _ => panic!("Incorrect Variable"),
Some(VariableType::Scoreboard { objective }) => assert_eq!(objective, "test"), }
_ => panic!("Incorrect Variable"), } else {
panic!("Variable missing")
} }
} }
} }