git.delta.rocks / jrsonnet / refs/commits / a9b3ad095ce8

--- a/crates/jsonnet-evaluator/Cargo.toml
+++ b/crates/jsonnet-evaluator/Cargo.toml
@@ -7,8 +7,10 @@
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["serialized-stdlib"]
+default = ["serialized-stdlib", "faster"]
 serialized-stdlib = ["serde", "bincode"]
+# Replace some standard library functions with faster implementations
+faster = []
 
 [dependencies]
 jsonnet-parser = { path = "../jsonnet-parser" }

--- a/crates/jsonnet-evaluator/build.rs
+++ b/crates/jsonnet-evaluator/build.rs
@@ -1,11 +1,14 @@
 use bincode::serialize;
-use jsonnet_parser::{parse, ParserSettings};
+use jsonnet_parser::{
+	parse, Expr, FieldMember, FieldName, LocExpr, Member, ObjBody, ParserSettings,
+};
 use jsonnet_stdlib::STDLIB_STR;
 use std::{
 	env,
 	fs::File,
 	io::Write,
 	path::{Path, PathBuf},
+	rc::Rc,
 };
 
 fn main() {
@@ -18,6 +21,32 @@
 	)
 	.expect("parse");
 
+	let parsed = if cfg!(feature = "faster") {
+		let LocExpr(expr, location) = parsed;
+		LocExpr(
+			Rc::new(match Rc::try_unwrap(expr).unwrap() {
+				Expr::Obj(ObjBody::MemberList(members)) => Expr::Obj(ObjBody::MemberList(
+					members
+						.into_iter()
+						.filter(|p| {
+							!matches!(
+								p,
+								Member::Field(FieldMember {
+									name: FieldName::Fixed(name),
+									..
+								}) if name == "join"
+							)
+						})
+						.collect(),
+				)),
+				_ => panic!("std value should be object"),
+			}),
+			location,
+		)
+	} else {
+		parsed
+	};
+
 	let out_dir = env::var("OUT_DIR").unwrap();
 	let dest_path = Path::new(&out_dir).join("stdlib.bincode");
 	let mut f = File::create(&dest_path).unwrap();

661							panic!("bad extVar call");661							panic!("bad extVar call");
662						}662						}
663					}663					}
664					("std", "filter") => {
665						assert_eq!(args.len(), 2);
666						if let (Val::Func(predicate), Val::Arr(arr)) = (
667							evaluate(context, &args[0].1)?,
668							evaluate(context, &args[1].1)?,
669						) {
670							Val::Arr(
671								arr.into_iter()
672									.filter(|e| {
673										predicate
674											.evaluate_values(&context, &[e.clone()])
675											.unwrap()
676											.try_cast_bool("filter predicate")
677											.unwrap()
678									})
679									.collect(),
680							)
681						} else {
682							panic!("bad filter call");
683						}
684					}
685					// faster
686					("std", "join") => {
687						assert_eq!(args.len(), 2);
688						let joiner = evaluate(context, &args[0].1)?.unwrap_if_lazy()?;
689						let items = evaluate(context, &args[1].1)?.unwrap_if_lazy()?;
690						println!("Before");
691						let result = match (joiner, items) {
692							(Val::Arr(joiner_items), Val::Arr(items)) => {
693								// TODO: Minimal size should be known
694								let mut out = Vec::new();
695
696								let mut first = true;
697								for item in items {
698									if let Val::Arr(items) = item.unwrap_if_lazy()? {
699										if !first {
700											out.extend(joiner_items.iter().cloned());
701										}
702										first = false;
703										out.extend(items);
704									} else {
705										panic!("all array items should be arrays")
706									}
707								}
708
709								Val::Arr(out)
710							}
711							(Val::Str(joiner), Val::Arr(items)) => {
712								let mut out = String::new();
713
714								let mut first = true;
715								for item in items {
716									if let Val::Str(item) = item.unwrap_if_lazy()? {
717										if !first {
718											out += &joiner;
719										}
720										first = false;
721										out += &item;
722									} else {
723										panic!("all array items should be strings")
724									}
725								}
726
727								Val::Str(out)
728							}
729							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),
730						};
731						println!("After");
732						result
733					}
664					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),734					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),
665				},735				},
666				Val::Func(f) => {736				Val::Func(f) => {