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.

1 files changed, 78 insertions, 101 deletions

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: &S) -> Result<State, ()>
-    where S: AsRef<str>
+where
+    S: AsRef<str>,
 {
     Ok(match s.as_ref() {
         "State::Anywhere" => State::Anywhere,
@@ -42,12 +43,13 @@ fn state_from_str<S>(s: &S) -> Result<State, ()>
         "State::OscString" => State::OscString,
         "State::SosPmApcString" => State::SosPmApcString,
         "State::Utf8" => State::Utf8,
-        _ => return Err(())
+        _ => return Err(()),
     })
 }
 
 fn action_from_str<S>(s: &S) -> Result<Action, ()>
-    where S: AsRef<str>
+where
+    S: AsRef<str>,
 {
     Ok(match s.as_ref() {
         "Action::None" => Action::None,
@@ -66,13 +68,13 @@ fn action_from_str<S>(s: &S) -> Result<Action, ()>
         "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<Arm>> {
     // Must start on open brace
-    try!(parser.expect(&Token::OpenDelim(DelimToken::Brace)));
+    parser.expect(&Token::OpenDelim(DelimToken::Brace))?;
 
     let mut arms: Vec<Arm> = 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<Ar
             Err(e) => {
                 // Recover by skipping to the end of the block.
                 return Err(e);
-            }
+            },
         }
     }
 
@@ -99,53 +101,43 @@ struct TableDefinitionExprs {
 
 fn state_from_expr(expr: P<Expr>, cx: &mut ExtCtxt) -> Result<State, ()> {
     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<u8, ()> {
-    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<InputMapping, ()> {
     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<InputDefinition, ()> {
         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<TableDefinitionExprs>,
-    cx: &mut ExtCtxt
+    cx: &mut ExtCtxt,
 ) -> Result<Vec<TableDefinition>, ()> {
     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<TableDefinitionExprs>>
-{
+fn parse_table_definition_list<'a>(
+    parser: &mut Parser<'a>,
+) -> PResult<'a, Vec<TableDefinitionExprs>> {
     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<T>(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<T>(defs: T) -> [[u8; 256]; 16]
 }
 
 fn build_table_ast(cx: &mut ExtCtxt, sp: Span, table: [[u8; 256]; 16]) -> P<ast::Expr> {
-    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<ast:
 fn expand_state_table<'cx>(
     cx: &'cx mut ExtCtxt,
     sp: Span,
-    args: &[TokenTree])
-    -> Box<MacResult + 'cx>
-{
+    args: &[TokenTree],
+) -> Box<dyn MacResult + 'cx> {
     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]