diff --git a/src/parse.rs b/src/parse.rs
index 961c3be89c2cd64bddddc6c2fed7c66793ae8487..1b26b060513c9e9d23f05c738220e6fccf356cc2 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -2,11 +2,13 @@ use std::collections::{HashMap, HashSet};
use std::iter::Peekable;
use std::slice::Iter;
-use syn::{self, DelimToken, Ident, IntTy, Lit, Path, Token, BinOpToken, TokenTree, Ty};
+use syn::{self, DelimToken, Ident, IntTy, Lit, Path, Token, BinOpToken,
+ TokenTree, Ty};
use error::*;
-use {Cro, Ips, Ops, App, Idle, Init, Resources, Static, Statics, Task, Tasks, Expr};
+use {Cro, Ips, Ops, App, Idle, Init, Resources, Static, Statics, Task, Tasks,
+ Expr};
/// Parses the contents of `app! { $App }`
pub fn app(input: &str) -> Result<App> {
@@ -23,7 +25,8 @@ pub fn app(input: &str) -> Result<App> {
"device" => {
ensure!(device.is_none(), "duplicated `device` field");
- device = Some(::parse::path(tts).chain_err(|| "parsing `device`")?);
+ device =
+ Some(::parse::path(tts).chain_err(|| "parsing `device`")?);
}
"idle" => {
ensure!(idle.is_none(), "duplicated `idle` field");
@@ -38,12 +41,15 @@ pub fn app(input: &str) -> Result<App> {
"resources" => {
ensure!(resources.is_none(), "duplicated `resources` field");
- resources = Some(::parse::statics(tts).chain_err(|| "parsing `resources`")?);
+ resources = Some(::parse::statics(tts).chain_err(
+ || "parsing `resources`",
+ )?);
}
"tasks" => {
ensure!(tasks.is_none(), "duplicated `tasks` field");
- tasks = Some(::parse::tasks(tts).chain_err(|| "parsing `tasks`")?);
+ tasks =
+ Some(::parse::tasks(tts).chain_err(|| "parsing `tasks`")?);
}
_ => bail!("unknown field: `{}`", key),
}
@@ -71,7 +77,11 @@ fn bool(tt: Option<&TokenTree>) -> Result<bool> {
}
/// Parses a delimited token tree
-fn delimited<R, F>(tts: &mut Peekable<Iter<TokenTree>>, delimiter: DelimToken, f: F) -> Result<R>
+fn delimited<R, F>(
+ tts: &mut Peekable<Iter<TokenTree>>,
+ delimiter: DelimToken,
+ f: F,
+) -> Result<R>
where
F: FnOnce(&[TokenTree]) -> Result<R>,
{
@@ -137,9 +147,14 @@ fn idle(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Idle> {
path = Some(::parse::path(tts)?);
}
"resources" => {
- ensure!(resources.is_none(), "duplicated `resources` field");
+ ensure!(
+ resources.is_none(),
+ "duplicated `resources` field"
+ );
- resources = Some(::parse::resources(tts).chain_err(|| "parsing `resources`")?);
+ resources = Some(::parse::resources(tts).chain_err(
+ || "parsing `resources`",
+ )?);
}
_ => bail!("unknown field: `{}`", key),
}
@@ -188,7 +203,10 @@ fn resources(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Resources> {
let mut tts = tts.iter().peekable();
while let Some(tt) = tts.next() {
if let &TokenTree::Token(Token::Ident(ref ident)) = tt {
- ensure!(!idents.contains(ident), "ident {} listed more than once");
+ ensure!(
+ !idents.contains(ident),
+ "ident {} listed more than once"
+ );
idents.insert(ident.clone());
@@ -262,18 +280,20 @@ fn statics(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Statics> {
let mut tts = tts.iter();
while let Some(tt) = tts.next() {
match tt {
- &TokenTree::Token(Token::Ident(ref id)) if id.as_ref() == "static" => {}
+ &TokenTree::Token(Token::Ident(ref id))
+ if id.as_ref() == "static" => {}
_ => {
bail!("expected keyword `static`, found {:?}", tt);
}
}
let tt = tts.next();
- let ident = if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
- id
- } else {
- bail!("expected Ident, found {:?}", tt);
- };
+ let ident =
+ if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
+ id
+ } else {
+ bail!("expected Ident, found {:?}", tt);
+ };
ensure!(
!statics.contains_key(ident),
@@ -334,22 +354,33 @@ fn task(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Task> {
"enabled" => {
ensure!(enabled.is_none(), "duplicated `enabled` field");
- enabled = Some(::parse::bool(tts.next()).chain_err(|| "parsing `enabled`")?);
+ enabled = Some(::parse::bool(tts.next()).chain_err(
+ || "parsing `enabled`",
+ )?);
}
"path" => {
ensure!(path.is_none(), "duplicated `path` field");
- path = Some(::parse::path(tts).chain_err(|| "parsing `path`")?);
+ path = Some(
+ ::parse::path(tts).chain_err(|| "parsing `path`")?,
+ );
}
"priority" => {
ensure!(priority.is_none(), "duplicated `priority` field");
- priority = Some(::parse::u8(tts.next()).chain_err(|| "parsing `priority`")?);
+ priority = Some(::parse::u8(tts.next()).chain_err(
+ || "parsing `priority`",
+ )?);
}
"resources" => {
- ensure!(resources.is_none(), "duplicated `resources` field");
+ ensure!(
+ resources.is_none(),
+ "duplicated `resources` field"
+ );
- resources = Some(::parse::resources(tts).chain_err(|| "parsing `resources`")?);
+ resources = Some(::parse::resources(tts).chain_err(
+ || "parsing `resources`",
+ )?);
}
_ => bail!("unknown field: `{}`", key),
}
@@ -499,42 +530,56 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
let mut ty_arg = None;
let mut ty_ret = syn::parse_type(&"()")?;
let mut op_sync = None;
- let _ = ::parse::delimited(&mut tts, DelimToken::Brace, |tts| {
- fields(&tts, |key, mut tts| {
- match key.as_ref() {
- "sig" => {
- let tt = tts.next();
- if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
+ let _ =
+ ::parse::delimited(&mut tts, DelimToken::Brace, |tts| {
+ fields(&tts, |key, mut tts| {
+ match key.as_ref() {
+ "sig" => {
+ let tt = tts.next();
+ if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
ensure!(id.as_ref() == "fn", "expected `fn` Ident, found {:?}", tt);
} else {
bail!("expected `fn` Ident, found {:?}", tt);
}
- ty_arg = Some(::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
- Ok(syn::parse_type(&format!("({})", quote!(#(#tts)*)))?)
- })?);
-
- let tt = tts.peek().cloned();
- let ty_ret: Result<Ty> = match tt {
- Some(&TokenTree::Token(Token::Comma)) => Ok(
+ ty_arg = Some(::parse::delimited(
+ &mut tts,
+ DelimToken::Paren,
+ |tts| {
+ Ok(syn::parse_type(
+ &format!("({})", quote!(#(#tts)*)),
+ )?)
+ },
+ )?);
+
+ let tt = tts.peek().cloned();
+ ty_ret =
+ match tt {
+ Some(&TokenTree::Token(Token::Comma)) => Ok(
syn::parse_type(&"()")?,
),
- Some(&TokenTree::Token(Token::RArrow)) => {
+ Some(&TokenTree::Token(Token::RArrow)) => {
+ tts.next();
::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
}
- _ => bail!("expected `-> Type,' or `,` found {:?}", tt),
- };
+ _ => {
+ bail!(
+ "expected `-> Type,' or `,` found {:?}",
+ tt
+ )
+ }
+ }?;
- }
- "sync" => {
- op_sync = Some(::parse::resources(&mut tts)?);
- }
+ }
+ "sync" => {
+ op_sync = Some(::parse::resources(&mut tts)?);
+ }
- "async" => (),
- _ => bail!("unknown field: `{}`", key),
- };
- Ok(())
- })
- })?;
+ "async" => (),
+ _ => bail!("unknown field: `{}`", key),
+ };
+ Ok(())
+ })
+ })?;
let tt = tts.next();
match tt {
@@ -576,7 +621,11 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> {
let tt = tts.next();
if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
- ensure!(id.as_ref() == "fn", "expected `fn` Ident, found {:?}", tt);
+ ensure!(
+ id.as_ref() == "fn",
+ "expected `fn` Ident, found {:?}",
+ tt
+ );
} else {
bail!("expected `fn` Ident, found {:?}", tt);
}
@@ -596,7 +645,9 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> {
let tt = tts.peek().cloned();
let ty_ret: Result<Ty> = match tt {
- Some(&TokenTree::Token(Token::Comma)) => Ok(syn::parse_type(&"()")?),
+ Some(&TokenTree::Token(Token::Comma)) => Ok(syn::parse_type(
+ &"()",
+ )?),
Some(&TokenTree::Token(Token::RArrow)) => {
tts.next();
::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
@@ -639,7 +690,10 @@ fn ty(token: &TokenTree, tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ty> {
}
/// Parses `$Expr `
-fn expr(token: &TokenTree, tts: &mut Peekable<Iter<TokenTree>>) -> Result<::Expr> {
+fn expr(
+ token: &TokenTree,
+ tts: &mut Peekable<Iter<TokenTree>>,
+) -> Result<::Expr> {
let mut fragments = vec![];
loop {
if let Some(tt) = tts.next() {