git.delta.rocks / jrsonnet / refs/commits / 90e93cc51b3a

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -492,6 +492,7 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0ffa0837f2dfa6fb90868c2b5468cad482e175f7dad97e7421951e663f2b527"
 dependencies = [
+ "indexmap",
  "itoa",
  "ryu",
  "serde",

--- a/bindings/jsonnet/Cargo.toml
+++ b/bindings/jsonnet/Cargo.toml
@@ -17,3 +17,4 @@
 
 [features]
 interop = []
+exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -58,7 +58,11 @@
 pub extern "C" fn jsonnet_string_output(vm: &EvaluationState, v: c_int) {
 	match v {
 		1 => vm.set_manifest_format(ManifestFormat::String),
-		0 => vm.set_manifest_format(ManifestFormat::Json(4)),
+		0 => vm.set_manifest_format(ManifestFormat::Json {
+			padding: 4,
+			#[cfg(feature = "exp-preserve-order")]
+			preserve_order: false,
+		}),
 		_ => panic!("incorrect output format"),
 	}
 }

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -5,8 +5,7 @@
 use std::{ffi::CStr, os::raw::c_char};
 
 use gcmodule::Cc;
-use jrsonnet_evaluator::{val::ArrValue, EvaluationState, LazyBinding, LazyVal, ObjMember, Val};
-use jrsonnet_parser::Visibility;
+use jrsonnet_evaluator::{val::ArrValue, EvaluationState, LazyVal, Val};
 
 /// # Safety
 ///
@@ -41,19 +40,9 @@
 	val: &Val,
 ) {
 	match obj {
-		Val::Obj(old) => {
-			let new_obj = old.clone().extend_with_field(
-				CStr::from_ptr(name).to_str().unwrap().into(),
-				ObjMember {
-					add: false,
-					visibility: Visibility::Normal,
-					invoke: LazyBinding::Bound(LazyVal::new_resolved(val.clone())),
-					location: None,
-				},
-			);
-
-			*obj = Val::Obj(new_obj);
-		}
+		Val::Obj(old) => old
+			.extend_field(CStr::from_ptr(name).to_str().unwrap().into())
+			.value(val.clone()),
 		_ => panic!("should receive object"),
 	}
 }

--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -9,6 +9,12 @@
 [features]
 # Use mimalloc as allocator
 mimalloc = ["mimallocator"]
+# Experimental feature, which allows to preserve order of object fields
+exp-preserve-order = [
+    "jrsonnet-evaluator/exp-preserve-order",
+    "jrsonnet-evaluator/exp-serde-preserve-order",
+    "jrsonnet-cli/exp-preserve-order",
+]
 
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2" }

--- a/crates/jrsonnet-cli/Cargo.toml
+++ b/crates/jrsonnet-cli/Cargo.toml
@@ -6,6 +6,9 @@
 license = "MIT"
 edition = "2021"
 
+[features]
+exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]
+
 [dependencies]
 jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.4.2", features = [
     "explaining-traces",

--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -43,20 +43,30 @@
 	/// `0` for hard tabs, `-1` for single line output [default: 3 for json, 2 for yaml]
 	#[clap(long)]
 	line_padding: Option<usize>,
