From 2066aa0bb464f48c0891324633fe2e6309a49d04 Mon Sep 17 00:00:00 2001 From: "Arend van Beelen jr." Date: Mon, 25 Mar 2024 12:33:38 +0100 Subject: [PATCH] Keep Builtins Marzano-specific --- crates/core/src/pattern/built_in_functions.rs | 95 +++++++++++++++---- 1 file changed, 74 insertions(+), 21 deletions(-) diff --git a/crates/core/src/pattern/built_in_functions.rs b/crates/core/src/pattern/built_in_functions.rs index 2c0ad5ecd..5de4cdf68 100644 --- a/crates/core/src/pattern/built_in_functions.rs +++ b/crates/core/src/pattern/built_in_functions.rs @@ -17,7 +17,7 @@ use super::{ patterns_to_resolved, JoinFn, LazyBuiltIn, ListBinding, ResolvedPattern, ResolvedSnippet, }, variable::get_absolute_file_name, - State, + MarzanoContext, State, }; use anyhow::{anyhow, bail, Result}; use im::vector; @@ -76,7 +76,12 @@ impl Name for CallBuiltIn { // eg. capitalize returns an owned string_constant pattern, but unique would return a borrowed // value. -type F = dyn for<'a> Fn(Vec>>, &mut State<'a>) -> Result> +type F = dyn for<'a> Fn( + &'a [Option], + &'a MarzanoContext<'a>, + &mut State<'a>, + &mut AnalysisLogs, + ) -> Result> + Send + Sync; @@ -89,10 +94,12 @@ pub struct BuiltInFunction { impl BuiltInFunction { fn call<'a>( &self, - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { - (self.func)(args, state) + (self.func)(args, context, state, logs) } pub fn new(name: &'static str, params: Vec<&'static str>, func: Box) -> Self { @@ -116,13 +123,11 @@ impl BuiltIns { pub(crate) fn call<'a>( &self, call: &'a CallBuiltIn, - context: &'a impl Context, + context: &'a MarzanoContext<'a>, state: &mut State<'a>, logs: &mut AnalysisLogs, ) -> Result> { - let args = patterns_to_resolved(&call.args, state, context, logs)?; - - self.0[call.index].call(args, state) + self.0[call.index].call(&call.args, context, state, logs) } pub fn extend_builtins(&mut self, other: BuiltIns) -> Result<()> { @@ -178,9 +183,13 @@ impl From> for BuiltIns { /// Turn an arbitrary path into a resolved and normalized absolute path fn resolve_path_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let current_file = get_absolute_file_name(state)?; let target_path = match &args[0] { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, @@ -201,9 +210,13 @@ fn capitalize(s: &str) -> String { } fn capitalize_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let s = match &args[0] { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, None => return Err(anyhow!("No argument provided for capitalize function")), @@ -212,9 +225,13 @@ fn capitalize_fn<'a>( } fn lowercase_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let s = match &args[0] { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, None => return Err(anyhow!("lowercase takes 1 argument")), @@ -223,9 +240,13 @@ fn lowercase_fn<'a>( } fn uppercase_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let s = match &args[0] { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, None => return Err(anyhow!("uppercase takes 1 argument")), @@ -234,9 +255,13 @@ fn uppercase_fn<'a>( } fn text_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let s = match args.first() { Some(Some(resolved_pattern)) => resolved_pattern.text(&state.files)?, _ => return Err(anyhow!("text takes 1 argument")), @@ -245,9 +270,13 @@ fn text_fn<'a>( } fn trim_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let trim_chars = match &args[1] { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, None => return Err(anyhow!("trim takes 2 arguments: string and trim_chars")), @@ -265,9 +294,13 @@ fn trim_fn<'a>( } fn split_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let string = if let Some(string) = &args[0] { string.text(&state.files)? } else { @@ -286,9 +319,13 @@ fn split_fn<'a>( } fn random_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + match args.as_slice() { [Some(start), Some(end)] => { let start = start.text(&state.files)?; @@ -314,9 +351,13 @@ fn random_fn<'a>( } fn join_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let separator = &args[1]; let separator = match separator { Some(resolved_pattern) => resolved_pattern.text(&state.files)?, @@ -342,9 +383,13 @@ fn join_fn<'a>( } fn distinct_fn<'a>( - args: Vec>>, - _state: &mut State<'a>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, + state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let list = args.into_iter().next().unwrap(); match list { Some(ResolvedPattern::List(list)) => { @@ -387,9 +432,13 @@ fn distinct_fn<'a>( // Shuffle a list fn shuffle_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let list = args .into_iter() .next() @@ -431,9 +480,13 @@ fn shuffle_fn<'a>( } fn length_fn<'a>( - args: Vec>>, + args: &'a [Option], + context: &'a MarzanoContext<'a>, state: &mut State<'a>, + logs: &mut AnalysisLogs, ) -> Result> { + let args = patterns_to_resolved(args, state, context, logs)?; + let list = args.into_iter().next().unwrap(); match &list { Some(ResolvedPattern::List(list)) => {