commit a4319b77d1bbf5e2fc7fda90b331adb956df32cb
author David Tolnay <dtolnay@gmail.com> Sat Jun 02 00:49:15 2018 -0700
committer David Tolnay <dtolnay@gmail.com> Sat Jun 02 00:49:15 2018 -0700
tree b58781bf3a5ff8e635893b19e0994f1b23deed3f
parent 357e0d271ed8bdc51dbf7a9bd9c4d4857c4a37cc

Eliminate the old "term" naming

src/attr.rs

diff --git a/src/attr.rs b/src/attr.rs
index 2d0f244..9e69494 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -169,7 +169,7 @@
                     lit: Lit::new(l.clone()),
                 }))
             }
-            TokenTree::Ident(ref term) => match &term.to_string()[..] {
+            TokenTree::Ident(ref v) => match &v.to_string()[..] {
                 v @ "true" | v @ "false" => Some(Meta::NameValue(MetaNameValue {
                     ident: ident,
                     eq_token: Token![=]([a.span()]),

src/buffer.rs

diff --git a/src/buffer.rs b/src/buffer.rs
index 3ca7f7f..420b034 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -373,7 +373,7 @@
     pub fn ident(mut self) -> Option<(Ident, Cursor<'a>)> {
         self.ignore_none();
         match *self.entry() {
-            Entry::Ident(ref term) => Some((term.clone(), unsafe { self.bump() })),
+            Entry::Ident(ref ident) => Some((ident.clone(), unsafe { self.bump() })),
             _ => None,
         }
     }
@@ -426,7 +426,7 @@
                 TokenTree::from(g)
             }
             Entry::Literal(ref lit) => lit.clone().into(),
-            Entry::Ident(ref term) => term.clone().into(),
+            Entry::Ident(ref ident) => ident.clone().into(),
             Entry::Punct(ref op) => op.clone().into(),
             Entry::End(..) => {
                 return None;

src/lit.rs

diff --git a/src/lit.rs b/src/lit.rs
index b4debdb..47555d4 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -430,16 +430,16 @@
                     }
                 }
                 _ => match input.ident() {
-                    Some((term, rest)) => Ok((
+                    Some((ident, rest)) => Ok((
                         Lit::Bool(LitBool {
-                            value: if term == "true" {
+                            value: if ident == "true" {
                                 true
-                            } else if term == "false" {
+                            } else if ident == "false" {
                                 false
                             } else {
                                 return parse_error();
                             },
-                            span: term.span(),
+                            span: ident.span(),
                         }),
                         rest,
                     )),

src/synom.rs

diff --git a/src/synom.rs b/src/synom.rs
index 55feb31..ac719ff 100644
--- a/src/synom.rs
+++ b/src/synom.rs
@@ -249,11 +249,11 @@
 
 impl Synom for Ident {
     fn parse(input: Cursor) -> PResult<Self> {
-        let (term, rest) = match input.ident() {
-            Some(term) => term,
+        let (ident, rest) = match input.ident() {
+            Some(ident) => ident,
             _ => return parse_error(),
         };
-        match &term.to_string()[..] {
+        match &ident.to_string()[..] {
 			"_"
 			// From https://doc.rust-lang.org/grammar.html#keywords
 			| "abstract" | "alignof" | "as" | "become" | "box" | "break" | "const"
@@ -266,7 +266,7 @@
 			_ => {}
 		}
 
-        Ok((term, rest))
+        Ok((ident, rest))
     }
 
     fn description() -> Option<&'static str> {

src/token.rs

diff --git a/src/token.rs b/src/token.rs
index 8141d31..18250b1 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -350,9 +350,9 @@
 impl ::Synom for Underscore {
     fn parse(input: ::buffer::Cursor) -> ::synom::PResult<Underscore> {
         match input.ident() {
-            Some((term, rest)) => {
-                if term == "_" {
-                    Ok((Underscore([term.span()]), rest))
+            Some((ident, rest)) => {
+                if ident == "_" {
+                    Ok((Underscore([ident.span()]), rest))
                 } else {
                     ::parse_error()
                 }
@@ -798,9 +798,9 @@
     }
 
     pub fn keyword<'a, T>(keyword: &str, tokens: Cursor<'a>, new: fn(Span) -> T) -> PResult<'a, T> {
-        if let Some((term, rest)) = tokens.ident() {
-            if term == keyword {
-                return Ok((new(term.span()), rest));
+        if let Some((ident, rest)) = tokens.ident() {
+            if ident == keyword {
+                return Ok((new(ident.span()), rest));
             }
         }
         parse_error()