badmanners/maud
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update to rustc 1.27.0-nightly (2f2a11dfc 2018-05-16)

Browse source
This commit is contained in:
Chris Wong 2018-05-17 20:55:29 +12:00
parent 9d90e94c87
commit 2455de589c
3 changed files with 45 additions and 44 deletions

4
maud_macros/src/generate.rs
View file

@ -5,7 +5,7 @@ use proc_macro::{
Literal, Literal,
quote, quote,
Span, Span,
Term, Ident,
TokenStream, TokenStream,
TokenTree, TokenTree,
}; };
@ -181,7 +181,7 @@ fn desugar_classes_or_ids(
markups.push(Markup::Special(Special { head, body })); markups.push(Markup::Special(Special { head, body }));
} }
Some(Attribute { Some(Attribute {
name: TokenStream::from(TokenTree::Term(Term::new(attr_name, Span::call_site()))), name: TokenStream::from(TokenTree::Ident(Ident::new(attr_name, Span::call_site()))),
attr_type: AttrType::Normal { attr_type: AttrType::Normal {
value: Markup::Block(Block { value: Markup::Block(Block {
markups, markups,

4
maud_macros/src/lib.rs
View file

@ -16,7 +16,7 @@ mod ast;
mod generate; mod generate;
mod parse; mod parse;
use proc_macro::{Literal, Span, Term, TokenStream, TokenTree}; use proc_macro::{Literal, Span, Ident, TokenStream, TokenTree};
use proc_macro::quote; use proc_macro::quote;
type ParseResult<T> = Result<T, String>; type ParseResult<T> = Result<T, String>;
@ -34,7 +34,7 @@ pub fn html_debug(input: TokenStream) -> TokenStream {
} }
fn expand(input: TokenStream) -> TokenStream { fn expand(input: TokenStream) -> TokenStream {
let output_ident = TokenTree::Term(Term::new("__maud_output", Span::def_site())); let output_ident = TokenTree::Ident(Ident::new("__maud_output", Span::def_site()));
// Heuristic: the size of the resulting markup tends to correlate with the // Heuristic: the size of the resulting markup tends to correlate with the
// code size of the template itself // code size of the template itself
let size_hint = input.to_string().len(); let size_hint = input.to_string().len();

81
maud_macros/src/parse.rs
View file

@ -85,13 +85,13 @@ impl Parser {
loop { loop {
match self.peek2() { match self.peek2() {
None => break, None => break,
Some((TokenTree::Op(op), _)) if op.op() == ';' => self.advance(), Some((TokenTree::Punct(ref punct), _)) if punct.as_char() == ';' => self.advance(),
Some(( Some((
TokenTree::Op(op), TokenTree::Punct(ref punct),
Some(TokenTree::Term(term)), Some(TokenTree::Ident(ref ident)),
)) if op.op() == '@' && term.as_str() == "let" => { )) if punct.as_char() == '@' && ident.to_string() == "let" => {
self.advance2(); self.advance2();
let keyword = TokenTree::Term(term); let keyword = TokenTree::Ident(ident.clone());
result.push(self.let_expr(keyword)?); result.push(self.let_expr(keyword)?);
}, },
_ => result.push(self.markup()?), _ => result.push(self.markup()?),
@ -113,12 +113,12 @@ impl Parser {
self.literal(&lit)? self.literal(&lit)?
}, },
// Special form // Special form
TokenTree::Op(op) if op.op() == '@' => { TokenTree::Punct(ref punct) if punct.as_char() == '@' => {
self.advance(); self.advance();
match self.next() { match self.next() {
Some(TokenTree::Term(term)) => { Some(TokenTree::Ident(ident)) => {
let keyword = TokenTree::Term(term); let keyword = TokenTree::Ident(ident.clone());
match term.as_str() { match ident.to_string().as_str() {
"if" => { "if" => {
let mut segments = Vec::new(); let mut segments = Vec::new();
self.if_expr(vec![keyword], &mut segments)?; self.if_expr(vec![keyword], &mut segments)?;
@ -135,7 +135,7 @@ impl Parser {
} }
}, },
// Element // Element
TokenTree::Term(_) => { TokenTree::Ident(_) => {
let name = self.namespaced_name()?; let name = self.namespaced_name()?;
self.element(name)? self.element(name)?
}, },
@ -195,16 +195,16 @@ impl Parser {
fn else_if_expr(&mut self, segments: &mut Vec<ast::Special>) -> ParseResult<()> { fn else_if_expr(&mut self, segments: &mut Vec<ast::Special>) -> ParseResult<()> {
match self.peek2() { match self.peek2() {
Some(( Some((
TokenTree::Op(op), TokenTree::Punct(ref punct),
Some(TokenTree::Term(else_keyword)), Some(TokenTree::Ident(ref else_keyword)),
)) if op.op() == '@' && else_keyword.as_str() == "else" => { )) if punct.as_char() == '@' && else_keyword.to_string() == "else" => {
self.advance2(); self.advance2();
let else_keyword = TokenTree::Term(else_keyword); let else_keyword = TokenTree::Ident(else_keyword.clone());
match self.peek() { match self.peek() {
// `@else if` // `@else if`
Some(TokenTree::Term(if_keyword)) if if_keyword.as_str() == "if" => { Some(TokenTree::Ident(ref if_keyword)) if if_keyword.to_string() == "if" => {
self.advance(); self.advance();
let if_keyword = TokenTree::Term(if_keyword); let if_keyword = TokenTree::Ident(if_keyword.clone());
self.if_expr(vec![else_keyword, if_keyword], segments) self.if_expr(vec![else_keyword, if_keyword], segments)
}, },
// Just an `@else` // Just an `@else`
@ -252,8 +252,8 @@ impl Parser {
let mut head = vec![keyword]; let mut head = vec![keyword];
loop { loop {
match self.next() { match self.next() {
Some(TokenTree::Term(in_keyword)) if in_keyword.as_str() == "in" => { Some(TokenTree::Ident(ref in_keyword)) if in_keyword.to_string() == "in" => {
head.push(TokenTree::Term(in_keyword)); head.push(TokenTree::Ident(in_keyword.clone()));
break; break;
}, },
Some(token) => head.push(token), Some(token) => head.push(token),
@ -302,11 +302,11 @@ impl Parser {
let mut head = Vec::new(); let mut head = Vec::new();
loop { loop {
match self.peek2() { match self.peek2() {
Some((TokenTree::Op(eq), Some(TokenTree::Op(gt)))) Some((TokenTree::Punct(ref eq), Some(TokenTree::Punct(ref gt))))
if eq.op() == '=' && gt.op() == '>' && eq.spacing() == Spacing::Joint => { if eq.as_char() == '=' && gt.as_char() == '>' && eq.spacing() == Spacing::Joint => {
self.advance2(); self.advance2();
head.push(TokenTree::Op(eq)); head.push(TokenTree::Punct(eq.clone()));
head.push(TokenTree::Op(gt)); head.push(TokenTree::Punct(gt.clone()));
break; break;
}, },
Some((token, _)) => { Some((token, _)) => {
@ -326,8 +326,8 @@ impl Parser {
Some(TokenTree::Group(ref body)) if body.delimiter() == Delimiter::Brace => { Some(TokenTree::Group(ref body)) if body.delimiter() == Delimiter::Brace => {
let body = self.block(body.stream(), body.span())?; let body = self.block(body.stream(), body.span())?;
// Trailing commas are optional if the match arm is a braced block // Trailing commas are optional if the match arm is a braced block
if let Some(TokenTree::Op(op)) = self.peek() { if let Some(TokenTree::Punct(ref punct)) = self.peek() {
if op.op() == ',' { if punct.as_char() == ',' {
self.advance(); self.advance();
} }
} }
@ -339,7 +339,7 @@ impl Parser {
let mut body = vec![first_token]; let mut body = vec![first_token];
loop { loop {
match self.next() { match self.next() {
Some(TokenTree::Op(o)) if o.op() == ',' => break, Some(TokenTree::Punct(ref punct)) if punct.as_char() == ',' => break,
Some(token) => { Some(token) => {
if let Some(bigger_span) = span.join(token.span()) { if let Some(bigger_span) = span.join(token.span()) {
span = bigger_span; span = bigger_span;
@ -365,7 +365,7 @@ impl Parser {
match self.next() { match self.next() {
Some(token) => { Some(token) => {
match token { match token {
TokenTree::Op(ref op) if op.op() == '=' => { TokenTree::Punct(ref punct) if punct.as_char() == '=' => {
tokens.push(token.clone()); tokens.push(token.clone());
break; break;
}, },
@ -379,7 +379,7 @@ impl Parser {
match self.next() { match self.next() {
Some(token) => { Some(token) => {
match token { match token {
TokenTree::Op(ref op) if op.op() == ';' => { TokenTree::Punct(ref punct) if punct.as_char() == ';' => {
tokens.push(token.clone()); tokens.push(token.clone());
break; break;
}, },
@ -401,7 +401,8 @@ impl Parser {
} }
let attrs = self.attrs()?; let attrs = self.attrs()?;
let body = match self.peek() { let body = match self.peek() {
Some(TokenTree::Op(o)) if o.op() == ';' || o.op() == '/' => { Some(TokenTree::Punct(ref punct))
if punct.as_char() == ';' || punct.as_char() == '/' => {
// Void element // Void element
self.advance(); self.advance();
None None
@ -423,7 +424,7 @@ impl Parser {
let token_after = attempt.next(); let token_after = attempt.next();
match (maybe_name, token_after) { match (maybe_name, token_after) {
// Non-empty attribute // Non-empty attribute
(Ok(ref name), Some(TokenTree::Op(ref op))) if op.op() == '=' => { (Ok(ref name), Some(TokenTree::Punct(ref punct))) if punct.as_char() == '=' => {
self.commit(attempt); self.commit(attempt);
let value; let value;
{ {
@ -438,7 +439,7 @@ impl Parser {
}); });
}, },
// Empty attribute // Empty attribute
(Ok(ref name), Some(TokenTree::Op(ref op))) if op.op() == '?' => { (Ok(ref name), Some(TokenTree::Punct(ref punct))) if punct.as_char() == '?' => {
self.commit(attempt); self.commit(attempt);
let toggler = self.attr_toggler(); let toggler = self.attr_toggler();
attrs.push(ast::Attribute { attrs.push(ast::Attribute {
@ -447,7 +448,7 @@ impl Parser {
}); });
}, },
// Class shorthand // Class shorthand
(Err(_), Some(TokenTree::Op(op))) if op.op() == '.' => { (Err(_), Some(TokenTree::Punct(ref punct))) if punct.as_char() == '.' => {
self.commit(attempt); self.commit(attempt);
let name = self.name()?; let name = self.name()?;
if let Some(toggler) = self.attr_toggler() { if let Some(toggler) = self.attr_toggler() {
@ -457,7 +458,7 @@ impl Parser {
} }
}, },
// ID shorthand // ID shorthand
(Err(_), Some(TokenTree::Op(op))) if op.op() == '#' => { (Err(_), Some(TokenTree::Punct(ref punct))) if punct.as_char() == '#' => {
self.commit(attempt); self.commit(attempt);
ids.push(self.name()?); ids.push(self.name()?);
}, },
@ -485,7 +486,7 @@ impl Parser {
/// Parses an identifier, without dealing with namespaces. /// Parses an identifier, without dealing with namespaces.
fn name(&mut self) -> ParseResult<TokenStream> { fn name(&mut self) -> ParseResult<TokenStream> {
let mut result = Vec::new(); let mut result = Vec::new();
if let Some(token @ TokenTree::Term(_)) = self.peek() { if let Some(token @ TokenTree::Ident(_)) = self.peek() {
self.advance(); self.advance();
result.push(token); result.push(token);
} else { } else {
@ -494,14 +495,14 @@ impl Parser {
let mut expect_ident = false; let mut expect_ident = false;
loop { loop {
expect_ident = match self.peek() { expect_ident = match self.peek() {
Some(TokenTree::Op(op)) if op.op() == '-' => { Some(TokenTree::Punct(ref punct)) if punct.as_char() == '-' => {
self.advance(); self.advance();
result.push(TokenTree::Op(op)); result.push(TokenTree::Punct(punct.clone()));
true true
}, },
Some(TokenTree::Term(term)) if expect_ident => { Some(TokenTree::Ident(ref ident)) if expect_ident => {
self.advance(); self.advance();
result.push(TokenTree::Term(term)); result.push(TokenTree::Ident(ident.clone()));
false false
}, },
_ => break, _ => break,
@ -514,10 +515,10 @@ impl Parser {
/// if necessary. /// if necessary.
fn namespaced_name(&mut self) -> ParseResult<TokenStream> { fn namespaced_name(&mut self) -> ParseResult<TokenStream> {
let mut result = vec![self.name()?]; let mut result = vec![self.name()?];
if let Some(TokenTree::Op(op)) = self.peek() { if let Some(TokenTree::Punct(ref punct)) = self.peek() {
if op.op() == ':' { if punct.as_char() == ':' {
self.advance(); self.advance();
result.push(TokenStream::from(TokenTree::Op(op))); result.push(TokenStream::from(TokenTree::Punct(punct.clone())));
result.push(self.name()?); result.push(self.name()?);
} }
} }