From 310b308166e318040bb467d9c39cc754b705e4f0 Mon Sep 17 00:00:00 2001 From: Daniel Verkamp Date: Wed, 10 Oct 2018 09:59:55 -0700 Subject: [PATCH] rustfmt wire_format_derive and poll_token_derive BUG=None TEST=cargo test Change-Id: I62f00a71ed3693352de648bb8ee576335b32019f Signed-off-by: Daniel Verkamp Reviewed-on: https://chromium-review.googlesource.com/1273688 Reviewed-by: Zach Reizner --- p9/wire_format_derive/wire_format_derive.rs | 4 +- .../poll_token_derive/poll_token_derive.rs | 92 ++++--- sys_util/poll_token_derive/tests.rs | 237 ++++++++++-------- 3 files changed, 174 insertions(+), 159 deletions(-) diff --git a/p9/wire_format_derive/wire_format_derive.rs b/p9/wire_format_derive/wire_format_derive.rs index 5268b929bc..53bfdba636 100644 --- a/p9/wire_format_derive/wire_format_derive.rs +++ b/p9/wire_format_derive/wire_format_derive.rs @@ -8,8 +8,8 @@ #![recursion_limit = "256"] -extern crate proc_macro2; extern crate proc_macro; +extern crate proc_macro2; #[macro_use] extern crate quote; @@ -20,8 +20,8 @@ extern crate syn; use proc_macro::TokenStream; use proc_macro2::Span; use quote::Tokens; -use syn::{Data, DeriveInput, Fields, Ident}; use syn::spanned::Spanned; +use syn::{Data, DeriveInput, Fields, Ident}; /// The function that derives the actual implementation. #[proc_macro_derive(P9WireFormat)] diff --git a/sys_util/poll_token_derive/poll_token_derive.rs b/sys_util/poll_token_derive/poll_token_derive.rs index 3506b4de8a..5199366c05 100644 --- a/sys_util/poll_token_derive/poll_token_derive.rs +++ b/sys_util/poll_token_derive/poll_token_derive.rs @@ -207,7 +207,6 @@ impl ParseState { Tokenized::Enum => States::Ident, Tokenized::Visiblity => States::Start, _ => panic!("derives for enum types only"), - }; } @@ -237,9 +236,9 @@ impl ParseState { self.current_state = match tok { Tokenized::Ident(ident) => { let mut variant = Some(EnumVariant { - name: ident, - data: None, - }); + name: ident, + data: None, + }); mem::swap(&mut variant, &mut self.current_variant); if let Some(variant) = variant { self.model.variants.push(variant); @@ -247,14 +246,11 @@ impl ParseState { States::VariantIdent } Tokenized::IdentAndType(ident, type_) => { - let variant_data = EnumVariantData { - type_: type_, - name: None, - }; + let variant_data = EnumVariantData { type_, name: None }; let mut variant = Some(EnumVariant { - name: ident, - data: Some(variant_data), - }); + name: ident, + data: Some(variant_data), + }); mem::swap(&mut variant, &mut self.current_variant); if let Some(variant) = variant { self.model.variants.push(variant); @@ -278,12 +274,14 @@ impl ParseState { let variant = self.current_variant.as_mut().unwrap(); self.current_state = match tok { Tokenized::FieldIdent(ident) => { - assert!(variant.data.is_none(), - "enum variant can only have one field"); + assert!( + variant.data.is_none(), + "enum variant can only have one field" + ); variant.data = Some(EnumVariantData { - type_: "".to_owned(), - name: Some(ident), - }); + type_: "".to_owned(), + name: Some(ident), + }); States::VariantDataType } Tokenized::CloseBrace => States::VariantIdent, @@ -339,9 +337,10 @@ impl EnumModel { // The capture string is for everything between the variant identifier and the `=>` in // the match arm: the variant's data capture. let capture = match variant.data.as_ref() { - Some(&EnumVariantData { name: Some(ref name), .. }) => { - format!("{{ {}: data }}", name) - } + Some(&EnumVariantData { + name: Some(ref name), + .. + }) => format!("{{ {}: data }}", name), Some(&EnumVariantData { .. }) => "(data)".to_owned(), None => "".to_owned(), }; @@ -355,14 +354,11 @@ impl EnumModel { }; // Assembly of the match arm. - write!(match_statement, - "{}::{}{} => {}{},\n", - self.name, - variant.name, - capture, - index, - modifer) - .unwrap(); + write!( + match_statement, + "{}::{}{} => {}{},\n", + self.name, variant.name, capture, index, modifer + ).unwrap(); } match_statement.push_str("}"); match_statement @@ -382,24 +378,22 @@ impl EnumModel { // data, which includes both variant index and data bits. let data = match variant.data.as_ref() { Some(&EnumVariantData { - name: Some(ref name), - ref type_, - }) => format!("{{ {}: (data >> {}) as {} }}", name, variant_bits, type_), + name: Some(ref name), + ref type_, + }) => format!("{{ {}: (data >> {}) as {} }}", name, variant_bits, type_), Some(&EnumVariantData { - name: None, - ref type_, - }) => format!("((data >> {}) as {})", variant_bits, type_), + name: None, + ref type_, + }) => format!("((data >> {}) as {})", variant_bits, type_), None => "".to_owned(), }; // Assembly of the match arm. - write!(match_statement, - "{} => {}::{}{},\n", - index, - self.name, - variant.name, - data) - .unwrap(); + write!( + match_statement, + "{} => {}::{}{},\n", + index, self.name, variant.name, data + ).unwrap(); } match_statement.push_str("_ => unreachable!()\n}"); match_statement @@ -419,9 +413,11 @@ fn poll_token_inner(src: &str) -> String { state.handle_token(tok); } - assert_eq!(state.current_state, - States::End, - "unexpected end after parsing source enum"); + assert_eq!( + state.current_state, + States::End, + "unexpected end after parsing source enum" + ); // Given our basic model of a user given enum that is suitable as a token, we generate the // implementation. The implementation is NOT always well formed, such as when a variant's data @@ -429,7 +425,8 @@ fn poll_token_inner(src: &str) -> String { // would be difficult to detect every kind of error. Importantly, every implementation that we // generate here and goes on to compile succesfully is sound. let model = state.model; - format!("impl PollToken for {} {{ + format!( + "impl PollToken for {} {{ fn as_raw_token(&self) -> u64 {{ {} }} @@ -438,9 +435,10 @@ fn poll_token_inner(src: &str) -> String { {} }} }}", - model.name, - model.generate_as_raw_token(), - model.generate_from_raw_token()) + model.name, + model.generate_as_raw_token(), + model.generate_from_raw_token() + ) } /// Implements the PollToken trait for a given `enum`. diff --git a/sys_util/poll_token_derive/tests.rs b/sys_util/poll_token_derive/tests.rs index 0eacf6d5b8..d96c6757c5 100644 --- a/sys_util/poll_token_derive/tests.rs +++ b/sys_util/poll_token_derive/tests.rs @@ -21,27 +21,34 @@ mod tokenized { #[test] fn ident() { - assert_eq!(Tokenized::from_str("Important"), - Ident("Important".to_owned())); + assert_eq!( + Tokenized::from_str("Important"), + Ident("Important".to_owned()) + ); assert_eq!(Tokenized::from_str("hello,"), Ident("hello".to_owned())); assert_eq!(Tokenized::from_str("world2"), Ident("world2".to_owned())); assert_eq!(Tokenized::from_str("A,"), Ident("A".to_owned())); } - #[test] fn field_ident() { - assert_eq!(Tokenized::from_str("index:"), - FieldIdent("index".to_owned())); + assert_eq!( + Tokenized::from_str("index:"), + FieldIdent("index".to_owned()) + ); assert_eq!(Tokenized::from_str("a:"), FieldIdent("a".to_owned())); } #[test] fn ident_and_type() { - assert_eq!(Tokenized::from_str("a(u32)"), - IdentAndType("a".to_owned(), "u32".to_owned())); - assert_eq!(Tokenized::from_str("Socket(usize),"), - IdentAndType("Socket".to_owned(), "usize".to_owned())); + assert_eq!( + Tokenized::from_str("a(u32)"), + IdentAndType("a".to_owned(), "u32".to_owned()) + ); + assert_eq!( + Tokenized::from_str("Socket(usize),"), + IdentAndType("Socket".to_owned(), "usize".to_owned()) + ); } #[test] @@ -63,27 +70,31 @@ mod tokenized { } mod parse_state { - use {Tokenized, States, ParseState, EnumModel, EnumVariant, EnumVariantData}; use Tokenized::*; + use {EnumModel, EnumVariant, EnumVariantData, ParseState, States, Tokenized}; fn parse_tokens(tokens: &[Tokenized]) -> EnumModel { let mut state = ParseState::new(); for token in tokens { state.handle_token(token.clone()); } - assert_eq!(state.current_state, - States::End, - "unexpected end after parsing source enum"); + assert_eq!( + state.current_state, + States::End, + "unexpected end after parsing source enum" + ); state.model } #[test] fn empty_struct() { - let model = parse_tokens(&[Visiblity, - Enum, - Ident("Blarg".to_owned()), - OpenBrace, - CloseBrace]); + let model = parse_tokens(&[ + Visiblity, + Enum, + Ident("Blarg".to_owned()), + OpenBrace, + CloseBrace, + ]); let expected = EnumModel { name: "Blarg".to_string(), variants: Vec::new(), @@ -94,94 +105,106 @@ mod parse_state { #[test] #[should_panic] fn invalid_token() { - parse_tokens(&[Visiblity, - Enum, - Ident("Blarg".to_owned()), - OpenBrace, - CloseBrace, - CloseBrace]); + parse_tokens(&[ + Visiblity, + Enum, + Ident("Blarg".to_owned()), + OpenBrace, + CloseBrace, + CloseBrace, + ]); } #[test] fn only_unit_variants() { - let model = parse_tokens(&[Enum, - Ident("Foo".to_owned()), - OpenBrace, - Ident("A".to_owned()), - Ident("B".to_owned()), - Ident("C".to_owned()), - CloseBrace]); + let model = parse_tokens(&[ + Enum, + Ident("Foo".to_owned()), + OpenBrace, + Ident("A".to_owned()), + Ident("B".to_owned()), + Ident("C".to_owned()), + CloseBrace, + ]); let expected = EnumModel { name: "Foo".to_string(), - variants: vec![EnumVariant { - name: "A".to_owned(), - data: None, - }, - EnumVariant { - name: "B".to_owned(), - data: None, - }, - EnumVariant { - name: "C".to_owned(), - data: None, - }], + variants: vec![ + EnumVariant { + name: "A".to_owned(), + data: None, + }, + EnumVariant { + name: "B".to_owned(), + data: None, + }, + EnumVariant { + name: "C".to_owned(), + data: None, + }, + ], }; assert_eq!(model, expected); } #[test] fn unnamed_data() { - let model = parse_tokens(&[Enum, - Ident("Foo".to_owned()), - OpenBrace, - IdentAndType("A".to_owned(), "u32".to_owned()), - Ident("B".to_owned()), - IdentAndType("C".to_owned(), "usize".to_owned()), - CloseBrace]); + let model = parse_tokens(&[ + Enum, + Ident("Foo".to_owned()), + OpenBrace, + IdentAndType("A".to_owned(), "u32".to_owned()), + Ident("B".to_owned()), + IdentAndType("C".to_owned(), "usize".to_owned()), + CloseBrace, + ]); let expected = EnumModel { name: "Foo".to_string(), - variants: vec![EnumVariant { - name: "A".to_owned(), - data: Some(EnumVariantData { - name: None, - type_: "u32".to_owned(), - }), - }, - EnumVariant { - name: "B".to_owned(), - data: None, - }, - EnumVariant { - name: "C".to_owned(), - data: Some(EnumVariantData { - name: None, - type_: "usize".to_owned(), - }), - }], + variants: vec![ + EnumVariant { + name: "A".to_owned(), + data: Some(EnumVariantData { + name: None, + type_: "u32".to_owned(), + }), + }, + EnumVariant { + name: "B".to_owned(), + data: None, + }, + EnumVariant { + name: "C".to_owned(), + data: Some(EnumVariantData { + name: None, + type_: "usize".to_owned(), + }), + }, + ], }; assert_eq!(model, expected); } #[test] fn named_data() { - let model = parse_tokens(&[Enum, - Ident("Foo".to_owned()), - OpenBrace, - Ident("A".to_owned()), - OpenBrace, - FieldIdent("index".to_owned()), - Ident("u16".to_owned()), - CloseBrace, - CloseBrace]); + let model = parse_tokens(&[ + Enum, + Ident("Foo".to_owned()), + OpenBrace, + Ident("A".to_owned()), + OpenBrace, + FieldIdent("index".to_owned()), + Ident("u16".to_owned()), + CloseBrace, + CloseBrace, + ]); let expected = EnumModel { name: "Foo".to_string(), variants: vec![EnumVariant { - name: "A".to_owned(), - data: Some(EnumVariantData { - name: Some("index".to_owned()), - type_: "u16".to_owned(), - }), - }], + name: "A".to_owned(), + data: Some(EnumVariantData { + name: Some("index".to_owned()), + type_: "u16".to_owned(), + }), + }], }; assert_eq!(model, expected); } @@ -195,40 +218,34 @@ mod enum_model { let mut model = EnumModel { name: "Baz".to_string(), variants: vec![EnumVariant { - name: "A".to_owned(), - data: None, - }], + name: "A".to_owned(), + data: None, + }], }; assert_eq!(model.variant_bits(), 0); - model.variants.append( - &mut vec![ - EnumVariant { - name: "B".to_owned(), - data: None, - }, - EnumVariant { - name: "C".to_owned(), - data: None, - } - ] - ); + model.variants.append(&mut vec![ + EnumVariant { + name: "B".to_owned(), + data: None, + }, + EnumVariant { + name: "C".to_owned(), + data: None, + }, + ]); assert_eq!(model.variant_bits(), 2); for _ in 0..1021 { - model - .variants - .push(EnumVariant { - name: "Dynamic".to_owned(), - data: None, - }); + model.variants.push(EnumVariant { + name: "Dynamic".to_owned(), + data: None, + }); } assert_eq!(model.variant_bits(), 10); - model - .variants - .push(EnumVariant { - name: "OneMore".to_owned(), - data: None, - }); + model.variants.push(EnumVariant { + name: "OneMore".to_owned(), + data: None, + }); assert_eq!(model.variant_bits(), 11); } }