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

Don't throw away spans

Browse source
This commit is contained in:
Chris Wong 2017-07-16 22:11:10 +12:00
parent 6a593388ae
commit e61385645e
1 changed files with 22 additions and 22 deletions

44
maud_macros/src/parse.rs
View file

@ -30,12 +30,12 @@ struct Parser {
} }
impl Parser { impl Parser {
fn next(&mut self) -> Option<TokenNode> { fn next(&mut self) -> Option<TokenTree> {
self.input.next().map(|tt| tt.kind) self.input.next()
} }
fn peek(&mut self) -> Option<TokenNode> { fn peek(&mut self) -> Option<TokenTree> {
self.input.peek().map(|tt| tt.kind) self.input.peek()
} }
fn advance(&mut self) { fn advance(&mut self) {
@ -52,7 +52,7 @@ impl Parser {
loop { loop {
match self.peek() { match self.peek() {
None => return Ok(()), None => return Ok(()),
Some(TokenNode::Op(';', _)) => self.advance(), Some(TokenTree { kind: TokenNode::Op(';', _), .. }) => self.advance(),
_ => self.markup(render)?, _ => self.markup(render)?,
} }
} }
@ -66,15 +66,15 @@ impl Parser {
}; };
match token { match token {
// Literal // Literal
TokenNode::Literal(lit) => { TokenTree { kind: TokenNode::Literal(lit), .. } => {
self.advance(); self.advance();
self.literal(lit, render)?; self.literal(lit, render)?;
}, },
// Special form // Special form
TokenNode::Op('@', _) => { TokenTree { kind: TokenNode::Op('@', _), .. } => {
self.advance(); self.advance();
match self.next() { match self.next() {
Some(TokenNode::Term(term)) => match term.as_str() { Some(TokenTree { kind: TokenNode::Term(term), .. }) => match term.as_str() {
"if" => self.if_expr(render)?, "if" => self.if_expr(render)?,
"while" => self.while_expr(render)?, "while" => self.while_expr(render)?,
"for" => self.for_expr(render)?, "for" => self.for_expr(render)?,
@ -86,17 +86,17 @@ impl Parser {
} }
} }
// Element // Element
TokenNode::Term(_) => { TokenTree { kind: TokenNode::Term(_), .. } => {
let name = self.namespaced_name()?; let name = self.namespaced_name()?;
self.element(&name, render)?; self.element(&name, render)?;
}, },
// Splice // Splice
TokenNode::Group(Delimiter::Parenthesis, expr) => { TokenTree { kind: TokenNode::Group(Delimiter::Parenthesis, expr), .. } => {
self.advance(); self.advance();
render.splice(expr); render.splice(expr);
} }
// Block // Block
TokenNode::Group(Delimiter::Brace, block) => { TokenTree { kind: TokenNode::Group(Delimiter::Brace, block), .. } => {
self.advance(); self.advance();
Parser { Parser {
in_attr: self.in_attr, in_attr: self.in_attr,
@ -173,7 +173,7 @@ impl Parser {
self.attrs(render)?; self.attrs(render)?;
render.element_open_end(); render.element_open_end();
match self.peek() { match self.peek() {
Some(TokenNode::Op('/', _)) => { Some(TokenTree { kind: TokenNode::Op('/', _), .. }) => {
// Void element // Void element
self.advance(); self.advance();
}, },
@ -196,7 +196,7 @@ impl Parser {
let token_after = self.next(); let token_after = self.next();
match (maybe_name, token_after) { match (maybe_name, token_after) {
// Non-empty attribute // Non-empty attribute
(Ok(name), Some(TokenNode::Op('=', _))) => { (Ok(name), Some(TokenTree { kind: TokenNode::Op('=', _), .. })) => {
render.attribute_start(&name); render.attribute_start(&name);
{ {
// Parse a value under an attribute context // Parse a value under an attribute context
@ -207,9 +207,9 @@ impl Parser {
render.attribute_end(); render.attribute_end();
}, },
// Empty attribute // Empty attribute
(Ok(name), Some(TokenNode::Op('?', _))) => match self.peek() { (Ok(name), Some(TokenTree { kind: TokenNode::Op('?', _), .. })) => match self.peek() {
// Toggle the attribute based on a boolean expression // Toggle the attribute based on a boolean expression
Some(TokenNode::Group(Delimiter::Bracket, cond)) => { Some(TokenTree { kind: TokenNode::Group(Delimiter::Bracket, cond), .. }) => {
self.advance(); self.advance();
let body = { let body = {
let mut render = render.fork(); let mut render = render.fork();
@ -222,11 +222,11 @@ impl Parser {
_ => render.attribute_empty(&name), _ => render.attribute_empty(&name),
}, },
// Class shorthand // Class shorthand
(Err(_), Some(TokenNode::Op('.', _))) => { (Err(_), Some(TokenTree { kind: TokenNode::Op('.', _), .. })) => {
let class_name = self.name()?; let class_name = self.name()?;
match self.peek() { match self.peek() {
// Toggle the class based on a boolean expression // Toggle the class based on a boolean expression
Some(TokenNode::Group(Delimiter::Bracket, cond)) => { Some(TokenTree { kind: TokenNode::Group(Delimiter::Bracket, cond), .. }) => {
self.advance(); self.advance();
classes_toggled.push((cond, class_name)); classes_toggled.push((cond, class_name));
}, },
@ -235,7 +235,7 @@ impl Parser {
} }
}, },
// ID shorthand // ID shorthand
(Err(_), Some(TokenNode::Op('#', _))) => { (Err(_), Some(TokenTree { kind: TokenNode::Op('#', _), .. })) => {
ids.push(self.name()?); ids.push(self.name()?);
}, },
// If it's not a valid attribute, backtrack and bail out // If it's not a valid attribute, backtrack and bail out
@ -273,7 +273,7 @@ impl Parser {
/// Parses an identifier, without dealing with namespaces. /// Parses an identifier, without dealing with namespaces.
fn name(&mut self) -> ParseResult<String> { fn name(&mut self) -> ParseResult<String> {
let mut s = if let Some(TokenNode::Term(term)) = self.peek() { let mut s = if let Some(TokenTree { kind: TokenNode::Term(term), .. }) = self.peek() {
self.advance(); self.advance();
String::from(term.as_str()) String::from(term.as_str())
} else { } else {
@ -282,12 +282,12 @@ 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(TokenNode::Op('-', _)) => { Some(TokenTree { kind: TokenNode::Op('-', _), .. }) => {
self.advance(); self.advance();
s.push('-'); s.push('-');
true true
}, },
Some(TokenNode::Term(term)) if expect_ident => { Some(TokenTree { kind: TokenNode::Term(term), .. }) if expect_ident => {
self.advance(); self.advance();
s.push_str(term.as_str()); s.push_str(term.as_str());
false false
@ -302,7 +302,7 @@ impl Parser {
/// if necessary. /// if necessary.
fn namespaced_name(&mut self) -> ParseResult<String> { fn namespaced_name(&mut self) -> ParseResult<String> {
let mut s = self.name()?; let mut s = self.name()?;
if let Some(TokenNode::Op(':', _)) = self.peek() { if let Some(TokenTree { kind: TokenNode::Op(':', _), .. }) = self.peek() {
self.advance(); self.advance();
s.push(':'); s.push(':');
s.push_str(&self.name()?); s.push_str(&self.name()?);