style: fix clippy warnings

Cargo.toml

@@ -89,6 +89,7 @@ regex = "1.10"
 lru = "0.12.3"
 
 json-structural-diff = "0.1.0"
+syn-dissect-closure = "0.1.0"
 
 [workspace.lints.rust]
 unsafe_op_in_unsafe_fn = "deny"
@@ -107,9 +108,9 @@ macro_expanded_macro_exports_accessed_by_absolute_paths = "allow"
 all = "warn"
 
 [workspace.lints.clippy]
-all = "warn"
-nursery = "warn"
-pedantic = "warn"
+all = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
 
 ptr_arg = "allow"
 # Too verbose

bindings/jsonnet/src/native.rs

@@ -20,6 +20,7 @@ use crate::VM;
 /// - `ctx` User pointer, given in `jsonnet_native_callback`.
 /// - `argv` Array of arguments from Jsonnet code.
 /// - `param` success Set this byref param to 1 to indicate success and 0 for failure.
+///
 /// Returns the content of the imported file, or an error message.
 type JsonnetNativeCallback = unsafe extern "C" fn(
  ctx: *const c_void,

cmds/jrsonnet-fmt/src/comments.rs

@@ -20,7 +20,7 @@ pub fn format_comments(comments: &ChildTrivia, loc: CommentLocation, out: &mut P
  let Ok(c) = c else {
  let mut text = c.as_ref().unwrap_err() as &str;
  while !text.is_empty() {
- let pos = text.find(|c| c == '\n' || c == '\t').unwrap_or(text.len());
+ let pos = text.find(['\n', '\t']).unwrap_or(text.len());
  let sliced = &text[..pos];
  p!(out, string(sliced.to_string()));
  text = &text[pos..];

cmds/jrsonnet-fmt/src/tests.rs

@@ -75,5 +75,5 @@ fn complex_comments_snapshot() {
  b: '',
  },
  }"
- )))
+ )));
 }

crates/jrsonnet-evaluator/src/function/arglike.rs

@@ -91,6 +91,7 @@ pub trait ArgsLike {
  handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
  ) -> Result<()>;
  fn named_names(&self, handler: &mut dyn FnMut(&IStr));
+ fn is_empty(&self) -> bool;
 }
 
 impl ArgsLike for Vec<Val> {
@@ -117,6 +118,9 @@ impl ArgsLike for Vec<Val> {
  Ok(())
  }
  fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}
+ fn is_empty(&self) -> bool {
+ self.is_empty()
+ }
 }
 
 impl ArgsLike for ArgsDesc {
@@ -173,6 +177,10 @@ impl ArgsLike for ArgsDesc {
  handler(name);
  }
  }
+
+ fn is_empty(&self) -> bool {
+ self.unnamed.is_empty() && self.named.is_empty()
+ }
 }
 
 impl<V: ArgLike, S> ArgsLike for HashMap<IStr, V, S> {
@@ -206,6 +214,10 @@ impl<V: ArgLike, S> ArgsLike for HashMap<IStr, V, S> {
  handler(name);
  }
  }
+
+ fn is_empty(&self) -> bool {
+ self.is_empty()
+ }
 }
 impl<V, S> OptionalContext for HashMap<IStr, V, S> where V: ArgLike + OptionalContext {}
 
@@ -235,6 +247,10 @@ impl<A: ArgLike> ArgsLike for GcHashMap<IStr, A> {
  fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
  self.0.named_names(handler);
  }
+
+ fn is_empty(&self) -> bool {
+ self.0.is_empty()
+ }
 }
 
 macro_rules! impl_args_like {
@@ -267,43 +283,13 @@ macro_rules! impl_args_like {
  Ok(())
  }
  fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}
- }
- impl<$($gen: ArgLike,)*> OptionalContext for ($($gen,)*) where $($gen: OptionalContext),* {}
 
- impl<$($gen: ArgLike,)*> ArgsLike for ($((IStr, $gen),)*) {
- fn unnamed_len(&self) -> usize {
- 0
- }
- fn unnamed_iter(
- &self,
- _ctx: Context,
- _tailstrict: bool,
- _handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
- ) -> Result<()> {
- Ok(())
- }
- #[allow(non_snake_case)]
- fn named_iter(
- &self,
- ctx: Context,
- tailstrict: bool,
- handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
- ) -> Result<()> {
- let ($($gen,)*) = self;
- $(
- handler(&$gen.0, $gen.1.evaluate_arg(ctx.clone(), tailstrict)?)?;
- )*
- Ok(())
- }
- #[allow(non_snake_case)]
- fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
- let ($($gen,)*) = self;
- $(
- handler(&$gen.0);
- )*
+ fn is_empty(&self) -> bool {
+ // impl_args_like only implements non-empty tuples.
+ false
  }
  }