+	/// Preserve order in object manifestification
+	#[cfg(feature = "exp-preserve-order")]
+	#[clap(long)]
+	exp_preserve_order: bool,
 }
 impl ConfigureState for ManifestOpts {
 	fn configure(&self, state: &EvaluationState) -> Result<()> {
 		if self.string {
 			state.set_manifest_format(ManifestFormat::String);
 		} else {
+			#[cfg(feature = "exp-preserve-order")]
+			let preserve_order = self.exp_preserve_order;
 			match self.format {
 				ManifestFormatName::String => state.set_manifest_format(ManifestFormat::String),
-				ManifestFormatName::Json => {
-					state.set_manifest_format(ManifestFormat::Json(self.line_padding.unwrap_or(3)))
-				}
-				ManifestFormatName::Yaml => {
-					state.set_manifest_format(ManifestFormat::Yaml(self.line_padding.unwrap_or(2)))
-				}
+				ManifestFormatName::Json => state.set_manifest_format(ManifestFormat::Json {
+					padding: self.line_padding.unwrap_or(3),
+					#[cfg(feature = "exp-preserve-order")]
+					preserve_order,
+				}),
+				ManifestFormatName::Yaml => state.set_manifest_format(ManifestFormat::Yaml {
+					padding: self.line_padding.unwrap_or(2),
+					#[cfg(feature = "exp-preserve-order")]
+					preserve_order,
+				}),
 			}
 		}
 		if self.yaml_stream {

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -15,6 +15,10 @@
 # Allows library authors to throw custom errors
 anyhow-error = ["anyhow"]
 
+# Allows to preserve field order in objects
+exp-preserve-order = []
+exp-serde-preserve-order = ["serde_json/preserve_order"]
+
 [dependencies]
 jrsonnet-interner = { path = "../jrsonnet-interner", version = "0.4.2" }
 jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.4.2" }

--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -21,6 +21,8 @@
 	pub mtype: ManifestType,
 	pub newline: &'s str,
 	pub key_val_sep: &'s str,
+	#[cfg(feature = "exp-preserve-order")]
+	pub preserve_order: bool,
 }
 
 pub fn manifest_json_ex(val: &Val, options: &ManifestJsonOptions<'_>) -> Result<String> {
@@ -85,7 +87,10 @@
 		Val::Obj(obj) => {
 			obj.run_assertions()?;
 			buf.push('{');
-			let fields = obj.fields();
+			let fields = obj.fields(
+				#[cfg(feature = "exp-preserve-order")]
+				options.preserve_order,
+			);
 			if !fields.is_empty() {
 				if mtype != ManifestType::ToString && mtype != ManifestType::Minify {
 					buf.push_str(options.newline);
@@ -182,6 +187,10 @@
 	/// safe_key: 1
 	/// ```
 	pub quote_keys: bool,
+	/// If true - then order of fields is preserved as written,
+	/// instead of sorting alphabetically
+	#[cfg(feature = "exp-preserve-order")]
+	pub preserve_order: bool,
 }
 
 /// From https://github.com/chyh1990/yaml-rust/blob/da52a68615f2ecdd6b7e4567019f280c433c1521/src/emitter.rs#L289
@@ -287,7 +296,14 @@
 			if o.is_empty() {
 				buf.push_str("{}");
 			} else {
-				for (i, key) in o.fields().iter().enumerate() {
+				for (i, key) in o
+					.fields(
+						#[cfg(feature = "exp-preserve-order")]
+						options.preserve_order,
+					)
+					.iter()
+					.enumerate()
+				{
 					if i != 0 {
 						buf.push('\n');
 						buf.push_str(cur_padding);

--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -162,11 +162,7 @@
 	Ok(match x {
 		A(x) => x.chars().count(),
 		B(x) => x.len(),
-		C(x) => x
-			.fields_visibility()
-			.into_iter()
-			.filter(|(_k, v)| *v)
-			.count(),
+		C(x) => x.len(),
 		D(f) => f.args_len(),
 	})
 }
@@ -191,8 +187,20 @@
 }
 
 #[jrsonnet_macros::builtin]
-fn builtin_object_fields_ex(obj: ObjValue, inc_hidden: bool) -> Result<VecVal> {
-	let out = obj.fields_ex(inc_hidden);
+fn builtin_object_fields_ex(
+	obj: ObjValue,
+	inc_hidden: bool,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> Result<VecVal> {
+	#[cfg(not(feature = "exp-preserve-order"))]
+	let preserve_order = false;
+	#[cfg(feature = "exp-preserve-order")]
+	let preserve_order = preserve_order.unwrap_or(false);
+	let out = obj.fields_ex(
+		inc_hidden,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order,
+	);
 	Ok(VecVal(Cc::new(
 		out.into_iter().map(Val::Str).collect::<Vec<_>>(),
 	)))
@@ -586,6 +594,7 @@
 	indent: IStr,
 	newline: Option<IStr>,
 	key_val_sep: Option<IStr>,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
 ) -> Result<String> {
 	let newline = newline.as_deref().unwrap_or("\n");
 	let key_val_sep = key_val_sep.as_deref().unwrap_or(": ");
@@ -596,6 +605,8 @@
 			mtype: ManifestType::Std,
 			newline,
 			key_val_sep,
+			#[cfg(feature = "exp-preserve-order")]
+			preserve_order: preserve_order.unwrap_or(false),
 		},
 	)
 }
@@ -605,6 +616,7 @@
 	value: Any,
 	indent_array_in_object: Option<bool>,
 	quote_keys: Option<bool>,
+	#[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
 ) -> Result<String> {
 	manifest_yaml_ex(
 		&value.0,
@@ -616,6 +628,8 @@
 				""
 			},
 			quote_keys: quote_keys.unwrap_or(true),
+			#[cfg(feature = "exp-preserve-order")]
+			preserve_order: preserve_order.unwrap_or(false),
 		},
 	)
 }

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -28,7 +28,10 @@
 			}
 			Val::Obj(o) => {
 				let mut out = Map::new();
-				for key in o.fields() {
+				for key in o.fields(
+					#[cfg(feature = "exp-preserve-order")]
+					cfg!(feature = "exp-serde-preserve-order"),
+				) {
 					out.insert(
 						(&key as &str).into(),
 						o.get(key)?

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -100,7 +100,11 @@
 			ext_natives: Default::default(),
 			tla_vars: Default::default(),
 			import_resolver: Box::new(DummyImportResolver),
-			manifest_format: ManifestFormat::Json(4),
+			manifest_format: ManifestFormat::Json {
+				padding: 4,
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order: false,
+			},
 			trace_format: Box::new(CompactFormat {
 				padding: 4,
 				resolver: trace::PathResolver::Absolute,

18	push_frame, throw, weak_ptr_eq, weak_raw, Bindable, LazyBinding, LazyVal, Result, Val,18	push_frame, throw, weak_ptr_eq, weak_raw, Bindable, LazyBinding, LazyVal, Result, Val,
19};19};
20
21#[cfg(not(feature = "exp-preserve-order"))]
22pub(crate) mod ordering {
23	use gcmodule::Trace;
24
25	#[derive(Clone, Copy, Default, Debug, Trace)]
26	pub struct FieldIndex;
27	impl FieldIndex {
28		pub fn next(self) -> Self {
29			Self
30		}
31	}
32
33	#[derive(Clone, Copy, Default, Debug, Trace)]
34	pub struct SuperDepth;
35	impl SuperDepth {
36		pub fn deeper(self) -> Self {
37			Self
38		}
39	}
40
41	#[derive(Clone, Copy)]
42	pub struct FieldSortKey;
43	impl FieldSortKey {
44		pub fn new(_: SuperDepth, _: FieldIndex) -> Self {
45			Self
46		}
47	}
48}
49
50#[cfg(feature = "exp-preserve-order")]
51mod ordering {
52	use std::cmp::Reverse;
53
54	use gcmodule::Trace;
55
56	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]
57	pub struct FieldIndex(u32);
58	impl FieldIndex {
59		pub fn next(self) -> Self {
60			Self(self.0 + 1)
61		}
62	}
63
64	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]
65	pub struct SuperDepth(u32);
66	impl SuperDepth {
67		pub fn deeper(self) -> Self {
68			Self(self.0 + 1)
69		}
70	}
71
72	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
73	pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);
74	impl FieldSortKey {
75		pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {
76			Self(Reverse(depth), index)
77		}
78		pub fn collide(self, other: Self) -> Self {
79			if self.0 .0 > other.0 .0 {
80				self
81			} else if self.0 .0 < other.0 .0 {
82				other
83			} else {
84				unreachable!("object can't have two fields with same name")
85			}
86		}
87	}
88}
89
90pub(crate) use ordering::*;
2091
21#[derive(Debug, Trace)]92#[derive(Debug, Trace)]
22pub struct ObjMember {93pub struct ObjMember {
23	pub add: bool,94	pub add: bool,
24	pub visibility: Visibility,95	pub visibility: Visibility,
96	original_index: FieldIndex,
25	pub invoke: LazyBinding,97	pub invoke: LazyBinding,
26	pub location: Option<ExprLocation>,98	pub location: Option<ExprLocation>,
27}99}
120			),192			),
121		}193		}
122	}194	}
195	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {
196		let mut new = GcHashMap::with_capacity(1);
197		new.insert(key, value);
198		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))
199	}
200	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder> {
201		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())
202	}
123	pub fn with_this(&self, this_obj: Self) -> Self {203	pub fn with_this(&self, this_obj: Self) -> Self {
124		Self(Cc::new(ObjValueInternals {204		Self(Cc::new(ObjValueInternals {
125			super_obj: self.0.super_obj.clone(),205			super_obj: self.0.super_obj.clone(),
131		}))211		}))
132	}212	}
213
214	pub fn len(&self) -> usize {
215		self.fields_visibility()
216			.into_iter()
217			.filter(|(_, (visible, _))| *visible)
218			.count()
219	}
133220
134	pub fn is_empty(&self) -> bool {221	pub fn is_empty(&self) -> bool {
135		if !self.0.this_entries.is_empty() {222		if !self.0.this_entries.is_empty() {
145	/// Run callback for every field found in object232	/// Run callback for every field found in object
146	pub(crate) fn enum_fields(&self, handler: &mut impl FnMut(&IStr, &ObjMember) -> bool) -> bool {233	pub(crate) fn enum_fields(
234		&self,
235		depth: SuperDepth,
236		handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,
237	) -> bool {
147		if let Some(s) = &self.0.super_obj {238		if let Some(s) = &self.0.super_obj {
148			if s.enum_fields(handler) {239			if s.enum_fields(depth.deeper(), handler) {
149				return true;240				return true;
150			}241			}
151		}242		}
152		for (name, member) in self.0.this_entries.iter() {243		for (name, member) in self.0.this_entries.iter() {
153			if handler(name, member) {244			if handler(depth, name, member) {
154				return true;245				return true;
155			}246			}
156		}247		}
157		false248		false
158	}249	}
159250
160	pub fn fields_visibility(&self) -> FxHashMap<IStr, bool> {251	pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {
161		let mut out = FxHashMap::default();252		let mut out = FxHashMap::default();
162		self.enum_fields(&mut |name, member| {253		self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {
254			let new_sort_key = FieldSortKey::new(depth, member.original_index);
163			match member.visibility {255			match member.visibility {
164				Visibility::Normal => {256				Visibility::Normal => {
165					let entry = out.entry(name.to_owned());257					let entry = out.entry(name.to_owned());
166					entry.or_insert(true);258					let v = entry.or_insert((true, new_sort_key));
259					v.1 = new_sort_key;
167				}260				}
168				Visibility::Hidden => {261				Visibility::Hidden => {
169					out.insert(name.to_owned(), false);262					out.insert(name.to_owned(), (false, new_sort_key));
170				}263				}
171				Visibility::Unhide => {264				Visibility::Unhide => {
172					out.insert(name.to_owned(), true);265					out.insert(name.to_owned(), (true, new_sort_key));
173				}266				}
174			};267			};
175			false268			false
176		});269		});
177		out270		out
178	}271	}
179	pub fn fields_ex(&self, include_hidden: bool) -> Vec<IStr> {272	pub fn fields_ex(
273		&self,
274		include_hidden: bool,
275		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
276	) -> Vec<IStr> {
277		#[cfg(feature = "exp-preserve-order")]
278		if preserve_order {
279			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self
280				.fields_visibility()
281				.into_iter()
282				.filter(|(_, (visible, _))| include_hidden || *visible)
283				.enumerate()
284				.map(|(idx, (k, (_, sk)))| (k, (sk, idx)))
285				.unzip();
286			keys.sort_unstable_by_key(|v| v.0);
287			// Reorder in-place by resulting indexes
288			for i in 0..fields.len() {
289				let x = fields[i].clone();
290				let mut j = i;
291				loop {
292					let k = keys[j].1;
293					keys[j].1 = j;
294					if k == i {
295						break;
296					}
297					fields[j] = fields[k].clone();
298					j = k
299				}
300				fields[j] = x;
301			}
302			return fields;
303		}
304
180		let mut fields: Vec<_> = self305		let mut fields: Vec<_> = self
181			.fields_visibility()306			.fields_visibility()
182			.into_iter()307			.into_iter()
183			.filter(|(_k, v)| include_hidden || *v)308			.filter(|(_, (visible, _))| include_hidden || *visible)
184			.map(|(k, _)| k)309			.map(|(k, _)| k)
185			.collect();310			.collect();
186		fields.sort_unstable();311		fields.sort_unstable();
187		fields312		fields
188	}313	}
189	pub fn fields(&self) -> Vec<IStr> {314	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {
190		self.fields_ex(false)315		self.fields_ex(
316			false,
317			#[cfg(feature = "exp-preserve-order")]
318			preserve_order,
319		)
191	}320	}
192321
236		self.get_raw(key, self.0.this_obj.as_ref())365		self.get_raw(key, self.0.this_obj.as_ref())
237	}366	}
238367
239	pub fn extend_with_field(self, key: IStr, value: ObjMember) -> Self {368	// pub fn extend_with(self, key: )
240		let mut new = GcHashMap::with_capacity(1);
241		new.insert(key, value);
242		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))
243	}
244369
245	fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {370	fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {
246		let real_this = real_this.unwrap_or(self);371		let real_this = real_this.unwrap_or(self);
339	super_obj: Option<ObjValue>,464	super_obj: Option<ObjValue>,
340	map: GcHashMap<IStr, ObjMember>,465	map: GcHashMap<IStr, ObjMember>,
341	assertions: Vec<TraceBox<dyn ObjectAssertion>>,466	assertions: Vec<TraceBox<dyn ObjectAssertion>>,
467	next_field_index: FieldIndex,
342}468}
343impl ObjValueBuilder {469impl ObjValueBuilder {
344	pub fn new() -> Self {470	pub fn new() -> Self {
349			super_obj: None,475			super_obj: None,
350			map: GcHashMap::with_capacity(capacity),476			map: GcHashMap::with_capacity(capacity),
351			assertions: Vec::new(),477			assertions: Vec::new(),
478			next_field_index: FieldIndex::default(),
352		}479		}
353	}480	}
354	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {481	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {
364		self.assertions.push(assertion);491		self.assertions.push(assertion);
365		self492		self
366	}493	}
367	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder {494	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder> {
495		let field_index = self.next_field_index;
496		self.next_field_index = self.next_field_index.next();
368		ObjMemberBuilder {497		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)
369			value: self,
370			name,
371			add: false,
372			visibility: Visibility::Normal,
373			location: None,
374		}
375	}498	}
376499
377	pub fn build(self) -> ObjValue {500	pub fn build(self) -> ObjValue {
385}508}
386509
387#[must_use = "value not added unless binding() was called"]510#[must_use = "value not added unless binding() was called"]
388pub struct ObjMemberBuilder<'v> {511pub struct ObjMemberBuilder<Kind> {
389	value: &'v mut ObjValueBuilder,512	kind: Kind,
390	name: IStr,513	name: IStr,
391	add: bool,514	add: bool,
392	visibility: Visibility,515	visibility: Visibility,
516	original_index: FieldIndex,
393	location: Option<ExprLocation>,517	location: Option<ExprLocation>,
394}518}
395519
396#[allow(clippy::missing_const_for_fn)]520#[allow(clippy::missing_const_for_fn)]
397impl<'v> ObjMemberBuilder<'v> {521impl<Kind> ObjMemberBuilder<Kind> {
522	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {
523		Self {
524			kind,
525			name,
526			original_index,
527			add: false,
528			visibility: Visibility::Normal,
529			location: None,
530		}
531	}
532
533	pub const fn with_add(mut self, add: bool) -> Self {
534		self.add = add;
535		self
536	}
537	pub fn add(self) -> Self {
538		self.with_add(true)
539	}
540	pub fn with_visibility(mut self, visibility: Visibility) -> Self {
541		self.visibility = visibility;
542		self
543	}
544	pub fn hide(self) -> Self {
545		self.with_visibility(Visibility::Hidden)
546	}
547	pub fn with_location(mut self, location: ExprLocation) -> Self {
548		self.location = Some(location);
549		self
550	}
551	fn build_member(self, binding: LazyBinding) -> (Kind, IStr, ObjMember) {
552		(
553			self.kind,
554			self.name,
555			ObjMember {
556				add: self.add,
557				visibility: self.visibility,
558				original_index: self.original_index,
559				invoke: binding,
560				location: self.location,
561			},
562		)
563	}
564}
565
398	pub const fn with_add(mut self, add: bool) -> Self {566pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);
399		self.add = add;567impl<'v> ObjMemberBuilder<ValueBuilder<'v>> {
400		self
401	}
402	pub fn add(self) -> Self {
403		self.with_add(true)
404	}
405	pub fn with_visibility(mut self, visibility: Visibility) -> Self {
406		self.visibility = visibility;
407		self
408	}
409	pub fn hide(self) -> Self {
410		self.with_visibility(Visibility::Hidden)
411	}
412	pub fn with_location(mut self, location: ExprLocation) -> Self {
413		self.location = Some(location);
414		self
415	}
416	pub fn value(self, value: Val) -> Result<()> {568	pub fn value(self, value: Val) -> Result<()> {
417		self.binding(LazyBinding::Bound(LazyVal::new_resolved(value)))569		self.binding(LazyBinding::Bound(LazyVal::new_resolved(value)))
418	}570	}
419	pub fn bindable(self, bindable: TraceBox<dyn Bindable>) -> Result<()> {571	pub fn bindable(self, bindable: TraceBox<dyn Bindable>) -> Result<()> {
420		self.binding(LazyBinding::Bindable(Cc::new(bindable)))572		self.binding(LazyBinding::Bindable(Cc::new(bindable)))
421	}573	}
422	pub fn binding(self, binding: LazyBinding) -> Result<()> {574	pub fn binding(self, binding: LazyBinding) -> Result<()> {
575		let (receiver, name, member) = self.build_member(binding);
576		let location = member.location.clone();
423		let old = self.value.map.insert(577		let old = receiver.0.map.insert(name.clone(), member);
424			self.name.clone(),
425			ObjMember {
426				add: self.add,
427				visibility: self.visibility,
428				invoke: binding,
429				location: self.location.clone(),
430			},
431		);
432		if old.is_some() {578		if old.is_some() {
433			push_frame(579			push_frame(
434				CallLocation(self.location.as_ref()),580				CallLocation(location.as_ref()),
435				|| format!("field <{}> initializtion", self.name.clone()),581				|| format!("field <{}> initializtion", name.clone()),
436				|| throw!(DuplicateFieldName(self.name.clone())),582				|| throw!(DuplicateFieldName(name.clone())),
437			)?583			)?
438		}584		}
439		Ok(())585		Ok(())
440	}586	}
441}587}
588
589pub struct ExtendBuilder<'v>(&'v mut ObjValue);
590impl<'v> ObjMemberBuilder<ExtendBuilder<'v>> {
591	pub fn value(self, value: Val) {
592		self.binding(LazyBinding::Bound(LazyVal::new_resolved(value)))
593	}
594	pub fn bindable(self, bindable: TraceBox<dyn Bindable>) {
595		self.binding(LazyBinding::Bindable(Cc::new(bindable)))
596	}
597	pub fn binding(self, binding: LazyBinding) -> () {
598		let (receiver, name, member) = self.build_member(binding);
599		let new = receiver.0.clone();
600		*receiver.0 = new.extend_with_raw_member(name, member)
601	}
602}
442603

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -167,11 +167,31 @@
 #[derive(Clone)]
 pub enum ManifestFormat {
 	YamlStream(Box<ManifestFormat>),
-	Yaml(usize),
-	Json(usize),
+	Yaml {
+		padding: usize,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order: bool,
+	},
+	Json {
+		padding: usize,
+		#[cfg(feature = "exp-preserve-order")]
+		preserve_order: bool,
+	},
 	ToString,
 	String,
 }
