Merge #107

bors[bot] · burrbull · web-flow · commit b80f8caf3e64 · 2020-02-12T17:59:20.000Z
107: more Self r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul &lt;zgarbul.andrey@gmail.com&gt;
diff --git a/src/svd/access.rs b/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[..] {
diff --git a/src/svd/addressblock.rs b/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")?,
diff --git a/src/svd/bitrange.rs b/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,
diff --git a/src/svd/cluster.rs b/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)?;
diff --git a/src/svd/clusterinfo.rs b/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")?,
diff --git a/src/svd/cpu.rs b/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")?)?,
diff --git a/src/svd/device.rs b/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)?,
diff --git a/src/svd/dimelement.rs b/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)?,
diff --git a/src/svd/endian.rs b/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[..] {
diff --git a/src/svd/enumeratedvalue.rs b/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))
     }
 }
diff --git a/src/svd/enumeratedvalues.rs b/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,
diff --git a/src/svd/field.rs b/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))
         }
     }
 }
diff --git a/src/svd/fieldinfo.rs b/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))
     }
 }
 
diff --git a/src/svd/interrupt.rs b/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))
     }
 }
 
diff --git a/src/svd/modifiedwritevalues.rs b/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()?;
 
diff --git a/src/svd/peripheral.rs b/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")?,
diff --git a/src/svd/register.rs b/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)?;
diff --git a/src/svd/registercluster.rs b/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" {
diff --git a/src/svd/registerinfo.rs b/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")?,
diff --git a/src/svd/registerproperties.rs b/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)?,
diff --git a/src/svd/usage.rs b/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[..] {
diff --git a/src/svd/writeconstraint.rs b/src/svd/writeconstraint.rs

Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ pub struct EnumeratedValue {`
`38`	`38`	`pub(crate) _extensible: (),`
`39`	`39`	`}`
`40`	`40`	`impl EnumeratedValue {`
`41`		`- fn _parse(tree: &Element, name: String) -> Result<EnumeratedValue> {`
`42`		`- Ok(EnumeratedValue {`
	`41`	`+ fn _parse(tree: &Element, name: String) -> Result<Self> {`
	`42`	`+ Ok(Self {`
`43`	`43`	`name,`
`44`	`44`	`description: tree.get_child_text_opt("description")?,`
`45`	`45`	`// TODO: this .ok() approach is simple, but does not expose errors parsing child objects.`
`@@ -51,17 +51,17 @@ impl EnumeratedValue {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`	`impl Parse for EnumeratedValue {`
`54`		`- type Object = EnumeratedValue;`
	`54`	`+ type Object = Self;`
`55`	`55`	`type Error = anyhow::Error;`
`56`	`56`
`57`		`- fn parse(tree: &Element) -> Result<EnumeratedValue> {`
	`57`	`+ fn parse(tree: &Element) -> Result<Self> {`
`58`	`58`	`if tree.name != "enumeratedValue" {`
`59`	`59`	`return Err(`
`60`	`60`	`SVDError::NotExpectedTag(tree.clone(), "enumeratedValue".to_string()).into(),`
`61`	`61`	`);`
`62`	`62`	`}`
`63`	`63`	`let name = tree.get_child_text("name")?;`
`64`		`- EnumeratedValue::_parse(tree, name.clone())`
	`64`	`+ Self::_parse(tree, name.clone())`
`65`	`65`	.with_context(\|\| format!("In enumerated value `{}`", name))
`66`	`66`	`}`
`67`	`67`	`}`