git.delta.rocks / jrsonnet / refs/commits / 58696dc4e430

--- a/cmds/jrsonnet-fmt/src/comments.rs
+++ b/cmds/jrsonnet-fmt/src/comments.rs
@@ -72,7 +72,7 @@
 					if matches!(loc, CommentLocation::ItemInline) {
 						p!(pi: str(" "));
 					}
-					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */"))
+					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */") nl)
 				} else if !lines.is_empty() {
 					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
 						let offset = a

--- a/cmds/jrsonnet-fmt/src/main.rs
+++ b/cmds/jrsonnet-fmt/src/main.rs
@@ -372,8 +372,8 @@
 					return p!(new: str("{ }"));
 				}
 				let mut pi = p!(new: str("{") >i nl);
-				for mem in children.into_iter() {
-					if mem.should_start_with_newline {
+				for (i, mem) in children.into_iter().enumerate() {
+					if mem.should_start_with_newline && i != 0 {
 						p!(pi: nl);
 					}
 					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));

--- a/crates/jrsonnet-cli/src/manifest.rs
+++ b/crates/jrsonnet-cli/src/manifest.rs
@@ -6,7 +6,7 @@
 };
 use jrsonnet_stdlib::{TomlFormat, YamlFormat};
 
-#[derive(Clone, ValueEnum)]
+#[derive(Clone, Copy, ValueEnum)]
 pub enum ManifestFormatName {
 	/// Expect string as output, and write them directly
 	String,
@@ -18,9 +18,11 @@
 #[derive(Parser)]
 #[clap(next_help_heading = "MANIFESTIFICATION OUTPUT")]
 pub struct ManifestOpts {
-	/// Output format, wraps resulting value to corresponding std.manifest call.
-	#[clap(long, short = 'f', default_value = "json")]
-	format: ManifestFormatName,
+	/// Output format, wraps resulting value to corresponding std.manifest call
+	///
+	/// [default: json, yaml when -y is used]
+	#[clap(long, short = 'f')]
+	format: Option<ManifestFormatName>,
 	/// Expect plain string as output.
 	/// Mutually exclusive with `--format`
 	#[clap(long, short = 'S', conflicts_with = "format")]
@@ -29,7 +31,9 @@
 	#[clap(long, short = 'y', conflicts_with = "string")]
 	yaml_stream: bool,
 	/// Number of spaces to pad output manifest with.
-	/// `0` for hard tabs, `-1` for single line output [default: 3 for json, 2 for yaml/toml]
+	/// `0` for hard tabs, `-1` for single line output
+	///
+	/// [default: 3 for json, 2 for yaml/toml]
 	#[clap(long)]
 	line_padding: Option<usize>,
 	/// Preserve order in object manifestification
@@ -44,7 +48,12 @@
 		} else {
 			#[cfg(feature = "exp-preserve-order")]
 			let preserve_order = self.preserve_order;
-			match self.format {
+			let format = match self.format {
+				Some(v) => v,
+				None if self.yaml_stream => ManifestFormatName::Yaml,
+				None => ManifestFormatName::Json,
+			};
+			match format {
 				ManifestFormatName::String => Box::new(ToStringFormat),
 				ManifestFormatName::Json => Box::new(JsonFormat::cli(
 					self.line_padding.unwrap_or(3),

--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -372,7 +372,7 @@
 	pub fn new_inclusive(start: i32, end: i32) -> Self {
 		Self { start, end }
 	}
-	fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {
+	fn range(&self) -> impl ExactSizeIterator<Item = i32> + DoubleEndedIterator {
 		WithExactSize(
 			self.start..=self.end,
 			(self.end as usize)
@@ -461,7 +461,7 @@
 			ArrayThunk::Waiting(..) => {}
 		};
 
-		let ArrayThunk::Waiting(_) =
+		let ArrayThunk::Waiting(()) =
 			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
 		else {
 			unreachable!()
@@ -508,7 +508,7 @@
 		match &self.cached.borrow()[index] {
 			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
 			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
-			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}
+			ArrayThunk::Waiting(()) | ArrayThunk::Pending => {}
 		};
 
 		Some(Thunk::new(ArrayElement {
@@ -597,9 +597,7 @@
 	}
 
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		let Some(key) = self.keys.get(index) else {
-			return None;
-		};
+		let key = self.keys.get(index)?;
 		Some(self.obj.get_lazy_or_bail(key.clone()))
 	}
 
@@ -649,9 +647,7 @@
 	}
 
 	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
-		let Some(key) = self.keys.get(index) else {
-			return None;
-		};
+		let key = self.keys.get(index)?;
 		// Nothing can fail in the key part, yet value is still
 		// lazy-evaluated
 		Some(Thunk::evaluated(

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -89,7 +89,7 @@
 	specs: &[CompSpec],
 	callback: &mut impl FnMut(Context) -> Result<()>,
 ) -> Result<()> {
-	match specs.get(0) {
+	match specs.first() {
 		None => callback(ctx)?,
 		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
 			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -6,8 +6,8 @@
 use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
 use crate::{gc::TraceBox, tb, Context, Result, Val};
 
-/// Can't have str | IStr, because constant BuiltinParam causes
-/// E0492: constant functions cannot refer to interior mutable data
+/// Can't have `str` | `IStr`, because constant `BuiltinParam` causes
+/// `E0492: constant functions cannot refer to interior mutable data`
 #[derive(Clone, Trace)]
 pub struct ParamName(Option<Cow<'static, str>>);
 impl ParamName {
@@ -27,10 +27,9 @@
 }
 impl PartialEq<IStr> for ParamName {
 	fn eq(&self, other: &IStr) -> bool {
-		match &self.0 {
-			Some(s) => s.as_bytes() == other.as_bytes(),
-			None => false,
-		}
+		self.0
+			.as_ref()
+			.map_or(false, |s| s.as_bytes() == other.as_bytes())
 	}
 }
 
@@ -87,7 +86,7 @@
 			params: params
 				.into_iter()
 				.map(|n| BuiltinParam {
-					name: ParamName::new_dynamic(n.to_string()),
+					name: ParamName::new_dynamic(n),
 					has_default: false,
 				})
 				.collect(),

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -159,11 +159,11 @@
 			Val::Null => serializer.serialize_none(),
 			Val::Str(s) => serializer.serialize_str(&s.clone().into_flat()),
 			Val::Num(n) => {
-				if n.fract() != 0.0 {
-					serializer.serialize_f64(*n)
-				} else {
+				if n.fract() == 0.0 {
 					let n = *n as i64;
 					serializer.serialize_i64(n)
+				} else {
+					serializer.serialize_f64(*n)
 				}
 			}
 			#[cfg(feature = "exp-bigint")]

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -41,10 +41,12 @@
 	clippy::missing_const_for_fn,
 	// too many false-positives with .expect() calls
 	clippy::missing_panics_doc,
-    // false positive for IStr type. There is an configuration option for
-    // such cases, but it doesn't work:
-    // https://github.com/rust-lang/rust-clippy/issues/9801
-    clippy::mutable_key_type,
+	// false positive for IStr type. There is an configuration option for
+	// such cases, but it doesn't work:
+	// https://github.com/rust-lang/rust-clippy/issues/9801
+	clippy::mutable_key_type,
+	// false positives
+	clippy::redundant_pub_crate,
 )]
 
 // For jrsonnet-macros

--- a/crates/jrsonnet-evaluator/src/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/manifest.rs
@@ -175,6 +175,8 @@
 	manifest_json_ex_buf(val, &mut out, &mut String::new(), options)?;
 	Ok(out)
 }
+
+#[allow(clippy::too_many_lines)]
 fn manifest_json_ex_buf(
 	val: &Val,
 	buf: &mut String,

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -171,7 +171,7 @@
 			// .field("assertions_ran", &self.assertions_ran)
 			.field("this_entries", &self.this_entries)
 			// .field("value_cache", &self.value_cache)
-			.finish()
+			.finish_non_exhaustive()
 	}
 }
 
@@ -347,7 +347,7 @@
 		out.with_super(self);
 		let mut member = out.field(key);
 		if value.flags.add() {
-			member = member.add()
+			member = member.add();
 		}
 		if let Some(loc) = value.location {
 			member = member.with_location(loc);
@@ -395,7 +395,7 @@
 
 	pub fn get(&self, key: IStr) -> Result<Option<Val>> {
 		self.run_assertions()?;
-		self.get_for(key, self.0.this().unwrap_or(self.clone()))
+		self.get_for(key, self.0.this().unwrap_or_else(|| self.clone()))
 	}
 
 	pub fn get_for(&self, key: IStr, this: ObjValue) -> Result<Option<Val>> {
@@ -474,7 +474,7 @@
 			type Output = Val;
 
 			fn get(self: Box<Self>) -> Result<Self::Output> {
-				Ok(self.obj.get_or_bail(self.key)?)
+				self.obj.get_or_bail(self.key)
 			}
 		}
 
@@ -495,7 +495,7 @@
 			SuperDepth::default(),
 			&mut |depth, index, name, visibility| {
 				let new_sort_key = FieldSortKey::new(depth, index);
-				let entry = out.entry(name.clone());
+				let entry = out.entry(name);
 				let (visible, _) = entry.or_insert((true, new_sort_key));
 				match visibility {
 					Visibility::Normal => {}
@@ -634,7 +634,7 @@
 			SuperDepth::default(),
 			&mut |depth, index, name, visibility| {
 				let new_sort_key = FieldSortKey::new(depth, index);
-				let entry = out.entry(name.clone());
+				let entry = out.entry(name);
 				let (visible, _) = entry.or_insert((true, new_sort_key));
 				match visibility {
 					Visibility::Normal => {}

--- a/crates/jrsonnet-evaluator/src/stdlib/format.rs
+++ b/crates/jrsonnet-evaluator/src/stdlib/format.rs
@@ -248,7 +248,7 @@
 	let (cflags, str) = try_parse_cflags(str)?;
 	let (width, str) = try_parse_field_width(str)?;
 	let (precision, str) = try_parse_precision(str)?;
-	let (_, str) = try_parse_length_modifier(str)?;
+	let ((), str) = try_parse_length_modifier(str)?;
 	let (convtype, str) = parse_conversion_type(str)?;
 
 	Ok((

--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -449,25 +449,21 @@
 	}
 
 	fn from_untyped(value: Val) -> Result<Self> {
-		match &value {
-			Val::Arr(a) => {
-				if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {
-					return Ok(bytes.0.as_slice().into());
-				};
-				<Self as Typed>::TYPE.check(&value)?;
-				// Any::downcast_ref::<ByteArray>(&a);
-				let mut out = Vec::with_capacity(a.len());
-				for e in a.iter() {
-					let r = e?;
-					out.push(u8::from_untyped(r)?);
-				}
-				Ok(out.as_slice().into())
-			}
-			_ => {
-				<Self as Typed>::TYPE.check(&value)?;
-				unreachable!()
-			}
+		let Val::Arr(a) = &value else {
+			<Self as Typed>::TYPE.check(&value)?;
+			unreachable!()
+		};
+		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {
+			return Ok(bytes.0.as_slice().into());
+		};
+		<Self as Typed>::TYPE.check(&value)?;
+		// Any::downcast_ref::<ByteArray>(&a);
+		let mut out = Vec::with_capacity(a.len());
+		for e in a.iter() {
+			let r = e?;
+			out.push(u8::from_untyped(r)?);
 		}
+		Ok(out.as_slice().into())
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/typed/mod.rs
+++ b/crates/jrsonnet-evaluator/src/typed/mod.rs
@@ -90,7 +90,7 @@
 	item: impl Fn() -> Result<()>,
 ) -> Result<()> {
 	State::push_description(error_reason, || match item() {
-		Ok(_) => Ok(()),
+		Ok(()) => Ok(()),
 		Err(mut e) => {
 			if let ErrorKind::TypeError(e) = &mut e.error_mut() {
 				(e.1).0.push(path());

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -351,6 +351,8 @@
 	}
 }
 impl PartialEq for StrValue {
+	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.
+	#[allow(clippy::unconditional_recursion)]
 	fn eq(&self, other: &Self) -> bool {
 		let a = self.clone().into_flat();
 		let b = other.clone().into_flat();

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -6,7 +6,7 @@
 #![warn(clippy::pedantic, clippy::nursery)]
 #![allow(clippy::missing_const_for_fn)]
 use std::{
-	borrow::{Borrow, Cow},
+	borrow::Cow,
 	cell::RefCell,
 	fmt::{self, Display},
 	hash::{BuildHasherDefault, Hash, Hasher},
@@ -14,7 +14,7 @@
 	str,
 };
 
-use hashbrown::HashMap;
+use hashbrown::{hash_map::RawEntryMut, HashMap};
 use jrsonnet_gcmodule::Trace;
 use rustc_hash::FxHasher;
 
@@ -57,17 +57,6 @@
 	}
 }
 
-impl Borrow<str> for IStr {
-	fn borrow(&self) -> &str {
-		self.as_str()
-	}
-}
-impl Borrow<[u8]> for IStr {
-	fn borrow(&self) -> &[u8] {
-		self.as_bytes()
-	}
-}
-
 impl PartialEq for IStr {
 	fn eq(&self, other: &Self) -> bool {
 		// all IStr should be inlined into same pool
@@ -142,12 +131,6 @@
 	type Target = [u8];
 
 	fn deref(&self) -> &Self::Target {
-		self.0.as_slice()
-	}
-}
-
-impl Borrow<[u8]> for IBytes {
-	fn borrow(&self) -> &[u8] {
 		self.0.as_slice()
 	}
 }
@@ -285,9 +268,9 @@
 		let mut pool = pool.borrow_mut();
 		let entry = pool.raw_entry_mut().from_key(bytes);
 		match entry {
-			hashbrown::hash_map::RawEntryMut::Occupied(i) => IBytes(i.get_key_value().0.clone()),
-			hashbrown::hash_map::RawEntryMut::Vacant(e) => {
-				let (k, _) = e.insert(Inner::new_bytes(bytes), ());
+			RawEntryMut::Occupied(i) => IBytes(i.get_key_value().0.clone()),
+			RawEntryMut::Vacant(e) => {
+				let (k, ()) = e.insert(Inner::new_bytes(bytes), ());
 				IBytes(k.clone())
 			}
 		}

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -374,6 +374,7 @@
 				fn params(&self) -> &[BuiltinParam] {
 					PARAMS
 				}
+				#[allow(unused_variable)]
 				fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {
 					let parsed = parse_builtin_call(ctx.clone(), &PARAMS, args, false)?;
 

--- a/crates/jrsonnet-stdlib/src/encoding.rs
+++ b/crates/jrsonnet-stdlib/src/encoding.rs
@@ -39,5 +39,5 @@
 	let bytes = STANDARD
 		.decode(str.as_bytes())
 		.map_err(|e| runtime_error!("invalid base64: {e}"))?;
-	Ok(String::from_utf8(bytes).map_err(|_| runtime_error!("bad utf8"))?)
+	String::from_utf8(bytes).map_err(|_| runtime_error!("bad utf8"))
 }

--- a/crates/jrsonnet-stdlib/src/misc.rs
+++ b/crates/jrsonnet-stdlib/src/misc.rs
@@ -47,7 +47,7 @@
 		.ext_natives
 		.get(&x)
 		.cloned()
-		.map_or(Val::Null, |v| Val::Func(v))
+		.map_or(Val::Null, Val::Func)
 }
 
 #[builtin(fields(

--- a/flake.lock
+++ b/flake.lock
@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1694529238,
-        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1701376520,
-        "narHash": "sha256-U3iGiOZqgu7wvVzgfoQzGGFMqNsDj/q/6zPIjCy7ajg=",
+        "lastModified": 1705391267,
+        "narHash": "sha256-gGVm9QudiRtYTX8PN9cTTy7uuJcL4I2lRMoPx496kXk=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "c74cc3c3db2ed5e68895953d75c397797d499133",
+        "rev": "41a9a7f170c740acb24f3390323877d11c69d5ee",
         "type": "github"
       },
       "original": {
@@ -50,11 +50,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1701310566,
-        "narHash": "sha256-CL9J3xUR2Ejni4LysrEGX0IdO+Y4BXCiH/By0lmF3eQ=",
+        "lastModified": 1705371439,
+        "narHash": "sha256-P1kulUXpYWkcrjiX3sV4j8ACJZh9XXSaaD+jDLBDLKo=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "6d3c6e185198b8bf7ad639f22404a75aa9a09bff",
+        "rev": "b21f3c0d5bf0f0179f5f0140e8e0cd099618bd04",
         "type": "github"
       },
       "original": {

--- a/flake.nix
+++ b/flake.nix
@@ -25,14 +25,14 @@
         lib = pkgs.lib;
         rust =
           (pkgs.rustChannelOf {
-            date = "2023-10-28";
+            date = "2024-01-10";
             channel = "nightly";
           })
           .default
           .override {
             extensions = ["rust-src" "miri" "rust-analyzer" "clippy"];
           };
-      in rec {
+      in {
         packages = rec {
           go-jsonnet = pkgs.callPackage ./nix/go-jsonnet.nix {};
           sjsonnet = pkgs.callPackage ./nix/sjsonnet.nix {};

--- a/tests/suite/std_param_names.jsonnet
+++ b/tests/suite/std_param_names.jsonnet
@@ -103,6 +103,7 @@
     asin: ['x'],
     acos: ['x'],
     atan: ['x'],
+    atan2: ['y', 'x'],
     type: ['x'],
     filter: ['func', 'arr'],
     objectHasEx: ['obj', 'fname', 'hidden'],