Auto merge of #12669 - weihanglo:lint-refactor, r=epage

refactor: fix lint errors in preparation of `[lints]` table integration

Author: bors

Cargo.lock

@@ -1,8 +1,8 @@
 allow-print-in-tests = true
 allow-dbg-in-tests = true
 disallowed-methods = [
-    { path = "std::env::var", reason = "Use `Config::get_env` instead. See rust-lang/cargo#11588" },
-    { path = "std::env::var_os", reason = "Use `Config::get_env_os` instead. See rust-lang/cargo#11588" },
-    { path = "std::env::vars", reason = "Not recommended to use in Cargo. See rust-lang/cargo#11588" },
-    { path = "std::env::vars_os", reason = "Not recommended to use in Cargo. See rust-lang/cargo#11588" },
+    { path = "std::env::var", reason = "use `Config::get_env` instead. See rust-lang/cargo#11588" },
+    { path = "std::env::var_os", reason = "use `Config::get_env_os` instead. See rust-lang/cargo#11588" },
+    { path = "std::env::vars", reason = "not recommended to use in Cargo. See rust-lang/cargo#11588" },
+    { path = "std::env::vars_os", reason = "not recommended to use in Cargo. See rust-lang/cargo#11588" },
 ]

clippy.toml

@@ -21,7 +21,7 @@ pub enum ParseErrorKind {
 }
 
 impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "failed to parse `{}` as a cfg expression: {}",
@@ -31,7 +31,7 @@ impl fmt::Display for ParseError {
 }
 
 impl fmt::Display for ParseErrorKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use ParseErrorKind::*;
         match self {
             UnterminatedString => write!(f, "unterminated string in cfg"),

crates/cargo-platform/src/error.rs

@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
 use proc_macro::*;
 use std::process::Command;
 use std::sync::Once;

crates/cargo-test-macro/src/lib.rs

@@ -790,7 +790,7 @@ impl HttpServer {
         }
     }
 