- impl<$($gen: ArgLike,)*> OptionalContext for ($((IStr, $gen),)*) where $($gen: OptionalContext),* {}
+ impl<$($gen: ArgLike,)*> OptionalContext for ($($gen,)*) where $($gen: OptionalContext),* {}
  };
  ($count:expr; $($cur:ident)* @ $c:ident $($rest:ident)*) => {
  impl_args_like!($count; $($cur)*);
@@ -342,5 +328,8 @@ impl ArgsLike for () {
  }
 
  fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}
+ fn is_empty(&self) -> bool {
+ true
+ }
 }
 impl OptionalContext for () {}

crates/jrsonnet-evaluator/src/function/mod.rs

@@ -12,7 +12,10 @@ use self::{
  native::NativeDesc,
  parse::{parse_default_function_call, parse_function_call},
 };
-use crate::{evaluate, evaluate_trivial, gc::TraceBox, tb, Context, ContextBuilder, Result, Val};
+use crate::{
+ bail, error::ErrorKind::*, evaluate, evaluate_trivial, gc::TraceBox, tb, Context,
+ ContextBuilder, Result, Thunk, Val,
+};
 
 pub mod arglike;
 pub mod builtin;
@@ -94,6 +97,8 @@ pub enum FuncVal {
  Id,
  /// Plain function implemented in jsonnet.
  Normal(Cc<FuncDesc>),
+ /// Function without arguments works just as a fancy thunk value.
+ Thunk(Thunk<Val>),
  /// Standard library function.
  StaticBuiltin(#[trace(skip)] &'static dyn StaticBuiltin),
  /// User-provided function.
@@ -104,6 +109,7 @@ impl Debug for FuncVal {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  match self {
  Self::Id => f.debug_tuple("Id").finish(),
+ Self::Thunk(arg0) => f.debug_tuple("Thunk").field(arg0).finish(),
  Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),
  Self::StaticBuiltin(arg0) => {
  f.debug_tuple("StaticBuiltin").field(&arg0.name()).finish()
@@ -146,6 +152,7 @@ impl FuncVal {
  )
  })
  .collect(),
+ Self::Thunk(_) => vec![],
  }
  }
  /// Amount of non-default required arguments
@@ -155,6 +162,7 @@ impl FuncVal {
  Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),
  Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
  Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
+ Self::Thunk(_) => 0,
  }
  }
  /// Function name, as defined in code.
@@ -164,6 +172,7 @@ impl FuncVal {
  Self::Normal(normal) => normal.name.clone(),
  Self::StaticBuiltin(builtin) => builtin.name().into(),
  Self::Builtin(builtin) => builtin.name().into(),
+ Self::Thunk(_) => "thunk".into(),
  }
  }
  /// Call function using arguments evaluated in specified `call_ctx` [`Context`].
@@ -182,6 +191,12 @@ impl FuncVal {
  let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;
  evaluate(body_ctx, &func.body)
  }
+ Self::Thunk(thunk) => {
+ if args.is_empty() {
+ bail!(TooManyArgsFunctionHas(0, vec![],))
+ }
+ thunk.evaluate()
+ }
  Self::StaticBuiltin(b) => b.call(call_ctx, loc, args),
  Self::Builtin(b) => b.call(call_ctx, loc, args),
  }

crates/jrsonnet-evaluator/src/stdlib/format.rs

