Merge #107

107: more Self r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

src/svd/access.rs

@@ -19,10 +19,10 @@ pub enum Access {
 }
 
 impl Parse for Access {
-    type Object = Access;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Access> {
+    fn parse(tree: &Element) -> Result<Self> {
         let text = tree.get_text()?;
 
         match &text[..] {

src/svd/addressblock.rs

@@ -21,11 +21,11 @@ pub struct AddressBlock {
 }
 
 impl Parse for AddressBlock {
-    type Object = AddressBlock;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<AddressBlock> {
-        Ok(AddressBlock {
+    fn parse(tree: &Element) -> Result<Self> {
+        Ok(Self {
             offset: tree.get_child_u32("offset")?,
             size: tree.get_child_u32("size")?,
             usage: tree.get_child_text("usage")?,

src/svd/bitrange.rs

@@ -35,10 +35,10 @@ pub enum BitRangeType {
 }
 
 impl Parse for BitRange {
-    type Object = BitRange;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<BitRange> {
+    fn parse(tree: &Element) -> Result<Self> {
         let (end, start, range_type): (u32, u32, BitRangeType) = if let Some(range) =
             tree.get_child("bitRange")
         {
@@ -113,7 +113,7 @@ impl Parse for BitRange {
             return Err(SVDError::InvalidBitRange(tree.clone(), InvalidBitRange::Syntax).into());
         };
 
-        Ok(BitRange {
+        Ok(Self {
             offset: start,
             width: end - start + 1,
             range_type,

src/svd/cluster.rs

@@ -29,10 +29,10 @@ impl Deref for Cluster {
 }
 
 impl Parse for Cluster {
-    type Object = Cluster;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Cluster> {
+    fn parse(tree: &Element) -> Result<Self> {
         assert_eq!(tree.name, "cluster");
 
         let info = ClusterInfo::parse(tree)?;

src/svd/clusterinfo.rs

@@ -47,18 +47,18 @@ pub struct ClusterInfo {
 }
 
 impl Parse for ClusterInfo {
-    type Object = ClusterInfo;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<ClusterInfo> {
+    fn parse(tree: &Element) -> Result<Self> {
         let name = tree.get_child_text("name")?;
-        ClusterInfo::_parse(tree, name.clone()).with_context(|| format!("In cluster `{}`", name))
+        Self::_parse(tree, name.clone()).with_context(|| format!("In cluster `{}`", name))
     }
 }
 
 impl ClusterInfo {
-    fn _parse(tree: &Element, name: String) -> Result<ClusterInfo> {
-        Ok(ClusterInfo {
+    fn _parse(tree: &Element, name: String) -> Result<Self> {
+        Ok(Self {
             name, // TODO: Handle naming of cluster
             derived_from: tree.attributes.get("derivedFrom").map(|s| s.to_owned()),
             description: tree.get_child_text_opt("description")?,

src/svd/cpu.rs

@@ -40,15 +40,15 @@ pub struct Cpu {
 }
 
 impl Parse for Cpu {
-    type Object = Cpu;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Cpu> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name != "cpu" {
             return Err(SVDError::NameMismatch(tree.clone()).into());
         }
 
-        Ok(Cpu {
+        Ok(Self {
             name: tree.get_child_text("name")?,
             revision: tree.get_child_text("revision")?,
             endian: Endian::parse(tree.get_child_elem("endian")?)?,

src/svd/device.rs

@@ -62,12 +62,12 @@ pub struct Device {
 }
 
 impl Parse for Device {
-    type Object = Device;
+    type Object = Self;
     type Error = anyhow::Error;
 
     /// Parses a SVD file
-    fn parse(tree: &Element) -> Result<Device> {
-        Ok(Device {
+    fn parse(tree: &Element) -> Result<Self> {
+        Ok(Self {
             name: tree.get_child_text("name")?,
             schema_version: tree.attributes.get("schemaVersion").cloned(),
             cpu: parse::optional::<Cpu>("cpu", tree)?,

src/svd/dimelement.rs

@@ -31,11 +31,11 @@ pub struct DimElement {
 }
 
 impl Parse for DimElement {
-    type Object = DimElement;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<DimElement> {
-        Ok(DimElement {
+    fn parse(tree: &Element) -> Result<Self> {
+        Ok(Self {
             dim: tree.get_child_u32("dim")?,
             dim_increment: tree.get_child_u32("dimIncrement")?,
             dim_index: parse_optional::<DimIndex>("dimIndex", tree)?,

src/svd/endian.rs

@@ -20,10 +20,10 @@ pub enum Endian {
 }
 
 impl Parse for Endian {
-    type Object = Endian;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Endian> {
+    fn parse(tree: &Element) -> Result<Self> {
         let text = tree.get_text()?;
 
         match &text[..] {

src/svd/enumeratedvalue.rs

@@ -38,8 +38,8 @@ pub struct EnumeratedValue {
     pub(crate) _extensible: (),
 }
 impl EnumeratedValue {
-    fn _parse(tree: &Element, name: String) -> Result<EnumeratedValue> {
-        Ok(EnumeratedValue {
+    fn _parse(tree: &Element, name: String) -> Result<Self> {
+        Ok(Self {
             name,
             description: tree.get_child_text_opt("description")?,
             // TODO: this .ok() approach is simple, but does not expose errors parsing child objects.
@@ -51,17 +51,17 @@ impl EnumeratedValue {
     }
 }
 impl Parse for EnumeratedValue {
-    type Object = EnumeratedValue;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<EnumeratedValue> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name != "enumeratedValue" {
             return Err(
                 SVDError::NotExpectedTag(tree.clone(), "enumeratedValue".to_string()).into(),
             );
         }
         let name = tree.get_child_text("name")?;
-        EnumeratedValue::_parse(tree, name.clone())
+        Self::_parse(tree, name.clone())
             .with_context(|| format!("In enumerated value `{}`", name))
     }
 }

src/svd/enumeratedvalues.rs

@@ -39,15 +39,15 @@ pub struct EnumeratedValues {
 }
 
 impl Parse for EnumeratedValues {
-    type Object = EnumeratedValues;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<EnumeratedValues> {
+    fn parse(tree: &Element) -> Result<Self> {
         assert_eq!(tree.name, "enumeratedValues");
         let derived_from = tree.attributes.get("derivedFrom").map(|s| s.to_owned());
         let is_derived = derived_from.is_some();
 
-        Ok(EnumeratedValues {
+        Ok(Self {
             name: tree.get_child_text_opt("name")?,
             usage: parse::optional::<Usage>("usage", tree)?,
             derived_from,

src/svd/field.rs

@@ -30,10 +30,10 @@ impl Deref for Field {
 }
 
 impl Parse for Field {
-    type Object = Field;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Field> {
+    fn parse(tree: &Element) -> Result<Self> {
         assert_eq!(tree.name, "field");
 
         let info = FieldInfo::parse(tree)?;
@@ -44,9 +44,9 @@ impl Parse for Field {
             if let Some(indices) = &array_info.dim_index {
                 assert_eq!(array_info.dim as usize, indices.len())
             }
-            Ok(Field::Array(info, array_info))
+            Ok(Self::Array(info, array_info))
         } else {
-            Ok(Field::Single(info))
+            Ok(Self::Single(info))
         }
     }
 }

src/svd/fieldinfo.rs

@@ -61,15 +61,15 @@ pub struct FieldInfo {
 }
 
 impl Parse for FieldInfo {
-    type Object = FieldInfo;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<FieldInfo> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name != "field" {
             return Err(SVDError::NotExpectedTag(tree.clone(), "field".to_string()).into());
         }
         let name = tree.get_child_text("name")?;
-        FieldInfo::_parse(tree, name.clone()).with_context(|| format!("In field `{}`", name))
+        Self::_parse(tree, name.clone()).with_context(|| format!("In field `{}`", name))
     }
 }
 

src/svd/interrupt.rs

@@ -28,8 +28,8 @@ pub struct Interrupt {
 }
 
 impl Interrupt {
-    fn _parse(tree: &Element, name: String) -> Result<Interrupt> {
-        Ok(Interrupt {
+    fn _parse(tree: &Element, name: String) -> Result<Self> {
+        Ok(Self {
             name,
             description: tree.get_child_text_opt("description")?,
             value: tree.get_child_u32("value")?,
@@ -38,15 +38,15 @@ impl Interrupt {
 }
 
 impl Parse for Interrupt {
-    type Object = Interrupt;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Interrupt> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name != "interrupt" {
             return Err(SVDError::NotExpectedTag(tree.clone(), "interrupt".to_string()).into());
         }
         let name = tree.get_child_text("name")?;
-        Interrupt::_parse(tree, name.clone()).with_context(|| format!("In interrupt `{}`", name))
+        Self::_parse(tree, name.clone()).with_context(|| format!("In interrupt `{}`", name))
     }
 }
 

src/svd/modifiedwritevalues.rs

@@ -24,10 +24,10 @@ pub enum ModifiedWriteValues {
 }
 
 impl Parse for ModifiedWriteValues {
-    type Object = ModifiedWriteValues;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<ModifiedWriteValues> {
+    fn parse(tree: &Element) -> Result<Self> {
         use self::ModifiedWriteValues::*;
         let text = tree.get_text()?;
 

src/svd/peripheral.rs

@@ -74,21 +74,21 @@ pub struct Peripheral {
 }
 
 impl Parse for Peripheral {
-    type Object = Peripheral;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Peripheral> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name != "peripheral" {
             return Err(SVDError::NotExpectedTag(tree.clone(), "peripheral".to_string()).into());
         }
         let name = tree.get_child_text("name")?;
-        Peripheral::_parse(tree, name.clone()).with_context(|| format!("In peripheral `{}`", name))
+        Self::_parse(tree, name.clone()).with_context(|| format!("In peripheral `{}`", name))
     }
 }
 
 impl Peripheral {
-    fn _parse(tree: &Element, name: String) -> Result<Peripheral> {
-        Ok(Peripheral {
+    fn _parse(tree: &Element, name: String) -> Result<Self> {
+        Ok(Self {
             name,
             version: tree.get_child_text_opt("version")?,
             display_name: tree.get_child_text_opt("displayName")?,

src/svd/register.rs

@@ -30,10 +30,10 @@ impl Deref for Register {
 }
 
 impl Parse for Register {
-    type Object = Register;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Register> {
+    fn parse(tree: &Element) -> Result<Self> {
         assert_eq!(tree.name, "register");
 
         let info = RegisterInfo::parse(tree)?;

src/svd/registercluster.rs

@@ -28,10 +28,10 @@ impl From<Cluster> for RegisterCluster {
 }
 
 impl Parse for RegisterCluster {
-    type Object = RegisterCluster;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<RegisterCluster> {
+    fn parse(tree: &Element) -> Result<Self> {
         if tree.name == "register" {
             Ok(RegisterCluster::Register(Register::parse(tree)?))
         } else if tree.name == "cluster" {

src/svd/registerinfo.rs

@@ -85,19 +85,19 @@ pub struct RegisterInfo {
 }
 
 impl Parse for RegisterInfo {
-    type Object = RegisterInfo;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<RegisterInfo> {
+    fn parse(tree: &Element) -> Result<Self> {
         let name = tree.get_child_text("name")?;
-        RegisterInfo::_parse(tree, name.clone()).with_context(|| format!("In register `{}`", name))
+        Self::_parse(tree, name.clone()).with_context(|| format!("In register `{}`", name))
     }
 }
 
 impl RegisterInfo {
-    fn _parse(tree: &Element, name: String) -> Result<RegisterInfo> {
+    fn _parse(tree: &Element, name: String) -> Result<Self> {
         let properties = RegisterProperties::parse(tree)?;
-        Ok(RegisterInfo {
+        Ok(Self {
             name,
             alternate_group: tree.get_child_text_opt("alternateGroup")?,
             alternate_register: tree.get_child_text_opt("alternateRegister")?,

src/svd/registerproperties.rs

@@ -42,11 +42,11 @@ pub struct RegisterProperties {
 }
 
 impl Parse for RegisterProperties {
-    type Object = RegisterProperties;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<RegisterProperties> {
-        Ok(RegisterProperties {
+    fn parse(tree: &Element) -> Result<Self> {
+        Ok(Self {
             size: parse::optional::<u32>("size", tree)?,
             reset_value: parse::optional::<u32>("resetValue", tree)?,
             reset_mask: parse::optional::<u32>("resetMask", tree)?,

src/svd/usage.rs

@@ -18,10 +18,10 @@ pub enum Usage {
 }
 
 impl Parse for Usage {
-    type Object = Usage;
+    type Object = Self;
     type Error = anyhow::Error;
 
-    fn parse(tree: &Element) -> Result<Usage> {
+    fn parse(tree: &Element) -> Result<Self> {
         let text = tree.get_text()?;
 
         match &text[..] {