-    fn check_authorized(&self, req: &Request, mutation: Option<Mutation>) -> bool {
+    fn check_authorized(&self, req: &Request, mutation: Option<Mutation<'_>>) -> bool {
         let (private_key, private_key_subject) = if mutation.is_some() || self.auth_required {
             match &self.token {
                 Token::Plaintext(token) => return Some(token) == req.authorization.as_ref(),
@@ -832,7 +832,8 @@ impl HttpServer {
             url: &'a str,
             kip: &'a str,
         }
-        let footer: Footer = t!(serde_json::from_slice(untrusted_token.untrusted_footer()).ok());
+        let footer: Footer<'_> =
+            t!(serde_json::from_slice(untrusted_token.untrusted_footer()).ok());
         if footer.kip != paserk_pub_key_id {
             return false;
         }
@@ -846,7 +847,6 @@ impl HttpServer {
         if footer.url != "https://github.com/rust-lang/crates.io-index"
             && footer.url != &format!("sparse+http://{}/index/", self.addr.to_string())
         {
-            dbg!(footer.url);
             return false;
         }
 
@@ -862,20 +862,18 @@ impl HttpServer {
             _challenge: Option<&'a str>, // todo: PASETO with challenges
             v: Option<u8>,
         }
-        let message: Message = t!(serde_json::from_str(trusted_token.payload()).ok());
+        let message: Message<'_> = t!(serde_json::from_str(trusted_token.payload()).ok());
         let token_time = t!(OffsetDateTime::parse(message.iat, &Rfc3339).ok());
         let now = OffsetDateTime::now_utc();
         if (now - token_time) > Duration::MINUTE {
             return false;
         }
         if private_key_subject.as_deref() != message.sub {
-            dbg!(message.sub);
             return false;
         }
         // - If the claim v is set, that it has the value of 1.
         if let Some(v) = message.v {
             if v != 1 {
-                dbg!(message.v);
                 return false;
             }
         }
@@ -885,22 +883,18 @@ impl HttpServer {
         if let Some(mutation) = mutation {
             //  - That the operation matches the mutation field and is one of publish, yank, or unyank.
             if message.mutation != Some(mutation.mutation) {
-                dbg!(message.mutation);
                 return false;
             }
             //  - That the package, and version match the request.
             if message.name != mutation.name {
-                dbg!(message.name);
                 return false;
             }
             if message.vers != mutation.vers {
-                dbg!(message.vers);
                 return false;
             }
             //  - If the mutation is publish, that the version has not already been published, and that the hash matches the request.
             if mutation.mutation == "publish" {
                 if message.cksum != mutation.cksum {
-                    dbg!(message.cksum);
                     return false;
                 }
             }

crates/cargo-test-support/src/registry.rs

@@ -12,7 +12,7 @@ use std::path::Path;
 type FormatterRef<'a> = &'a (dyn Formatter + Send + Sync);
 
 /// Processes the handlebars template at the given file.
-pub fn expand(file: &Path, formatter: FormatterRef) -> Result<String, Error> {
+pub fn expand(file: &Path, formatter: FormatterRef<'_>) -> Result<String, Error> {
     let mut handlebars = Handlebars::new();
     handlebars.set_strict_mode(true);
     handlebars.register_helper("lower", Box::new(lower));
@@ -174,10 +174,10 @@ impl HelperDef for ManLinkHelper<'_> {
 ///
 /// This sets a variable to a value within the template context.
 fn set_decorator(
-    d: &Decorator,
-    _: &Handlebars,
+    d: &Decorator<'_, '_>,
+    _: &Handlebars<'_>,
     _ctx: &Context,
-    rc: &mut RenderContext,
+    rc: &mut RenderContext<'_, '_>,
 ) -> Result<(), RenderError> {
     let data_to_set = d.hash();
     for (k, v) in data_to_set {
@@ -187,7 +187,7 @@ fn set_decorator(
 }
 
 /// Sets a variable to a value within the context.
-fn set_in_context(rc: &mut RenderContext, key: &str, value: serde_json::Value) {
+fn set_in_context(rc: &mut RenderContext<'_, '_>, key: &str, value: serde_json::Value) {
     let mut ctx = match rc.context() {
         Some(c) => (*c).clone(),
         None => Context::wraps(serde_json::Value::Object(serde_json::Map::new())).unwrap(),
@@ -201,7 +201,7 @@ fn set_in_context(rc: &mut RenderContext, key: &str, value: serde_json::Value) {
 }
 
 /// Removes a variable from the context.
-fn remove_from_context(rc: &mut RenderContext, key: &str) {
+fn remove_from_context(rc: &mut RenderContext<'_, '_>, key: &str) {
     let ctx = rc.context().expect("cannot remove from null context");
     let mut ctx = (*ctx).clone();
     if let serde_json::Value::Object(m) = ctx.data_mut() {

crates/mdman/src/format.rs renamed to crates/mdman/src/format/mod.rs

@@ -64,7 +64,7 @@ pub fn convert(
 type EventIter<'a> = Box<dyn Iterator<Item = (Event<'a>, Range<usize>)> + 'a>;
 
 /// Creates a new markdown parser with the given input.
-pub(crate) fn md_parser(input: &str, url: Option<Url>) -> EventIter {
+pub(crate) fn md_parser(input: &str, url: Option<Url>) -> EventIter<'_> {
     let mut options = Options::empty();
     options.insert(Options::ENABLE_TABLES);
     options.insert(Options::ENABLE_FOOTNOTES);

crates/mdman/src/hbs.rs

@@ -48,7 +48,7 @@ fn run() -> Result<(), Error> {
         if same_file::is_same_file(source, &out_path).unwrap_or(false) {
             bail!("cannot output to the same file as the source");
         }
-        println!("Converting {} -> {}", source.display(), out_path.display());
+        eprintln!("Converting {} -> {}", source.display(), out_path.display());
         let result = mdman::convert(&source, opts.format, opts.url.clone(), opts.man_map.clone())
             .with_context(|| format!("failed to translate {}", source.display()))?;
 

crates/mdman/src/lib.rs

@@ -163,7 +163,7 @@ pub fn resolve_with_config_raw(
             if std::thread::panicking() && self.list.len() != self.used.len() {
                 // we found a case that causes a panic and did not use all of the input.
                 // lets print the part of the input that was used for minimization.
-                println!(
+                eprintln!(
                     "{:?}",
                     PrettyPrintRegistry(
                         self.list