Prepare more for new proc_macro API

alexcrichton · alexcrichton · commit b2c9462f2a96 · 2018-04-04T07:36:41.000-07:00
* 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
@@ -169,7 +169,6 @@ pub struct LineColumn {
 }
 
 #[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 @@ impl Span {
     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,33 +409,31 @@ impl fmt::Display for Op {
 #[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 {
         self.inner.as_str()
     }
 
     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 @@ impl fmt::Debug for Term {
 #[derive(Clone)]
 pub struct Literal {
     inner: imp::Literal,
-    span: Span,
     _marker: marker::PhantomData<Rc<()>>,
 }
 
@@ -476,7 +477,6 @@ impl Literal {
     fn _new(inner: imp::Literal) -> Literal {
         Literal {
             inner: inner,
-            span: Span::call_site(),
             _marker: marker::PhantomData,
         }
     }
@@ -540,11 +540,11 @@ impl Literal {
     }
 
     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
@@ -8,7 +8,6 @@ use std::cmp;
 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 @@ impl fmt::Display for TokenStream {
                         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 @@ impl Span {
 #[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 @@ impl Term {
             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 @@ impl Interner {
 }
 
 #[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 @@ impl Literal {
             }
         }
         escaped.push('"');
-        Literal(escaped)
-    }
-
-    pub fn doccomment(s: &str) -> Literal {
-        Literal(s.to_string())
+        Literal::_new(escaped)
     }
 
     pub fn float(n: f64) -> Literal {
@@ -517,45 +524,33 @@ impl Literal {
         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)
     }
 }
 
 macro_rules! ints {
     ($($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 @@ macro_rules! floats {
             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 @@ impl<'a> From<&'a str> for Literal {
             .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 @@ fn literal(input: Cursor) -> PResult<::Literal> {
             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

Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,6 @@ pub struct LineColumn {`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`#[derive(Copy, Clone)]`
`172`		`-#[cfg_attr(procmacro2_semver_exempt, derive(PartialEq, Eq))]`
`173`	`172`	`pub struct Span {`
`174`	`173`	`inner: imp::Span,`
`175`	`174`	`_marker: marker::PhantomData<Rc<()>>,`
`@@ -239,6 +238,11 @@ impl Span {`
`239`	`238`	`pub fn join(&self, other: Span) -> Option<Span> {`
`240`	`239`	`self.inner.join(other.inner).map(Span::_new)`
`241`	`240`	`}`
	`241`	`+`
	`242`	`+ #[cfg(procmacro2_semver_exempt)]`
	`243`	`+ pub fn eq(&self, other: &Span) -> bool {`
	`244`	`+ self.inner.eq(&other.inner)`
	`245`	`+ }`
`242`	`246`	`}`
`243`	`247`
`244`	`248`	`impl fmt::Debug for Span {`
`@@ -405,33 +409,31 @@ impl fmt::Display for Op {`
`405`	`409`	`#[derive(Copy, Clone)]`
`406`	`410`	`pub struct Term {`
`407`	`411`	`inner: imp::Term,`
`408`		`- span: Span,`
`409`	`412`	`_marker: marker::PhantomData<Rc<()>>,`
`410`	`413`	`}`
`411`	`414`
`412`	`415`	`impl Term {`
`413`		`- fn _new(inner: imp::Term, span: Span) -> Term {`
	`416`	`+ fn _new(inner: imp::Term) -> Term {`
`414`	`417`	`Term {`
`415`	`418`	`inner: inner,`
`416`		`- span: span,`
`417`	`419`	`_marker: marker::PhantomData,`
`418`	`420`	`}`
`419`	`421`	`}`
`420`	`422`
`421`	`423`	`pub fn new(string: &str, span: Span) -> Term {`
`422`		`- Term::_new(imp::Term::intern(string), span)`
	`424`	`+ Term::_new(imp::Term::new(string, span.inner))`
`423`	`425`	`}`
`424`	`426`
`425`	`427`	`pub fn as_str(&self) -> &str {`
`426`	`428`	`self.inner.as_str()`
`427`	`429`	`}`
`428`	`430`
`429`	`431`	`pub fn span(&self) -> Span {`
`430`		`- self.span`
	`432`	`+ Span::_new(self.inner.span())`
`431`	`433`	`}`
`432`	`434`
`433`	`435`	`pub fn set_span(&mut self, span: Span) {`
`434`		`- self.span = span;`
	`436`	`+ self.inner.set_span(span.inner);`
`435`	`437`	`}`
`436`	`438`	`}`
`437`	`439`
`@@ -450,7 +452,6 @@ impl fmt::Debug for Term {`
`450`	`452`	`#[derive(Clone)]`
`451`	`453`	`pub struct Literal {`
`452`	`454`	`inner: imp::Literal,`
`453`		`- span: Span,`
`454`	`455`	`_marker: marker::PhantomData<Rc<()>>,`
`455`	`456`	`}`
`456`	`457`
`@@ -476,7 +477,6 @@ impl Literal {`
`476`	`477`	`fn _new(inner: imp::Literal) -> Literal {`
`477`	`478`	`Literal {`
`478`	`479`	`inner: inner,`
`479`		`- span: Span::call_site(),`
`480`	`480`	`_marker: marker::PhantomData,`
`481`	`481`	`}`
`482`	`482`	`}`
`@@ -540,11 +540,11 @@ impl Literal {`
`540`	`540`	`}`
`541`	`541`
`542`	`542`	`pub fn span(&self) -> Span {`
`543`		`- self.span`
	`543`	`+ Span::_new(self.inner.span())`
`544`	`544`	`}`
`545`	`545`
`546`	`546`	`pub fn set_span(&mut self, span: Span) {`
`547`		`- self.span = span;`
	`547`	`+ self.inner.set_span(span.inner);`
`548`	`548`	`}`
`549`	`549`	`}`
`550`	`550`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@ use std::cmp;`
`8`	`8`	`use std::collections::HashMap;`
`9`	`9`	`use std::fmt;`
`10`	`10`	`use std::iter;`
`11`		`-use std::marker::PhantomData;`
`12`	`11`	`use std::rc::Rc;`
`13`	`12`	`use std::str::FromStr;`
`14`	`13`	`use std::vec;`
`@@ -105,13 +104,7 @@ impl fmt::Display for TokenStream {`
`105`	`104`	`Spacing::Joint => joint = true,`
`106`	`105`	`}`
`107`	`106`	`}`
`108`		`- TokenTree::Literal(ref tt) => {`
`109`		`- write!(f, "{}", tt)?;`
`110`		`- // handle comments`
`111`		`- if tt.inner.0.starts_with("/") {`
`112`		`- write!(f, "\n")?;`
`113`		`- }`
`114`		`- }`
	`107`	`+ TokenTree::Literal(ref tt) => write!(f, "{}", tt)?,`
`115`	`108`	`}`
`116`	`109`	`}`
`117`	`110`
`@@ -404,16 +397,16 @@ impl Span {`
`404`	`397`	`#[derive(Copy, Clone)]`
`405`	`398`	`pub struct Term {`
`406`	`399`	`intern: usize,`
`407`		`- not_send_sync: PhantomData<*const ()>,`
	`400`	`+ span: Span,`
`408`	`401`	`}`
`409`	`402`
`410`	`403`	`thread_local!(static SYMBOLS: RefCell<Interner> = RefCell::new(Interner::new()));`
`411`	`404`
`412`	`405`	`impl Term {`
`413`		`- pub fn intern(string: &str) -> Term {`
	`406`	`+ pub fn new(string: &str, span: Span) -> Term {`
`414`	`407`	`Term {`
`415`	`408`	`intern: SYMBOLS.with(\|s\| s.borrow_mut().intern(string)),`
`416`		`- not_send_sync: PhantomData,`
	`409`	`+ span,`
`417`	`410`	`}`
`418`	`411`	`}`
`419`	`412`
`@@ -424,6 +417,14 @@ impl Term {`
`424`	`417`	`unsafe { &(s as const str) }`
`425`	`418`	`})`
`426`	`419`	`}`
	`420`	`+`
	`421`	`+ pub fn span(&self) -> Span {`
	`422`	`+ self.span`
	`423`	`+ }`
	`424`	`+`
	`425`	`+ pub fn set_span(&mut self, span: Span) {`
	`426`	`+ self.span = span;`
	`427`	`+ }`
`427`	`428`	`}`
`428`	`429`
`429`	`430`	`impl fmt::Debug for Term {`
`@@ -471,18 +472,28 @@ impl Interner {`
`471`	`472`	`}`
`472`	`473`
`473`	`474`	`#[derive(Clone, Debug)]`
`474`		`-pub struct Literal(String);`
	`475`	`+pub struct Literal {`
	`476`	`+ text: String,`
	`477`	`+ span: Span,`
	`478`	`+}`
`475`	`479`
`476`	`480`	`impl Literal {`
	`481`	`+ fn _new(text: String) -> Literal {`
	`482`	`+ Literal {`
	`483`	`+ text,`
	`484`	`+ span: Span::call_site(),`
	`485`	`+ }`
	`486`	`+ }`
	`487`	`+`
`477`	`488`	`pub fn byte_char(byte: u8) -> Literal {`
`478`	`489`	`match byte {`
`479`		`- 0 => Literal(format!("b'\\0'")),`
`480`		`- b'\"' => Literal(format!("b'\"'")),`
	`490`	`+ 0 => Literal::_new(format!("b'\\0'")),`
	`491`	`+ b'\"' => Literal::_new(format!("b'\"'")),`
`481`	`492`	`n => {`
`482`	`493`	`let mut escaped = "b'".to_string();`
`483`	`494`	`escaped.extend(ascii::escape_default(n).map(\|c\| c as char));`
`484`	`495`	`escaped.push('\'');`
`485`		`- Literal(escaped)`
	`496`	`+ Literal::_new(escaped)`
`486`	`497`	`}`
`487`	`498`	`}`
`488`	`499`	`}`
`@@ -502,11 +513,7 @@ impl Literal {`
`502`	`513`	`}`
`503`	`514`	`}`
`504`	`515`	`escaped.push('"');`
`505`		`- Literal(escaped)`
`506`		`- }`
`507`		`-`
`508`		`- pub fn doccomment(s: &str) -> Literal {`
`509`		`- Literal(s.to_string())`
	`516`	`+ Literal::_new(escaped)`
`510`	`517`	`}`
`511`	`518`
`512`	`519`	`pub fn float(n: f64) -> Literal {`
`@@ -517,45 +524,33 @@ impl Literal {`
`517`	`524`	`if !s.contains('.') {`
`518`	`525`	`s += ".0";`
`519`	`526`	`}`
`520`		`- Literal(s)`
	`527`	`+ Literal::_new(s)`
`521`	`528`	`}`
`522`	`529`
`523`	`530`	`pub fn integer(s: i64) -> Literal {`
`524`		`- Literal(s.to_string())`
	`531`	`+ Literal::_new(s.to_string())`
`525`	`532`	`}`
`526`	`533`
`527`		`- pub fn raw_string(s: &str, pounds: usize) -> Literal {`
`528`		`- let mut ret = format!("r");`
`529`		`- ret.extend((0..pounds).map(\|_\| "#"));`
`530`		`- ret.push('"');`
`531`		`- ret.push_str(s);`
`532`		`- ret.push('"');`
`533`		`- ret.extend((0..pounds).map(\|_\| "#"));`
`534`		`- Literal(ret)`
	`534`	`+ pub fn span(&self) -> Span {`
	`535`	`+ self.span`
`535`	`536`	`}`
`536`	`537`
`537`		`- pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {`
`538`		`- let mut ret = format!("br");`
`539`		`- ret.extend((0..pounds).map(\|_\| "#"));`
`540`		`- ret.push('"');`
`541`		`- ret.push_str(s);`
`542`		`- ret.push('"');`
`543`		`- ret.extend((0..pounds).map(\|_\| "#"));`
`544`		`- Literal(ret)`
	`538`	`+ pub fn set_span(&mut self, span: Span) {`
	`539`	`+ self.span = span;`
`545`	`540`	`}`
`546`	`541`	`}`
`547`	`542`
`548`	`543`	`impl fmt::Display for Literal {`
`549`	`544`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`550`		`- self.0.fmt(f)`
	`545`	`+ self.text.fmt(f)`
`551`	`546`	`}`
`552`	`547`	`}`
`553`	`548`
`554`	`549`	`macro_rules! ints {`
`555`	`550`	`($($t:ty,)*) => {$(`
`556`	`551`	`impl From<$t> for Literal {`
`557`	`552`	`fn from(t: $t) -> Literal {`
`558`		`- Literal(format!(concat!("{}", stringify!($t)), t))`
	`553`	`+ Literal::_new(format!(concat!("{}", stringify!($t)), t))`
`559`	`554`	`}`
`560`	`555`	`}`
`561`	`556`	`)*}`
`@@ -572,7 +567,7 @@ macro_rules! floats {`
`572`	`567`	`fn from(t: $t) -> Literal {`
`573`	`568`	`assert!(!t.is_nan());`
`574`	`569`	`assert!(!t.is_infinite());`
`575`		`- Literal(format!(concat!("{}", stringify!($t)), t))`
	`570`	`+ Literal::_new(format!(concat!("{}", stringify!($t)), t))`
`576`	`571`	`}`
`577`	`572`	`}`
`578`	`573`	`)*}`
`@@ -589,13 +584,13 @@ impl<'a> From<&'a str> for Literal {`
`589`	`584`	`.collect::<String>();`
`590`	`585`	`s.push('"');`
`591`	`586`	`s.insert(0, '"');`
`592`		`- Literal(s)`
	`587`	`+ Literal::_new(s)`
`593`	`588`	`}`
`594`	`589`	`}`
`595`	`590`
`596`	`591`	`impl From<char> for Literal {`
`597`	`592`	`fn from(t: char) -> Literal {`
`598`		`- Literal(format!("'{}'", t.escape_default().collect::<String>()))`
	`593`	`+ Literal::_new(format!("'{}'", t.escape_default().collect::<String>()))`
`599`	`594`	`}`
`600`	`595`	`}`
`601`	`596`
`@@ -710,7 +705,7 @@ fn literal(input: Cursor) -> PResult<::Literal> {`
`710`	`705`	`let end = start + len;`
`711`	`706`	`Ok((`
`712`	`707`	`a,`
`713`		`- ::Literal::_new(Literal(input.rest[start..end].to_string())),`
	`708`	`+ ::Literal::_new(Literal::_new(input.rest[start..end].to_string())),`
`714`	`709`	`))`
`715`	`710`	`}`
`716`	`711`	`Err(LexError) => Err(LexError),`