Update names to be consistent with proc_macro
diff --git a/src/cursor.rs b/src/cursor.rs
index ce8934d..f4fe859 100644
--- a/src/cursor.rs
+++ b/src/cursor.rs
@@ -231,10 +231,10 @@
/// If the cursor is pointing at a Term, return it and a cursor pointing at
/// the next `TokenTree`.
- pub fn word(mut self) -> Option<(Cursor<'a>, Span, Term)> {
+ pub fn term(mut self) -> Option<(Cursor<'a>, Span, Term)> {
self.ignore_none();
match *self.entry() {
- Entry::Term(span, sym) => Some((unsafe { self.bump() }, span, sym)),
+ Entry::Term(span, term) => Some((unsafe { self.bump() }, span, term)),
_ => None,
}
}
@@ -244,7 +244,7 @@
pub fn op(mut self) -> Option<(Cursor<'a>, Span, char, Spacing)> {
self.ignore_none();
match *self.entry() {
- Entry::Op(span, chr, kind) => Some((unsafe { self.bump() }, span, chr, kind)),
+ Entry::Op(span, chr, spacing) => Some((unsafe { self.bump() }, span, chr, spacing)),
_ => None,
}
}
@@ -293,9 +293,9 @@
span: span,
kind: TokenNode::Term(sym),
},
- Entry::Op(span, chr, kind) => TokenTree {
+ Entry::Op(span, chr, spacing) => TokenTree {
span: span,
- kind: TokenNode::Op(chr, kind),
+ kind: TokenNode::Op(chr, spacing),
},
Entry::End(..) => {
return None;
diff --git a/src/ident.rs b/src/ident.rs
index f93fb43..f370e34 100644
--- a/src/ident.rs
+++ b/src/ident.rs
@@ -87,7 +87,7 @@
/// ```
#[derive(Copy, Clone, Debug)]
pub struct Ident {
- sym: Term,
+ term: Term,
pub span: Span,
}
@@ -132,7 +132,7 @@
}
Ident {
- sym: Term::intern(s),
+ term: Term::intern(s),
span: span,
}
}
@@ -182,13 +182,13 @@
impl AsRef<str> for Ident {
fn as_ref(&self) -> &str {
- self.sym.as_str()
+ self.term.as_str()
}
}
impl Display for Ident {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- self.sym.as_str().fmt(formatter)
+ self.term.as_str().fmt(formatter)
}
}
@@ -231,14 +231,14 @@
impl Synom for Ident {
fn parse(input: Cursor) -> PResult<Self> {
- let (rest, span, sym) = match input.word() {
- Some(word) => word,
+ let (rest, span, term) = match input.term() {
+ Some(term) => term,
_ => return parse_error(),
};
- if sym.as_str().starts_with('\'') {
+ if term.as_str().starts_with('\'') {
return parse_error();
}
- match sym.as_str() {
+ match term.as_str() {
// From https://doc.rust-lang.org/grammar.html#keywords
"abstract" | "alignof" | "as" | "become" | "box" | "break" | "const"
| "continue" | "crate" | "do" | "else" | "enum" | "extern" | "false" | "final"
@@ -254,7 +254,7 @@
rest,
Ident {
span: span,
- sym: sym,
+ term: term,
},
))
}
@@ -275,7 +275,7 @@
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append(TokenTree {
span: self.span,
- kind: TokenNode::Term(self.sym),
+ kind: TokenNode::Term(self.term),
})
}
}
diff --git a/src/lifetime.rs b/src/lifetime.rs
index dabe581..65f3f37 100644
--- a/src/lifetime.rs
+++ b/src/lifetime.rs
@@ -8,13 +8,13 @@
#[cfg_attr(feature = "extra-traits", derive(Debug))]
#[cfg_attr(feature = "clone-impls", derive(Clone))]
pub struct Lifetime {
- sym: Term,
+ term: Term,
pub span: Span,
}
impl Lifetime {
- pub fn new(sym: Term, span: Span) -> Self {
- let s = sym.as_str();
+ pub fn new(term: Term, span: Span) -> Self {
+ let s = term.as_str();
if !s.starts_with('\'') {
panic!(
@@ -51,7 +51,7 @@
}
Lifetime {
- sym: sym,
+ term: term,
span: span,
}
}
@@ -59,13 +59,13 @@
impl Display for Lifetime {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
- self.sym.as_str().fmt(formatter)
+ self.term.as_str().fmt(formatter)
}
}
impl PartialEq for Lifetime {
fn eq(&self, other: &Lifetime) -> bool {
- self.sym.as_str() == other.sym.as_str()
+ self.term.as_str() == other.term.as_str()
}
}
@@ -79,13 +79,13 @@
impl Ord for Lifetime {
fn cmp(&self, other: &Lifetime) -> Ordering {
- self.sym.as_str().cmp(other.sym.as_str())
+ self.term.as_str().cmp(other.term.as_str())
}
}
impl Hash for Lifetime {
fn hash<H: Hasher>(&self, h: &mut H) {
- self.sym.as_str().hash(h)
+ self.term.as_str().hash(h)
}
}
@@ -99,18 +99,18 @@
impl Synom for Lifetime {
fn parse(input: Cursor) -> PResult<Self> {
- let (rest, span, sym) = match input.word() {
- Some(word) => word,
+ let (rest, span, term) = match input.term() {
+ Some(term) => term,
_ => return parse_error(),
};
- if !sym.as_str().starts_with('\'') {
+ if !term.as_str().starts_with('\'') {
return parse_error();
}
Ok((
rest,
Lifetime {
- sym: sym,
+ term: term,
span: span,
},
))
@@ -132,7 +132,7 @@
fn to_tokens(&self, tokens: &mut Tokens) {
tokens.append(TokenTree {
span: self.span,
- kind: TokenNode::Term(self.sym),
+ kind: TokenNode::Term(self.term),
})
}
}
diff --git a/src/lit.rs b/src/lit.rs
index 83d9f9d..b7b1e3e 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -112,11 +112,11 @@
value: LitKind::Other(lit),
},
)),
- _ => match input.word() {
- Some((rest, span, sym)) => {
- let kind = if sym.as_str() == "true" {
+ _ => match input.term() {
+ Some((rest, span, term)) => {
+ let kind = if term.as_str() == "true" {
LitKind::Bool(true)
- } else if sym.as_str() == "false" {
+ } else if term.as_str() == "false" {
LitKind::Bool(false)
} else {
return parse_error();
diff --git a/src/token.rs b/src/token.rs
index d3e320a..a41b6e8 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -9,23 +9,23 @@
macro_rules! tokens {
(
- ops: {
- $($op:tt pub struct $op_name:ident/$len:tt #[$op_doc:meta])*
+ punct: {
+ $($punct:tt pub struct $punct_name:ident/$len:tt #[$punct_doc:meta])*
}
- delim: {
- $($delim:tt pub struct $delim_name:ident #[$delim_doc:meta])*
+ delimiter: {
+ $($delimiter:tt pub struct $delimiter_name:ident #[$delimiter_doc:meta])*
}
- syms: {
- $($sym:tt pub struct $sym_name:ident #[$sym_doc:meta])*
+ keyword: {
+ $($keyword:tt pub struct $keyword_name:ident #[$keyword_doc:meta])*
}
) => (
- $(op! { #[$op_doc] $op pub struct $op_name/$len })*
- $(delim! { #[$delim_doc] $delim pub struct $delim_name })*
- $(sym! { #[$sym_doc] $sym pub struct $sym_name })*
+ $(token_punct! { #[$punct_doc] $punct pub struct $punct_name/$len })*
+ $(token_delimiter! { #[$delimiter_doc] $delimiter pub struct $delimiter_name })*
+ $(token_keyword! { #[$keyword_doc] $keyword pub struct $keyword_name })*
)
}
-macro_rules! op {
+macro_rules! token_punct {
(#[$doc:meta] $s:tt pub struct $name:ident/$len:tt) => {
#[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
#[derive(Default)]
@@ -65,14 +65,14 @@
#[cfg(feature = "printing")]
impl ::quote::ToTokens for $name {
fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
- printing::op($s, &self.0, tokens);
+ printing::punct($s, &self.0, tokens);
}
}
#[cfg(feature = "parsing")]
impl ::Synom for $name {
fn parse(tokens: $crate::synom::Cursor) -> $crate::synom::PResult<$name> {
- parsing::op($s, tokens, $name)
+ parsing::punct($s, tokens, $name)
}
fn description() -> Option<&'static str> {
@@ -82,7 +82,7 @@
}
}
-macro_rules! sym {
+macro_rules! token_keyword {
(#[$doc:meta] $s:tt pub struct $name:ident) => {
#[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
#[derive(Default)]
@@ -116,20 +116,20 @@
#[cfg(feature = "printing")]
impl ::quote::ToTokens for $name {
fn to_tokens(&self, tokens: &mut ::quote::Tokens) {
- printing::sym($s, &self.0, tokens);
+ printing::keyword($s, &self.0, tokens);
}
}
#[cfg(feature = "parsing")]
impl ::Synom for $name {
fn parse(tokens: $crate::synom::Cursor) -> $crate::synom::PResult<$name> {
- parsing::sym($s, tokens, $name)
+ parsing::keyword($s, tokens, $name)
}
}
}
}
-macro_rules! delim {
+macro_rules! token_delimiter {
(#[$doc:meta] $s:tt pub struct $name:ident) => {
#[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
#[derive(Default)]
@@ -181,7 +181,7 @@
}
tokens! {
- ops: {
+ punct: {
"+" pub struct Add/1 /// `+`
"+=" pub struct AddEq/2 /// `+=`
"&" pub struct And/1 /// `&`
@@ -228,13 +228,13 @@
"-=" pub struct SubEq/2 /// `-=`
"_" pub struct Underscore/1 /// `_`
}
- delim: {
+ delimiter: {
"{" pub struct Brace /// `{...}`
"[" pub struct Bracket /// `[...]`
"(" pub struct Paren /// `(...)`
" " pub struct Group /// None-delimited group
}
- syms: {
+ keyword: {
"as" pub struct As /// `as`
"auto" pub struct Auto /// `auto`
"box" pub struct Box /// `box`
@@ -500,7 +500,7 @@
}
}
- pub fn op<'a, T, R>(s: &str, mut tokens: Cursor<'a>, new: fn(T) -> R) -> PResult<'a, R>
+ pub fn punct<'a, T, R>(s: &str, mut tokens: Cursor<'a>, new: fn(T) -> R) -> PResult<'a, R>
where
T: FromSpans,
{
@@ -526,9 +526,9 @@
Ok((tokens, new(T::from_spans(&spans))))
}
- pub fn sym<'a, T>(sym: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
- if let Some((rest, span, s)) = tokens.word() {
- if s.as_str() == sym {
+ pub fn keyword<'a, T>(keyword: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
+ if let Some((rest, span, term)) = tokens.term() {
+ if term.as_str() == keyword {
return Ok((rest, new(span)));
}
}
@@ -553,11 +553,11 @@
_ => panic!("unknown delimiter: {}", delim),
};
- if let Some(seqinfo) = tokens.group(delim) {
- match f(seqinfo.inside) {
+ if let Some(group) = tokens.group(delim) {
+ match f(group.inside) {
Ok((remaining, ret)) => {
if remaining.eof() {
- return Ok((seqinfo.outside, (new(seqinfo.span), ret)));
+ return Ok((group.outside, (new(group.span), ret)));
}
}
Err(err) => return Err(err),
@@ -572,7 +572,7 @@
use proc_macro2::{Spacing, Span, Term, TokenNode, TokenTree};
use quote::Tokens;
- pub fn op(s: &str, spans: &[Span], tokens: &mut Tokens) {
+ pub fn punct(s: &str, spans: &[Span], tokens: &mut Tokens) {
assert_eq!(s.len(), spans.len());
let mut chars = s.chars();
@@ -592,7 +592,7 @@
});
}
- pub fn sym(s: &str, span: &Span, tokens: &mut Tokens) {
+ pub fn keyword(s: &str, span: &Span, tokens: &mut Tokens) {
tokens.append(TokenTree {
span: *span,
kind: TokenNode::Term(Term::intern(s)),