Skip to content

Commit 36c3ec3

Browse files
bors[bot]therealprof
bors[bot]
and
therealprof
committed
Merge #330
330: Branch/indent refactoring r=adamgreig a=therealprof I refactored some quasi-quoted code to make it a more more forward compatible with newer versions of the syn and quote crates which we'll probably want to move to at some point. r? @ryankurte Co-authored-by: Daniel Egger <[email protected]>
2 parents 4a263a9 + 1c32ddd commit 36c3ec3

File tree

5 files changed

+60
-60
lines changed

5 files changed

+60
-60
lines changed

‎src/generate/device.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -157,7 +157,7 @@ pub fn render(
157157
}
158158

159159
let p = p.name.to_sanitized_upper_case();
160-
let id = Ident::new(&*p);
160+
let id = Ident::from(&*p);
161161
fields.push(quote! {
162162
#[doc = #p]
163163
pub #id: #id
@@ -166,9 +166,9 @@ pub fn render(
166166
}
167167

168168
let take = match target {
169-
Target::CortexM => Some(Ident::new("cortex_m")),
170-
Target::Msp430 => Some(Ident::new("msp430")),
171-
Target::RISCV => Some(Ident::new("riscv")),
169+
Target::CortexM => Some(Ident::from("cortex_m")),
170+
Target::Msp430 => Some(Ident::from("msp430")),
171+
Target::RISCV => Some(Ident::from("riscv")),
172172
Target::None => None,
173173
}
174174
.map(|krate| {

‎src/generate/interrupt.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ pub fn render(
4242
}
4343
pos += 1;
4444

45-
let name_uc = Ident::new(interrupt.name.to_sanitized_upper_case());
45+
let name_uc = Ident::from(interrupt.name.to_sanitized_upper_case());
4646
let description = format!(
4747
"{} - {}",
4848
interrupt.value,

‎src/generate/peripheral.rs‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -33,14 +33,14 @@ pub fn render(
3333
return Ok(out);
3434
}
3535

36-
let name_pc = Ident::new(&*p.name.to_sanitized_upper_case());
36+
let name_pc = Ident::from(&*p.name.to_sanitized_upper_case());
3737
let address = util::hex(p.base_address);
3838
let description = util::respace(p.description.as_ref().unwrap_or(&p.name));
3939
let derive_regs = p_derivedfrom.is_some() && p_original.registers.is_none();
4040

41-
let name_sc = Ident::new(&*p.name.to_sanitized_snake_case());
41+
let name_sc = Ident::from(&*p.name.to_sanitized_snake_case());
4242
let base = if derive_regs {
43-
Ident::new(&*p_derivedfrom.unwrap().name.to_sanitized_snake_case())
43+
Ident::from(&*p_derivedfrom.unwrap().name.to_sanitized_snake_case())
4444
} else {
4545
name_sc.clone()
4646
};
@@ -450,7 +450,7 @@ fn register_or_cluster_block(
450450
// Check if we need padding
451451
let pad = region.offset - last_end;
452452
if pad != 0 {
453-
let name = Ident::new(format!("_reserved{}", i));
453+
let name = Ident::from(format!("_reserved{}", i));
454454
let pad = pad as usize;
455455
fields.append(quote! {
456456
#name : [u8; #pad],
@@ -469,7 +469,7 @@ fn register_or_cluster_block(
469469

470470
if is_region_a_union {
471471
let name = &reg_block_field.field.ident;
472-
let mut_name = Ident::new(format!("{}_mut", name.as_ref().unwrap()));
472+
let mut_name = Ident::from(format!("{}_mut", name.as_ref().unwrap()));
473473
let ty = &reg_block_field.field.ty;
474474
let offset = reg_block_field.offset as usize;
475475
have_accessors = true;
@@ -496,7 +496,7 @@ fn register_or_cluster_block(
496496
});
497497

498498
reg_block_field.field.to_tokens(&mut region_fields);
499-
Ident::new(",").to_tokens(&mut region_fields);
499+
Ident::from(",").to_tokens(&mut region_fields);
500500
}
501501
}
502502

@@ -515,7 +515,7 @@ fn register_or_cluster_block(
515515
// name, along with the region number, falling back to
516516
// the offset and end in case we couldn't figure out a
517517
// nice identifier.
518-
let name = Ident::new(format!("_reserved_{}_{}", i, region.compute_ident().unwrap_or_else(|| format!("{}_{}", region.offset, region.end))));
518+
let name = Ident::from(format!("_reserved_{}_{}", i, region.compute_ident().unwrap_or_else(|| format!("{}_{}", region.offset, region.end))));
519519
let pad = (region.end - region.offset) as usize;
520520
fields.append(quote! {
521521
#name: [u8; #pad],
@@ -524,7 +524,7 @@ fn register_or_cluster_block(
524524
last_end = region.end;
525525
}
526526

527-
let name = Ident::new(match name {
527+
let name = Ident::from(match name {
528528
Some(name) => name.to_sanitized_upper_case(),
529529
None => "RegisterBlock".into(),
530530
});
@@ -723,7 +723,7 @@ fn cluster_block(
723723
}
724724
.replace("[%s]", "")
725725
.replace("%s", "");
726-
let name_sc = Ident::new(&*mod_name.to_sanitized_snake_case());
726+
let name_sc = Ident::from(&*mod_name.to_sanitized_snake_case());
727727
let reg_block = register_or_cluster_block(&c.children, defaults, Some(&mod_name), nightly)?;
728728

729729
// Generate definition for each of the registers.
@@ -775,7 +775,7 @@ fn expand_svd_register(register: &Register, name: Option<&str>) -> Vec<syn::Fiel
775775
syn::Path {
776776
global: false,
777777
segments: vec![syn::PathSegment {
778-
ident: Ident::new(ident),
778+
ident: Ident::from(ident),
779779
parameters: syn::PathParameters::none(),
780780
}],
781781
},
@@ -814,7 +814,7 @@ fn expand_svd_register(register: &Register, name: Option<&str>) -> Vec<syn::Fiel
814814
info.name.replace("%s", "")
815815
};
816816

817-
let ident = Ident::new(nb_name.to_sanitized_snake_case());
817+
let ident = Ident::from(nb_name.to_sanitized_snake_case());
818818
let ty = name_to_ty(&ty_name, name);
819819

820820
out.push(syn::Field {
@@ -848,7 +848,7 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
848848
syn::Path {
849849
global: false,
850850
segments: vec![syn::PathSegment {
851-
ident: Ident::new(ident),
851+
ident: Ident::from(ident),
852852
parameters: syn::PathParameters::none(),
853853
}],
854854
},
@@ -857,7 +857,7 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
857857

858858
match register {
859859
Register::Single(info) => syn::Field {
860-
ident: Some(Ident::new(info.name.to_sanitized_snake_case())),
860+
ident: Some(Ident::from(info.name.to_sanitized_snake_case())),
861861
vis: syn::Visibility::Public,
862862
attrs: vec![],
863863
ty: name_to_ty(&info.name, name),
@@ -871,7 +871,7 @@ fn convert_svd_register(register: &Register, name: Option<&str>) -> syn::Field {
871871
info.name.replace("%s", "")
872872
};
873873

874-
let ident = Ident::new(nb_name.to_sanitized_snake_case());
874+
let ident = Ident::from(nb_name.to_sanitized_snake_case());
875875

876876
let ty = syn::Ty::Array(
877877
Box::new(name_to_ty(&nb_name, name)),
@@ -900,7 +900,7 @@ fn expand_svd_cluster(cluster: &Cluster) -> Vec<syn::Field> {
900900
syn::Path {
901901
global: false,
902902
segments: vec![syn::PathSegment {
903-
ident: Ident::new(name.to_sanitized_upper_case()),
903+
ident: Ident::from(name.to_sanitized_upper_case()),
904904
parameters: syn::PathParameters::none(),
905905
}],
906906
},
@@ -939,7 +939,7 @@ fn expand_svd_cluster(cluster: &Cluster) -> Vec<syn::Field> {
939939
info.name.replace("%s", "")
940940
};
941941

942-
let ident = Ident::new(name.to_sanitized_snake_case());
942+
let ident = Ident::from(name.to_sanitized_snake_case());
943943
let ty = name_to_ty(&ty_name);
944944

945945
out.push(syn::Field {
@@ -962,7 +962,7 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
962962
syn::Path {
963963
global: false,
964964
segments: vec![syn::PathSegment {
965-
ident: Ident::new(name.to_sanitized_upper_case()),
965+
ident: Ident::from(name.to_sanitized_upper_case()),
966966
parameters: syn::PathParameters::none(),
967967
}],
968968
},
@@ -971,7 +971,7 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
971971

972972
match cluster {
973973
Cluster::Single(info) => syn::Field {
974-
ident: Some(Ident::new(info.name.to_sanitized_snake_case())),
974+
ident: Some(Ident::from(info.name.to_sanitized_snake_case())),
975975
vis: syn::Visibility::Public,
976976
attrs: vec![],
977977
ty: name_to_ty(&info.name),
@@ -985,7 +985,7 @@ fn convert_svd_cluster(cluster: &Cluster) -> syn::Field {
985985
info.name.replace("%s", "")
986986
};
987987

988-
let ident = Ident::new(name.to_sanitized_snake_case());
988+
let ident = Ident::from(name.to_sanitized_snake_case());
989989

990990
let ty = syn::Ty::Array(
991991
Box::new(name_to_ty(&name)),

‎src/generate/register.rs‎

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -16,8 +16,8 @@ pub fn render(
1616
) -> Result<Vec<Tokens>> {
1717
let access = util::access_of(register);
1818
let name = util::name_of(register);
19-
let name_pc = Ident::new(&*name.to_sanitized_upper_case());
20-
let name_sc = Ident::new(&*name.to_sanitized_snake_case());
19+
let name_pc = Ident::from(&*name.to_sanitized_upper_case());
20+
let name_sc = Ident::from(&*name.to_sanitized_snake_case());
2121
let rsize = register
2222
.size
2323
.or(defs.size)
@@ -228,14 +228,14 @@ pub fn fields(
228228
let BitRange { offset, width, range_type: _ } = f.bit_range;
229229
let sc = f.name.to_sanitized_snake_case();
230230
let pc = f.name.to_sanitized_upper_case();
231-
let pc_r = Ident::new(&*format!("{}R", pc));
232-
let pc_w = Ident::new(&*format!("{}W", pc));
233-
let _pc_w = Ident::new(&*format!("_{}W", pc));
234-
let _sc = Ident::new(&*format!("_{}", sc));
231+
let pc_r = Ident::from(&*format!("{}R", pc));
232+
let pc_w = Ident::from(&*format!("{}W", pc));
233+
let _pc_w = Ident::from(&*format!("_{}W", pc));
234+
let _sc = Ident::from(&*format!("_{}", sc));
235235
let bits = if width == 1 {
236-
Ident::new("bit")
236+
Ident::from("bit")
237237
} else {
238-
Ident::new("bits")
238+
Ident::from("bits")
239239
};
240240
let mut description = if width == 1 {
241241
format!("Bit {}", offset)
@@ -256,7 +256,7 @@ pub fn fields(
256256
width,
257257
access: f.access,
258258
evs: &f.enumerated_values,
259-
sc: Ident::new(&*sc),
259+
sc: Ident::from(&*sc),
260260
mask: util::hex((((1 as u64) << width) - 1) as u32),
261261
name: &f.name,
262262
offset: util::unsuffixed(u64::from(f.bit_range.offset)),
@@ -312,7 +312,7 @@ pub fn fields(
312312
.filter(|field| field.name.to_lowercase() != "reserved")
313313
.map(|ev| {
314314
let sc =
315-
Ident::new(&*ev.name.to_sanitized_snake_case());
315+
Ident::from(&*ev.name.to_sanitized_snake_case());
316316
let description = ev.description
317317
.as_ref()
318318
.map(|s| &**s)
@@ -325,7 +325,7 @@ pub fn fields(
325325
Ok(Variant {
326326
description,
327327
sc,
328-
pc: Ident::new(&*ev.name
328+
pc: Ident::from(&*ev.name
329329
.to_sanitized_upper_case()),
330330
value,
331331
})
@@ -335,22 +335,22 @@ pub fn fields(
335335
let pc_r = &f.pc_r;
336336
if let Some(base) = &base {
337337
let pc = base.field.to_sanitized_upper_case();
338-
let base_pc_r = Ident::new(&*format!("{}R", pc));
338+
let base_pc_r = Ident::from(&*format!("{}R", pc));
339339
let desc = format!("Possible values of the field `{}`", f.name,);
340340

341341
if let (Some(peripheral), Some(register)) = (&base.peripheral, &base.register) {
342342
let pmod_ = peripheral.to_sanitized_snake_case();
343343
let rmod_ = register.to_sanitized_snake_case();
344-
let pmod_ = Ident::new(&*pmod_);
345-
let rmod_ = Ident::new(&*rmod_);
344+
let pmod_ = Ident::from(&*pmod_);
345+
let rmod_ = Ident::from(&*rmod_);
346346

347347
mod_items.push(quote! {
348348
#[doc = #desc]
349349
pub type #pc_r = crate::#pmod_::#rmod_::#base_pc_r;
350350
});
351351
} else if let Some(register) = &base.register {
352352
let mod_ = register.to_sanitized_snake_case();
353-
let mod_ = Ident::new(&*mod_);
353+
let mod_ = Ident::from(&*mod_);
354354

355355
mod_items.push(quote! {
356356
#[doc = #desc]
@@ -485,9 +485,9 @@ pub fn fields(
485485
let sc = &v.sc;
486486

487487
let is_variant = if sc.as_ref().starts_with('_') {
488-
Ident::new(&*format!("is{}", sc))
488+
Ident::from(&*format!("is{}", sc))
489489
} else {
490-
Ident::new(&*format!("is_{}", sc))
490+
Ident::from(&*format!("is_{}", sc))
491491
};
492492

493493
let doc = format!("Checks if the value of the field is `{}`", pc);
@@ -595,13 +595,13 @@ pub fn fields(
595595

596596
let base_pc_w = base.as_ref().map(|base| {
597597
let pc = base.field.to_sanitized_upper_case();
598-
let base_pc_w = Ident::new(&*format!("{}W", pc));
598+
let base_pc_w = Ident::from(&*format!("{}W", pc));
599599

600600
if let (Some(peripheral), Some(register)) = (&base.peripheral, &base.register) {
601601
let pmod_ = peripheral.to_sanitized_snake_case();
602602
let rmod_ = register.to_sanitized_snake_case();
603-
let pmod_ = Ident::new(&*pmod_);
604-
let rmod_ = Ident::new(&*rmod_);
603+
let pmod_ = Ident::from(&*pmod_);
604+
let rmod_ = Ident::from(&*rmod_);
605605

606606
mod_items.push(quote! {
607607
#[doc = #pc_w_doc]
@@ -614,7 +614,7 @@ pub fn fields(
614614
}
615615
} else if let Some(register) = &base.register {
616616
let mod_ = register.to_sanitized_snake_case();
617-
let mod_ = Ident::new(&*mod_);
617+
let mod_ = Ident::from(&*mod_);
618618

619619
mod_items.push(quote! {
620620
#[doc = #pc_w_doc]
@@ -654,9 +654,9 @@ pub fn fields(
654654
.unwrap_or_else(|| {
655655
format!("`{:b}`", value)
656656
}),
657-
pc: Ident::new(&*ev.name
657+
pc: Ident::from(&*ev.name
658658
.to_sanitized_upper_case()),
659-
sc: Ident::new(&*ev.name
659+
sc: Ident::from(&*ev.name
660660
.to_sanitized_snake_case()),
661661
value,
662662
})
@@ -804,7 +804,7 @@ fn unsafety(write_constraint: Option<&WriteConstraint>, width: u32) -> Option<Id
804804
// if a writeConstraint exists then respect it
805805
None
806806
}
807-
_ => Some(Ident::new("unsafe")),
807+
_ => Some(Ident::from("unsafe")),
808808
}
809809
}
810810

‎src/util.rs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -220,21 +220,21 @@ pub fn hex(n: u32) -> Tokens {
220220
let mut t = Tokens::new();
221221
let (h2, h1) = ((n >> 16) & 0xffff, n & 0xffff);
222222
t.append(if h2 != 0 {
223-
format!("0x{:04x}_{:04x}", h2, h1)
223+
Ident::from(format!("0x{:04x}_{:04x}", h2, h1))
224224
} else if h1 & 0xff00 != 0 {
225-
format!("0x{:04x}", h1)
225+
Ident::from(format!("0x{:04x}", h1))
226226
} else if h1 != 0 {
227-
format!("0x{:02x}", h1 & 0xff)
227+
Ident::from(format!("0x{:02x}", h1 & 0xff))
228228
} else {
229-
String::from("0")
229+
Ident::from("0")
230230
});
231231
t
232232
}
233233

234234
pub fn hex_or_bool(n: u32, width: u32) -> Tokens {
235235
if width == 1 {
236236
let mut t = Tokens::new();
237-
t.append(if n == 0 { "false" } else { "true" });
237+
t.append(Ident::from(if n == 0 { "false" } else { "true" }));
238238
t
239239
} else {
240240
hex(n)
@@ -244,14 +244,14 @@ pub fn hex_or_bool(n: u32, width: u32) -> Tokens {
244244
/// Turns `n` into an unsuffixed token
245245
pub fn unsuffixed(n: u64) -> Tokens {
246246
let mut t = Tokens::new();
247-
t.append(format!("{}", n));
247+
t.append(Ident::from(format!("{}", n)));
248248
t
249249
}
250250

251251
pub fn unsuffixed_or_bool(n: u64, width: u32) -> Tokens {
252252
if width == 1 {
253253
let mut t = Tokens::new();
254-
t.append(if n == 0 { "false" } else { "true" });
254+
t.append(Ident::from(if n == 0 { "false" } else { "true" }));
255255
t
256256
} else {
257257
unsuffixed(n)
@@ -266,11 +266,11 @@ pub trait U32Ext {
266266
impl U32Ext for u32 {
267267
fn to_ty(&self) -> Result<Ident> {
268268
Ok(match *self {
269-
1 => Ident::new("bool"),
270-
2..=8 => Ident::new("u8"),
271-
9..=16 => Ident::new("u16"),
272-
17..=32 => Ident::new("u32"),
273-
33..=64 => Ident::new("u64"),
269+
1 => Ident::from("bool"),
270+
2..=8 => Ident::from("u8"),
271+
9..=16 => Ident::from("u16"),
272+
17..=32 => Ident::from("u32"),
273+
33..=64 => Ident::from("u64"),
274274
_ => Err(format!(
275275
"can't convert {} bits into a Rust integral type",
276276
*self

0 commit comments

Comments
 (0)