Use svd-parser 0.7 and Edition 2018

Cargo.toml

@@ -36,5 +36,5 @@ error-chain = "0.11.0"
 inflections = "1.1.0"
 log = { version = "~0.4", features = ["std"] }
 quote = "0.3.15"
-svd-parser = "0.6"
+svd-parser = "0.7"
 syn = "0.11.11"

src/generate/peripheral.rs

@@ -1,9 +1,8 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 
-use either::Either;
 use quote::{ToTokens, Tokens};
-use crate::svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register};
+use crate::svd::{Cluster, ClusterInfo, Defaults, Peripheral, Register, RegisterCluster};
 use syn::{self, Ident};
 use log::warn;
 
@@ -131,9 +130,9 @@ impl Region {
         let mut idents: Vec<_> = self
             .fields
             .iter()
-            .filter_map(|f| match f.field.ident {
+            .filter_map(|f| match &f.field.ident {
                 None => None,
-                Some(ref ident) => Some(ident.as_ref()),
+                Some(ident) => Some(ident.as_ref()),
             })
             .collect();
         if idents.is_empty() {
@@ -172,9 +171,9 @@ impl Region {
         let idents: Vec<_> = self
             .fields
             .iter()
-            .filter_map(|f| match f.field.ident {
+            .filter_map(|f| match &f.field.ident {
                 None => None,
-                Some(ref ident) => Some(ident.as_ref()),
+                Some(ident) => Some(ident.as_ref()),
             })
             .collect();
 
@@ -356,7 +355,7 @@ impl FieldRegions {
 }
 
 fn register_or_cluster_block(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
     nightly: bool,
@@ -369,7 +368,7 @@ fn register_or_cluster_block(
 }
 
 fn register_or_cluster_block_stable(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Tokens> {
@@ -433,7 +432,7 @@ fn register_or_cluster_block_stable(
 }
 
 fn register_or_cluster_block_nightly(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Tokens> {
@@ -552,16 +551,16 @@ fn register_or_cluster_block_nightly(
 /// Expand a list of parsed `Register`s or `Cluster`s, and render them to
 /// `RegisterBlockField`s containing `Field`s.
 fn expand(
-    ercs: &[Either<Register, Cluster>],
+    ercs: &[RegisterCluster],
     defs: &Defaults,
     name: Option<&str>,
 ) -> Result<Vec<RegisterBlockField>> {
     let mut ercs_expanded = vec![];
 
     for erc in ercs {
-        ercs_expanded.extend(match erc {
-            Either::Left(ref register) => expand_register(register, defs, name)?,
-            Either::Right(ref cluster) => expand_cluster(cluster, defs)?,
+        ercs_expanded.extend(match &erc {
+            RegisterCluster::Register(register) => expand_register(register, defs, name)?,
+            RegisterCluster::Cluster(cluster) => expand_cluster(cluster, defs)?,
         });
     }
 
@@ -576,16 +575,16 @@ fn cluster_size_in_bits(info: &ClusterInfo, defs: &Defaults) -> Result<u32> {
     let mut size = 0;
 
     for c in &info.children {
-        let end = match *c {
-            Either::Left(ref reg) => {
+        let end = match c {
+            RegisterCluster::Register(reg) => {
                 let reg_size: u32 = expand_register(reg, defs, None)?
                     .iter()
                     .map(|rbf| rbf.size)
                     .sum();
 
                 (reg.address_offset * BITS_PER_BYTE) + reg_size
             }
-            Either::Right(ref clust) => {
+            RegisterCluster::Cluster(clust) => {
                 (clust.address_offset * BITS_PER_BYTE) + cluster_size_in_bits(clust, defs)?
             }
         };
@@ -605,14 +604,14 @@ fn expand_cluster(cluster: &Cluster, defs: &Defaults) -> Result<Vec<RegisterBloc
         .or_else(|_e| cluster_size_in_bits(cluster, defs))
         .chain_err(|| format!("Cluster {} has no determinable `size` field", cluster.name))?;
 
-    match *cluster {
-        Cluster::Single(ref info) => cluster_expanded.push(RegisterBlockField {
+    match cluster {
+        Cluster::Single(info) => cluster_expanded.push(RegisterBlockField {
             field: convert_svd_cluster(cluster),
             description: info.description.clone(),
             offset: info.address_offset,
             size: cluster_size,
         }),
-        Cluster::Array(ref info, ref array_info) => {
+        Cluster::Array(info, array_info) => {
             let sequential_addresses = cluster_size == array_info.dim_increment * BITS_PER_BYTE;
 
             // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
@@ -662,14 +661,14 @@ fn expand_register(
         .or(defs.size)
         .ok_or_else(|| format!("Register {} has no `size` field", register.name))?;
 
-    match *register {
-        Register::Single(ref info) => register_expanded.push(RegisterBlockField {
+    match register {
+        Register::Single(info) => register_expanded.push(RegisterBlockField {
             field: convert_svd_register(register, name),
-            description: info.description.clone(),
+            description: info.description.clone().unwrap(),
             offset: info.address_offset,
             size: register_size,
         }),
-        Register::Array(ref info, ref array_info) => {
+        Register::Array(info, array_info) => {
             let sequential_addresses = register_size == array_info.dim_increment * BITS_PER_BYTE;
 
             // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
@@ -685,15 +684,15 @@ fn expand_register(
             if array_convertible {
                 register_expanded.push(RegisterBlockField {
                     field: convert_svd_register(&register, name),
-                    description: info.description.clone(),
+                    description: info.description.clone().unwrap(),
                     offset: info.address_offset,
                     size: register_size * array_info.dim,
                 });
             } else {
                 for (field_num, field) in expand_svd_register(register, name).iter().enumerate() {
                     register_expanded.push(RegisterBlockField {
                         field: field.clone(),
-                        description: info.description.clone(),
+                        description: info.description.clone().unwrap(),
                         offset: info.address_offset + field_num as u32 * array_info.dim_increment,
                         size: register_size,
                     });
@@ -719,9 +718,9 @@ fn cluster_block(
     let description = util::escape_brackets(util::respace(&c.description).as_ref());
 
     // Generate the register block.
-    let mod_name = match *c {
-        Cluster::Single(ref info) => &info.name,
-        Cluster::Array(ref info, ref _ai) => &info.name,
+    let mod_name = match c {
+        Cluster::Single(info) => &info.name,
+        Cluster::Array(info, _ai) => &info.name,
     }
     .replace("[%s]", "")
     .replace("%s", "");
@@ -786,9 +785,9 @@ fn expand_svd_register(register: &Register, name: Option<&str>) -> Vec<syn::Fiel
 
     let mut out = vec![];
 
-    match *register {
-        Register::Single(ref _info) => out.push(convert_svd_register(register, name)),
-        Register::Array(ref info, ref array_info) => {
+    match register {
+        Register::Single(_info) => out.push(convert_svd_register(register, name)),
+        Register::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
 
             let indices = array_info
@@ -857,14 +856,14 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
         )
     };
 
-    match *register {
-        Register::Single(ref info) => syn::Field {
+    match register {
+        Register::Single(info) => syn::Field {
             ident: Some(Ident::new(info.name.to_sanitized_snake_case())),
             vis: syn::Visibility::Public,
             attrs: vec![],
             ty: name_to_ty(&info.name, name),
         },
-        Register::Array(ref info, ref array_info) => {
+        Register::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
 
             let nb_name = if has_brackets {
@@ -911,9 +910,9 @@ fn expand_svd_cluster(cluster: &Cluster) -> Vec<syn::Field> {
 
     let mut out = vec![];
 
-    match *cluster {
-        Cluster::Single(ref _info) => out.push(convert_svd_cluster(cluster)),
-        Cluster::Array(ref info, ref array_info) => {
+    match &cluster {
+        Cluster::Single(_info) => out.push(convert_svd_cluster(cluster)),
+        Cluster::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
 
             let indices = array_info
@@ -971,14 +970,14 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
         )
     };
 
-    match *cluster {
-        Cluster::Single(ref info) => syn::Field {
+    match cluster {
+        Cluster::Single(info) => syn::Field {
             ident: Some(Ident::new(info.name.to_sanitized_snake_case())),
             vis: syn::Visibility::Public,
             attrs: vec![],
             ty: name_to_ty(&info.name),
         },
-        Cluster::Array(ref info, ref array_info) => {
+        Cluster::Array(info, array_info) => {
             let has_brackets = info.name.contains("[%s]");
 
             let name = if has_brackets {

src/generate/register.rs

@@ -1,8 +1,7 @@
 use cast::u64;
-use either::Either;
 use quote::Tokens;
-use crate::svd::{Access, BitRange, Cluster, Defaults, EnumeratedValues, Field, Peripheral, Register,
-          Usage, WriteConstraint};
+use crate::svd::{Access, BitRange, Defaults, EnumeratedValues, Field, Peripheral, Register,
+          RegisterCluster, Usage, WriteConstraint};
 use syn::Ident;
 
 use crate::errors::*;
@@ -31,7 +30,7 @@ pub fn render(
         rsize.next_power_of_two()
     };
     let rty = rsize.to_ty()?;
-    let description = util::escape_brackets(util::respace(&register.description).as_ref());
+    let description = util::escape_brackets(util::respace(&register.description.clone().unwrap()).as_ref());
 
     let unsafety = unsafety(register.write_constraint.as_ref(), rsize);
 
@@ -222,7 +221,8 @@ pub fn fields(
 
     impl<'a> F<'a> {
         fn from(f: &'a Field) -> Result<Self> {
-            let BitRange { offset, width } = f.bit_range;
+            // TODO(AJM) - do we need to do anything with this range type?
+            let BitRange { offset, width, range_type: _ } = f.bit_range;
             let sc = f.name.to_sanitized_snake_case();
             let pc = f.name.to_sanitized_upper_case();
             let pc_r = Ident::new(&*format!("{}R", pc));
@@ -239,7 +239,7 @@ pub fn fields(
             } else {
                 format!("Bits {}:{}", offset, offset + width - 1)
             };
-            if let Some(ref d) = f.description {
+            if let Some(d) = &f.description {
                 description.push_str(" - ");
                 description.push_str(&*util::respace(&util::escape_brackets(d)));
             }
@@ -330,14 +330,12 @@ pub fn fields(
                     .collect::<Result<Vec<_>>>()?;
 
                 let pc_r = &f.pc_r;
-                if let Some(ref base) = base {
+                if let Some(base) = &base {
                     let pc = base.field.to_sanitized_upper_case();
                     let base_pc_r = Ident::new(&*format!("{}R", pc));
                     let desc = format!("Possible values of the field `{}`", f.name,);
 
-                    if let (Some(ref peripheral), Some(ref register)) =
-                        (base.peripheral, base.register)
-                    {
+                    if let (Some(peripheral), Some(register)) = (&base.peripheral, &base.register) {
                         let pmod_ = peripheral.to_sanitized_snake_case();
                         let rmod_ = register.to_sanitized_snake_case();
                         let pmod_ = Ident::new(&*pmod_);
@@ -347,7 +345,7 @@ pub fn fields(
                             #[doc = #desc]
                             pub type #pc_r = ::#pmod_::#rmod_::#base_pc_r;
                         });
-                    } else if let Some(ref register) = base.register {
+                    } else if let Some(register) = &base.register {
                         let mod_ = register.to_sanitized_snake_case();
                         let mod_ = Ident::new(&*mod_);
 
@@ -596,9 +594,7 @@ pub fn fields(
                     let pc = base.field.to_sanitized_upper_case();
                     let base_pc_w = Ident::new(&*format!("{}W", pc));
 
-                    if let (Some(ref peripheral), Some(ref register)) =
-                        (base.peripheral, base.register)
-                    {
+                    if let (Some(peripheral), Some(register)) = (&base.peripheral, &base.register) {
                         let pmod_ = peripheral.to_sanitized_snake_case();
                         let rmod_ = register.to_sanitized_snake_case();
                         let pmod_ = Ident::new(&*pmod_);
@@ -613,7 +609,7 @@ pub fn fields(
                         quote! {
                             ::#pmod_::#rmod_::#base_pc_w
                         }
-                    } else if let Some(ref register) = base.register {
+                    } else if let Some(register) = &base.register {
                         let mod_ = register.to_sanitized_snake_case();
                         let mod_ = Ident::new(&*mod_);
 
@@ -791,8 +787,8 @@ pub fn fields(
 }
 
 fn unsafety(write_constraint: Option<&WriteConstraint>, width: u32) -> Option<Ident> {
-    match write_constraint {
-        Some(&WriteConstraint::Range(ref range))
+    match &write_constraint {
+        Some(&WriteConstraint::Range(range))
             if u64::from(range.min) == 0 && u64::from(range.max) == (1u64 << width) - 1 =>
         {
             // the SVD has acknowledged that it's safe to write
@@ -827,7 +823,7 @@ fn lookup<'a>(
 ) -> Result<Option<(&'a EnumeratedValues, Option<Base<'a>>)>> {
     let evs = evs.iter()
         .map(|evs| {
-            if let Some(ref base) = evs.derived_from {
+            if let Some(base) = &evs.derived_from {
                 let mut parts = base.split('.');
 
                 match (parts.next(), parts.next(), parts.next(), parts.next()) {
@@ -865,7 +861,7 @@ fn lookup<'a>(
         })
         .collect::<Result<Vec<_>>>()?;
 
-    for &(ref evs, ref base) in evs.iter() {
+    for (evs, base) in evs.iter() {
         if evs.usage == Some(usage) {
             return Ok(Some((*evs, base.clone())));
         }
@@ -979,7 +975,7 @@ fn lookup_in_register<'r>(
         } else {
             let fields = matches
                 .iter()
-                .map(|&(ref f, _)| &f.name)
+                .map(|(f, _)| &f.name)
                 .collect::<Vec<_>>();
             Err(format!(
                 "Fields {:?} have an \
@@ -1014,12 +1010,12 @@ fn lookup_in_peripherals<'p>(
 
 fn periph_all_registers<'a>(p: &'a Peripheral) -> Vec<&'a Register> {
     let mut par: Vec<&Register> = Vec::new();
-    let mut rem: Vec<&Either<Register, Cluster>> = Vec::new();
+    let mut rem: Vec<&RegisterCluster> = Vec::new();
     if p.registers.is_none() {
         return par;
     }
 
-    if let Some(ref regs) = p.registers {
+    if let Some(regs) = &p.registers {
         for r in regs.iter() {
             rem.push(r);
         }
@@ -1032,13 +1028,15 @@ fn periph_all_registers<'a>(p: &'a Peripheral) -> Vec<&'a Register> {
         }
 
         let b = b.unwrap();
-        match *b {
-            Either::Left(ref reg) => {
+        match b {
+            RegisterCluster::Register(reg) => {
                 par.push(reg);
             }
-            Either::Right(ref cluster) => for c in cluster.children.iter() {
-                rem.push(c);
-            },
+            RegisterCluster::Cluster(cluster) => {
+                for c in cluster.children.iter() {
+                    rem.push(c);
+                }
+            }
         }
     }
     par