+impl ManifestFormat {
+	#[cfg(feature = "exp-preserve-order")]
+	fn preserve_order(&self) -> bool {
+		match self {
+			ManifestFormat::YamlStream(s) => s.preserve_order(),
+			ManifestFormat::Yaml { preserve_order, .. } => *preserve_order,
+			ManifestFormat::Json { preserve_order, .. } => *preserve_order,
+			ManifestFormat::ToString => false,
+			ManifestFormat::String => false,
+		}
+	}
+}
 
 #[derive(Debug, Clone, Trace)]
 pub struct Slice {
@@ -559,6 +579,8 @@
 					mtype: ManifestType::ToString,
 					newline: "\n",
 					key_val_sep: ": ",
+					#[cfg(feature = "exp-preserve-order")]
+					preserve_order: false,
 				},
 			)?
 			.into(),
@@ -571,7 +593,10 @@
 			Self::Obj(obj) => obj,
 			_ => throw!(MultiManifestOutputIsNotAObject),
 		};
-		let keys = obj.fields();
+		let keys = obj.fields(
+			#[cfg(feature = "exp-preserve-order")]
+			ty.preserve_order(),
+		);
 		let mut out = Vec::with_capacity(keys.len());
 		for key in keys {
 			let value = obj
@@ -622,8 +647,24 @@
 
 				out.into()
 			}
