Fix mysterious clippy lints (#2640)

Author: slerpyyy

source/rust_verify_test/tests/common/mod.rs

@@ -1,4 +1,4 @@
-#![allow(dead_code)]
+#![allow(dead_code, clippy::result_large_err)]
 
 extern crate rustc_driver;
 extern crate rustc_errors;
@@ -54,7 +54,6 @@ pub struct TestErr {
     pub json_output: Option<serde_json::Value>, // captured when `--output-json` is used
 }
 
-#[allow(dead_code)]
 pub fn verify_files(
     name: &str,
     files: impl IntoIterator<Item = (String, String)>,
@@ -66,10 +65,9 @@ pub fn verify_files(
 
 use std::{cell::RefCell, path};
 thread_local! {
-    pub static THREAD_LOCAL_TEST_NAME: RefCell<Option<String>> = RefCell::new(None);
+    pub static THREAD_LOCAL_TEST_NAME: RefCell<Option<String>> = const { RefCell::new(None) };
 }
 
-#[allow(dead_code)]
 pub fn verify_files_vstd(
     name: &str,
     files: impl IntoIterator<Item = (String, String)>,
@@ -80,7 +78,6 @@ pub fn verify_files_vstd(
     verify_files_vstd_all_diags(name, files, entry_file, import_vstd, options).map(|_| ())
 }
 
-#[allow(dead_code)]
 pub fn verify_files_vstd_all_diags(
     name: &str,
     files: impl IntoIterator<Item = (String, String)>,
@@ -597,7 +594,6 @@ pub fn run_cargo_with_target(
     run
 }
 
-#[allow(dead_code)]
 pub const FEATURE_PRELUDE: &str = crate::common::code_str! {
     // If we're using the pre-macro-expanded vstd lib, then it might have
     // some macro-internal stuff in it, and rustc needs this option in order to accept it.
@@ -621,13 +617,11 @@ pub const FEATURE_PRELUDE: &str = crate::common::code_str! {
     #![feature(const_destruct)]
 };
 
-#[allow(dead_code)]
 pub const USE_PRELUDE: &str = crate::common::code_str! {
     use verus_builtin::*;
     use verus_builtin_macros::*;
 };
 
-#[allow(dead_code)]
 pub fn verify_one_file(name: &str, code: String, options: &[&str]) -> Result<TestErr, TestErr> {
     let mut options: Vec<_> = options.into_iter().map(|x| *x).collect();
     let mut no_prelude = false;
@@ -791,14 +785,10 @@ pub fn relevant_error_span(err: &Vec<DiagnosticSpan>) -> &DiagnosticSpan {
     }) {
         return e;
     }
-    err.iter()
-        .filter(|e| e.label != Some(vir::def::THIS_PRE_FAILED.to_string()))
-        .next()
-        .expect("span")
+    err.iter().find(|e| e.label != Some(vir::def::THIS_PRE_FAILED.to_string())).expect("span")
 }
 
 /// Assert that one verification failure happened on source lines containing the string "FAILS".
-#[allow(dead_code)]
 pub fn assert_one_fails(err: TestErr) {
     assert_eq!(err.errors.len(), 1);
     assert!(
@@ -812,7 +802,6 @@ pub fn assert_one_fails(err: TestErr) {
 
 /// When this testcase has ONE verification failure,
 /// assert that all spans are properly reported (All spans are respoinsible to the verification failure)
-#[allow(dead_code)]
 pub fn assert_expand_fails(err: TestErr, span_count: usize) {
     assert_fails(err.clone(), 1);
 
@@ -825,7 +814,6 @@ pub fn assert_expand_fails(err: TestErr, span_count: usize) {
 }
 
 /// Assert that `count` verification failures happened on source lines containin the string "FAILS".
-#[allow(dead_code)]
 pub fn assert_fails(err: TestErr, count: usize) {
     assert_eq!(err.errors.len(), count);
     for c in 0..count {
@@ -839,20 +827,17 @@ pub fn assert_fails(err: TestErr, count: usize) {
     }
 }
 
-#[allow(dead_code)]
 pub fn assert_vir_error_msg(err: TestErr, expected_msg: &str) {
     assert_eq!(err.errors.len(), 1);
     assert!(err.errors[0].code.is_none()); // thus likely a VIR error
     assert!(err.errors[0].message.contains(expected_msg));
 }
 
-#[allow(dead_code)]
 pub fn assert_any_vir_error_msg(err: TestErr, expected_msg: &str) {
     assert!(err.errors.iter().all(|x| x.code.is_none())); // thus likely a VIR error
     assert!(err.errors.iter().any(|x| x.message.contains(expected_msg)));
 }
 
-#[allow(dead_code)]
 pub fn assert_vir_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     assert!(err.errors.len() == expected_msgs.len());
     assert!(err.errors.iter().all(|x| x.code.is_none())); // thus likely a VIR error
@@ -861,20 +846,17 @@ pub fn assert_vir_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     }
 }
 
-#[allow(dead_code)]
 pub fn assert_custom_attr_error_msg(err: TestErr, expected_msg: &str) {
     assert!(
         err.errors.iter().any(|x| x.message.contains("custom attribute panicked")
             && x.rendered.contains(expected_msg))
     );
 }
 
-#[allow(dead_code)]
 pub fn assert_help_error_msg(err: TestErr, expected_msg: &str) {
     assert!(err.errors.iter().any(|x| x.rendered.contains(expected_msg)));
 }
 
-#[allow(dead_code)]
 pub fn assert_help_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     assert!(
         expected_msgs
@@ -883,7 +865,6 @@ pub fn assert_help_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     );
 }
 
-#[allow(dead_code)]
 pub fn assert_rust_error_msg(err: TestErr, expected_msg: &str) {
     assert_eq!(err.errors.len(), 1);
     let error_re = regex::Regex::new(r"^E[0-9]{4}$").unwrap();
@@ -896,14 +877,11 @@ pub fn assert_rust_error_msg(err: TestErr, expected_msg: &str) {
     assert!(err.errors[0].message.contains(expected_msg));
 }
 
-#[allow(dead_code)]
-pub fn assert_rust_error_msg_skip_spec_msgs(err: TestErr, expected_msg: &str) {
-    let mut err = err;
-    err.errors = err.errors.into_iter().filter(|e| !e.message.contains("(Verus spec")).collect();
+pub fn assert_rust_error_msg_skip_spec_msgs(mut err: TestErr, expected_msg: &str) {
+    err.errors.retain(|e| !e.message.contains("(Verus spec"));
     assert_rust_error_msg(err, expected_msg)
 }
 
-#[allow(dead_code)]
 pub fn assert_rust_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     assert_eq!(err.errors.len(), expected_msgs.len());
     let error_re = regex::Regex::new(r"^E[0-9]{4}$").unwrap();
@@ -918,7 +896,6 @@ pub fn assert_rust_error_msgs(err: TestErr, expected_msgs: &[&str]) {
     }
 }
 
-#[allow(dead_code)]
 pub fn assert_rust_error_msg_all(err: TestErr, expected_msg: &str) {
     assert!(err.errors.len() >= 1);
     let error_re = regex::Regex::new(r"^E[0-9]{4}$").unwrap();
@@ -928,7 +905,6 @@ pub fn assert_rust_error_msg_all(err: TestErr, expected_msg: &str) {
     }
 }
 
-#[allow(dead_code)]
 pub fn assert_rust_error_msg_any(err: TestErr, expected_msg: &str) {
     assert!(err.errors.len() >= 1);
     let error_re = regex::Regex::new(r"^E[0-9]{4}$").unwrap();
@@ -942,7 +918,6 @@ pub fn assert_rust_error_msg_any(err: TestErr, expected_msg: &str) {
     assert!(found);
 }
 
-#[allow(dead_code)]
 pub fn assert_spans_contain(err: &Diagnostic, needle: &str) {
     assert!(
         err.spans
@@ -952,7 +927,6 @@ pub fn assert_spans_contain(err: &Diagnostic, needle: &str) {
     );
 }
 
-#[allow(dead_code)]
 pub fn assert_fails_bv(err: TestErr, fail32: bool, fail64: bool) {
     assert_eq!(err.errors.len(), (if fail32 { 1 } else { 0 }) + (if fail64 { 1 } else { 0 }));
     if fail32 {
@@ -964,29 +938,22 @@ pub fn assert_fails_bv(err: TestErr, fail32: bool, fail64: bool) {
     }
 }
 
-#[allow(dead_code)]
 pub fn assert_fails_bv_32bit(err: TestErr) {
     assert_fails_bv(err, true, false);
 }
 
-#[allow(dead_code)]
 pub fn assert_fails_bv_64bit(err: TestErr) {
     assert_fails_bv(err, false, true);
 }
 
-#[allow(dead_code)]
 pub fn assert_fails_bv_32bit_64bit(err: TestErr) {
     assert_fails_bv(err, true, true);
 }
 
 pub fn typ_inv_relevant_error_span(err: &Vec<DiagnosticSpan>) -> &DiagnosticSpan {
-    err.iter()
-        .filter(|e| e.label != Some("type invariant declared here".to_string()))
-        .next()
-        .expect("span")
+    err.iter().find(|e| e.label != Some("type invariant declared here".to_string())).expect("span")
 }
 
-#[allow(dead_code)]
 pub fn assert_has_recommends_failure(err: TestErr) {
     assert!(err.errors.len() > 0);
     let mut found_rec_failure = false;
@@ -999,7 +966,6 @@ pub fn assert_has_recommends_failure(err: TestErr) {
     assert!(found_rec_failure);
 }
 
-#[allow(dead_code)]
 pub fn assert_fails_type_invariant_error(err: TestErr, count: usize) {
     assert_eq!(err.errors.len(), count);
     for c in 0..count {

source/rust_verify_test/tests/examples.rs

@@ -156,6 +156,6 @@ fn run_example_for_file(file_path: &str) {
             }
         }
         eprintln!("- stdout -\n{}\n", stdout);
-        assert!(false);
+        panic!();
     }
 }

source/rust_verify_test/tests/output_json.rs

@@ -255,8 +255,9 @@ fn with_json_func_details(err: &TestErr, func: &str, body: impl FnOnce(&FuncDeta
         .and_then(|v| v.as_object())
         .expect("`func-details` missing or not an object");
 
-    let details_json =
-        func_details.get(func).expect(&format!("func-details has no entry for `{func}`"));
+    let details_json = func_details
+        .get(func)
+        .unwrap_or_else(|| panic!("func-details has no entry for `{}`", func));
 
     let details =
         serde_json::from_value(details_json.clone()).expect("failed to deserialize FuncDetails");

source/verus/src/record_history.rs

@@ -63,10 +63,9 @@ pub fn record_history_commit(
                     .iter()
                     .filter(|d| d.starts_with(&cur_path))
                     .map(|d| {
-                        (
-                            d.components().skip(cur_path_components).next().unwrap(),
-                            d.components().skip(cur_path_components).count() == 1,
-                        )
+                        let name = d.components().nth(cur_path_components).unwrap();
+                        let is_file = d.components().skip(cur_path_components).count() == 1;
+                        (name, is_file)
                     })
                     .collect();
                 for (name, is_file) in here.into_iter() {