Fix Rust 1.83 warnings

Cargo.toml

@@ -38,6 +38,7 @@ once_cell = "1.19.0"
 percent-encoding = "2.3.1"
 rand = "0.8.5"
 regex = "1.10.4"
+rustversion = "1.0.18"
 semver = "1.0.20"
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.68"

crates/generate-book/src/main.rs

@@ -49,7 +49,7 @@ struct Chapter<'a> {
   language: Language,
 }
 
-impl<'a> Chapter<'a> {
+impl Chapter<'_> {
   fn title(&self) -> String {
     if self.index == 0 {
       return self.language.introduction().into();

src/alias.rs

@@ -47,7 +47,7 @@ impl<'src> Display for Alias<'src, Name<'src>> {
   }
 }
 
-impl<'src> Display for Alias<'src> {
+impl Display for Alias<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(
       f,

src/assignment.rs

@@ -3,7 +3,7 @@ use super::*;
 /// An assignment, e.g `foo := bar`
 pub(crate) type Assignment<'src> = Binding<'src, Expression<'src>>;
 
-impl<'src> Display for Assignment<'src> {
+impl Display for Assignment<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     if self.export {
       write!(f, "export ")?;

src/ast.rs

@@ -11,7 +11,7 @@ pub(crate) struct Ast<'src> {
   pub(crate) working_directory: PathBuf,
 }
 
-impl<'src> Display for Ast<'src> {
+impl Display for Ast<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     let mut iter = self.items.iter().peekable();
 

src/attribute.rs

@@ -113,7 +113,7 @@ impl<'src> Attribute<'src> {
   }
 }
 
-impl<'src> Display for Attribute<'src> {
+impl Display for Attribute<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(f, "{}", self.name())?;
 

src/color_display.rs

@@ -13,7 +13,7 @@ pub(crate) trait ColorDisplay {
 
 pub(crate) struct Wrapper<'a>(&'a dyn ColorDisplay, Color);
 
-impl<'a> Display for Wrapper<'a> {
+impl Display for Wrapper<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     self.0.fmt(f, self.1)
   }

src/condition.rs

@@ -7,13 +7,13 @@ pub(crate) struct Condition<'src> {
   pub(crate) operator: ConditionalOperator,
 }
 
-impl<'src> Display for Condition<'src> {
+impl Display for Condition<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(f, "{} {} {}", self.lhs, self.operator, self.rhs)
   }
 }
 
-impl<'src> Serialize for Condition<'src> {
+impl Serialize for Condition<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/dependency.rs

@@ -7,7 +7,7 @@ pub(crate) struct Dependency<'src> {
   pub(crate) recipe: Rc<Recipe<'src>>,
 }
 
-impl<'src> Display for Dependency<'src> {
+impl Display for Dependency<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     if self.arguments.is_empty() {
       write!(f, "{}", self.recipe.name())

src/error.rs

@@ -240,7 +240,7 @@ impl<'src> From<CompileError<'src>> for Error<'src> {
   }
 }
 
-impl<'src> From<ConfigError> for Error<'src> {
+impl From<ConfigError> for Error<'_> {
   fn from(config_error: ConfigError) -> Self {
     Self::Config { config_error }
   }
@@ -252,13 +252,13 @@ impl<'src> From<dotenvy::Error> for Error<'src> {
   }
 }
 
-impl<'src> From<SearchError> for Error<'src> {
+impl From<SearchError> for Error<'_> {
   fn from(search_error: SearchError) -> Self {
     Self::Search { search_error }
   }
 }
 
-impl<'src> ColorDisplay for Error<'src> {
+impl ColorDisplay for Error<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     use Error::*;
 

src/executor.rs

@@ -5,7 +5,7 @@ pub(crate) enum Executor<'a> {
   Shebang(Shebang<'a>),
 }
 
-impl<'a> Executor<'a> {
+impl Executor<'_> {
   pub(crate) fn command<'src>(
     &self,
     path: &Path,

src/expression.rs

@@ -60,7 +60,7 @@ impl<'src> Expression<'src> {
   }
 }
 
-impl<'src> Display for Expression<'src> {
+impl Display for Expression<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     match self {
       Self::And { lhs, rhs } => write!(f, "{lhs} && {rhs}"),
@@ -86,7 +86,7 @@ impl<'src> Display for Expression<'src> {
   }
 }
 
-impl<'src> Serialize for Expression<'src> {
+impl Serialize for Expression<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/fragment.rs

@@ -9,7 +9,7 @@ pub(crate) enum Fragment<'src> {
   Interpolation { expression: Expression<'src> },
 }
 
-impl<'src> Serialize for Fragment<'src> {
+impl Serialize for Fragment<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/interpreter.rs

@@ -6,7 +6,7 @@ pub(crate) struct Interpreter<'src> {
   pub(crate) command: StringLiteral<'src>,
 }
 
-impl<'src> Interpreter<'src> {
+impl Interpreter<'_> {
   pub(crate) fn default_script_interpreter() -> &'static Interpreter<'static> {
     static INSTANCE: Lazy<Interpreter<'static>> = Lazy::new(|| Interpreter {
       arguments: vec![StringLiteral::from_raw("-eu")],
@@ -16,7 +16,7 @@ impl<'src> Interpreter<'src> {
   }
 }
 
-impl<'src> Display for Interpreter<'src> {
+impl Display for Interpreter<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(f, "{}", self.command)?;
 

src/item.rs

@@ -27,7 +27,7 @@ pub(crate) enum Item<'src> {
   },
 }
 
-impl<'src> Display for Item<'src> {
+impl Display for Item<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     match self {
       Self::Alias(alias) => write!(f, "{alias}"),

src/justfile.rs

@@ -427,7 +427,7 @@ impl<'src> Justfile<'src> {
   }
 }
 
-impl<'src> ColorDisplay for Justfile<'src> {
+impl ColorDisplay for Justfile<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     let mut items = self.recipes.len() + self.assignments.len() + self.aliases.len();
     for (name, assignment) in &self.assignments {

src/keyed.rs

@@ -18,6 +18,7 @@ where
   serializer.serialize_str(keyed.key())
 }
 
+#[rustversion::attr(since(1.83), allow(clippy::ref_option))]
 pub(crate) fn serialize_option<'src, S, K>(
   recipe: &Option<K>,
   serializer: S,

src/line.rs

@@ -9,7 +9,7 @@ pub(crate) struct Line<'src> {
   pub(crate) number: usize,
 }
 
-impl<'src> Line<'src> {
+impl Line<'_> {
   pub(crate) fn is_empty(&self) -> bool {
     self.fragments.is_empty()
   }

src/loader.rs

@@ -17,7 +17,7 @@ impl Loader {
     &'src self,
     root: &Path,
     path: &Path,
-  ) -> RunResult<(&'src Path, &'src str)> {
+  ) -> RunResult<'src, (&'src Path, &'src str)> {
     let src = fs::read_to_string(path).map_err(|io_error| Error::Load {
       path: path.into(),
       io_error,

src/name.rs

@@ -28,7 +28,7 @@ impl Display for Name<'_> {
   }
 }
 
-impl<'src> Serialize for Name<'src> {
+impl Serialize for Name<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/namepath.rs

@@ -16,7 +16,7 @@ impl<'src> Namepath<'src> {
   }
 }
 
-impl<'src> Display for Namepath<'src> {
+impl Display for Namepath<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     for (i, name) in self.0.iter().enumerate() {
       if i > 0 {
@@ -28,7 +28,7 @@ impl<'src> Display for Namepath<'src> {
   }
 }
 
-impl<'src> Serialize for Namepath<'src> {
+impl Serialize for Namepath<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/parameter.rs

@@ -13,7 +13,7 @@ pub(crate) struct Parameter<'src> {
   pub(crate) name: Name<'src>,
 }
 
-impl<'src> ColorDisplay for Parameter<'src> {
+impl ColorDisplay for Parameter<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     if let Some(prefix) = self.kind.prefix() {
       write!(f, "{}", color.annotation().paint(prefix))?;

src/recipe.rs

@@ -482,7 +482,7 @@ impl<'src, D> Recipe<'src, D> {
   }
 }
 
-impl<'src, D: Display> ColorDisplay for Recipe<'src, D> {
+impl<D: Display> ColorDisplay for Recipe<'_, D> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     if !self
       .attributes

src/recipe_signature.rs

@@ -5,7 +5,7 @@ pub(crate) struct RecipeSignature<'a> {
   pub(crate) recipe: &'a Recipe<'a>,
 }
 
-impl<'a> ColorDisplay for RecipeSignature<'a> {
+impl ColorDisplay for RecipeSignature<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     write!(f, "{}", self.name)?;
     for parameter in &self.recipe.parameters {

src/set.rs

@@ -12,7 +12,7 @@ impl<'src> Keyed<'src> for Set<'src> {
   }
 }
 
-impl<'src> Display for Set<'src> {
+impl Display for Set<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(f, "set {} := {}", self.name, self.value)
   }

src/setting.rs

@@ -22,7 +22,7 @@ pub(crate) enum Setting<'src> {
   WorkingDirectory(StringLiteral<'src>),
 }
 
-impl<'src> Display for Setting<'src> {
+impl Display for Setting<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     match self {
       Self::AllowDuplicateRecipes(value)

src/show_whitespace.rs

@@ -3,7 +3,7 @@ use super::*;
 /// String wrapper that uses nonblank characters to display spaces and tabs
 pub struct ShowWhitespace<'str>(pub &'str str);
 
-impl<'str> Display for ShowWhitespace<'str> {
+impl Display for ShowWhitespace<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     for c in self.0.chars() {
       match c {

src/string_literal.rs

@@ -22,7 +22,7 @@ impl<'src> StringLiteral<'src> {
   }
 }
 
-impl<'src> Display for StringLiteral<'src> {
+impl Display for StringLiteral<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     if self.expand {
       write!(f, "x")?;
@@ -38,7 +38,7 @@ impl<'src> Display for StringLiteral<'src> {
   }
 }
 
-impl<'src> Serialize for StringLiteral<'src> {
+impl Serialize for StringLiteral<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/suggestion.rs

@@ -6,7 +6,7 @@ pub(crate) struct Suggestion<'src> {
   pub(crate) target: Option<&'src str>,
 }
 
-impl<'src> Display for Suggestion<'src> {
+impl Display for Suggestion<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     write!(f, "Did you mean `{}`", self.name)?;
     if let Some(target) = self.target {

src/thunk.rs

@@ -183,7 +183,7 @@ impl Display for Thunk<'_> {
   }
 }
 
-impl<'src> Serialize for Thunk<'src> {
+impl Serialize for Thunk<'_> {
   fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
   where
     S: Serializer,

src/token.rs

@@ -21,7 +21,7 @@ impl<'src> Token<'src> {
   }
 }
 
-impl<'src> ColorDisplay for Token<'src> {
+impl ColorDisplay for Token<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
     let width = if self.length == 0 { 1 } else { self.length };
 

src/unresolved_dependency.rs

@@ -6,7 +6,7 @@ pub(crate) struct UnresolvedDependency<'src> {
   pub(crate) arguments: Vec<Expression<'src>>,
 }
 
-impl<'src> Display for UnresolvedDependency<'src> {
+impl Display for UnresolvedDependency<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     if self.arguments.is_empty() {
       write!(f, "{}", self.recipe)

src/variables.rs

@@ -10,7 +10,7 @@ impl<'expression, 'src> Variables<'expression, 'src> {
   }
 }
 
-impl<'expression, 'src> Iterator for Variables<'expression, 'src> {
+impl<'src> Iterator for Variables<'_, 'src> {
   type Item = Token<'src>;
 
   fn next(&mut self) -> Option<Token<'src>> {