Auto merge of #353 - Eijebong:synup, r=dtolnay+SimonSapin

Update syn and bump version

Author: bors-servo

html5ever/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "html5ever"
-version = "0.22.4"
+version = "0.22.5"
 authors = [ "The html5ever Project Developers" ]
 license = "MIT / Apache-2.0"
 repository = "https://github.com/servo/html5ever"
@@ -42,5 +42,5 @@ typed-arena = "1.3.0"
 
 [build-dependencies]
 quote = "0.6"
-syn = { version = "0.14", features = ["extra-traits", "full", "fold"] }
+syn = { version = "0.15", features = ["extra-traits", "full", "fold"] }
 proc-macro2 = "0.4"

html5ever/macros/match_token.rs

@@ -106,6 +106,8 @@ use std::io::{Read, Write};
 use std::path::Path;
 use syn;
 use syn::fold::Fold;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::ext::IdentExt;
 use proc_macro2::TokenStream;
 
 pub fn expand(from: &Path, to: &Path) {
@@ -121,7 +123,7 @@ pub fn expand(from: &Path, to: &Path) {
 struct MatchTokenParser {}
 
 struct MatchToken {
-    expr: syn::Expr,
+    ident: syn::Ident,
     arms: Vec<MatchTokenArm>,
 }
 
@@ -154,82 +156,89 @@ pub struct Tag {
     name: Option<syn::Ident>,
 }
 
-impl syn::synom::Synom for Tag {
-    named!(parse -> Self, do_parse!(
-        punct!(<) >>
-        closing: option!(punct!(/)) >>
-        name: alt!(
-            syn!(syn::Ident) => { |i| Some(i) }
-            |
-            punct!(_) => { |_| None }
-        ) >>
-        punct!(>) >>
-        (
-            Tag {
-                kind: if closing.is_some() { TagKind::EndTag } else { TagKind::StartTag },
-                name: name
-            }
-        )
-    ));
+impl Parse for Tag {
+    fn parse(input: ParseStream) -> Result<Self> {
+        input.parse::<Token![<]>()?;
+        let closing: Option<Token![/]> = input.parse()?;
+        let name = match input.call(syn::Ident::parse_any)? {
+            ref wildcard if wildcard == "_" => None,
+            other => Some(other),
+        };
+        input.parse::<Token![>]>()?;
+        Ok(Tag {
+            kind: if closing.is_some() { TagKind::EndTag } else { TagKind::StartTag },
+            name: name
+        })
+    }
 }
 
-impl syn::synom::Synom for LHS {
-    named!(parse -> Self, do_parse!(
-        pats: alt!(
-            syn!(syn::Pat) => { |p| LHS::Pattern(p) }
-            |
-            many0!(syn!(Tag)) => { |t| LHS::Tags(t) }
-        ) >>
-        (
-            pats
-        )
-    ));
+impl Parse for LHS {
+    fn parse(input: ParseStream) -> Result<Self> {
+        if input.peek(Token![<]) {
+            let mut tags = Vec::new();
+            while !input.peek(Token![=>]) {
+                tags.push(input.parse()?);
+            }
+            Ok(LHS::Tags(tags))
+        } else {
+            let p: syn::Pat = input.parse()?;
+            Ok(LHS::Pattern(p))
+        }
+    }
 }
 
-impl syn::synom::Synom for MatchTokenArm {
-    named!(parse -> Self, do_parse!(
-        binding: option!(
-            do_parse!(
-                name: syn!(syn::Ident) >>
-                punct!(@) >>
-                (
-                    name
-                )
-            )
-        ) >>
-        lhs: syn!(LHS) >>
-        punct!(=>) >>
-        rhs: do_parse!(
-                expr: alt!(
-                    expr_nosemi => { |e| RHS::Expression(e) }
-                    |
-                    syn!(syn::Expr) => { |e| RHS::Expression(e) }
-                    |
-                    keyword!(else) => { |_| RHS::Else }
-                ) >>
-                option!(punct!(,)) >>
-                (expr)
-        ) >>
-        (
-            MatchTokenArm {
-               binding,
-               lhs,
-               rhs,
-            }
-        )
-    ));
+impl Parse for MatchTokenArm {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let binding = if input.peek2(Token![@]) {
+            let binding = input.parse::<syn::Ident>()?;
+            input.parse::<Token![@]>()?;
+            Some(binding)
+        } else {
+            None
+        };
+        let lhs = input.parse::<LHS>()?;
+        input.parse::<Token![=>]>()?;
+        let rhs = if input.peek(syn::token::Brace) {
+            let block = input.parse::<syn::Block>().unwrap();
+            let block = syn::ExprBlock {
+                attrs: vec![],
+                label: None,
+                block,
+            };
+            input.parse::<Option<Token![,]>>()?;
+            RHS::Expression(syn::Expr::Block(block))
+        } else if input.peek(Token![else]) {
+            input.parse::<Token![else]>()?;
+            input.parse::<Token![,]>()?;
+            RHS::Else
+        } else {
+            let expr = input.parse::<syn::Expr>().unwrap();
+            input.parse::<Option<Token![,]>>()?;
+            RHS::Expression(expr)
+        };
+
+        Ok(MatchTokenArm {
+           binding,
+           lhs,
+           rhs,
+        })
+    }
 }
 
-impl syn::synom::Synom for MatchToken {
-    named!(parse -> Self, do_parse!(
-        expr: syn!(syn::Expr) >>
-        arms: braces!(many0!(MatchTokenArm::parse)) >> (
-            MatchToken {
-                expr,
-                arms: arms.1
-            }
-        )
-    ));
+impl Parse for MatchToken {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let ident = input.parse::<syn::Ident>()?;
+        let content;
+        braced!(content in input);
+        let mut arms = vec![];
+        while !content.is_empty() {
+            arms.push(content.parse()?);
+        }
+        Ok(MatchToken {
+            ident,
+            arms,
+        })
+    }
 }
 
 pub fn expand_match_token(body: &TokenStream) -> syn::Expr {
@@ -240,7 +249,7 @@ pub fn expand_match_token(body: &TokenStream) -> syn::Expr {
 
 fn expand_match_token_macro(match_token: MatchToken) -> TokenStream {
     let mut arms = match_token.arms;
-    let to_be_matched = match_token.expr;
+    let to_be_matched = match_token.ident;
     // Handle the last arm specially at the end.
     let last_arm = arms.pop().unwrap();
 
@@ -438,27 +447,3 @@ fn make_tag_pattern(binding: &TokenStream, tag: Tag) -> TokenStream {
     }
 }
 
-named!(expr_nosemi -> syn::Expr, map!(alt!(
-    syn!(syn::ExprIf) => { syn::Expr::If }
-    |
-    syn!(syn::ExprIfLet) => { syn::Expr::IfLet }
-    |
-    syn!(syn::ExprWhile) => { syn::Expr::While }
-    |
-    syn!(syn::ExprWhileLet) => { syn::Expr::WhileLet }
-    |
-    syn!(syn::ExprForLoop) => { syn::Expr::ForLoop }
-    |
-    syn!(syn::ExprLoop) => { syn::Expr::Loop }
-    |
-    syn!(syn::ExprMatch) => { syn::Expr::Match }
-    |
-    syn!(syn::ExprCatch) => { syn::Expr::Catch }
-    |
-    syn!(syn::ExprYield) => { syn::Expr::Yield }
-    |
-    syn!(syn::ExprUnsafe) => { syn::Expr::Unsafe }
-    |
-    syn!(syn::ExprBlock) => { syn::Expr::Block }
-), syn::Expr::from));
-