From 0fd9dc432ed22546c3849de0fb6b64d60ed4b15e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Moritz=20H=C3=B6lting?= <87192362+moritz-hoelting@users.noreply.github.com> Date: Sun, 16 Mar 2025 23:26:20 +0100 Subject: [PATCH] first version of print internal function for easier displaying variable values --- Cargo.toml | 6 +- src/semantic/error.rs | 2 + src/semantic/mod.rs | 63 +++--- src/serde.rs | 2 +- src/syntax/syntax_tree/expression.rs | 14 ++ src/transpile/internal_functions.rs | 317 +++++++++++++++++++++++++++ src/transpile/lua.rs | 4 +- src/transpile/mod.rs | 3 + src/transpile/transpiler.rs | 114 +++++----- src/transpile/variables.rs | 32 ++- 10 files changed, 461 insertions(+), 96 deletions(-) create mode 100644 src/transpile/internal_functions.rs diff --git a/Cargo.toml b/Cargo.toml index aecee71..5197f0b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,8 +18,8 @@ license = "MIT OR Apache-2.0" default = ["fs_access", "lua", "shulkerbox", "zip"] fs_access = ["shulkerbox?/fs_access"] lua = ["dep:mlua"] -serde = ["dep:serde", "dep:flexbuffers", "shulkerbox?/serde"] -shulkerbox = ["dep:shulkerbox", "dep:chksum-md5"] +serde = ["dep:serde", "dep:serde_json", "shulkerbox?/serde"] +shulkerbox = ["dep:shulkerbox", "dep:chksum-md5", "dep:serde_json"] zip = ["shulkerbox?/zip"] [dependencies] @@ -28,12 +28,12 @@ chksum-md5 = { version = "0.1.0", optional = true } colored = "3.0.0" derive_more = { version = "2.0.1", default-features = false, features = ["deref", "deref_mut", "from"] } enum-as-inner = "0.6.0" -flexbuffers = { version = "25.2.10", optional = true } getset = "0.1.2" itertools = "0.14.0" mlua = { version = "0.10.2", features = ["lua54", "vendored"], optional = true } pathdiff = "0.2.3" serde = { version = "1.0.217", features = ["derive"], optional = true } +serde_json = { version = "1.0.138", optional = true } # shulkerbox = { version = "0.1.0", default-features = false, optional = true } shulkerbox = { git = "https://github.com/moritz-hoelting/shulkerbox", rev = "e9f2b9b91d72322ec2e063ce7b83415071306468", default-features = false, optional = true } strsim = "0.11.1" diff --git a/src/semantic/error.rs b/src/semantic/error.rs index 9be7db1..adac477 100644 --- a/src/semantic/error.rs +++ b/src/semantic/error.rs @@ -33,6 +33,7 @@ pub enum Error { IncompatibleFunctionAnnotation(#[from] IncompatibleFunctionAnnotation), } +// TODO: remove duplicate error (also in transpile) /// An error that occurs when a function declaration is missing. #[derive(Debug, Clone, PartialEq, Eq, Hash, Getters)] pub struct MissingFunctionDeclaration { @@ -43,6 +44,7 @@ pub struct MissingFunctionDeclaration { } impl MissingFunctionDeclaration { + #[expect(dead_code)] pub(super) fn from_context(identifier_span: Span, functions: &HashSet) -> Self { let own_name = identifier_span.str(); let alternatives = functions diff --git a/src/semantic/mod.rs b/src/semantic/mod.rs index bf10567..ccef284 100644 --- a/src/semantic/mod.rs +++ b/src/semantic/mod.rs @@ -4,14 +4,11 @@ use std::collections::HashSet; -use error::{ - IncompatibleFunctionAnnotation, InvalidNamespaceName, MissingFunctionDeclaration, - UnresolvedMacroUsage, -}; +use error::{IncompatibleFunctionAnnotation, InvalidNamespaceName}; use crate::{ base::{self, source_file::SourceElement as _, Handler}, - lexical::token::{MacroStringLiteral, MacroStringLiteralPart}, + lexical::token::MacroStringLiteral, syntax::syntax_tree::{ declaration::{Declaration, Function, ImportItems}, expression::{Expression, FunctionCall, Parenthesized, Primary}, @@ -387,28 +384,29 @@ impl MacroStringLiteral { /// Analyzes the semantics of the macro string literal. pub fn analyze_semantics( &self, - macro_names: &HashSet, - handler: &impl Handler, + _macro_names: &HashSet, + _handler: &impl Handler, ) -> Result<(), error::Error> { - let mut errors = Vec::new(); - for part in self.parts() { - if let MacroStringLiteralPart::MacroUsage { identifier, .. } = part { - if !macro_names.contains(identifier.span.str()) { - let err = error::Error::UnresolvedMacroUsage(UnresolvedMacroUsage { - span: identifier.span(), - }); - handler.receive(err.clone()); - errors.push(err); - } - } - } + // let mut errors = Vec::new(); + // TODO: allow macro string literals to also contain other variables + // for part in self.parts() { + // if let MacroStringLiteralPart::MacroUsage { identifier, .. } = part { + // if !macro_names.contains(identifier.span.str()) { + // let err = error::Error::UnresolvedMacroUsage(UnresolvedMacroUsage { + // span: identifier.span(), + // }); + // handler.receive(err.clone()); + // errors.push(err); + // } + // } + // } - #[expect(clippy::option_if_let_else)] - if let Some(err) = errors.first() { - Err(err.clone()) - } else { - Ok(()) - } + // #[expect(clippy::option_if_let_else)] + // if let Some(err) = errors.first() { + // Err(err.clone()) + // } else { + Ok(()) + // } } } @@ -462,13 +460,14 @@ impl FunctionCall { ) -> Result<(), error::Error> { let mut errors = Vec::new(); - if !function_names.contains(self.identifier().span.str()) { - let err = error::Error::MissingFunctionDeclaration( - MissingFunctionDeclaration::from_context(self.identifier().span(), function_names), - ); - handler.receive(err.clone()); - errors.push(err); - } + // TODO: also check for internal functions + // if !function_names.contains(self.identifier().span.str()) { + // let err = error::Error::MissingFunctionDeclaration( + // MissingFunctionDeclaration::from_context(self.identifier().span(), function_names), + // ); + // handler.receive(err.clone()); + // errors.push(err); + // } for expression in self .arguments() diff --git a/src/serde.rs b/src/serde.rs index 3f7e3d1..49ff465 100644 --- a/src/serde.rs +++ b/src/serde.rs @@ -42,7 +42,7 @@ where // hold guard so no other can serialize at the same time in same thread let s = DEDUPLICATE_SOURCE_FILES.with(|d| { let guard = d.read().unwrap(); - let mut serialized_data = flexbuffers::FlexbufferSerializer::new(); + let mut serialized_data = serde_json::Serializer::new(Vec::new()); self.0 .serialize(&mut serialized_data) .map_err(|_| serde::ser::Error::custom("could not buffer serialization"))?; diff --git a/src/syntax/syntax_tree/expression.rs b/src/syntax/syntax_tree/expression.rs index 80a8818..a6adcd6 100644 --- a/src/syntax/syntax_tree/expression.rs +++ b/src/syntax/syntax_tree/expression.rs @@ -545,6 +545,20 @@ impl<'a> Parser<'a> { arguments: token_tree.list, })) } + Reading::IntoDelimited(punc) if punc.punctuation == '[' => { + let token_tree = self.step_into( + Delimiter::Bracket, + |p| p.parse_expression(handler), + handler, + )?; + + Ok(Primary::Indexed(Indexed { + object: Box::new(Primary::Identifier(identifier)), + left_bracket: token_tree.open, + index: Box::new(token_tree.tree?), + right_bracket: token_tree.close, + })) + } _ => { // regular identifier Ok(Primary::Identifier(identifier)) diff --git a/src/transpile/internal_functions.rs b/src/transpile/internal_functions.rs new file mode 100644 index 0000000..4f6b2b5 --- /dev/null +++ b/src/transpile/internal_functions.rs @@ -0,0 +1,317 @@ +//! Functions provided by the language itself. + +use std::{ + ops::{Bound, Deref, RangeBounds}, + sync::Arc, +}; + +use shulkerbox::prelude::Command; + +use serde_json::{json, Value as JsonValue}; + +use crate::{ + base::{source_file::SourceElement as _, VoidHandler}, + lexical::token::{Identifier, MacroStringLiteralPart}, + semantic::error::InvalidFunctionArguments, + syntax::syntax_tree::expression::{Expression, FunctionCall, Primary}, + transpile::{ + error::{IllegalIndexing, IllegalIndexingReason, LuaRuntimeError, UnknownIdentifier}, + expression::{ComptimeValue, DataLocation, StorageType}, + util::MacroString, + TranspileError, + }, +}; + +use super::{Scope, TranspileResult, Transpiler, VariableData}; + +/// A function that can be called from the language. +pub type InternalFunction = + fn(&mut Transpiler, &Arc, &FunctionCall) -> TranspileResult>; + +/// Adds all internal functions to the scope. +pub fn add_all_to_scope(scope: &Arc) { + scope.set_variable( + "print", + VariableData::InternalFunction { + implementation: print_function, + }, + ); +} + +fn get_args_assert_in_range( + call: &FunctionCall, + range: impl RangeBounds, +) -> TranspileResult> { + let args = call + .arguments() + .as_ref() + .map(|args| args.elements().map(Deref::deref).collect::>()) + .unwrap_or_default(); + if range.contains(&args.len()) { + Ok(args) + } else { + let span = args + .first() + .and_then(|first| { + args.last() + .map(|last| first.span().join(&last.span()).expect("invalid span")) + }) + .unwrap_or_else(|| { + call.left_parenthesis() + .span() + .join(&call.right_parenthesis().span()) + .expect("invalid span") + }); + + let actual = args.len(); + let expected = match range.start_bound() { + Bound::Excluded(excluded) => (excluded + 1 > actual).then_some(excluded + 1), + Bound::Included(&included) => (included > actual).then_some(included), + Bound::Unbounded => None, + } + .or_else(|| match range.end_bound() { + Bound::Excluded(&excluded) => (excluded <= actual).then_some(excluded.wrapping_sub(1)), + Bound::Included(&included) => (included < actual).then_some(included), + Bound::Unbounded => None, + }) + .unwrap_or_default(); + + Err(TranspileError::InvalidFunctionArguments( + InvalidFunctionArguments { + expected, + actual: args.len(), + span, + }, + )) + } +} + +#[expect(clippy::too_many_lines)] +fn print_function( + transpiler: &mut Transpiler, + scope: &Arc, + call: &FunctionCall, +) -> TranspileResult> { + const PARAM_COLOR: &str = "gray"; + + #[expect(clippy::option_if_let_else)] + fn get_identifier_part( + ident: &Identifier, + _transpiler: &mut Transpiler, + scope: &Arc, + ) -> TranspileResult<(bool, Vec, JsonValue)> { + if let Some(var) = scope.get_variable(ident.span.str()).as_deref() { + match var { + VariableData::MacroParameter { macro_name, .. } => Ok(( + true, + Vec::new(), + json!({"text": format!("$({macro_name})"), "color": PARAM_COLOR}), + )), + VariableData::ScoreboardValue { objective, target } => Ok(( + false, + Vec::new(), + get_data_location(&DataLocation::ScoreboardValue { + objective: objective.to_string(), + target: target.to_string(), + }), + )), + VariableData::BooleanStorage { storage_name, path } => Ok(( + false, + Vec::new(), + get_data_location(&DataLocation::Storage { + storage_name: storage_name.to_string(), + path: path.to_string(), + r#type: StorageType::Boolean, + }), + )), + _ => todo!("get_identifier_part"), + } + } else { + Err(TranspileError::UnknownIdentifier(UnknownIdentifier { + identifier: ident.span(), + })) + } + } + + fn get_data_location(location: &DataLocation) -> JsonValue { + match location { + DataLocation::ScoreboardValue { objective, target } => { + json!({"score": {"name": target, "objective": objective}, "color": PARAM_COLOR}) + } + DataLocation::Storage { + storage_name, path, .. + } => json!({"nbt": path, "storage": storage_name, "color": PARAM_COLOR}), + DataLocation::Tag { .. } => todo!("implement tag"), + } + } + + let args = get_args_assert_in_range(call, 1..=2)?; + let first = args.first().expect("checked range"); + let (target, message_expression) = args.get(1).map_or_else( + || ("@a".into(), first), + |second| { + ( + first + .comptime_eval(scope, &VoidHandler) + .map_or_else(|| "@a".into(), |val| val.to_macro_string()), + second, + ) + }, + ); + + let mut contains_macro = matches!(target, MacroString::MacroString(_)); + + let (mut cmds, parts) = match message_expression { + Expression::Primary(primary) => match primary { + Primary::Boolean(boolean) => Ok(( + Vec::new(), + vec![JsonValue::String(boolean.value().to_string())], + )), + Primary::Integer(integer) => Ok(( + Vec::new(), + vec![JsonValue::String(integer.as_i64().to_string())], + )), + Primary::StringLiteral(string) => Ok(( + Vec::new(), + vec![JsonValue::String(string.str_content().to_string())], + )), + Primary::Lua(lua) => { + let (ret, _lua) = lua.eval(scope, &VoidHandler)?; + Ok(( + Vec::new(), + vec![JsonValue::String(ret.to_string().map_err(|err| { + TranspileError::LuaRuntimeError(LuaRuntimeError::from_lua_err( + &err, + lua.span(), + )) + })?)], + )) + } + Primary::Identifier(ident) => { + // TODO: get_identifier_part + let (cur_contains_macro, cmds, part) = + get_identifier_part(ident, transpiler, scope).expect("failed"); + contains_macro |= cur_contains_macro; + Ok((cmds, vec![part])) + } + Primary::Indexed(indexed) => match indexed.object().as_ref() { + Primary::Identifier(ident) => { + match scope.get_variable(ident.span.str()).as_deref() { + Some(VariableData::Scoreboard { objective }) => { + if let Some(ComptimeValue::String(index)) = + indexed.index().comptime_eval(scope, &VoidHandler) + { + Ok(( + Vec::new(), + vec![get_data_location(&DataLocation::ScoreboardValue { + objective: objective.to_string(), + target: index, + })], + )) + } else { + todo!("allow macro string, but throw error when index is not constant string") + } + } + Some(VariableData::ScoreboardArray { objective, targets }) => { + if let Some(ComptimeValue::Integer(index)) = + indexed.index().comptime_eval(scope, &VoidHandler) + { + #[expect(clippy::option_if_let_else)] + if let Some(target) = usize::try_from(index) + .ok() + .and_then(|index| targets.get(index)) + { + Ok(( + Vec::new(), + vec![get_data_location(&DataLocation::ScoreboardValue { + objective: objective.to_string(), + target: target.to_string(), + })], + )) + } else { + todo!("throw error when index is out of bounds") + } + } else { + todo!("throw error when index is not constant integer") + } + } + Some(VariableData::BooleanStorageArray { + storage_name, + paths, + }) => { + if let Some(ComptimeValue::Integer(index)) = + indexed.index().comptime_eval(scope, &VoidHandler) + { + #[expect(clippy::option_if_let_else)] + if let Some(path) = usize::try_from(index) + .ok() + .and_then(|index| paths.get(index)) + { + Ok(( + Vec::new(), + vec![get_data_location(&DataLocation::Storage { + storage_name: storage_name.to_string(), + path: path.to_string(), + r#type: StorageType::Boolean, + })], + )) + } else { + todo!("throw error when index is out of bounds") + } + } else { + todo!("throw error when index is not constant integer") + } + } + _ => todo!(), + } + } + _ => Err(TranspileError::IllegalIndexing(IllegalIndexing { + expression: indexed.object().span(), + reason: IllegalIndexingReason::NotIdentifier, + })), + }, + Primary::MacroStringLiteral(macro_string) => { + let mut cmds = Vec::new(); + let mut parts = Vec::new(); + for part in macro_string.parts() { + match part { + MacroStringLiteralPart::Text(text) => { + parts.push(JsonValue::String(text.str().to_string())); + } + MacroStringLiteralPart::MacroUsage { identifier, .. } => { + let (cur_contains_macro, cur_cmds, part) = + get_identifier_part(identifier, transpiler, scope)?; + contains_macro |= cur_contains_macro; + cmds.extend(cur_cmds); + parts.push(part); + } + } + } + Ok((cmds, parts)) + } + + _ => todo!("print_function Primary"), + }, + Expression::Binary(_) => todo!("print_function Binary"), + }?; + + // TODO: prepend prefix with datapack name to parts and remove following + let print_args = if parts.len() == 1 { + serde_json::to_string(&parts[0]).expect("json serialization failed") + } else { + serde_json::to_string(&parts).expect("json serialization failed") + }; + + // TODO: throw correct error + let cmd = format!("tellraw {target} {print_args}"); + + let cmd = if contains_macro { + Command::UsesMacro(cmd.parse::().expect("cannot fail").into()) + } else { + Command::Raw(cmd) + }; + + cmds.push(cmd); + + Ok(cmds) +} diff --git a/src/transpile/lua.rs b/src/transpile/lua.rs index 6f282df..21600c3 100644 --- a/src/transpile/lua.rs +++ b/src/transpile/lua.rs @@ -262,8 +262,8 @@ mod enabled { .map_err(|err| LuaRuntimeError::from_lua_err(&err, self.span()))?; Value::Table(table) } - Some(VariableData::Function { .. }) => { - todo!("functions are not supported yet"); + Some(VariableData::Function { .. } | VariableData::InternalFunction { .. }) => { + todo!("(internal) functions are not supported yet"); } None => { return Err(TranspileError::UnknownIdentifier(UnknownIdentifier { diff --git a/src/transpile/mod.rs b/src/transpile/mod.rs index 4c73fad..96d3874 100644 --- a/src/transpile/mod.rs +++ b/src/transpile/mod.rs @@ -29,6 +29,9 @@ use strum::EnumIs; #[cfg_attr(feature = "shulkerbox", doc(inline))] pub use transpiler::Transpiler; +#[cfg(feature = "shulkerbox")] +pub mod internal_functions; + mod variables; pub use variables::{Scope, VariableData}; diff --git a/src/transpile/transpiler.rs b/src/transpile/transpiler.rs index 7cd9433..db7b310 100644 --- a/src/transpile/transpiler.rs +++ b/src/transpile/transpiler.rs @@ -101,7 +101,7 @@ impl Transpiler { let scope = self .scopes .entry(program_identifier) - .or_default() + .or_insert_with(Scope::with_internal_functions) .to_owned(); self.transpile_program_declarations(program, &scope, handler); } @@ -129,7 +129,7 @@ impl Transpiler { let scope = self .scopes .entry(identifier_span.source_file().identifier().to_owned()) - .or_default() + .or_insert_with(Scope::with_internal_functions) .to_owned(); self.get_or_transpile_function(&identifier_span, None, &scope, handler)?; } @@ -831,60 +831,68 @@ impl Transpiler { .arguments() .as_ref() .map(|l| l.elements().map(Deref::deref).collect::>()); - let (location, arguments) = self.get_or_transpile_function( - &func.identifier().span, - arguments.as_deref(), - scope, - handler, - )?; - let mut function_call = format!("function {location}"); - match arguments { - TranspiledFunctionArguments::Static(arguments) => { - use std::fmt::Write; - let arguments_iter = arguments.iter().map(|(ident, v)| match v { - MacroString::String(s) => MacroString::String(format!( - r#"{macro_name}:"{escaped}""#, - macro_name = crate::util::identifier_to_macro(ident), - escaped = crate::util::escape_str(s) - )), - MacroString::MacroString(parts) => MacroString::MacroString( - std::iter::once(MacroStringPart::String(format!( - r#"{macro_name}:""#, - macro_name = crate::util::identifier_to_macro(ident) - ))) - .chain(parts.clone().into_iter().map(|part| match part { - MacroStringPart::String(s) => { - MacroStringPart::String(crate::util::escape_str(&s).to_string()) - } - macro_usage @ MacroStringPart::MacroUsage(_) => macro_usage, - })) - .chain(std::iter::once(MacroStringPart::String('"'.to_string()))) - .collect(), - ), - }); - let arguments = super::util::join_macro_strings(arguments_iter); + if let Some(VariableData::InternalFunction { implementation }) = + scope.get_variable(func.identifier().span.str()).as_deref() + { + implementation(self, scope, func).inspect_err(|err| { + handler.receive(err.clone()); + }) + } else { + let (location, arguments) = self.get_or_transpile_function( + &func.identifier().span, + arguments.as_deref(), + scope, + handler, + )?; + let mut function_call = format!("function {location}"); + match arguments { + TranspiledFunctionArguments::Static(arguments) => { + use std::fmt::Write; + let arguments_iter = arguments.iter().map(|(ident, v)| match v { + MacroString::String(s) => MacroString::String(format!( + r#"{macro_name}:"{escaped}""#, + macro_name = crate::util::identifier_to_macro(ident), + escaped = crate::util::escape_str(s) + )), + MacroString::MacroString(parts) => MacroString::MacroString( + std::iter::once(MacroStringPart::String(format!( + r#"{macro_name}:""#, + macro_name = crate::util::identifier_to_macro(ident) + ))) + .chain(parts.clone().into_iter().map(|part| match part { + MacroStringPart::String(s) => { + MacroStringPart::String(crate::util::escape_str(&s).to_string()) + } + macro_usage @ MacroStringPart::MacroUsage(_) => macro_usage, + })) + .chain(std::iter::once(MacroStringPart::String('"'.to_string()))) + .collect(), + ), + }); + let arguments = super::util::join_macro_strings(arguments_iter); - let cmd = match arguments { - MacroString::String(arguments) => { - write!(function_call, " {{{arguments}}}").unwrap(); - Command::Raw(function_call) - } - MacroString::MacroString(mut parts) => { - function_call.push_str(" {"); - parts.insert(0, MacroStringPart::String(function_call)); - parts.push(MacroStringPart::String('}'.to_string())); - Command::UsesMacro(MacroString::MacroString(parts).into()) - } - }; + let cmd = match arguments { + MacroString::String(arguments) => { + write!(function_call, " {{{arguments}}}").unwrap(); + Command::Raw(function_call) + } + MacroString::MacroString(mut parts) => { + function_call.push_str(" {"); + parts.insert(0, MacroStringPart::String(function_call)); + parts.push(MacroStringPart::String('}'.to_string())); + Command::UsesMacro(MacroString::MacroString(parts).into()) + } + }; - Ok(vec![cmd]) + Ok(vec![cmd]) + } + TranspiledFunctionArguments::Dynamic(mut cmds) => { + function_call.push_str(" with storage shulkerscript:function_arguments"); + cmds.push(Command::Raw(function_call)); + Ok(cmds) + } + TranspiledFunctionArguments::None => Ok(vec![Command::Raw(function_call)]), } - TranspiledFunctionArguments::Dynamic(mut cmds) => { - function_call.push_str(" with storage shulkerscript:function_arguments"); - cmds.push(Command::Raw(function_call)); - Ok(cmds) - } - TranspiledFunctionArguments::None => Ok(vec![Command::Raw(function_call)]), } } diff --git a/src/transpile/variables.rs b/src/transpile/variables.rs index b0f3e78..3836022 100644 --- a/src/transpile/variables.rs +++ b/src/transpile/variables.rs @@ -33,6 +33,7 @@ use super::{ MismatchedTypes, }, expression::{ComptimeValue, DataLocation, ExpectedType, StorageType}, + internal_functions::InternalFunction, FunctionData, TranspileAnnotationValue, TranspileError, TranspileResult, }; @@ -94,6 +95,11 @@ pub enum VariableData { /// The paths to the booleans. paths: Vec, }, + /// Compiler internal function. + InternalFunction { + /// The implementation + implementation: InternalFunction, + }, } #[derive(Debug, Clone, Copy, EnumAsInner)] @@ -133,6 +139,19 @@ impl<'a> Scope<'a> { Arc::new(Self::default()) } + /// Creates a new scope with internal functions. + #[cfg(feature = "shulkerbox")] + #[must_use] + pub fn with_internal_functions() -> Arc { + use super::internal_functions; + + let scope = Self::new(); + + internal_functions::add_all_to_scope(&scope); + + scope + } + /// Creates a new scope with a parent. #[must_use] pub fn with_parent(parent: &'a Arc) -> Arc { @@ -624,15 +643,18 @@ impl Transpiler { return Err(err); } }, - VariableData::Function { .. } | VariableData::MacroParameter { .. } => { + VariableData::Function { .. } + | VariableData::MacroParameter { .. } + | VariableData::InternalFunction { .. } => { let err = TranspileError::AssignmentError(AssignmentError { identifier: identifier.span(), message: format!( "Cannot assign to a {}.", - if matches!(target.as_ref(), VariableData::Function { .. }) { - "function" - } else { - "function argument" + match target.as_ref() { + VariableData::Function { .. } => "function", + VariableData::MacroParameter { .. } => "macro parameter", + VariableData::InternalFunction { .. } => "internal function", + _ => unreachable!(), } ), });