don't use named fields for enum SignatureVariant variant Function, si…

…nce that yields Clippy warnings, apparently due to a hidden bug in one of the derived trait macros invoked here (dearbitrary)
aptos-labs · Dec 7, 2024 · fdd0ca9 · fdd0ca9
1 parent 844871b
commit fdd0ca9
Show file tree

Hide file tree

Showing 29 changed files with 157 additions and 116 deletions.
diff --git a/api/types/src/bytecode.rs b/api/types/src/bytecode.rs
@@ -105,7 +105,7 @@ pub trait Bytecode {
                 mutable: true,
                 to: Box::new(self.new_move_type(t.borrow())),
             },
-            SignatureToken::Function { .. } => {
+            SignatureToken::Function( .. ) => {
                 // TODO(LAMBDA)
                 unimplemented!("signature token function to API MoveType")
             },

diff --git a/aptos-move/script-composer/src/decompiler.rs b/aptos-move/script-composer/src/decompiler.rs
@@ -208,7 +208,7 @@ impl LocalState {
             SignatureToken::Vector(s) => {
                 TypeTag::Vector(Box::new(Self::type_tag_from_sig_token(script, s)?))
             },
-            SignatureToken::Function { .. } => {
+            SignatureToken::Function(..) => {
                 // TODO(LAMBDA)
                 bail!("function types not yet implemented for script composer")
             },

diff --git a/third_party/move/move-binary-format/src/binary_views.rs b/third_party/move/move-binary-format/src/binary_views.rs
@@ -340,10 +340,12 @@ impl<'a> BinaryIndexedView<'a> {
             Reference(_) | MutableReference(_) => Ok(AbilitySet::REFERENCES),
             Signer => Ok(AbilitySet::SIGNER),
             TypeParameter(idx) => Ok(constraints[*idx as usize]),
-            Vector(ty) => AbilitySet::polymorphic_abilities(AbilitySet::VECTOR, vec![false], vec![
-                self.abilities(ty, constraints)?,
-            ]),
-            Function { abilities, .. } => Ok(*abilities),
+            Vector(ty) => AbilitySet::polymorphic_abilities(
+                AbilitySet::VECTOR,
+                vec![false],
+                vec![self.abilities(ty, constraints)?],
+            ),
+            Function(_, _, abilities) => Ok(*abilities),
             Struct(idx) => {
                 let sh = self.struct_handle_at(*idx);
                 Ok(sh.abilities)

diff --git a/third_party/move/move-binary-format/src/builders.rs b/third_party/move/move-binary-format/src/builders.rs
@@ -235,15 +235,11 @@ impl CompiledScriptBuilder {
                 MutableReference(Box::new(self.import_signature_token(module, ty)?))
             },
             Vector(ty) => Vector(Box::new(self.import_signature_token(module, ty)?)),
-            Function {
-                args,
-                results,
-                abilities,
-            } => Function {
-                args: import_vec(self, args)?,
-                results: import_vec(self, results)?,
-                abilities: *abilities,
-            },
+            Function(args, results, abilities) => Function(
+                import_vec(self, args)?,
+                import_vec(self, results)?,
+                *abilities,
+            ),
             Struct(idx) => Struct(self.import_struct(module, *idx)?),
             StructInstantiation(idx, inst_tys) => StructInstantiation(
                 self.import_struct(module, *idx)?,

diff --git a/third_party/move/move-binary-format/src/constant.rs b/third_party/move/move-binary-format/src/constant.rs
@@ -17,7 +17,7 @@ fn sig_to_ty(sig: &SignatureToken) -> Option<MoveTypeLayout> {
         SignatureToken::U128 => Some(MoveTypeLayout::U128),
         SignatureToken::U256 => Some(MoveTypeLayout::U256),
         SignatureToken::Vector(v) => Some(MoveTypeLayout::Vector(Box::new(sig_to_ty(v.as_ref())?))),
-        SignatureToken::Function { .. } => {
+        SignatureToken::Function(..) => {
             // TODO(LAMBDA): do we need representation in MoveTypeLayout?
             None
         },

diff --git a/third_party/move/move-binary-format/src/deserializer.rs b/third_party/move/move-binary-format/src/deserializer.rs
@@ -1180,11 +1180,11 @@ fn load_signature_token(cursor: &mut VersionedCursor) -> BinaryLoaderResult<Sign
                     if args.len() >= args_arity as usize {
                         results.push(tok);
                         if results.len() >= res_arity as usize {
-                            T::Saturated(SignatureToken::Function {
+                            T::Saturated(SignatureToken::Function(
                                 args,
                                 results,
                                 abilities,
-                            })
+                            ))
                         } else {
                             T::Function {
                                 args_arity,

diff --git a/third_party/move/move-binary-format/src/file_format.rs b/third_party/move/move-binary-format/src/file_format.rs
@@ -1263,11 +1263,11 @@ pub enum SignatureToken {
     /// Vector
     Vector(Box<SignatureToken>),
     /// Function, with n argument types and m result types, and an associated ability set.
-    Function {
-        args: Vec<SignatureToken>,
-        results: Vec<SignatureToken>,
-        abilities: AbilitySet,
-    },
+    Function(
+        Vec<SignatureToken>, // args
+        Vec<SignatureToken>, // results
+        AbilitySet, // abilities
+    ),
     /// User defined type
     Struct(StructHandleIndex),
     StructInstantiation(StructHandleIndex, Vec<SignatureToken>),
@@ -1310,7 +1310,7 @@ impl<'a> Iterator for SignatureTokenPreorderTraversalIter<'a> {
                         self.stack.extend(inner_toks.iter().rev())
                     },
 
-                    Function { args, results, .. } => {
+                    Function( args, results, .. ) => {
                         self.stack.extend(args.iter().rev());
                         self.stack.extend(results.iter().rev());
                     },
@@ -1348,7 +1348,7 @@ impl<'a> Iterator for SignatureTokenPreorderTraversalIterWithDepth<'a> {
                         .stack
                         .extend(inner_toks.iter().map(|tok| (tok, depth + 1)).rev()),
 
-                    Function { args, results, .. } => {
+                    Function( args, results, .. ) => {
                         self.stack
                             .extend(args.iter().map(|tok| (tok, depth + 1)).rev());
                         self.stack
@@ -1415,11 +1415,11 @@ impl std::fmt::Debug for SignatureToken {
             SignatureToken::Address => write!(f, "Address"),
             SignatureToken::Signer => write!(f, "Signer"),
             SignatureToken::Vector(boxed) => write!(f, "Vector({:?})", boxed),
-            SignatureToken::Function {
+            SignatureToken::Function (
                 args,
                 results,
                 abilities,
-            } => {
+            ) => {
                 write!(f, "Function({:?}, {:?}, {})", args, results, abilities)
             },
             SignatureToken::Reference(boxed) => write!(f, "Reference({:?})", boxed),
@@ -1443,7 +1443,7 @@ impl SignatureToken {
             | Address
             | Signer
             | Vector(_)
-            | Function { .. }
+            | Function ( .. )
             | Struct(_)
             | StructInstantiation(_, _)
             | Reference(_)
@@ -1482,7 +1482,7 @@ impl SignatureToken {
             Bool | U8 | U16 | U32 | U64 | U128 | U256 | Address => true,
             Vector(inner) => inner.is_valid_for_constant(),
             Signer
-            | Function { .. }
+            | Function ( .. )
             | Struct(_)
             | StructInstantiation(_, _)
             | Reference(_)
@@ -1495,7 +1495,7 @@ impl SignatureToken {
     pub fn is_function(&self) -> bool {
         use SignatureToken::*;
 
-        matches!(self, Function { .. })
+        matches!(self, Function ( .. ))
     }
 
     /// Set the index to this one. Useful for random testing.
@@ -1546,15 +1546,15 @@ impl SignatureToken {
             Address => Address,
             Signer => Signer,
             Vector(ty) => Vector(Box::new(ty.instantiate(subst_mapping))),
-            Function {
+            Function (
                 args,
                 results,
                 abilities,
-            } => Function {
-                args: inst_vec(args),
-                results: inst_vec(results),
-                abilities: *abilities,
-            },
+            ) => Function (
+                inst_vec(args),
+                inst_vec(results),
+                *abilities,
+            ),
             Struct(idx) => Struct(*idx),
             StructInstantiation(idx, struct_type_args) => {
                 StructInstantiation(*idx, inst_vec(struct_type_args))

diff --git a/third_party/move/move-binary-format/src/proptest_types/types.rs b/third_party/move/move-binary-format/src/proptest_types/types.rs
@@ -71,7 +71,7 @@ impl StDefnMaterializeState {
                 let inner = self.potential_abilities(ty);
                 inner.intersect(AbilitySet::VECTOR)
             },
-            Function { abilities, .. } => *abilities,
+            Function(_, _, abilities) => *abilities,
             Struct(idx) => {
                 let sh = &self.struct_handles[idx.0 as usize];
                 sh.abilities

diff --git a/third_party/move/move-binary-format/src/serializer.rs b/third_party/move/move-binary-format/src/serializer.rs
@@ -800,11 +800,11 @@ fn serialize_signature_token_single_node_impl(
             binary.push(SerializedType::TYPE_PARAMETER as u8)?;
             serialize_type_parameter_index(binary, *idx)?;
         },
-        SignatureToken::Function {
+        SignatureToken::Function(
             args,
             results,
             abilities,
-        } => {
+        ) => {
             binary.push(SerializedType::FUNCTION as u8)?;
             serialize_signature_size(binary, args.len())?;
             serialize_signature_size(binary, results.len())?;

diff --git a/...bytecode-verifier/bytecode-verifier-tests/src/unit_tests/feature_function_values_tests.rs b/...bytecode-verifier/bytecode-verifier-tests/src/unit_tests/feature_function_values_tests.rs
@@ -12,21 +12,21 @@ use move_core_types::{identifier::Identifier, vm_status::StatusCode};
 fn get_fun_type_bool_to_bool() -> SignatureToken {
     let bool_token = SignatureToken::Bool;
     let abilities = AbilitySet::PUBLIC_FUNCTIONS;
-    SignatureToken::Function {
-        args: vec![bool_token.clone()],
-        results: vec![bool_token.clone()],
+    SignatureToken::Function(
+        vec![bool_token.clone()],
+        vec![bool_token.clone()],
         abilities,
-    }
+    )
 }
 
 fn get_fun_type_nothing_to_bool() -> SignatureToken {
     let bool_token = SignatureToken::Bool;
     let abilities = AbilitySet::PUBLIC_FUNCTIONS;
-    SignatureToken::Function {
-        args: vec![],
-        results: vec![bool_token.clone()],
+    SignatureToken::Function(
+        vec![],
+        vec![bool_token.clone()],
         abilities,
-    }
+    )
 }
 
 #[test]

diff --git a/third_party/move/move-bytecode-verifier/invalid-mutations/src/bounds.rs b/third_party/move/move-bytecode-verifier/invalid-mutations/src/bounds.rs
@@ -369,6 +369,6 @@ fn struct_handle(token: &SignatureToken) -> Option<StructHandleIndex> {
         | Signer
         | Vector(_)
         | TypeParameter(_)
-        | Function { .. } => None,
+        | Function(..) => None,
     }
 }
diff --git a/third_party/move/move-bytecode-verifier/src/dependencies.rs b/third_party/move/move-bytecode-verifier/src/dependencies.rs
@@ -456,16 +456,16 @@ fn compare_types(
             compare_types(context, ty1, ty2, def_module)
         },
         (
-            SignatureToken::Function {
-                args: args1,
-                results: result1,
-                abilities: abilities1,
-            },
-            SignatureToken::Function {
-                args: args2,
-                results: result2,
-                abilities: abilities2,
-            },
+            SignatureToken::Function(
+                args1,
+                result1,
+                abilities1,
+            ),
+            SignatureToken::Function(
+                args2,
+                result2,
+                abilities2,
+            ),
         ) => {
             compare_cross_module_signatures(context, args1, args2, def_module)?;
             compare_cross_module_signatures(context, result1, result2, def_module)?;
@@ -504,7 +504,7 @@ fn compare_types(
         | (SignatureToken::Address, _)
         | (SignatureToken::Signer, _)
         | (SignatureToken::Vector(_), _)
-        | (SignatureToken::Function { .. }, _)
+        | (SignatureToken::Function(..), _)
         | (SignatureToken::Struct(_), _)
         | (SignatureToken::StructInstantiation(_, _), _)
         | (SignatureToken::Reference(_), _)

diff --git a/third_party/move/move-bytecode-verifier/src/features.rs b/third_party/move/move-bytecode-verifier/src/features.rs
@@ -87,7 +87,7 @@ impl<'a> FeatureVerifier<'a> {
         if !self.config.enable_function_values {
             for (idx, signature) in self.code.signatures().iter().enumerate() {
                 for signature_token in signature.0.iter() {
-                    if matches!(signature_token, SignatureToken::Function { .. }) {
+                    if matches!(signature_token, SignatureToken::Function(..)) {
                         return Err(PartialVMError::new(StatusCode::FEATURE_NOT_ENABLED)
                             .at_index(IndexKind::Signature, idx as u16)
                             .with_message("function values feature not enabled".to_string()));

diff --git a/third_party/move/move-bytecode-verifier/src/instantiation_loops.rs b/third_party/move/move-bytecode-verifier/src/instantiation_loops.rs
@@ -148,7 +148,7 @@ impl<'a> InstantiationLoopChecker<'a> {
                     type_params.insert(*idx);
                 },
                 Vector(ty) => rec(type_params, ty),
-                Function { args, results, .. } => {
+                Function(args, results, ..) => {
                     for ty in args {
                         rec(type_params, ty);
                     }

diff --git a/third_party/move/move-bytecode-verifier/src/instruction_consistency.rs b/third_party/move/move-bytecode-verifier/src/instruction_consistency.rs
@@ -289,7 +289,7 @@ impl<'a> InstructionConsistency<'a> {
     ) -> PartialVMResult<()> {
         let signature = self.resolver.signature_at(sig_index);
         if let Some(sig_token) = signature.0.first() {
-            if let SignatureToken::Function { args: params, .. } = sig_token {
+            if let SignatureToken::Function(params, ..) = sig_token {
                 if count as usize > params.len() {
                     return Err(
                         PartialVMError::new(StatusCode::NUMBER_OF_TYPE_ARGUMENTS_MISMATCH)

diff --git a/third_party/move/move-bytecode-verifier/src/reference_safety/mod.rs b/third_party/move/move-bytecode-verifier/src/reference_safety/mod.rs
@@ -250,7 +250,7 @@ fn fun_type(
     idx: SignatureIndex,
 ) -> PartialVMResult<(Vec<SignatureToken>, Vec<SignatureToken>)> {
     match verifier.resolver.signature_at(idx).0.first() {
-        Some(SignatureToken::Function { args, results, .. }) => Ok((args.clone(), results.clone())),
+        Some(SignatureToken::Function(args, results, ..)) => Ok((args.clone(), results.clone())),
         _ => Err(PartialVMError::new(
             StatusCode::VERIFIER_INVARIANT_VIOLATION,
         )),

diff --git a/third_party/move/move-bytecode-verifier/src/signature.rs b/third_party/move/move-bytecode-verifier/src/signature.rs
@@ -372,7 +372,7 @@ impl<'a> SignatureChecker<'a> {
                 }
             },
 
-            SignatureToken::Function { .. } => {
+            SignatureToken::Function(..) => {
                 return Err(PartialVMError::new(StatusCode::UNEXPECTED_VERIFIER_ERROR)
                     .with_message("function types not supported".to_string()));
             },
@@ -429,7 +429,7 @@ impl<'a> SignatureChecker<'a> {
                 Err(PartialVMError::new(StatusCode::INVALID_SIGNATURE_TOKEN)
                     .with_message("reference not allowed".to_string()))
             },
-            Function { .. } => Err(PartialVMError::new(StatusCode::UNEXPECTED_VERIFIER_ERROR)
+            Function(..) => Err(PartialVMError::new(StatusCode::UNEXPECTED_VERIFIER_ERROR)
                 .with_message("function types not supported".to_string())),
             Vector(ty) => self.check_signature_token(ty),
             StructInstantiation(_, type_arguments) => self.check_signature_tokens(type_arguments),
@@ -481,7 +481,7 @@ impl<'a> SignatureChecker<'a> {
                     type_parameters,
                 )
             },
-            SignatureToken::Function { .. } => {
+            SignatureToken::Function(..) => {
                 Err(PartialVMError::new(StatusCode::UNEXPECTED_VERIFIER_ERROR)
                     .with_message("function types not supported".to_string()))
             },

diff --git a/third_party/move/move-bytecode-verifier/src/signature_v2.rs b/third_party/move/move-bytecode-verifier/src/signature_v2.rs
@@ -173,11 +173,11 @@ fn check_ty<const N: usize>(
                 param_constraints,
             )?;
         },
-        Function {
+        Function(
             args,
             results,
             abilities,
-        } => {
+        ) => {
             assert_abilities(*abilities, required_abilities)?;
             for ty in args.iter().chain(results.iter()) {
                 check_ty(
@@ -275,7 +275,7 @@ fn check_phantom_params(
 
     match ty {
         Vector(ty) => check_phantom_params(struct_handles, context, false, ty)?,
-        Function { args, results, .. } => {
+        Function(args, results, ..) => {
             for ty in args.iter().chain(results) {
                 check_phantom_params(struct_handles, context, false, ty)?
             }
@@ -919,7 +919,7 @@ impl<'a, const N: usize> SignatureChecker<'a, N> {
                         checked_early_bind_insts.entry((*idx, *count))
                     {
                         // Note non-function case is checked in `verify_fun_sig_idx` above.
-                        if let Some(SignatureToken::Function { args, .. }) =
+                        if let Some(SignatureToken::Function(args, ..)) =
                             self.resolver.signature_at(*idx).0.first()
                         {
                             if *count as usize > args.len() {

diff --git a/third_party/move/move-bytecode-verifier/src/stack_usage_verifier.rs b/third_party/move/move-bytecode-verifier/src/stack_usage_verifier.rs
@@ -242,7 +242,7 @@ impl<'a> StackUsageVerifier<'a> {
             // InvokeFunction pops a function and the number of arguments and pushes the results of the
             // given function type
             Bytecode::InvokeFunction(idx) => {
-                if let Some(SignatureToken::Function { args, results, .. }) =
+                if let Some(SignatureToken::Function(args, results, ..)) =
                     self.resolver.signature_at(*idx).0.first()
                 {
                     ((1 + args.len()) as u64, results.len() as u64)
@@ -255,7 +255,7 @@ impl<'a> StackUsageVerifier<'a> {
 
             // EarlyBindFunction pops a function value and the captured arguments and returns 1 value
             Bytecode::EarlyBindFunction(idx, arg_count) => {
-                if let Some(SignatureToken::Function { args, .. }) =
+                if let Some(SignatureToken::Function(args, ..)) =
                     self.resolver.signature_at(*idx).0.first()
                 {
                     if args.len() <= *arg_count as usize {

diff --git a/third_party/move/move-bytecode-verifier/src/struct_defs.rs b/third_party/move/move-bytecode-verifier/src/struct_defs.rs
@@ -123,7 +123,7 @@ impl<'a> StructDefGraphBuilder<'a> {
                 )
             },
             T::Vector(inner) => self.add_signature_token(neighbors, cur_idx, inner)?,
-            T::Function { args, results, .. } => {
+            T::Function(args, results, ..) => {
                 for t in args.iter().chain(results) {
                     self.add_signature_token(neighbors, cur_idx, t)?
                 }