bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

new_mark -> apply_mark, new_rename -> apply_rename

Browse source
This commit is contained in:
John Clements 2014-07-03 14:38:59 -07:00
parent b8cd7f7c6d
commit aa91ef0cf8
3 changed files with 29 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/libsyntax/ext/expand.rs
View file

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

48
src/libsyntax/ext/mtwt.rs
View file

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

2
src/libsyntax/parse/token.rs
View file

@ -765,7 +765,7 @@ mod test {
use ext::mtwt; use ext::mtwt;
fn mark_ident(id : ast::Ident, m : ast::Mrk) -> ast::Ident { 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() { #[test] fn mtwt_token_eq_test() {