From ea940fcb74abce67b927788e4f9f64fc63073d37 Mon Sep 17 00:00:00 2001 From: Christian Duerr Date: Sat, 23 Nov 2019 02:01:09 +0100 Subject: Update to Rust 2018 This moves all crates in the workspace to the latest Rust standard and resolves various style and formatting issues. Fixes #32. --- codegen/src/ext/utf8.rs | 173 ++++++++++++++++++++-------------------------- codegen/src/ext/vt.rs | 179 +++++++++++++++++++++--------------------------- codegen/src/main.rs | 8 +-- 3 files changed, 158 insertions(+), 202 deletions(-) (limited to 'codegen/src') diff --git a/codegen/src/ext/utf8.rs b/codegen/src/ext/utf8.rs index 17ebc22..898722b 100644 --- a/codegen/src/ext/utf8.rs +++ b/codegen/src/ext/utf8.rs @@ -3,27 +3,28 @@ use std::fmt; use syntex::Registry; -use syntex_syntax::ast::{self, ExprKind, Arm, Expr, PatKind, LitKind, Pat}; +use syntex_syntax::ast::{self, Arm, Expr, ExprKind, LitKind, Pat, PatKind}; use syntex_syntax::codemap::Span; -use syntex_syntax::ext::base::{ExtCtxt, MacEager, MacResult, DummyResult}; +use syntex_syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult}; use syntex_syntax::ext::build::AstBuilder; -use syntex_syntax::parse::token::{Token, DelimToken}; use syntex_syntax::parse::parser::Parser; +use syntex_syntax::parse::token::{DelimToken, Token}; use syntex_syntax::parse::PResult; use syntex_syntax::ptr::P; use syntex_syntax::tokenstream::TokenTree; -#[path="../../../utf8parse/src/types.rs"] +#[path = "../../../utf8parse/src/types.rs"] mod types; -use self::types::{State, Action, pack}; +use self::types::{pack, Action, State}; pub fn register(registry: &mut Registry) { registry.add_macro("utf8_state_table", expand_state_table); } fn state_from_str(s: &S) -> Result - where S: AsRef +where + S: AsRef, { Ok(match s.as_ref() { "State::Ground" => State::Ground, @@ -34,12 +35,13 @@ fn state_from_str(s: &S) -> Result "State::U3_2_ed" => State::U3_2_ed, "State::Utf8_4_3_f0" => State::Utf8_4_3_f0, "State::Utf8_4_3_f4" => State::Utf8_4_3_f4, - _ => return Err(()) + _ => return Err(()), }) } fn action_from_str(s: &S) -> Result - where S: AsRef +where + S: AsRef, { Ok(match s.as_ref() { "Action::InvalidSequence" => Action::InvalidSequence, @@ -50,13 +52,13 @@ fn action_from_str(s: &S) -> Result "Action::SetByte3" => Action::SetByte3, "Action::SetByte3Top" => Action::SetByte3Top, "Action::SetByte4" => Action::SetByte4, - _ => return Err(()) + _ => return Err(()), }) } fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec> { // Must start on open brace - try!(parser.expect(&Token::OpenDelim(DelimToken::Brace))); + parser.expect(&Token::OpenDelim(DelimToken::Brace))?; let mut arms: Vec = Vec::new(); while parser.token != Token::CloseDelim(DelimToken::Brace) { @@ -65,7 +67,7 @@ fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec { // Recover by skipping to the end of the block. return Err(e); - } + }, } } @@ -83,53 +85,43 @@ struct TableDefinitionExprs { fn state_from_expr(expr: P, cx: &mut ExtCtxt) -> Result { let s = match expr.node { - ExprKind::Path(ref _qself, ref path) => { - path.to_string() - }, + ExprKind::Path(ref _qself, ref path) => path.to_string(), _ => { cx.span_err(expr.span, "expected State"); - return Err(()) - } + return Err(()); + }, }; state_from_str(&s).map_err(|_| { cx.span_err(expr.span, "expected State"); - () }) } fn u8_lit_from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result { - static MSG: &'static str = "expected u8 int literal"; + static MSG: &str = "expected u8 int literal"; match expr.node { - ExprKind::Lit(ref lit) => { - match lit.node { - LitKind::Int(val, _) => { - Ok(val as u8) - }, - _ => { - cx.span_err(lit.span, MSG); - return Err(()); - } - } + ExprKind::Lit(ref lit) => match lit.node { + LitKind::Int(val, _) => Ok(val as u8), + _ => { + cx.span_err(lit.span, MSG); + Err(()) + }, }, _ => { cx.span_err(expr.span, MSG); - return Err(()); - } + Err(()) + }, } } fn input_mapping_from_arm(arm: Arm, cx: &mut ExtCtxt) -> Result { let Arm { pats, body, .. } = arm; - let input = try!(InputDefinition::from_pat(&pats[0], cx)); - let transition = try!(Transition::from_expr(&body, cx)); + let input = InputDefinition::from_pat(&pats[0], cx)?; + let transition = Transition::from_expr(&body, cx)?; - Ok(InputMapping { - input: input, - transition: transition, - }) + Ok(InputMapping { input, transition }) } /// What happens when certain input is received @@ -143,11 +135,11 @@ enum Transition { impl fmt::Debug for Transition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - Transition::State(state) => try!(write!(f, "State({:?})", state)), - Transition::Action(action) => try!(write!(f, "Action({:?})", action)), + Transition::State(state) => write!(f, "State({:?})", state)?, + Transition::Action(action) => write!(f, "Action({:?})", action)?, Transition::StateAction(state, action) => { - try!(write!(f, "StateAction({:?}, {:?})", state, action)); - } + write!(f, "StateAction({:?}, {:?})", state, action)?; + }, } write!(f, " -> {:?}", self.pack_u8()) @@ -156,8 +148,8 @@ impl fmt::Debug for Transition { impl Transition { // State is stored in the top 4 bits - fn pack_u8(&self) -> u8 { - match *self { + fn pack_u8(self) -> u8 { + match self { Transition::State(state) => pack(state, Action::InvalidSequence), Transition::Action(action) => pack(State::Ground, action), Transition::StateAction(state, action) => pack(state, action), @@ -176,15 +168,13 @@ impl Transition { if let ExprKind::Path(_, ref path) = tup_expr.node { let path_str = path.to_string(); if path_str.starts_with('A') { - action = Some(try!(action_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid action"); - }))); + action = Some(action_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid action"); + })?); } else { - state = Some(try!(state_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid state"); - }))); + state = Some(state_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid state"); + })?); } } } @@ -196,7 +186,7 @@ impl Transition { _ => { cx.span_err(expr.span, "expected Action and/or State"); Err(()) - } + }, } }, ExprKind::Path(_, ref path) => { @@ -204,16 +194,14 @@ impl Transition { let path_str = path.to_string(); if path_str.starts_with('A') { - let action = try!(action_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid action"); - })); + let action = action_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid action"); + })?; Ok(Transition::Action(action)) } else { - let state = try!(state_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid state"); - })); + let state = state_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid state"); + })?; Ok(Transition::State(state)) } @@ -221,7 +209,7 @@ impl Transition { _ => { cx.span_err(expr.span, "expected Action and/or State"); Err(()) - } + }, } } } @@ -229,25 +217,23 @@ impl Transition { #[derive(Debug)] enum InputDefinition { Specific(u8), - Range { start: u8, end: u8 } + Range { start: u8, end: u8 }, } impl InputDefinition { fn from_pat(pat: &Pat, cx: &mut ExtCtxt) -> Result { Ok(match pat.node { PatKind::Lit(ref lit_expr) => { - InputDefinition::Specific(try!(u8_lit_from_expr(&lit_expr, cx))) + InputDefinition::Specific(u8_lit_from_expr(&lit_expr, cx)?) }, - PatKind::Range(ref start_expr, ref end_expr) => { - InputDefinition::Range { - start: try!(u8_lit_from_expr(start_expr, cx)), - end: try!(u8_lit_from_expr(end_expr, cx)), - } + PatKind::Range(ref start_expr, ref end_expr) => InputDefinition::Range { + start: u8_lit_from_expr(start_expr, cx)?, + end: u8_lit_from_expr(end_expr, cx)?, }, _ => { cx.span_err(pat.span, "expected literal or range expression"); - return Err(()) - } + return Err(()); + }, }) } } @@ -266,45 +252,39 @@ struct TableDefinition { fn parse_raw_definitions( definitions: Vec, - cx: &mut ExtCtxt + cx: &mut ExtCtxt, ) -> Result, ()> { let mut out = Vec::new(); for raw in definitions { let TableDefinitionExprs { state_expr, mapping_arms } = raw; - let state = try!(state_from_expr(state_expr, cx)); + let state = state_from_expr(state_expr, cx)?; let mut mappings = Vec::new(); for arm in mapping_arms { - mappings.push(try!(input_mapping_from_arm(arm, cx))); + mappings.push(input_mapping_from_arm(arm, cx)?); } - out.push(TableDefinition { - state: state, - mappings: mappings, - }) + out.push(TableDefinition { state, mappings }) } Ok(out) } fn parse_table_definition<'a>(parser: &mut Parser<'a>) -> PResult<'a, TableDefinitionExprs> { - let state_expr = try!(parser.parse_expr()); - try!(parser.expect(&Token::FatArrow)); - let mappings = try!(parse_table_input_mappings(parser)); + let state_expr = parser.parse_expr()?; + parser.expect(&Token::FatArrow)?; + let mappings = parse_table_input_mappings(parser)?; - Ok(TableDefinitionExprs { - state_expr: state_expr, - mapping_arms: mappings - }) + Ok(TableDefinitionExprs { state_expr, mapping_arms: mappings }) } -fn parse_table_definition_list<'a>(parser: &mut Parser<'a>) - -> PResult<'a, Vec> -{ +fn parse_table_definition_list<'a>( + parser: &mut Parser<'a>, +) -> PResult<'a, Vec> { let mut definitions = Vec::new(); while parser.token != Token::Eof { - definitions.push(try!(parse_table_definition(parser))); + definitions.push(parse_table_definition(parser)?); parser.eat(&Token::Comma); } @@ -312,7 +292,8 @@ fn parse_table_definition_list<'a>(parser: &mut Parser<'a>) } fn build_state_tables(defs: T) -> [[u8; 256]; 8] - where T: AsRef<[TableDefinition]> +where + T: AsRef<[TableDefinition]>, { let mut result = [[0u8; 256]; 8]; @@ -341,11 +322,10 @@ fn build_state_tables(defs: T) -> [[u8; 256]; 8] } fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 8]) -> P { - let table = table.iter() + let table = table + .iter() .map(|list| { - let exprs = list.iter() - .map(|num| cx.expr_u8(sp, *num)) - .collect(); + let exprs = list.iter().map(|num| cx.expr_u8(sp, *num)).collect(); cx.expr_vec(sp, exprs) }) .collect(); @@ -356,9 +336,8 @@ fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 8]) -> P( cx: &'cx mut ExtCtxt, sp: Span, - args: &[TokenTree]) - -> Box -{ + args: &[TokenTree], +) -> Box { macro_rules! ptry { ($pres:expr) => { match $pres { @@ -366,9 +345,9 @@ fn expand_state_table<'cx>( Err(mut err) => { err.emit(); return DummyResult::any(sp); - } + }, } - } + }; } // Parse the lookup spec diff --git a/codegen/src/ext/vt.rs b/codegen/src/ext/vt.rs index 3f5bcf3..aff7d68 100644 --- a/codegen/src/ext/vt.rs +++ b/codegen/src/ext/vt.rs @@ -3,27 +3,28 @@ use std::fmt; use syntex::Registry; -use syntex_syntax::ast::{self, ExprKind, Arm, Expr, PatKind, LitKind, Pat}; +use syntex_syntax::ast::{self, Arm, Expr, ExprKind, LitKind, Pat, PatKind}; use syntex_syntax::codemap::Span; -use syntex_syntax::ext::base::{ExtCtxt, MacEager, MacResult, DummyResult}; +use syntex_syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult}; use syntex_syntax::ext::build::AstBuilder; -use syntex_syntax::parse::token::{Token, DelimToken}; use syntex_syntax::parse::parser::Parser; +use syntex_syntax::parse::token::{DelimToken, Token}; use syntex_syntax::parse::PResult; use syntex_syntax::ptr::P; use syntex_syntax::tokenstream::TokenTree; -#[path="../../../src/definitions.rs"] +#[path = "../../../src/definitions.rs"] mod definitions; -use self::definitions::{State, Action}; +use self::definitions::{Action, State}; pub fn register(registry: &mut Registry) { registry.add_macro("vt_state_table", expand_state_table); } fn state_from_str(s: &S) -> Result - where S: AsRef +where + S: AsRef, { Ok(match s.as_ref() { "State::Anywhere" => State::Anywhere, @@ -42,12 +43,13 @@ fn state_from_str(s: &S) -> Result "State::OscString" => State::OscString, "State::SosPmApcString" => State::SosPmApcString, "State::Utf8" => State::Utf8, - _ => return Err(()) + _ => return Err(()), }) } fn action_from_str(s: &S) -> Result - where S: AsRef +where + S: AsRef, { Ok(match s.as_ref() { "Action::None" => Action::None, @@ -66,13 +68,13 @@ fn action_from_str(s: &S) -> Result "Action::Put" => Action::Put, "Action::Unhook" => Action::Unhook, "Action::BeginUtf8" => Action::BeginUtf8, - _ => return Err(()) + _ => return Err(()), }) } fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec> { // Must start on open brace - try!(parser.expect(&Token::OpenDelim(DelimToken::Brace))); + parser.expect(&Token::OpenDelim(DelimToken::Brace))?; let mut arms: Vec = Vec::new(); while parser.token != Token::CloseDelim(DelimToken::Brace) { @@ -81,7 +83,7 @@ fn parse_table_input_mappings<'a>(parser: &mut Parser<'a>) -> PResult<'a, Vec { // Recover by skipping to the end of the block. return Err(e); - } + }, } } @@ -99,53 +101,43 @@ struct TableDefinitionExprs { fn state_from_expr(expr: P, cx: &mut ExtCtxt) -> Result { let s = match expr.node { - ExprKind::Path(ref _qself, ref path) => { - path.to_string() - }, + ExprKind::Path(ref _qself, ref path) => path.to_string(), _ => { cx.span_err(expr.span, "expected State"); - return Err(()) - } + return Err(()); + }, }; state_from_str(&s).map_err(|_| { cx.span_err(expr.span, "expected State"); - () }) } fn u8_lit_from_expr(expr: &Expr, cx: &mut ExtCtxt) -> Result { - static MSG: &'static str = "expected u8 int literal"; + static MSG: &str = "expected u8 int literal"; match expr.node { - ExprKind::Lit(ref lit) => { - match lit.node { - LitKind::Int(val, _) => { - Ok(val as u8) - }, - _ => { - cx.span_err(lit.span, MSG); - return Err(()); - } - } + ExprKind::Lit(ref lit) => match lit.node { + LitKind::Int(val, _) => Ok(val as u8), + _ => { + cx.span_err(lit.span, MSG); + Err(()) + }, }, _ => { cx.span_err(expr.span, MSG); - return Err(()); - } + Err(()) + }, } } fn input_mapping_from_arm(arm: Arm, cx: &mut ExtCtxt) -> Result { let Arm { pats, body, .. } = arm; - let input = try!(InputDefinition::from_pat(&pats[0], cx)); - let transition = try!(Transition::from_expr(&body, cx)); + let input = InputDefinition::from_pat(&pats[0], cx)?; + let transition = Transition::from_expr(&body, cx)?; - Ok(InputMapping { - input: input, - transition: transition, - }) + Ok(InputMapping { input, transition }) } /// What happens when certain input is received @@ -159,11 +151,11 @@ enum Transition { impl fmt::Debug for Transition { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - Transition::State(state) => try!(write!(f, "State({:?})", state)), - Transition::Action(action) => try!(write!(f, "Action({:?})", action)), + Transition::State(state) => write!(f, "State({:?})", state)?, + Transition::Action(action) => write!(f, "Action({:?})", action)?, Transition::StateAction(state, action) => { - try!(write!(f, "StateAction({:?}, {:?})", state, action)); - } + write!(f, "StateAction({:?}, {:?})", state, action)?; + }, } write!(f, " -> {:?}", self.pack_u8()) @@ -172,13 +164,11 @@ impl fmt::Debug for Transition { impl Transition { // State is stored in the top 4 bits - fn pack_u8(&self) -> u8 { - match *self { + fn pack_u8(self) -> u8 { + match self { Transition::State(state) => state as u8, Transition::Action(action) => (action as u8) << 4, - Transition::StateAction(state, action) => { - ((action as u8) << 4) | (state as u8) - } + Transition::StateAction(state, action) => ((action as u8) << 4) | (state as u8), } } } @@ -194,15 +184,13 @@ impl Transition { if let ExprKind::Path(_, ref path) = tup_expr.node { let path_str = path.to_string(); if path_str.starts_with('A') { - action = Some(try!(action_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid action"); - }))); + action = Some(action_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid action"); + })?); } else { - state = Some(try!(state_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid state"); - }))); + state = Some(state_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid state"); + })?); } } } @@ -214,7 +202,7 @@ impl Transition { _ => { cx.span_err(expr.span, "expected Action and/or State"); Err(()) - } + }, } }, ExprKind::Path(_, ref path) => { @@ -222,16 +210,14 @@ impl Transition { let path_str = path.to_string(); if path_str.starts_with('A') { - let action = try!(action_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid action"); - })); + let action = action_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid action"); + })?; Ok(Transition::Action(action)) } else { - let state = try!(state_from_str(&path_str) - .map_err(|_| { - cx.span_err(expr.span, "invalid state"); - })); + let state = state_from_str(&path_str).map_err(|_| { + cx.span_err(expr.span, "invalid state"); + })?; Ok(Transition::State(state)) } @@ -239,7 +225,7 @@ impl Transition { _ => { cx.span_err(expr.span, "expected Action and/or State"); Err(()) - } + }, } } } @@ -247,25 +233,23 @@ impl Transition { #[derive(Debug)] enum InputDefinition { Specific(u8), - Range { start: u8, end: u8 } + Range { start: u8, end: u8 }, } impl InputDefinition { fn from_pat(pat: &Pat, cx: &mut ExtCtxt) -> Result { Ok(match pat.node { PatKind::Lit(ref lit_expr) => { - InputDefinition::Specific(try!(u8_lit_from_expr(&lit_expr, cx))) + InputDefinition::Specific(u8_lit_from_expr(&lit_expr, cx)?) }, - PatKind::Range(ref start_expr, ref end_expr) => { - InputDefinition::Range { - start: try!(u8_lit_from_expr(start_expr, cx)), - end: try!(u8_lit_from_expr(end_expr, cx)), - } + PatKind::Range(ref start_expr, ref end_expr) => InputDefinition::Range { + start: u8_lit_from_expr(start_expr, cx)?, + end: u8_lit_from_expr(end_expr, cx)?, }, _ => { cx.span_err(pat.span, "expected literal or range expression"); - return Err(()) - } + return Err(()); + }, }) } } @@ -284,45 +268,39 @@ struct TableDefinition { fn parse_raw_definitions( definitions: Vec, - cx: &mut ExtCtxt + cx: &mut ExtCtxt, ) -> Result, ()> { let mut out = Vec::new(); for raw in definitions { let TableDefinitionExprs { state_expr, mapping_arms } = raw; - let state = try!(state_from_expr(state_expr, cx)); + let state = state_from_expr(state_expr, cx)?; let mut mappings = Vec::new(); for arm in mapping_arms { - mappings.push(try!(input_mapping_from_arm(arm, cx))); + mappings.push(input_mapping_from_arm(arm, cx)?); } - out.push(TableDefinition { - state: state, - mappings: mappings, - }) + out.push(TableDefinition { state, mappings }) } Ok(out) } fn parse_table_definition<'a>(parser: &mut Parser<'a>) -> PResult<'a, TableDefinitionExprs> { - let state_expr = try!(parser.parse_expr()); - try!(parser.expect(&Token::FatArrow)); - let mappings = try!(parse_table_input_mappings(parser)); + let state_expr = parser.parse_expr()?; + parser.expect(&Token::FatArrow)?; + let mappings = parse_table_input_mappings(parser)?; - Ok(TableDefinitionExprs { - state_expr: state_expr, - mapping_arms: mappings - }) + Ok(TableDefinitionExprs { state_expr, mapping_arms: mappings }) } -fn parse_table_definition_list<'a>(parser: &mut Parser<'a>) - -> PResult<'a, Vec> -{ +fn parse_table_definition_list<'a>( + parser: &mut Parser<'a>, +) -> PResult<'a, Vec> { let mut definitions = Vec::new(); while parser.token != Token::Eof { - definitions.push(try!(parse_table_definition(parser))); + definitions.push(parse_table_definition(parser)?); parser.eat(&Token::Comma); } @@ -330,7 +308,8 @@ fn parse_table_definition_list<'a>(parser: &mut Parser<'a>) } fn build_state_tables(defs: T) -> [[u8; 256]; 16] - where T: AsRef<[TableDefinition]> +where + T: AsRef<[TableDefinition]>, { let mut result = [[0u8; 256]; 16]; @@ -359,11 +338,10 @@ fn build_state_tables(defs: T) -> [[u8; 256]; 16] } fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 16]) -> P { - let table = table.iter() + let table = table + .iter() .map(|list| { - let exprs = list.iter() - .map(|num| cx.expr_u8(sp, *num)) - .collect(); + let exprs = list.iter().map(|num| cx.expr_u8(sp, *num)).collect(); cx.expr_vec(sp, exprs) }) .collect(); @@ -374,9 +352,8 @@ fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 16]) -> P( cx: &'cx mut ExtCtxt, sp: Span, - args: &[TokenTree]) - -> Box -{ + args: &[TokenTree], +) -> Box { macro_rules! ptry { ($pres:expr) => { match $pres { @@ -384,9 +361,9 @@ fn expand_state_table<'cx>( Err(mut err) => { err.emit(); return DummyResult::any(sp); - } + }, } - } + }; } // Parse the lookup spec @@ -405,7 +382,7 @@ fn expand_state_table<'cx>( #[cfg(test)] mod tests { - use definitions::{State, Action}; + use super::definitions::{Action, State}; use super::Transition; #[test] diff --git a/codegen/src/main.rs b/codegen/src/main.rs index 0d21577..7cc6cd0 100644 --- a/codegen/src/main.rs +++ b/codegen/src/main.rs @@ -1,11 +1,11 @@ #![allow(dead_code)] -extern crate syntex; -extern crate syntex_syntax; - -mod ext; use std::path::Path; +use syntex; + +mod ext; + fn main() { // Expand VT parser state table let mut registry = syntex::Registry::new(); -- cgit