Simplify private scheme
diff --git a/src/data.rs b/src/data.rs
index 36f82c6..1b1b928 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -73,7 +73,7 @@
/// [`Field`]: struct.Field.html
pub fn iter(&self) -> punctuated::Iter<Field> {
match *self {
- Fields::Unit => private::<punctuated::Iter<Field>>::empty(),
+ Fields::Unit => private::empty_punctuated_iter(),
Fields::Named(ref f) => f.named.iter(),
Fields::Unnamed(ref f) => f.unnamed.iter(),
}
@@ -86,7 +86,7 @@
/// [`Field`]: struct.Field.html
pub fn iter_mut(&mut self) -> punctuated::IterMut<Field> {
match *self {
- Fields::Unit => private::<punctuated::IterMut<Field>>::empty(),
+ Fields::Unit => private::empty_punctuated_iter_mut(),
Fields::Named(ref mut f) => f.named.iter_mut(),
Fields::Unnamed(ref mut f) => f.unnamed.iter_mut(),
}
diff --git a/src/expr.rs b/src/expr.rs
index b6aef5a..f1077fe 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1026,7 +1026,7 @@
#[cfg(feature = "full")]
use ext::IdentExt;
- use parse::{Parse, ParseBuffer, ParseStream, Result};
+ use parse::{Parse, ParseStream, Result};
use path;
// When we're parsing expressions which occur before blocks, like in an if
@@ -1814,7 +1814,7 @@
#[cfg(feature = "full")]
fn expr_group(input: ParseStream) -> Result<ExprGroup> {
- let group = private::<ParseBuffer>::parse_group(input)?;
+ let group = private::parse_group(input)?;
Ok(ExprGroup {
attrs: Vec::new(),
group_token: group.token,
diff --git a/src/group.rs b/src/group.rs
index 7acb318..7872d9a 100644
--- a/src/group.rs
+++ b/src/group.rs
@@ -29,9 +29,9 @@
fn parse_delimited(&self, delimiter: Delimiter) -> Result<(Span, ParseBuffer<'a>)> {
self.step(|cursor| {
if let Some((content, span, rest)) = cursor.group(delimiter) {
- let unexpected = private::<ParseBuffer>::get_unexpected(self);
+ let unexpected = private::get_unexpected(self);
let content =
- private::<ParseBuffer>::new(span, cursor.advance(content), unexpected);
+ private::new_parse_buffer(span, cursor.advance(content), unexpected);
Ok(((span, content), rest))
} else {
let message = match delimiter {
@@ -76,7 +76,7 @@
}
}
-impl<'a> private<ParseBuffer<'a>> {
+impl private {
pub fn parse_group(input: ParseStream) -> Result<Group> {
input.parse_delimited(Delimiter::None)
.map(|(span, content)| Group {
diff --git a/src/lib.rs b/src/lib.rs
index 2f208d8..1a4abbe 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -591,7 +591,7 @@
////////////////////////////////////////////////////////////////////////////////
#[allow(non_camel_case_types)]
-struct private<T>(T);
+struct private;
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/parse.rs b/src/parse.rs
index 30fbf66..02e2eae 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -238,8 +238,8 @@
}).unwrap()
}
-impl<'a> private<ParseBuffer<'a>> {
- pub fn new(scope: Span, cursor: Cursor, unexpected: Rc<Cell<Option<Span>>>) -> ParseBuffer {
+impl private {
+ pub fn new_parse_buffer(scope: Span, cursor: Cursor, unexpected: Rc<Cell<Option<Span>>>) -> ParseBuffer {
let extend = unsafe { mem::transmute::<Cursor, Cursor<'static>>(cursor) };
ParseBuffer {
scope: scope,
@@ -470,7 +470,7 @@
fn parse2(self, tokens: TokenStream) -> Result<T> {
let buf = TokenBuffer::new2(tokens);
let unexpected = Rc::new(Cell::new(None));
- let state = private::<ParseBuffer>::new(Span::call_site(), buf.begin(), unexpected);
+ let state = private::new_parse_buffer(Span::call_site(), buf.begin(), unexpected);
let node = self(&state)?;
state.check_unexpected()?;
if state.is_empty() {
diff --git a/src/punctuated.rs b/src/punctuated.rs
index 7bec24d..19fd6c6 100644
--- a/src/punctuated.rs
+++ b/src/punctuated.rs
@@ -466,8 +466,8 @@
}
#[cfg(any(feature = "full", feature = "derive"))]
-impl<'a, T> private<Iter<'a, T>> {
- pub fn empty() -> Iter<'a, T> {
+impl private {
+ pub fn empty_punctuated_iter<'a, T>() -> Iter<'a, T> {
Iter {
inner: Box::new(iter::empty()),
}
@@ -520,8 +520,8 @@
}
#[cfg(any(feature = "full", feature = "derive"))]
-impl<'a, T> private<IterMut<'a, T>> {
- pub fn empty() -> IterMut<'a, T> {
+impl private {
+ pub fn empty_punctuated_iter_mut<'a, T>() -> IterMut<'a, T> {
IterMut {
inner: Box::new(iter::empty()),
}
diff --git a/src/token.rs b/src/token.rs
index 4a14e05..8daa2fe 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -122,7 +122,7 @@
#[cfg(feature = "parsing")]
use lookahead;
#[cfg(feature = "parsing")]
-use parse::{Lookahead1, Parse, ParseBuffer, ParseStream};
+use parse::{Lookahead1, Parse, ParseStream};
use span::IntoSpans;
/// Marker trait for types that represent single tokens.
@@ -153,7 +153,7 @@
let scope = Span::call_site();
let cursor = lookahead.cursor();
let unexpected = Rc::new(Cell::new(None));
- ::private::<ParseBuffer>::new(scope, cursor, unexpected)
+ ::private::new_parse_buffer(scope, cursor, unexpected)
.parse::<Self>()
.is_ok()
}
diff --git a/src/ty.rs b/src/ty.rs
index 23e516a..2c0a10e 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -250,7 +250,7 @@
pub mod parsing {
use super::*;
- use parse::{Parse, ParseBuffer, ParseStream, Result};
+ use parse::{Parse, ParseStream, Result};
use path;
impl Parse for Type {
@@ -677,7 +677,7 @@
impl Parse for TypeGroup {
fn parse(input: ParseStream) -> Result<Self> {
- let group = private::<ParseBuffer>::parse_group(input)?;
+ let group = private::parse_group(input)?;
Ok(TypeGroup {
group_token: group.token,
elem: group.content.parse()?,