new_mark -> apply_mark, new_rename -> apply_rename

src/libsyntax/ext/expand.rs

@@ -852,7 +852,7 @@ impl<'a> Folder for IdentRenamer<'a> {
     fn fold_ident(&mut self, id: Ident) -> Ident {
         Ident {
             name: id.name,
-            ctxt: mtwt::new_renames(self.renames, id.ctxt),
+            ctxt: mtwt::apply_renames(self.renames, id.ctxt),
         }
     }
 }
@@ -870,7 +870,7 @@ fn fold_pat(&mut self, pat: Gc<ast::Pat>) -> Gc<ast::Pat> {
         match pat.node {
             ast::PatIdent(binding_mode, Spanned{span: ref sp, node: id}, ref sub) => {
                 let new_ident = Ident{name: id.name,
-                                      ctxt: mtwt::new_renames(self.renames, id.ctxt)};
+                                      ctxt: mtwt::apply_renames(self.renames, id.ctxt)};
                 let new_node =
                     ast::PatIdent(binding_mode,
                                   Spanned{span: self.new_span(*sp), node: new_ident},
@@ -990,7 +990,7 @@ impl Folder for Marker {
     fn fold_ident(&mut self, id: Ident) -> Ident {
         ast::Ident {
             name: id.name,
-            ctxt: mtwt::new_mark(self.mark, id.ctxt)
+            ctxt: mtwt::apply_mark(self.mark, id.ctxt)
         }
     }
     fn fold_mac(&mut self, m: &ast::Mac) -> ast::Mac {
@@ -998,7 +998,7 @@ fn fold_mac(&mut self, m: &ast::Mac) -> ast::Mac {
             MacInvocTT(ref path, ref tts, ctxt) => {
                 MacInvocTT(self.fold_path(path),
                            fold_tts(tts.as_slice(), self),
-                           mtwt::new_mark(self.mark, ctxt))
+                           mtwt::apply_mark(self.mark, ctxt))
             }
         };
         Spanned {

src/libsyntax/ext/mtwt.rs

@@ -58,12 +58,12 @@ pub enum SyntaxContext_ {
 pub type RenameList = Vec<(Ident, Name)>;
 
 /// Extend a syntax context with a given mark
-pub fn new_mark(m: Mrk, ctxt: SyntaxContext) -> SyntaxContext {
-    with_sctable(|table| new_mark_internal(m, ctxt, table))
+pub fn apply_mark(m: Mrk, ctxt: SyntaxContext) -> SyntaxContext {
+    with_sctable(|table| apply_mark_internal(m, ctxt, table))
 }
 
 // Extend a syntax context with a given mark and sctable (explicit memoization)
-fn new_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxContext {
+fn apply_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxContext {
     let key = (ctxt, m);
     let new_ctxt = |_: &(SyntaxContext, Mrk)|
                    idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt));
@@ -72,13 +72,13 @@ fn new_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxCont
 }
 
 /// Extend a syntax context with a given rename
-pub fn new_rename(id: Ident, to:Name,
+pub fn apply_rename(id: Ident, to:Name,
                   ctxt: SyntaxContext) -> SyntaxContext {
-    with_sctable(|table| new_rename_internal(id, to, ctxt, table))
+    with_sctable(|table| apply_rename_internal(id, to, ctxt, table))
 }
 
 // Extend a syntax context with a given rename and sctable (explicit memoization)
-fn new_rename_internal(id: Ident,
+fn apply_rename_internal(id: Ident,
                        to: Name,
                        ctxt: SyntaxContext,
                        table: &SCTable) -> SyntaxContext {
@@ -93,10 +93,10 @@ fn new_rename_internal(id: Ident,
 // if these rename lists get long, it would make sense
 // to consider memoizing this fold. This may come up
 // when we add hygiene to item names.
-pub fn new_renames(renames: &RenameList, ctxt: SyntaxContext) -> SyntaxContext {
+pub fn apply_renames(renames: &RenameList, ctxt: SyntaxContext) -> SyntaxContext {
     renames.iter().fold(ctxt, |ctxt, &(from, to)| {
-            new_rename(from, to, ctxt)
-        })
+        apply_rename(from, to, ctxt)
+    })
 }
 
 /// Fetch the SCTable from TLS, create one if it doesn't yet exist.
@@ -277,8 +277,8 @@ fn xor_push(marks: &mut Vec<Mrk>, mark: Mrk) {
 #[cfg(test)]
 mod tests {
     use ast::{EMPTY_CTXT, Ident, Mrk, Name, SyntaxContext};
-    use super::{resolve, xor_push, new_mark_internal, new_sctable_internal};
-    use super::{new_rename_internal, new_renames, marksof_internal, resolve_internal};
+    use super::{resolve, xor_push, apply_mark_internal, new_sctable_internal};
+    use super::{apply_rename_internal, apply_renames, marksof_internal, resolve_internal};
     use super::{SCTable, EmptyCtxt, Mark, Rename, IllegalCtxt};
     use std::collections::HashMap;
 
@@ -319,8 +319,8 @@ fn unfold_test_sc(tscs : Vec<TestSC> , tail: SyntaxContext, table: &SCTable)
         -> SyntaxContext {
         tscs.iter().rev().fold(tail, |tail : SyntaxContext, tsc : &TestSC|
                   {match *tsc {
-                      M(mrk) => new_mark_internal(mrk,tail,table),
-                      R(ident,name) => new_rename_internal(ident,name,tail,table)}})
+                      M(mrk) => apply_mark_internal(mrk,tail,table),
+                      R(ident,name) => apply_rename_internal(ident,name,tail,table)}})
     }
 
     // gather a SyntaxContext back into a vector of TestSCs
@@ -365,7 +365,7 @@ fn test_unfold_refold(){
     fn unfold_marks(mrks: Vec<Mrk> , tail: SyntaxContext, table: &SCTable)
                     -> SyntaxContext {
         mrks.iter().rev().fold(tail, |tail:SyntaxContext, mrk:&Mrk|
-                   {new_mark_internal(*mrk,tail,table)})
+                   {apply_mark_internal(*mrk,tail,table)})
     }
 
     #[test] fn unfold_marks_test() {
@@ -397,13 +397,13 @@ fn test_marksof () {
         // rename where stop doesn't match:
         { let chain = vec!(M(9),
                         R(id(name1,
-                             new_mark_internal (4, EMPTY_CTXT,&mut t)),
+                             apply_mark_internal (4, EMPTY_CTXT,&mut t)),
                           100101102),
                         M(14));
          let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t);
          assert_eq! (marksof_internal (ans, stopname, &t), vec!(9,14));}
         // rename where stop does match
-        { let name1sc = new_mark_internal(4, EMPTY_CTXT, &mut t);
+        { let name1sc = apply_mark_internal(4, EMPTY_CTXT, &mut t);
          let chain = vec!(M(9),
                        R(id(name1, name1sc),
                          stopname),
@@ -427,7 +427,7 @@ fn resolve_tests () {
         { let sc = unfold_test_sc(vec!(R(id(50,EMPTY_CTXT),51),M(12)),EMPTY_CTXT,&mut t);
          assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),a);}
         // - rename where names do match, but marks don't
-        { let sc1 = new_mark_internal(1,EMPTY_CTXT,&mut t);
+        { let sc1 = apply_mark_internal(1,EMPTY_CTXT,&mut t);
          let sc = unfold_test_sc(vec!(R(id(a,sc1),50),
                                    M(1),
                                    M(2)),
@@ -450,11 +450,11 @@ fn resolve_tests () {
                                   EMPTY_CTXT,&mut t);
          assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt), 51); }
         // the simplest double-rename:
-        { let a_to_a50 = new_rename_internal(id(a,EMPTY_CTXT),50,EMPTY_CTXT,&mut t);
-         let a50_to_a51 = new_rename_internal(id(a,a_to_a50),51,a_to_a50,&mut t);
+        { let a_to_a50 = apply_rename_internal(id(a,EMPTY_CTXT),50,EMPTY_CTXT,&mut t);
+         let a50_to_a51 = apply_rename_internal(id(a,a_to_a50),51,a_to_a50,&mut t);
          assert_eq!(resolve_internal(id(a,a50_to_a51),&mut t, &mut rt),51);
          // mark on the outside doesn't stop rename:
-         let sc = new_mark_internal(9,a50_to_a51,&mut t);
+         let sc = apply_mark_internal(9,a50_to_a51,&mut t);
          assert_eq!(resolve_internal(id(a,sc),&mut t, &mut rt),51);
          // but mark on the inside does:
          let a50_to_a51_b = unfold_test_sc(vec!(R(id(a,a_to_a50),51),
@@ -474,10 +474,10 @@ fn mtwt_resolve_test(){
     #[test]
     fn hashing_tests () {
         let mut t = new_sctable_internal();
-        assert_eq!(new_mark_internal(12,EMPTY_CTXT,&mut t),2);
-        assert_eq!(new_mark_internal(13,EMPTY_CTXT,&mut t),3);
+        assert_eq!(apply_mark_internal(12,EMPTY_CTXT,&mut t),2);
+        assert_eq!(apply_mark_internal(13,EMPTY_CTXT,&mut t),3);
         // using the same one again should result in the same index:
-        assert_eq!(new_mark_internal(12,EMPTY_CTXT,&mut t),2);
+        assert_eq!(apply_mark_internal(12,EMPTY_CTXT,&mut t),2);
         // I'm assuming that the rename table will behave the same....
     }
 
@@ -498,7 +498,7 @@ fn resolve_table_hashing_tests() {
     fn new_resolves_test() {
         let renames = vec!((Ident{name:23,ctxt:EMPTY_CTXT},24),
                            (Ident{name:29,ctxt:EMPTY_CTXT},29));
-        let new_ctxt1 = new_renames(&renames,EMPTY_CTXT);
+        let new_ctxt1 = apply_renames(&renames,EMPTY_CTXT);
         assert_eq!(resolve(Ident{name:23,ctxt:new_ctxt1}),24);
         assert_eq!(resolve(Ident{name:29,ctxt:new_ctxt1}),29);
     }

src/libsyntax/parse/token.rs

@@ -765,7 +765,7 @@ mod test {
     use ext::mtwt;
 
     fn mark_ident(id : ast::Ident, m : ast::Mrk) -> ast::Ident {
-        ast::Ident{name:id.name,ctxt:mtwt::new_mark(m,id.ctxt)}
+        ast::Ident{name:id.name,ctxt:mtwt::apply_mark(m,id.ctxt)}
     }
 
     #[test] fn mtwt_token_eq_test() {