From 9279e52c0003aab5ab27973e1237da4e2e484b62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Moritz=20H=C3=B6lting?= <87192362+moritz-hoelting@users.noreply.github.com> Date: Wed, 26 Feb 2025 13:05:59 +0100 Subject: [PATCH] change function transpilation to use scope instead of separate map --- src/transpile/error.rs | 32 ++--- src/transpile/transpiler.rs | 241 +++++++++++++++++------------------- src/transpile/variables.rs | 101 ++++++++------- 3 files changed, 188 insertions(+), 186 deletions(-) diff --git a/src/transpile/error.rs b/src/transpile/error.rs index 2dd1b9c..394c4d7 100644 --- a/src/transpile/error.rs +++ b/src/transpile/error.rs @@ -1,6 +1,6 @@ //! Errors that can occur during transpilation. -use std::{collections::BTreeMap, fmt::Display}; +use std::{fmt::Display, sync::Arc}; use getset::Getters; use itertools::Itertools; @@ -13,7 +13,10 @@ use crate::{ semantic::error::{ConflictingFunctionNames, InvalidFunctionArguments, UnexpectedExpression}, }; -use super::FunctionData; +use super::{ + variables::{Scope, VariableType}, + FunctionData, +}; /// Errors that can occur during transpilation. #[allow(clippy::module_name_repetitions, missing_docs)] @@ -47,20 +50,21 @@ pub struct MissingFunctionDeclaration { impl MissingFunctionDeclaration { #[cfg_attr(not(feature = "shulkerbox"), expect(unused))] - pub(super) fn from_context( - identifier_span: Span, - functions: &BTreeMap<(String, String), FunctionData>, - ) -> Self { + pub(super) fn from_scope(identifier_span: Span, scope: &Arc) -> Self { let own_name = identifier_span.str(); - let own_program_identifier = identifier_span.source_file().identifier(); - let alternatives = functions + let alternatives = scope + .get_variables() + .read() + .unwrap() .iter() - .filter_map(|((program_identifier, function_name), data)| { - let normalized_distance = - strsim::normalized_damerau_levenshtein(own_name, function_name); - (program_identifier == own_program_identifier - && (normalized_distance > 0.8 - || strsim::damerau_levenshtein(own_name, function_name) < 3)) + .filter_map(|(name, value)| { + let data = match value.as_ref() { + VariableType::Function { function_data, .. } => function_data, + _ => return None, + }; + + 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)) }) .sorted_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal)) diff --git a/src/transpile/transpiler.rs b/src/transpile/transpiler.rs index a2c9048..482d87c 100644 --- a/src/transpile/transpiler.rs +++ b/src/transpile/transpiler.rs @@ -4,6 +4,7 @@ use chksum_md5 as md5; use std::{ collections::{BTreeMap, HashMap}, ops::Deref, + sync::{Arc, OnceLock}, }; use shulkerbox::datapack::{self, Command, Datapack, Execute}; @@ -37,10 +38,10 @@ use super::{ #[derive(Debug)] pub struct Transpiler { datapack: shulkerbox::datapack::Datapack, + /// Top-level [`Scope`] for each program identifier + scopes: BTreeMap>>, /// Key: (program identifier, function name) 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 aliases: HashMap<(String, String), (String, String)>, } @@ -51,8 +52,8 @@ impl Transpiler { pub fn new(pack_format: u8) -> Self { Self { datapack: shulkerbox::datapack::Datapack::new(pack_format), + scopes: BTreeMap::new(), functions: BTreeMap::new(), - function_locations: HashMap::new(), aliases: HashMap::new(), } } @@ -74,10 +75,18 @@ impl Transpiler { handler: &impl Handler, ) -> Result<(), TranspileError> { tracing::trace!("Transpiling program declarations"); - - let scope = Scope::new(); - 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); } @@ -101,6 +110,11 @@ impl Transpiler { ); 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)?; } @@ -111,7 +125,7 @@ impl Transpiler { fn transpile_program_declarations( &mut self, program: &ProgramFile, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) { let namespace = program.namespace(); @@ -127,7 +141,7 @@ impl Transpiler { &mut self, declaration: &Declaration, namespace: &Namespace, - _scope: &Scope, + scope: &Arc, handler: &impl Handler, ) { let program_identifier = declaration.span().source_file().identifier().clone(); @@ -148,25 +162,31 @@ impl Transpiler { ) }) .collect(); - self.functions.insert( - (program_identifier, name), - FunctionData { - namespace: namespace.namespace_name().str_content().to_string(), - identifier_span: identifier_span.clone(), - parameters: function - .parameters() - .as_ref() - .map(|l| { - l.elements() - .map(|i| i.span.str().to_string()) - .collect::>() - }) - .unwrap_or_default(), - statements, - public: function.is_public(), - annotations, + let function_data = FunctionData { + namespace: namespace.namespace_name().str_content().to_string(), + identifier_span: identifier_span.clone(), + parameters: function + .parameters() + .as_ref() + .map(|l| { + l.elements() + .map(|i| i.span.str().to_string()) + .collect::>() + }) + .unwrap_or_default(), + statements, + 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) => { let path = import.module().str_content(); @@ -220,7 +240,7 @@ impl Transpiler { &mut self, identifier_span: &Span, arguments: Option<&[&Expression]>, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult<(String, Option>)> { let program_identifier = identifier_span.source_file().identifier(); @@ -229,71 +249,57 @@ impl Transpiler { identifier_span.str().to_string(), ); let alias_query = self.aliases.get(&program_query).cloned(); - let already_transpiled = { - let locations = &self.function_locations; - locations - .get(&program_query) - .or_else(|| { - alias_query - .clone() - .and_then(|q| locations.get(&q).filter(|(_, p)| *p)) - }) - .is_some() + let already_transpiled = match scope + .get_variable(identifier_span.str()) + .expect("called function should be in scope") + .as_ref() + { + VariableType::Function { path, .. } => Some(path.get().is_some()), + _ => None, + } + .expect("called variable should be of type function"); + + 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 { tracing::trace!("Function not transpiled yet, transpiling."); - let function_scope = scope.new_child(); + let function_scope = Scope::with_parent(scope); - let statements = { - 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 - })?; + for (i, param) in function_data.parameters.iter().enumerate() { + function_scope.set_variable(param, VariableType::FunctionArgument { index: i }); + } - for (i, param) in function_data.parameters.iter().enumerate() { - function_scope.set_variable(param, VariableType::FunctionArgument { index: i }); - } - - function_data.statements.clone() - }; + let statements = function_data.statements.clone(); let commands = 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 .annotations .get("deobfuscate") @@ -333,55 +339,30 @@ impl Transpiler { self.datapack.add_load(&function_location); } - self.function_locations.insert( - ( - program_identifier.to_string(), - identifier_span.str().to_string(), - ), - (function_location, function_data.public), - ); + match scope + .get_variable(identifier_span.str()) + .expect("variable should be in scope if called") + .as_ref() + { + VariableType::Function { path, .. } => { + path.set(function_location.clone()).unwrap(); + } + _ => todo!("implement error handling") + } } - let parameters = { - 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 - })?; + let parameters = function_data.parameters.clone(); - function_data.parameters.clone() - }; - - let function_location = self - .function_locations - .get(&program_query) - .or_else(|| { - alias_query.and_then(|q| self.function_locations.get(&q).filter(|(_, p)| *p)) - }) + let function_location = function_path + .get() .ok_or_else(|| { let error = TranspileError::MissingFunctionDeclaration( - MissingFunctionDeclaration::from_context( - identifier_span.clone(), - &self.functions, - ), + MissingFunctionDeclaration::from_scope(identifier_span.clone(), scope), ); handler.receive(error.clone()); error }) - .map(|(s, _)| s.to_owned())?; + .map(|s| s.to_owned())?; let arg_count = arguments.map(<[&Expression]>::len); if arg_count.is_some_and(|arg_count| arg_count != parameters.len()) { @@ -440,7 +421,7 @@ impl Transpiler { &mut self, statements: &[Statement], program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { let mut errors = Vec::new(); @@ -466,7 +447,7 @@ impl Transpiler { &mut self, statement: &Statement, program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { match statement { @@ -505,7 +486,7 @@ impl Transpiler { unreachable!("Only literal commands are allowed in functions at this time.") } 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) } Statement::DocComment(doccomment) => { @@ -513,7 +494,7 @@ impl Transpiler { Ok(Some(Command::Comment(content.to_string()))) } Statement::Grouping(group) => { - let child_scope = scope.new_child(); + let child_scope = Scope::with_parent(scope); let statements = group.block().statements(); let mut errors = Vec::new(); let commands = statements @@ -580,7 +561,7 @@ impl Transpiler { fn transpile_function_call( &mut self, func: &FunctionCall, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult { let arguments = func @@ -616,7 +597,7 @@ impl Transpiler { &mut self, execute: &ExecuteBlock, program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { self.transpile_execute_block_internal(execute, program_identifier, scope, handler) @@ -627,7 +608,7 @@ impl Transpiler { &mut self, execute: &ExecuteBlock, program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { match execute { @@ -715,7 +696,7 @@ impl Transpiler { then: Execute, el: Option<&Else>, program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { let (_, cond) = cond.clone().dissolve(); @@ -767,7 +748,7 @@ impl Transpiler { head: &ExecuteBlockHead, tail: Option, program_identifier: &str, - scope: &Scope, + scope: &Arc, handler: &impl Handler, ) -> TranspileResult> { Ok(match head { diff --git a/src/transpile/variables.rs b/src/transpile/variables.rs index e2396cc..a891264 100644 --- a/src/transpile/variables.rs +++ b/src/transpile/variables.rs @@ -1,11 +1,20 @@ #![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 { + Function { + function_data: FunctionData, + path: OnceLock, + }, FunctionArgument { index: usize, }, @@ -35,28 +44,30 @@ pub enum VariableType { #[derive(Debug, Default)] pub struct Scope<'a> { - parent: Option<&'a Scope<'a>>, - variables: RwLock>, + parent: Option<&'a Arc>, + variables: RwLock>>, } impl<'a> Scope<'a> { - pub fn new() -> Self { - Self::default() + pub fn new() -> Arc { + Arc::new(Self::default()) } - pub fn new_child(&'a self) -> Self { - Self { - parent: Some(self), - variables: RwLock::new(HashMap::new()), - } + pub fn with_parent(parent: &'a Arc) -> Arc { + Arc::new(Self { + parent: Some(parent), + ..Default::default() + }) } - pub fn get_variable(&self, name: &str) -> Option { + pub fn get_variable(&self, name: &str) -> Option> { let var = self.variables.read().unwrap().get(name).cloned(); if var.is_some() { var } 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 .write() .unwrap() - .insert(name.to_string(), var); + .insert(name.to_string(), Arc::new(var)); } - pub fn get_parent(&self) -> Option<&'a Self> { - self.parent + pub fn get_variables(&self) -> &RwLock>> { + &self.variables + } + + pub fn get_parent(&self) -> Option> { + self.parent.map(|v| v.clone()) } } @@ -81,37 +96,39 @@ mod tests { #[test] fn test_scope() { let scope = Scope::new(); - { - let mut variables = scope.variables.write().unwrap(); - variables.insert( - "test".to_string(), - VariableType::Scoreboard { - objective: "test".to_string(), - }, - ); - } - match scope.get_variable("test") { - Some(VariableType::Scoreboard { objective }) => assert_eq!(objective, "test"), - _ => panic!("Incorrect Variable"), + scope.set_variable( + "test", + 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"), + _ => panic!("Incorrect Variable"), + } + } else { + panic!("Variable missing") } } #[test] fn test_parent() { let scope = Scope::new(); - { - let mut variables = scope.variables.write().unwrap(); - variables.insert( - "test".to_string(), - VariableType::Scoreboard { - objective: "test".to_string(), - }, - ); - } - let child = scope.new_child(); - match child.get_variable("test") { - Some(VariableType::Scoreboard { objective }) => assert_eq!(objective, "test"), - _ => panic!("Incorrect Variable"), + scope.set_variable( + "test", + VariableType::Scoreboard { + objective: "test".to_string(), + }, + ); + let child = Scope::with_parent(&scope); + if let Some(var) = child.get_variable("test") { + match var.as_ref() { + VariableType::Scoreboard { objective } => assert_eq!(objective, "test"), + _ => panic!("Incorrect Variable"), + } + } else { + panic!("Variable missing") } } }