Enable clippy for external-crates/move in CI, with clippy changes in the code. (#13529)

## Description 

Enables clippy for `external-crates/move`, including fixes that clippy
flagged (with a few ignores).

Hopefully this will avoid issues in the codebase in the future that
clippy will flag automatically.

**Most of these changes were made automatically with `cargo clippy
--fix` so special care should be taken in reviewing this diff.**

## Test Plan 

CI should work as expected, and now report signals for `move-clippy`, as
I've called it. (I'm happy to bikeshed the name.)

---
If your changes are not user-facing and not a breaking change, you can
skip the following section. Otherwise, please indicate what changed, and
then add to the Release Notes section as highlighted during the release
process.

### Type of Change (Check all that apply)

- [ ] protocol change
- [ ] user-visible impact
- [ ] breaking change for a client SDKs
- [ ] breaking change for FNs (FN binary must upgrade)
- [ ] breaking change for validators or node operators (must upgrade
binaries)
- [ ] breaking change for on-chain data layout
- [ ] necessitate either a data wipe or data migration

### Release notes

---------

Co-authored-by: Brandon Williams <[email protected]>

Author: cgswords

move-binary-format/src/file_format.rs

@@ -416,8 +416,10 @@ pub struct FieldDefinition {
 #[cfg_attr(any(test, feature = "fuzzing"), proptest(no_params))]
 #[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
 #[repr(u8)]
+#[derive(Default)]
 pub enum Visibility {
     /// Accessible within its defining module only.
+    #[default]
     Private = 0x0,
     /// Accessible by any module or script outside of its declaring module.
     Public = 0x1,
@@ -432,12 +434,6 @@ impl Visibility {
     pub const DEPRECATED_SCRIPT: u8 = 0x2;
 }
 
-impl Default for Visibility {
-    fn default() -> Self {
-        Visibility::Private
-    }
-}
-
 impl std::convert::TryFrom<u8> for Visibility {
     type Error = ();
 

move-binary-format/src/views.rs

@@ -441,7 +441,7 @@ impl<'a, T: ModuleAccess> LocalsSignatureView<'a, T> {
         let parameters = self.parameters();
         SignatureTokenView::new(
             self.function_def_view.module,
-            if (index as usize) < parameters.len() {
+            if index < parameters.len() {
                 &parameters[index]
             } else {
                 &self.additional_locals()[index - parameters.len()]

move-bytecode-verifier/src/struct_defs.rs

@@ -104,7 +104,7 @@ impl<'a> StructDefGraphBuilder<'a> {
         token: &SignatureToken,
     ) -> PartialVMResult<()> {
         use SignatureToken as T;
-        Ok(match token {
+        match token {
             T::Bool
             | T::U8
             | T::U16
@@ -141,6 +141,7 @@ impl<'a> StructDefGraphBuilder<'a> {
                     self.add_signature_token(neighbors, cur_idx, t)?
                 }
             }
-        })
+        };
+        Ok(())
     }
 }

move-command-line-common/src/types.rs

@@ -47,7 +47,7 @@ pub enum ParsedType {
 }
 
 impl Display for TypeToken {
-    fn fmt<'f>(&self, formatter: &mut fmt::Formatter<'f>) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         let s = match *self {
             TypeToken::Whitespace => "[whitespace]",
             TypeToken::Ident => "[identifier]",

move-command-line-common/src/values.rs

@@ -117,7 +117,7 @@ impl ParsableValue for () {
 }
 
 impl Display for ValueToken {
-    fn fmt<'f>(&self, formatter: &mut fmt::Formatter<'f>) -> Result<(), fmt::Error> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         let s = match self {
             ValueToken::Number => "[num]",
             ValueToken::NumberTyped => "[num typed]",

move-compiler/src/cfgir/translate.rs

@@ -90,15 +90,15 @@ impl<'env> Context<'env> {
         assert!(self.blocks.insert(lbl, basic_block).is_none());
         let block_info = match self.loop_bounds.get(&lbl) {
             None => BlockInfo::Other,
-            Some(info) => BlockInfo::LoopHead(info.clone()),
+            Some(info) => BlockInfo::LoopHead(*info),
         };
         self.block_info.push((lbl, block_info));
     }
 
     // Returns the blocks inserted in insertion ordering
     pub fn finish_blocks(&mut self) -> (Label, BasicBlocks, Vec<(Label, BlockInfo)>) {
         self.next_label = None;
-        let start = mem::replace(&mut self.start, None);
+        let start = self.start.take();
         let blocks = mem::take(&mut self.blocks);
         let block_ordering = mem::take(&mut self.block_ordering);
         let block_info = mem::take(&mut self.block_info);
@@ -765,13 +765,13 @@ fn visit_function(
         struct_declared_abilities: &context.struct_declared_abilities,
         signature,
         acquires,
-        locals: &locals,
+        locals,
         infinite_loop_starts: &infinite_loop_starts,
     };
     let mut ds = Diagnostics::new();
     for visitor in &context.env.visitors().abs_int {
         let mut v = visitor.borrow_mut();
-        ds.extend(v.verify(&context.env, prog, &function_context, &cfg));
+        ds.extend(v.verify(context.env, prog, &function_context, &cfg));
     }
     context.env.add_diags(ds);
     context.env.pop_warning_filter_scope();

move-compiler/src/cfgir/visitor.rs

@@ -110,7 +110,7 @@ impl<V: SimpleDomain> AbstractDomain for V {
         );
         let mut result = JoinResult::Unchanged;
         for (local, other_state) in other_locals {
-            match (self.locals().get(&local).unwrap(), other_state) {
+            match (self.locals().get(local).unwrap(), other_state) {
                 // both available, join the value
                 (L::Available(loc, v1), L::Available(_, v2)) => {
                     let loc = *loc;
@@ -390,7 +390,7 @@ pub trait SimpleAbsInt: Sized {
             E::ModuleCall(mcall) => {
                 let evalues = self.exp(context, state, &mcall.arguments);
                 if let Some(vs) =
-                    self.call_custom(context, state, eloc, &parent_e.ty, &mcall, evalues)
+                    self.call_custom(context, state, eloc, &parent_e.ty, mcall, evalues)
                 {
                     return vs;
                 }

move-compiler/src/diagnostics/mod.rs

@@ -391,7 +391,7 @@ impl WarningFilters {
     pub fn union(&mut self, other: &Self) {
         for (prefix, filters) in &other.0 {
             self.0
-                .entry(prefix.clone())
+                .entry(*prefix)
                 .or_insert_with(UnprefixedWarningFilters::new)
                 .union(filters);
         }
@@ -468,7 +468,7 @@ impl UnprefixedWarningFilters {
                 codes.extend(
                     other_codes
                         .iter()
-                        .filter(|((category, _), _)| !categories.contains_key(&category)),
+                        .filter(|((category, _), _)| !categories.contains_key(category)),
                 );
             }
         }
@@ -489,7 +489,7 @@ impl UnprefixedWarningFilters {
                     categories: BTreeMap::new(),
                     codes: BTreeMap::new(),
                 };
-                return self.add(filter_category, filter_code, filter_name);
+                self.add(filter_category, filter_code, filter_name)
             }
             Self::Specified { categories, .. } if categories.contains_key(&filter_category) => (),
             Self::Specified { categories, codes } => {
@@ -509,16 +509,16 @@ impl UnprefixedWarningFilters {
         let unused_fn_tparam_info = UnusedItem::FunTypeParam.into_info();
         let filtered_codes = BTreeMap::from([
             (
-                (unused_fun_info.category() as u8, unused_fun_info.code()),
+                (unused_fun_info.category(), unused_fun_info.code()),
                 Some(FILTER_UNUSED_FUNCTION),
             ),
             (
-                (unused_field_info.category() as u8, unused_field_info.code()),
+                (unused_field_info.category(), unused_field_info.code()),
                 Some(FILTER_UNUSED_STRUCT_FIELD),
             ),
             (
                 (
-                    unused_fn_tparam_info.category() as u8,
+                    unused_fn_tparam_info.category(),
                     unused_fn_tparam_info.code(),
                 ),
                 Some(FILTER_UNUSED_TYPE_PARAMETER),

move-compiler/src/editions/mod.rs

@@ -28,8 +28,9 @@ pub struct Edition {
 #[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord)]
 pub enum FeatureGate {}
 
-#[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug, PartialOrd, Ord, Default)]
 pub enum Flavor {
+    #[default]
     GlobalStorage,
     Sui,
 }
@@ -74,19 +75,19 @@ impl Edition {
 
     // Intended only for implementing the lazy static (supported feature map) above
     fn prev(&self) -> Option<Self> {
-        match self {
-            &Self::LEGACY => None,
-            &Self::E2024_ALPHA => Some(Self::LEGACY),
+        match *self {
+            Self::LEGACY => None,
+            Self::E2024_ALPHA => Some(Self::LEGACY),
             _ => self.unknown_edition_panic(),
         }
     }
 
     // Inefficient and should be called only to implement the lazy static
     // (supported feature map) above
     fn features(&self) -> BTreeSet<FeatureGate> {
-        match self {
-            &Self::LEGACY => BTreeSet::new(),
-            &Self::E2024_ALPHA => self.prev().unwrap().features(),
+        match *self {
+            Self::LEGACY => BTreeSet::new(),
+            Self::E2024_ALPHA => self.prev().unwrap().features(),
             _ => self.unknown_edition_panic(),
         }
     }
@@ -232,9 +233,3 @@ impl Default for Edition {
         Edition::LEGACY
     }
 }
-
-impl Default for Flavor {
-    fn default() -> Self {
-        Flavor::GlobalStorage
-    }
-}

move-compiler/src/expansion/translate.rs

@@ -52,7 +52,7 @@ impl<'env, 'map> Context<'env, 'map> {
     ) -> Self {
         let mut all_filter_alls = WarningFilters::new();
         for allow in compilation_env.filter_attributes() {
-            for f in compilation_env.filter_from_str(FILTER_ALL, allow.clone()) {
+            for f in compilation_env.filter_from_str(FILTER_ALL, *allow) {
                 all_filter_alls.add(f);
             }
         }
@@ -804,7 +804,7 @@ fn warning_filter(
                     n
                 }
             };
-            let filters = context.env.filter_from_str(name_, allow.clone());
+            let filters = context.env.filter_from_str(name_, allow);
             if filters.is_empty() {
                 let msg = format!("Unknown warning filter '{name_}'");
                 context
@@ -2662,7 +2662,7 @@ fn check_valid_address_name_(
 
 fn check_valid_local_name(context: &mut Context, v: &Var) {
     fn is_valid(s: Symbol) -> bool {
-        s.starts_with('_') || s.starts_with(|c| matches!(c, 'a'..='z'))
+        s.starts_with('_') || s.starts_with(|c: char| c.is_ascii_lowercase())
     }
     if !is_valid(v.value()) {
         let msg = format!(
@@ -2822,7 +2822,7 @@ fn check_valid_module_member_name_impl(
 }
 
 pub fn is_valid_struct_constant_or_schema_name(s: &str) -> bool {
-    s.starts_with(|c| matches!(c, 'A'..='Z'))
+    s.starts_with(|c: char| c.is_ascii_uppercase())
 }
 
 // Checks for a restricted name in any decl case