@@ -308,22 +308,21 @@ pub fn render_integer(
  prefix: &str,
  caps: bool,
 ) {
- let radix = radix as f64;
- let iv = iv.floor();
+ let iv = iv.floor() as i64;
  // Digit char indexes in reverse order, i.e
  // for radix = 16 and n = 12f: [15, 2, 1]
- let digits = if iv == 0.0 {
+ let digits = if iv == 0 {
  vec![0u8]
  } else {
  let mut v = iv.abs();
  let mut nums = Vec::with_capacity(1);
- while v != 0.0 {
+ while v != 0 {
  nums.push((v % radix) as u8);
- v = (v / radix).floor();
+ v /= radix;
  }
  nums
  };
- let neg = iv < 0.0;
+ let neg = iv < 0;
  #[allow(clippy::bool_to_int_with_if)]
  let zp = padding.saturating_sub(if neg || blank || sign { 1 } else { 0 });
  let zp2 = zp

crates/jrsonnet-rowan-parser/src/ast.rs

@@ -16,12 +16,14 @@ pub trait AstNode {
  Self: Sized;
 
  fn syntax(&self) -> &SyntaxNode;
+ #[must_use]
  fn clone_for_update(&self) -> Self
  where
  Self: Sized,
  {
  Self::cast(self.syntax().clone_for_update()).unwrap()
  }
+ #[must_use]
  fn clone_subtree(&self) -> Self
  where
  Self: Sized,
@@ -70,6 +72,8 @@ impl<N: AstNode> Iterator for AstChildren<N> {
 }
 
 pub mod support {
+ use rowan::NodeOrToken;
+
  use super::{AstChildren, AstNode, AstToken, SyntaxKind, SyntaxNode, SyntaxToken};
 
  pub fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
@@ -89,7 +93,7 @@ pub mod support {
  pub fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
  parent
  .children_with_tokens()
- .filter_map(|it| it.into_token())
+ .filter_map(NodeOrToken::into_token)
  .find(|it| it.kind() == kind)
  }
 }

crates/jrsonnet-rowan-parser/src/event.rs

@@ -26,7 +26,7 @@ pub enum Event {
  // VirtualToken { kind: SyntaxKind },
  /// Position of finished node
  Finish {
- /// Same as forward_parent of Start, but for wrapping
+ /// Same as `forward_parent` of Start, but for wrapping
  wrapper: Option<NonZeroUsize>,
  error: Option<Box<SyntaxError>>,
  },
@@ -57,13 +57,14 @@ impl<'i> Sink<'i> {
  if self.offset == 0 {
  return 0.into();
  };
- if let Some(lex) = self.lexemes.get(self.offset) {
- lex.range.start()
- } else if let Some(lex) = self.lexemes.get(self.offset - 1) {
- lex.range.end()
- } else {
- panic!("hard oob")
- }
+ self.lexemes.get(self.offset).map_or_else(
+ || {
+ self.lexemes
+ .get(self.offset - 1)
+ .map_or_else(|| panic!("hard oob"), |lex| lex.range.end())
+ },
+ |lex| lex.range.start(),
+ )
  }
 
  pub(super) fn finish(mut self) -> Parse {
@@ -139,7 +140,7 @@ impl<'i> Sink<'i> {
  self.errors.push(LocatedSyntaxError {
  error: *error,
  range: TextRange::new(range.0, range.1),
- })
+ });
  }
  self.builder.finish_node();
  depth -= 1;
@@ -158,7 +159,7 @@ impl<'i> Sink<'i> {
  self.errors.push(LocatedSyntaxError {
  error: *error,
  range: TextRange::new(range.0, range.1),
- })
+ });
  }
 
  if depth == 1 {

crates/jrsonnet-stdlib/src/manifest/mod.rs

@@ -98,6 +98,7 @@ pub fn builtin_manifest_yaml_doc(
 }
 
 #[builtin]
+#[allow(clippy::fn_params_excessive_bools)]
 pub fn builtin_manifest_yaml_stream(
  value: Val,
  #[default(false)] indent_array_in_object: bool,

crates/jrsonnet-stdlib/src/manifest/yaml.rs

@@ -76,7 +76,7 @@ fn yaml_needs_quotes(string: &str) -> bool {
 
  string.is_empty()
  || need_quotes_spaces(string)
- || string.starts_with(|c| matches!(c, '&' | '*' | '?' | '|' | '-' | '<' | '>' | '=' | '!' | '%' | '@'))
+ || string.starts_with(['&' , '*' , '?' , '|' , '-' , '<' , '>' , '=' , '!' , '%' , '@'])
  || string.contains(|c| matches!(c, ':' | '{' | '}' | '[' | ']' | ',' | '#' | '`' | '\"' | '\'' | '\\' | '\0'..='\x06' | '\t' | '\n' | '\r' | '\x0e'..='\x1a' | '\x1c'..='\x1f'))
  || [
  // http://yaml.org/type/bool.html

crates/jrsonnet-stdlib/src/strings.rs

@@ -267,15 +267,16 @@ fn new_trim_pattern(chars: IndexableVal) -> Result<impl Fn(char) -> bool> {
 }
 
 #[cfg(test)]
+#[allow(clippy::float_cmp)]
 mod tests {
  use super::*;
 
  #[test]
  fn parse_nat_base_8() {
  assert_eq!(parse_nat::<8>("0").unwrap(), 0.);
  assert_eq!(parse_nat::<8>("5").unwrap(), 5.);
- assert_eq!(parse_nat::<8>("32").unwrap(), 0o32 as f64);
- assert_eq!(parse_nat::<8>("761").unwrap(), 0o761 as f64);
+ assert_eq!(parse_nat::<8>("32").unwrap(), f64::from(0o32));
+ assert_eq!(parse_nat::<8>("761").unwrap(), f64::from(0o761));
  }
 
  #[test]
@@ -290,7 +291,7 @@ mod tests {
  fn parse_nat_base_16() {
  assert_eq!(parse_nat::<16>("0").unwrap(), 0.);
  assert_eq!(parse_nat::<16>("A").unwrap(), 10.);
- assert_eq!(parse_nat::<16>("a9").unwrap(), 0xA9 as f64);
- assert_eq!(parse_nat::<16>("BbC").unwrap(), 0xBBC as f64);
+ assert_eq!(parse_nat::<16>("a9").unwrap(), f64::from(0xA9));
+ assert_eq!(parse_nat::<16>("BbC").unwrap(), f64::from(0xBBC));
  }
 }