Update scale-info to 2.5.0 (#896)

* Upodate scale-info to 2.5.0

* A couple more clippy fixes

* more deprecation things that appeared

subxt/src/constants/constants_client.rs

@@ -68,7 +68,7 @@ impl<T: Config, Client: OfflineClientT<T>> ConstantsClient<T, Client> {
         let constant = pallet.constant(address.constant_name())?;
         let value = <Address::Target as DecodeWithMetadata>::decode_with_metadata(
             &mut &*constant.value,
-            constant.ty.id(),
+            constant.ty.id,
             &metadata,
         )?;
         Ok(value)

subxt/src/events/events_type.rs

@@ -239,7 +239,7 @@ impl EventDetails {
             // Skip over the bytes for this field:
             scale_decode::visitor::decode_with_visitor(
                 input,
-                field_metadata.ty().id(),
+                field_metadata.ty.id,
                 &metadata.runtime_metadata().types,
                 scale_decode::visitor::IgnoreVisitor,
             )

subxt/src/metadata/metadata_type.rs

@@ -380,7 +380,7 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
                 .types
                 .resolve(type_id)
                 .ok_or(InvalidMetadataError::MissingType(type_id))?;
-            if let scale_info::TypeDef::Variant(var) = ty.type_def() {
+            if let scale_info::TypeDef::Variant(var) = &ty.type_def {
                 Ok(var)
             } else {
                 Err(InvalidMetadataError::TypeDefNotVariant(type_id))
@@ -390,20 +390,20 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
             .pallets
             .iter()
             .map(|pallet| {
-                let call_ty_id = pallet.calls.as_ref().map(|c| c.ty.id());
-                let event_ty_id = pallet.event.as_ref().map(|e| e.ty.id());
+                let call_ty_id = pallet.calls.as_ref().map(|c| c.ty.id);
+                let event_ty_id = pallet.event.as_ref().map(|e| e.ty.id);
 
                 let call_metadata = pallet.calls.as_ref().map_or(Ok(HashMap::new()), |call| {
-                    let type_def_variant = get_type_def_variant(call.ty.id())?;
+                    let type_def_variant = get_type_def_variant(call.ty.id)?;
                     let call_indexes = type_def_variant
-                        .variants()
+                        .variants
                         .iter()
                         .map(|v| {
                             (
-                                v.name().clone(),
+                                v.name.clone(),
                                 CallMetadata {
-                                    call_index: v.index(),
-                                    fields: v.fields().to_vec(),
+                                    call_index: v.index,
+                                    fields: v.fields.to_vec(),
                                 },
                             )
                         })
@@ -443,16 +443,16 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
         for pallet in &metadata.pallets {
             if let Some(event) = &pallet.event {
                 let pallet_name: Arc<str> = pallet.name.to_string().into();
-                let event_type_id = event.ty.id();
+                let event_type_id = event.ty.id;
                 let event_variant = get_type_def_variant(event_type_id)?;
-                for variant in event_variant.variants() {
+                for variant in &event_variant.variants {
                     events.insert(
-                        (pallet.index, variant.index()),
+                        (pallet.index, variant.index),
                         EventMetadata {
                             pallet: pallet_name.clone(),
-                            event: variant.name().to_owned(),
-                            fields: variant.fields().to_vec(),
-                            docs: variant.docs().to_vec(),
+                            event: variant.name.clone(),
+                            fields: variant.fields.clone(),
+                            docs: variant.docs.clone(),
                         },
                     );
                 }
@@ -463,14 +463,14 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
         for pallet in &metadata.pallets {
             if let Some(error) = &pallet.error {
                 let pallet_name: Arc<str> = pallet.name.to_string().into();
-                let error_variant = get_type_def_variant(error.ty.id())?;
-                for variant in error_variant.variants() {
+                let error_variant = get_type_def_variant(error.ty.id)?;
+                for variant in &error_variant.variants {
                     errors.insert(
-                        (pallet.index, variant.index()),
+                        (pallet.index, variant.index),
                         ErrorMetadata {
                             pallet: pallet_name.clone(),
-                            error: variant.name().clone(),
-                            docs: variant.docs().to_vec(),
+                            error: variant.name.clone(),
+                            docs: variant.docs.clone(),
                         },
                     );
                 }
@@ -479,10 +479,10 @@ impl TryFrom<RuntimeMetadataPrefixed> for Metadata {
 
         let dispatch_error_ty = metadata
             .types
-            .types()
+            .types
             .iter()
-            .find(|ty| ty.ty().path().segments() == ["sp_runtime", "DispatchError"])
-            .map(|ty| ty.id());
+            .find(|ty| ty.ty.path.segments == ["sp_runtime", "DispatchError"])
+            .map(|ty| ty.id);
 
         Ok(Metadata {
             inner: Arc::new(MetadataInner {

subxt/src/storage/storage_address.rs

@@ -155,16 +155,16 @@ where
             }
             StorageEntryType::Map { hashers, key, .. } => {
                 let ty = metadata
-                    .resolve_type(key.id())
-                    .ok_or_else(|| StorageAddressError::TypeNotFound(key.id()))?;
+                    .resolve_type(key.id)
+                    .ok_or(StorageAddressError::TypeNotFound(key.id))?;
 
                 // If the key is a tuple, we encode each value to the corresponding tuple type.
                 // If the key is not a tuple, encode a single value to the key type.
-                let type_ids = match ty.type_def() {
+                let type_ids = match &ty.type_def {
                     TypeDef::Tuple(tuple) => {
-                        either::Either::Left(tuple.fields().iter().map(|f| f.id()))
+                        either::Either::Left(tuple.fields.iter().map(|f| f.id))
                     }
-                    _other => either::Either::Right(std::iter::once(key.id())),
+                    _other => either::Either::Right(std::iter::once(key.id)),
                 };
 
                 if type_ids.len() != self.storage_entry_keys.len() {

subxt/src/storage/storage_type.rs

@@ -352,8 +352,8 @@ fn lookup_storage_return_type(
 /// Fetch the return type out of a [`StorageEntryType`].
 fn return_type_from_storage_entry_type(entry: &StorageEntryType<PortableForm>) -> u32 {
     match entry {
-        StorageEntryType::Plain(ty) => ty.id(),
-        StorageEntryType::Map { value, .. } => value.id(),
+        StorageEntryType::Plain(ty) => ty.id,
+        StorageEntryType::Map { value, .. } => value.id,
     }
 }
 
@@ -367,8 +367,8 @@ fn decode_storage_with_metadata<T: DecodeWithMetadata>(
     let ty = &metadata.pallet(pallet_name)?.storage(storage_entry)?.ty;
 
     let id = match ty {
-        StorageEntryType::Plain(ty) => ty.id(),
-        StorageEntryType::Map { value, .. } => value.id(),
+        StorageEntryType::Plain(ty) => ty.id,
+        StorageEntryType::Map { value, .. } => value.id,
     };
 
     let val = T::decode_with_metadata(bytes, id, metadata)?;

subxt/src/utils/wrapper_opaque.rs

@@ -87,7 +87,7 @@ impl<T> EncodeAsType for WrapperKeepOpaque<T> {
         };
 
         // Do a basic check that the target shape lines up.
-        let scale_info::TypeDef::Composite(_) = ty.type_def() else {
+        let scale_info::TypeDef::Composite(_) = ty.type_def else {
             return Err(Error::new(ErrorKind::WrongShape {
                 actual: Kind::Struct,
                 expected: type_id,
@@ -95,7 +95,7 @@ impl<T> EncodeAsType for WrapperKeepOpaque<T> {
         };
 
         // Check that the name also lines up.
-        if ty.path().ident().as_deref() != Some("WrapperKeepOpaque") {
+        if ty.path.ident().as_deref() != Some("WrapperKeepOpaque") {
             return Err(Error::new(ErrorKind::WrongShape {
                 actual: Kind::Struct,
                 expected: type_id,
@@ -188,7 +188,7 @@ mod test {
         let mut types = scale_info::Registry::new();
         let id = types.register_type(&m);
         let portable_registry: scale_info::PortableRegistry = types.into();
-        (id.id(), portable_registry)
+        (id.id, portable_registry)
     }
 
     fn roundtrips_like_scale_codec<T>(t: T)