From dde603757d00936c64aa9c4b96a5b0067999e6d8 Mon Sep 17 00:00:00 2001
From: Chris Wong <lambda.fairy@gmail.com>
Date: Sat, 22 Apr 2017 15:36:07 +1200
Subject: [PATCH] Rename `PResult` to `ParseResult`
---
maud_macros/src/lib.rs | 3 +--
maud_macros/src/parse.rs | 41 ++++++++++++++++++++--------------------
2 files changed, 21 insertions(+), 23 deletions(-)
diff --git a/maud_macros/src/lib.rs b/maud_macros/src/lib.rs
index f9b291b..dba1944 100644
--- a/maud_macros/src/lib.rs
+++ b/maud_macros/src/lib.rs
@@ -14,7 +14,6 @@ extern crate maud;
use rustc_plugin::Registry;
use syntax::codemap::Span;
-use syntax::errors::FatalError;
use syntax::ext::base::{DummyResult, ExtCtxt, MacEager, MacResult};
use syntax::print::pprust;
use syntax::tokenstream::TokenTree;
@@ -23,7 +22,7 @@ mod lints;
mod parse;
mod render;
-type PResult<T> = Result<T, FatalError>;
+type ParseResult<T> = Result<T, ()>;
fn expand_html<'cx>(cx: &'cx mut ExtCtxt, sp: Span, args: &[TokenTree]) -> Box<MacResult + 'cx> {
match parse::parse(cx, sp, args) {
diff --git a/maud_macros/src/parse.rs b/maud_macros/src/parse.rs
index c6e3e82..9406a97 100644
--- a/maud_macros/src/parse.rs
+++ b/maud_macros/src/parse.rs
@@ -1,7 +1,6 @@
use std::mem;
use syntax::ast::LitKind;
use syntax::codemap::Span;
-use syntax::errors::FatalError;
use syntax::ext::base::ExtCtxt;
use syntax::fold::Folder;
use syntax::parse;
@@ -11,12 +10,12 @@ use syntax::symbol::keywords;
use syntax::tokenstream::{Delimited, TokenStream, TokenTree};
use super::render::Renderer;
-use super::PResult;
+use super::ParseResult;
macro_rules! error {
($cx:expr, $sp:expr, $msg:expr) => ({
$cx.span_err($sp, $msg);
- return Err(::syntax::errors::FatalError);
+ return Err(());
})
}
@@ -63,7 +62,7 @@ macro_rules! keyword {
($sp:pat, $x:ident) => (TokenTree::Token($sp, ref $x @ Token::Ident(..)))
}
-pub fn parse(cx: &ExtCtxt, sp: Span, input: &[TokenTree]) -> PResult<Vec<TokenTree>> {
+pub fn parse(cx: &ExtCtxt, sp: Span, input: &[TokenTree]) -> ParseResult<Vec<TokenTree>> {
let input: Vec<TokenTree> = FlattenNtFolder.fold_tts(input.iter().cloned().collect())
.into_trees().collect();
let mut render = Renderer::new(cx);
@@ -109,7 +108,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses and renders multiple blocks of markup.
- fn markups(&mut self, render: &mut Renderer) -> PResult<()> {
+ fn markups(&mut self, render: &mut Renderer) -> ParseResult<()> {
loop {
match *self.input {
[] => return Ok(()),
@@ -120,7 +119,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses and renders a single block of markup.
- fn markup(&mut self, render: &mut Renderer) -> PResult<()> {
+ fn markup(&mut self, render: &mut Renderer) -> ParseResult<()> {
match *self.input {
// Literal
[ref tt @ literal!(), ..] => {
@@ -185,9 +184,9 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses and renders a literal string.
- fn literal(&mut self, tt: &TokenTree, render: &mut Renderer) -> PResult<()> {
+ fn literal(&mut self, tt: &TokenTree, render: &mut Renderer) -> ParseResult<()> {
let mut rust_parser = parse::stream_to_parser(self.cx.parse_sess, tt.clone().into());
- let lit = rust_parser.parse_lit().map_err(|mut e| { e.emit(); FatalError })?;
+ let lit = rust_parser.parse_lit().map_err(|mut e| e.emit())?;
if let LitKind::Str(s, _) = lit.node {
render.string(&s.as_str());
Ok(())
@@ -199,7 +198,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders an `@if` expression.
///
/// The leading `@if` should already be consumed.
- fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> PResult<()> {
+ fn if_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial if
let mut if_cond = vec![];
let if_body;
@@ -242,7 +241,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders an `@while` expression.
///
/// The leading `@while` should already be consumed.
- fn while_expr(&mut self, sp: Span, render: &mut Renderer) -> PResult<()> {
+ fn while_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut cond = vec![];
let body;
loop { match *self.input {
@@ -264,7 +263,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders a `@for` expression.
///
/// The leading `@for` should already be consumed.
- fn for_expr(&mut self, sp: Span, render: &mut Renderer) -> PResult<()> {
+ fn for_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![];
loop { match *self.input {
[keyword!(_, k), ..] if k.is_keyword(keywords::In) => {
@@ -298,7 +297,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders a `@match` expression.
///
/// The leading `@match` should already be consumed.
- fn match_expr(&mut self, sp: Span, render: &mut Renderer) -> PResult<()> {
+ fn match_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
// Parse the initial match
let mut match_var = vec![];
let match_bodies;
@@ -323,7 +322,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
Ok(())
}
- fn match_bodies(&mut self, render: &mut Renderer) -> PResult<Vec<TokenTree>> {
+ fn match_bodies(&mut self, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
let mut bodies = Vec::new();
loop { match *self.input {
[] => break,
@@ -336,7 +335,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
Ok(bodies)
}
- fn match_body(&mut self, sp: Span, render: &mut Renderer) -> PResult<Vec<TokenTree>> {
+ fn match_body(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<Vec<TokenTree>> {
let mut body = vec![];
loop { match *self.input {
[ref tt @ fat_arrow!(), ..] => {
@@ -385,7 +384,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders a `@let` expression.
///
/// The leading `@let` should already be consumed.
- fn let_expr(&mut self, sp: Span, render: &mut Renderer) -> PResult<()> {
+ fn let_expr(&mut self, sp: Span, render: &mut Renderer) -> ParseResult<()> {
let mut pattern = vec![];
loop { match *self.input {
[eq!(), ..] => {
@@ -419,7 +418,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses and renders an element node.
///
/// The element name should already be consumed.
- fn element(&mut self, sp: Span, name: &str, render: &mut Renderer) -> PResult<()> {
+ fn element(&mut self, sp: Span, name: &str, render: &mut Renderer) -> ParseResult<()> {
if self.in_attr {
error!(self.cx, sp, "unexpected element, you silly bumpkin");
}
@@ -436,7 +435,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses and renders the attributes of an element.
- fn attrs(&mut self, render: &mut Renderer) -> PResult<()> {
+ fn attrs(&mut self, render: &mut Renderer) -> ParseResult<()> {
let mut classes_static = Vec::new();
let mut classes_toggled = Vec::new();
let mut ids = Vec::new();
@@ -531,13 +530,13 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses an identifier, without dealing with namespaces.
- fn name(&mut self) -> PResult<String> {
+ fn name(&mut self) -> ParseResult<String> {
let mut s = match *self.input {
[ident!(_, name), ..] => {
self.shift(1);
String::from(&name.name.as_str() as &str)
},
- _ => return Err(FatalError),
+ _ => return Err(()),
};
let mut expect_ident = false;
loop {
@@ -560,7 +559,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
/// Parses a HTML element or attribute name, along with a namespace
/// if necessary.
- fn namespaced_name(&mut self) -> PResult<String> {
+ fn namespaced_name(&mut self) -> ParseResult<String> {
let mut s = self.name()?;
if let [colon!(), ident!(_, _), ..] = *self.input {
self.shift(1);
@@ -571,7 +570,7 @@ impl<'cx, 'a, 'i> Parser<'cx, 'a, 'i> {
}
/// Parses the given token tree, returning a vector of statements.
- fn block(&mut self, sp: Span, tts: TokenStream, render: &mut Renderer) -> PResult<TokenStream> {
+ fn block(&mut self, sp: Span, tts: TokenStream, render: &mut Renderer) -> ParseResult<TokenStream> {
let mut render = render.fork();
let mut parse = Parser {
cx: self.cx,