-			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,
-			ManifestFormat::Json(padding) => self.to_json(*padding)?,
+			ManifestFormat::Yaml {
+				padding,
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order,
+			} => self.to_yaml(
+				*padding,
+				#[cfg(feature = "exp-preserve-order")]
+				*preserve_order,
+			)?,
+			ManifestFormat::Json {
+				padding,
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order,
+			} => self.to_json(
+				*padding,
+				#[cfg(feature = "exp-preserve-order")]
+				*preserve_order,
+			)?,
 			ManifestFormat::ToString => self.to_string()?,
 			ManifestFormat::String => match self {
 				Self::Str(s) => s.clone(),
@@ -633,7 +674,11 @@
 	}
 
 	/// For manifestification
-	pub fn to_json(&self, padding: usize) -> Result<IStr> {
+	pub fn to_json(
+		&self,
+		padding: usize,
+		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
+	) -> Result<IStr> {
 		manifest_json_ex(
 			self,
 			&ManifestJsonOptions {
@@ -645,13 +690,19 @@
 				},
 				newline: "\n",
 				key_val_sep: ": ",
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order,
 			},
 		)
 		.map(|s| s.into())
 	}
 
 	/// Calls `std.manifestJson`
-	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {
+	pub fn to_std_json(
+		&self,
+		padding: usize,
+		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
+	) -> Result<Rc<str>> {
 		manifest_json_ex(
 			self,
 			&ManifestJsonOptions {
@@ -659,12 +710,18 @@
 				mtype: ManifestType::Std,
 				newline: "\n",
 				key_val_sep: ": ",
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order,
 			},
 		)
 		.map(|s| s.into())
 	}
 
-	pub fn to_yaml(&self, padding: usize) -> Result<IStr> {
+	pub fn to_yaml(
+		&self,
+		padding: usize,
+		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,
+	) -> Result<IStr> {
 		let padding = &" ".repeat(padding);
 		manifest_yaml_ex(
 			self,
@@ -672,6 +729,8 @@
 				padding,
 				arr_element_padding: padding,
 				quote_keys: false,
+				#[cfg(feature = "exp-preserve-order")]
+				preserve_order,
 			},
 		)
 		.map(|s| s.into())
@@ -733,8 +792,15 @@
 			if ObjValue::ptr_eq(a, b) {
 				return Ok(true);
 			}
-			let fields = a.fields();
-			if fields != b.fields() {
+			let fields = a.fields(
+				#[cfg(feature = "exp-preserve-order")]
+				false,
+			);
+			if fields
+				!= b.fields(
+					#[cfg(feature = "exp-preserve-order")]
+					false,
+				) {
 				return Ok(false);
 			}
 			for field in fields {

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -122,6 +122,7 @@
 		ty: Box<Type>,
 		is_option: bool,
 		name: String,
+		cfg_attrs: Vec<Attribute>,
 		// ident: Ident,
 	},
 	Lazy {
@@ -134,20 +135,15 @@
 
 impl ArgInfo {
 	fn parse(arg: &FnArg) -> Result<Self> {
-		let typed = match arg {
+		let arg = match arg {
 			FnArg::Receiver(_) => unreachable!(),
 			FnArg::Typed(a) => a,
 		};
-		let ident = match &typed.pat as &Pat {
+		let ident = match &arg.pat as &Pat {
 			Pat::Ident(i) => i.ident.clone(),
-			_ => {
-				return Err(Error::new(
-					typed.pat.span(),
-					"arg should be plain identifier",
-				))
-			}
+			_ => return Err(Error::new(arg.pat.span(), "arg should be plain identifier")),
 		};
-		let ty = &typed.ty;
+		let ty = &arg.ty;
 		if type_is_path(ty, "CallLocation").is_some() {
 			return Ok(Self::Location);
 		} else if type_is_path(ty, "Self").is_some() {
@@ -172,11 +168,18 @@
 			(false, ty.clone())
 		};
 
+		let cfg_attrs = arg
+			.attrs
+			.iter()
+			.filter(|a| a.path.is_ident("cfg"))
+			.cloned()
+			.collect();
+
 		Ok(Self::Normal {
 			ty,
 			is_option,
 			name: ident.to_string(),
-			// ident,
+			cfg_attrs,
 		})
 	}
 }
@@ -215,13 +218,22 @@
 
 	let params_desc = args.iter().flat_map(|a| match a {
 		ArgInfo::Normal {
-			is_option, name, ..
-		}
-		| ArgInfo::Lazy { is_option, name } => Some(quote! {
+			is_option,
+			name,
+			cfg_attrs,
+			..
+		} => Some(quote! {
+			#(#cfg_attrs)*
+			BuiltinParam {
+				name: std::borrow::Cow::Borrowed(#name),
+				has_default: #is_option,
+			},
+		}),
+		ArgInfo::Lazy { is_option, name } => Some(quote! {
 			BuiltinParam {
 				name: std::borrow::Cow::Borrowed(#name),
 				has_default: #is_option,
-			}
+			},
 		}),
 		ArgInfo::Location => None,
 		ArgInfo::This => None,
@@ -232,23 +244,27 @@
 			ty,
 			is_option,
 			name,
-			// ident,
+			cfg_attrs,
 		} => {
 			let eval = quote! {::jrsonnet_evaluator::push_description_frame(
 				|| format!("argument <{}> evaluation", #name),
 				|| <#ty>::try_from(value.evaluate()?),
 			)?};
-			if *is_option {
+			let value = if *is_option {
 				quote! {if let Some(value) = parsed.get(#name) {
 					Some(#eval)
 				} else {
 					None
-				}}
+				},}
 			} else {
 				quote! {{
 					let value = parsed.get(#name).expect("args shape is checked");
 					#eval
-				}}
+				},}
+			};
+			quote! {
+				#(#cfg_attrs)*
+				#value
 			}
 		}
 		ArgInfo::Lazy { is_option, name } => {
@@ -260,12 +276,12 @@
 				}}
 			} else {
 				quote! {
-					parsed.get(#name).expect("args shape is correct").clone()
+					parsed.get(#name).expect("args shape is correct").clone(),
 				}
 			}
 		}
-		ArgInfo::Location => quote! {location},
-		ArgInfo::This => quote! {self},
+		ArgInfo::Location => quote! {location,},
+		ArgInfo::This => quote! {self,},
 	});
 
 	let fields = attr.fields.iter().map(|field| {
@@ -309,7 +325,7 @@
 				parser::ExprLocation,
 			};
 			const PARAMS: &'static [BuiltinParam] = &[
-				#(#params_desc),*
+				#(#params_desc)*
 			];
 
 			#static_ext
@@ -326,7 +342,7 @@
 				fn call(&self, context: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {
 					let parsed = parse_builtin_call(context, &PARAMS, args, false)?;
 
-					let result: #result = #name(#(#pass),*);
+					let result: #result = #name(#(#pass)*);
 					let result = result?;
 					result.try_into()
 				}