Prepare more for new proc_macro API
* Move storage of `Span` information on `Literal` and `Term` into the
stable/unstable layers as the unstable one will soon encompass this
* Remove `PartialEq` for `Span` as it's being replaced by an `eq` method.
diff --git a/src/lib.rs b/src/lib.rs
index 7ec1a73..715fccf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -169,7 +169,6 @@
}
#[derive(Copy, Clone)]
-#[cfg_attr(procmacro2_semver_exempt, derive(PartialEq, Eq))]
pub struct Span {
inner: imp::Span,
_marker: marker::PhantomData<Rc<()>>,
@@ -239,6 +238,11 @@
pub fn join(&self, other: Span) -> Option<Span> {
self.inner.join(other.inner).map(Span::_new)
}
+
+ #[cfg(procmacro2_semver_exempt)]
+ pub fn eq(&self, other: &Span) -> bool {
+ self.inner.eq(&other.inner)
+ }
}
impl fmt::Debug for Span {
@@ -405,21 +409,19 @@
#[derive(Copy, Clone)]
pub struct Term {
inner: imp::Term,
- span: Span,
_marker: marker::PhantomData<Rc<()>>,
}
impl Term {
- fn _new(inner: imp::Term, span: Span) -> Term {
+ fn _new(inner: imp::Term) -> Term {
Term {
inner: inner,
- span: span,
_marker: marker::PhantomData,
}
}
pub fn new(string: &str, span: Span) -> Term {
- Term::_new(imp::Term::intern(string), span)
+ Term::_new(imp::Term::new(string, span.inner))
}
pub fn as_str(&self) -> &str {
@@ -427,11 +429,11 @@
}
pub fn span(&self) -> Span {
- self.span
+ Span::_new(self.inner.span())
}
pub fn set_span(&mut self, span: Span) {
- self.span = span;
+ self.inner.set_span(span.inner);
}
}
@@ -450,7 +452,6 @@
#[derive(Clone)]
pub struct Literal {
inner: imp::Literal,
- span: Span,
_marker: marker::PhantomData<Rc<()>>,
}
@@ -476,7 +477,6 @@
fn _new(inner: imp::Literal) -> Literal {
Literal {
inner: inner,
- span: Span::call_site(),
_marker: marker::PhantomData,
}
}
@@ -540,11 +540,11 @@
}
pub fn span(&self) -> Span {
- self.span
+ Span::_new(self.inner.span())
}
pub fn set_span(&mut self, span: Span) {
- self.span = span;
+ self.inner.set_span(span.inner);
}
}
diff --git a/src/stable.rs b/src/stable.rs
index b04e4ca..8741d51 100644
--- a/src/stable.rs
+++ b/src/stable.rs
@@ -8,7 +8,6 @@
use std::collections::HashMap;
use std::fmt;
use std::iter;
-use std::marker::PhantomData;
use std::rc::Rc;
use std::str::FromStr;
use std::vec;
@@ -105,13 +104,7 @@
Spacing::Joint => joint = true,
}
}
- TokenTree::Literal(ref tt) => {
- write!(f, "{}", tt)?;
- // handle comments
- if tt.inner.0.starts_with("/") {
- write!(f, "\n")?;
- }
- }
+ TokenTree::Literal(ref tt) => write!(f, "{}", tt)?,
}
}
@@ -404,16 +397,16 @@
#[derive(Copy, Clone)]
pub struct Term {
intern: usize,
- not_send_sync: PhantomData<*const ()>,
+ span: Span,
}
thread_local!(static SYMBOLS: RefCell<Interner> = RefCell::new(Interner::new()));
impl Term {
- pub fn intern(string: &str) -> Term {
+ pub fn new(string: &str, span: Span) -> Term {
Term {
intern: SYMBOLS.with(|s| s.borrow_mut().intern(string)),
- not_send_sync: PhantomData,
+ span,
}
}
@@ -424,6 +417,14 @@
unsafe { &*(s as *const str) }
})
}
+
+ pub fn span(&self) -> Span {
+ self.span
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
+ }
}
impl fmt::Debug for Term {
@@ -471,18 +472,28 @@
}
#[derive(Clone, Debug)]
-pub struct Literal(String);
+pub struct Literal {
+ text: String,
+ span: Span,
+}
impl Literal {
+ fn _new(text: String) -> Literal {
+ Literal {
+ text,
+ span: Span::call_site(),
+ }
+ }
+
pub fn byte_char(byte: u8) -> Literal {
match byte {
- 0 => Literal(format!("b'\\0'")),
- b'\"' => Literal(format!("b'\"'")),
+ 0 => Literal::_new(format!("b'\\0'")),
+ b'\"' => Literal::_new(format!("b'\"'")),
n => {
let mut escaped = "b'".to_string();
escaped.extend(ascii::escape_default(n).map(|c| c as char));
escaped.push('\'');
- Literal(escaped)
+ Literal::_new(escaped)
}
}
}
@@ -502,11 +513,7 @@
}
}
escaped.push('"');
- Literal(escaped)
- }
-
- pub fn doccomment(s: &str) -> Literal {
- Literal(s.to_string())
+ Literal::_new(escaped)
}
pub fn float(n: f64) -> Literal {
@@ -517,37 +524,25 @@
if !s.contains('.') {
s += ".0";
}
- Literal(s)
+ Literal::_new(s)
}
pub fn integer(s: i64) -> Literal {
- Literal(s.to_string())
+ Literal::_new(s.to_string())
}
- pub fn raw_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("r");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(ret)
+ pub fn span(&self) -> Span {
+ self.span
}
- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("br");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(ret)
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
}
}
impl fmt::Display for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.text.fmt(f)
}
}
@@ -555,7 +550,7 @@
($($t:ty,)*) => {$(
impl From<$t> for Literal {
fn from(t: $t) -> Literal {
- Literal(format!(concat!("{}", stringify!($t)), t))
+ Literal::_new(format!(concat!("{}", stringify!($t)), t))
}
}
)*}
@@ -572,7 +567,7 @@
fn from(t: $t) -> Literal {
assert!(!t.is_nan());
assert!(!t.is_infinite());
- Literal(format!(concat!("{}", stringify!($t)), t))
+ Literal::_new(format!(concat!("{}", stringify!($t)), t))
}
}
)*}
@@ -589,13 +584,13 @@
.collect::<String>();
s.push('"');
s.insert(0, '"');
- Literal(s)
+ Literal::_new(s)
}
}
impl From<char> for Literal {
fn from(t: char) -> Literal {
- Literal(format!("'{}'", t.escape_default().collect::<String>()))
+ Literal::_new(format!("'{}'", t.escape_default().collect::<String>()))
}
}
@@ -710,7 +705,7 @@
let end = start + len;
Ok((
a,
- ::Literal::_new(Literal(input.rest[start..end].to_string())),
+ ::Literal::_new(Literal::_new(input.rest[start..end].to_string())),
))
}
Err(LexError) => Err(LexError),
diff --git a/src/unstable.rs b/src/unstable.rs
index 49d1d2c..a178d18 100644
--- a/src/unstable.rs
+++ b/src/unstable.rs
@@ -60,7 +60,7 @@
Delimiter::Brace => proc_macro::Delimiter::Brace,
Delimiter::None => proc_macro::Delimiter::None,
};
- let span = tt.span();
+ let span = tt.span().inner;
let group = proc_macro::TokenNode::Group(delim, tt.stream.inner.0);
(span, group)
}
@@ -69,14 +69,14 @@
Spacing::Joint => proc_macro::Spacing::Joint,
Spacing::Alone => proc_macro::Spacing::Alone,
};
- (tt.span(), proc_macro::TokenNode::Op(tt.op(), kind))
+ (tt.span().inner, proc_macro::TokenNode::Op(tt.op(), kind))
}
- TokenTree::Term(tt) => (tt.span(), proc_macro::TokenNode::Term(tt.inner.0)),
- TokenTree::Literal(tt) => (tt.span(), proc_macro::TokenNode::Literal(tt.inner.0)),
+ TokenTree::Term(tt) => (tt.inner.span, proc_macro::TokenNode::Term(tt.inner.term)),
+ TokenTree::Literal(tt) => (tt.inner.span, proc_macro::TokenNode::Literal(tt.inner.lit)),
};
TokenStream(
proc_macro::TokenTree {
- span: span.inner.0,
+ span: span.0,
kind,
}.into(),
)
@@ -141,11 +141,17 @@
o.span = span;
o.into()
}
- proc_macro::TokenNode::Term(s) => ::Term::_new(Term(s), span).into(),
+ proc_macro::TokenNode::Term(s) => {
+ ::Term::_new(Term {
+ term: s,
+ span: span.inner,
+ }).into()
+ }
proc_macro::TokenNode::Literal(l) => {
- let mut l = ::Literal::_new(Literal(l));
- l.span = span;
- l.into()
+ ::Literal::_new(Literal {
+ lit: l,
+ span: span.inner,
+ }).into()
}
})
}
@@ -264,87 +270,95 @@
}
#[derive(Copy, Clone)]
-pub struct Term(proc_macro::Term);
+pub struct Term {
+ term: proc_macro::Term,
+ span: Span,
+}
impl Term {
- pub fn intern(string: &str) -> Term {
- Term(proc_macro::Term::intern(string))
+ pub fn new(string: &str, span: Span) -> Term {
+ Term {
+ term: proc_macro::Term::intern(string),
+ span,
+ }
}
pub fn as_str(&self) -> &str {
- self.0.as_str()
+ self.term.as_str()
+ }
+
+ pub fn span(&self) -> Span {
+ self.span
+ }
+
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
}
}
impl fmt::Debug for Term {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.term.fmt(f)
}
}
#[derive(Clone)]
-pub struct Literal(proc_macro::Literal);
+pub struct Literal {
+ lit: proc_macro::Literal,
+ span: Span,
+}
impl Literal {
+ fn _new(lit: proc_macro::Literal) -> Literal {
+ Literal {
+ lit,
+ span: Span::call_site(),
+ }
+ }
+
pub fn byte_char(byte: u8) -> Literal {
match byte {
- 0 => Literal(to_literal("b'\\0'")),
- b'\"' => Literal(to_literal("b'\"'")),
+ 0 => Literal::_new(to_literal("b'\\0'")),
+ b'\"' => Literal::_new(to_literal("b'\"'")),
n => {
let mut escaped = "b'".to_string();
escaped.extend(ascii::escape_default(n).map(|c| c as char));
escaped.push('\'');
- Literal(to_literal(&escaped))
+ Literal::_new(to_literal(&escaped))
}
}
}
pub fn byte_string(bytes: &[u8]) -> Literal {
- Literal(proc_macro::Literal::byte_string(bytes))
- }
-
- pub fn doccomment(s: &str) -> Literal {
- Literal(to_literal(s))
+ Literal::_new(proc_macro::Literal::byte_string(bytes))
}
pub fn float(s: f64) -> Literal {
- Literal(proc_macro::Literal::float(s))
+ Literal::_new(proc_macro::Literal::float(s))
}
pub fn integer(s: i64) -> Literal {
- Literal(proc_macro::Literal::integer(s.into()))
+ Literal::_new(proc_macro::Literal::integer(s.into()))
}
- pub fn raw_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("r");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(to_literal(&ret))
+ pub fn span(&self) -> Span {
+ self.span
}
- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
- let mut ret = format!("br");
- ret.extend((0..pounds).map(|_| "#"));
- ret.push('"');
- ret.push_str(s);
- ret.push('"');
- ret.extend((0..pounds).map(|_| "#"));
- Literal(to_literal(&ret))
+ pub fn set_span(&mut self, span: Span) {
+ self.span = span;
}
}
impl fmt::Display for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.lit.fmt(f)
}
}
impl fmt::Debug for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- self.0.fmt(f)
+ self.lit.fmt(f)
}
}
@@ -360,7 +374,7 @@
($($t:ident,)*) => {$(
impl From<$t> for Literal {
fn from(t: $t) -> Literal {
- Literal(proc_macro::Literal::$t(t))
+ Literal::_new(proc_macro::Literal::$t(t))
}
}
)*}
@@ -375,7 +389,7 @@
($($t:ident,)*) => {$(
impl From<$t> for Literal {
fn from(t: $t) -> Literal {
- Literal(proc_macro::Literal::$t(t))
+ Literal::_new(proc_macro::Literal::$t(t))
}
}
)*}
@@ -387,12 +401,12 @@
impl<'a> From<&'a str> for Literal {
fn from(t: &'a str) -> Literal {
- Literal(proc_macro::Literal::string(t))
+ Literal::_new(proc_macro::Literal::string(t))
}
}
impl From<char> for Literal {
fn from(t: char) -> Literal {
- Literal(proc_macro::Literal::character(t))
+ Literal::_new(proc_macro::Literal::character(t))
}
}