auto merge of #13053 : alexcrichton/rust/removing-ref-cell-get, r=huonw

This commit removes the `get()` method from `Ref` and `RefMut` in favor of the `*` operator, and removes all usage of the `deref()` function manually from rustc, favoring using `*` instead.

Some of the code is a little wacky, but that's due to either #13044 or #13042

5 files changed, 52 insertions, 81 deletions

diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 1106dc61db7..bdb16f176c0 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -628,7 +628,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             vec!(
                 self.expr_str(span, msg),
                 self.expr_str(span,
-                              token::intern_and_get_ident(loc.file.deref().name)),
+                              token::intern_and_get_ident(loc.file.name)),
                 self.expr_uint(span, loc.line)))
     }
 
diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs
index 597e3584385..4ae9d436972 100644
--- a/src/libsyntax/ext/mtwt.rs
+++ b/src/libsyntax/ext/mtwt.rs
@@ -63,11 +63,10 @@ pub fn new_mark(m: Mrk, tail: SyntaxContext) -> SyntaxContext {
 // Extend a syntax context with a given mark and table
 fn new_mark_internal(m: Mrk, tail: SyntaxContext, table: &SCTable) -> SyntaxContext {
     let key = (tail, m);
-    let mut mark_memo = table.mark_memo.borrow_mut();
     let new_ctxt = |_: &(SyntaxContext, Mrk)|
-                   idx_push(table.table.borrow_mut().get(), Mark(m, tail));
+                   idx_push(&mut *table.table.borrow_mut(), Mark(m, tail));
 
-    *mark_memo.get().find_or_insert_with(key, new_ctxt)
+    *table.mark_memo.borrow_mut().find_or_insert_with(key, new_ctxt)
 }
 
 /// Extend a syntax context with a given rename
@@ -82,11 +81,10 @@ fn new_rename_internal(id: Ident,
                        tail: SyntaxContext,
                        table: &SCTable) -> SyntaxContext {
     let key = (tail,id,to);
-    let mut rename_memo = table.rename_memo.borrow_mut();
     let new_ctxt = |_: &(SyntaxContext, Ident, Mrk)|
-                   idx_push(table.table.borrow_mut().get(), Rename(id, to, tail));
+                   idx_push(&mut *table.table.borrow_mut(), Rename(id, to, tail));
 
-    *rename_memo.get().find_or_insert_with(key, new_ctxt)
+    *table.rename_memo.borrow_mut().find_or_insert_with(key, new_ctxt)
 }
 
 /// Fetch the SCTable from TLS, create one if it doesn't yet exist.
@@ -102,7 +100,7 @@ pub fn with_sctable<T>(op: |&SCTable| -> T) -> T {
             }
             Some(ts) => ts.clone()
         };
-        op(table.deref())
+        op(&*table)
     })
 }
 
@@ -119,8 +117,7 @@ fn new_sctable_internal() -> SCTable {
 /// Print out an SCTable for debugging
 pub fn display_sctable(table: &SCTable) {
     error!("SC table:");
-    let table = table.table.borrow();
-    for (idx,val) in table.get().iter().enumerate() {
+    for (idx,val) in table.table.borrow().iter().enumerate() {
         error!("{:4u} : {:?}",idx,val);
     }
 }
@@ -128,9 +125,9 @@ pub fn display_sctable(table: &SCTable) {
 /// Clear the tables from TLD to reclaim memory.
 pub fn clear_tables() {
     with_sctable(|table| {
-        *table.table.borrow_mut().get() = Vec::new();
-        *table.mark_memo.borrow_mut().get() = HashMap::new();
-        *table.rename_memo.borrow_mut().get() = HashMap::new();
+        *table.table.borrow_mut() = Vec::new();
+        *table.mark_memo.borrow_mut() = HashMap::new();
+        *table.rename_memo.borrow_mut() = HashMap::new();
     });
     with_resolve_table_mut(|table| *table = HashMap::new());
 }
@@ -166,7 +163,7 @@ fn with_resolve_table_mut<T>(op: |&mut ResolveTable| -> T) -> T {
             }
             Some(ts) => ts.clone()
         };
-        op(table.deref().borrow_mut().get())
+        op(&mut *table.borrow_mut())
     })
 }
 
@@ -183,7 +180,7 @@ fn resolve_internal(id: Ident,
     }
 
     let resolved = {
-        let result = *table.table.borrow().get().get(id.ctxt as uint);
+        let result = *table.table.borrow().get(id.ctxt as uint);
         match result {
             EmptyCtxt => id.name,
             // ignore marks here:
@@ -227,10 +224,7 @@ fn marksof_internal(ctxt: SyntaxContext,
     let mut result = Vec::new();
     let mut loopvar = ctxt;
     loop {
-        let table_entry = {
-            let table = table.table.borrow();
-            *table.get().get(loopvar as uint)
-        };
+        let table_entry = *table.table.borrow().get(loopvar as uint);
         match table_entry {
             EmptyCtxt => {
                 return result;
@@ -257,7 +251,7 @@ fn marksof_internal(ctxt: SyntaxContext,
 /// FAILS when outside is not a mark.
 pub fn outer_mark(ctxt: SyntaxContext) -> Mrk {
     with_sctable(|sctable| {
-        match *sctable.table.borrow().get().get(ctxt as uint) {
+        match *sctable.table.borrow().get(ctxt as uint) {
             Mark(mrk, _) => mrk,
             _ => fail!("can't retrieve outer mark when outside is not a mark")
         }
@@ -327,7 +321,7 @@ mod tests {
         let mut result = Vec::new();
         loop {
             let table = table.table.borrow();
-            match *table.get().get(sc as uint) {
+            match *table.get(sc as uint) {
                 EmptyCtxt => {return result;},
                 Mark(mrk,tail) => {
                     result.push(M(mrk));
@@ -351,9 +345,9 @@ mod tests {
         assert_eq!(unfold_test_sc(test_sc.clone(),EMPTY_CTXT,&mut t),4);
         {
             let table = t.table.borrow();
-            assert!(*table.get().get(2) == Mark(9,0));
-            assert!(*table.get().get(3) == Rename(id(101,0),14,2));
-            assert!(*table.get().get(4) == Mark(3,3));
+            assert!(*table.get(2) == Mark(9,0));
+            assert!(*table.get(3) == Rename(id(101,0),14,2));
+            assert!(*table.get(4) == Mark(3,3));
         }
         assert_eq!(refold_test_sc(4,&t),test_sc);
     }
@@ -372,8 +366,8 @@ mod tests {
         assert_eq!(unfold_marks(vec!(3,7),EMPTY_CTXT,&mut t),3);
         {
             let table = t.table.borrow();
-            assert!(*table.get().get(2) == Mark(7,0));
-            assert!(*table.get().get(3) == Mark(3,2));
+            assert!(*table.get(2) == Mark(7,0));
+            assert!(*table.get(3) == Mark(3,2));
         }
     }
 
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 137cd89bf30..8931fb0f443 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -57,7 +57,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
     let topmost = topmost_expn_info(cx.backtrace().unwrap());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
-    let filename = token::intern_and_get_ident(loc.file.deref().name);
+    let filename = token::intern_and_get_ident(loc.file.name);
     base::MRExpr(cx.expr_str(topmost.call_site, filename))
 }
 
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index b2f4904ec8f..b3e3023388b 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -42,26 +42,23 @@ impl<'a> ParserAnyMacro<'a> {
     /// allowed to be there.
     fn ensure_complete_parse(&self, allow_semi: bool) {
         let mut parser = self.parser.borrow_mut();
-        if allow_semi && parser.get().token == SEMI {
-            parser.get().bump()
+        if allow_semi && parser.token == SEMI {
+            parser.bump()
         }
-        if parser.get().token != EOF {
-            let token_str = parser.get().this_token_to_str();
+        if parser.token != EOF {
+            let token_str = parser.this_token_to_str();
             let msg = format!("macro expansion ignores token `{}` and any \
                                following",
                               token_str);
-            let span = parser.get().span;
-            parser.get().span_err(span, msg);
+            let span = parser.span;
+            parser.span_err(span, msg);
         }
     }
 }
 
 impl<'a> AnyMacro for ParserAnyMacro<'a> {
     fn make_expr(&self) -> @ast::Expr {
-        let ret = {
-            let mut parser = self.parser.borrow_mut();
-            parser.get().parse_expr()
-        };
+        let ret = self.parser.borrow_mut().parse_expr();
         self.ensure_complete_parse(true);
         ret
     }
@@ -69,8 +66,8 @@ impl<'a> AnyMacro for ParserAnyMacro<'a> {
         let mut ret = SmallVector::zero();
         loop {
             let mut parser = self.parser.borrow_mut();
-            let attrs = parser.get().parse_outer_attributes();
-            match parser.get().parse_item(attrs) {
+            let attrs = parser.parse_outer_attributes();
+            match parser.parse_item(attrs) {
                 Some(item) => ret.push(item),
                 None => break
             }
@@ -79,11 +76,8 @@ impl<'a> AnyMacro for ParserAnyMacro<'a> {
         ret
     }
     fn make_stmt(&self) -> @ast::Stmt {
-        let ret = {
-            let mut parser = self.parser.borrow_mut();
-            let attrs = parser.get().parse_outer_attributes();
-            parser.get().parse_stmt(attrs)
-        };
+        let attrs = self.parser.borrow_mut().parse_outer_attributes();
+        let ret = self.parser.borrow_mut().parse_stmt(attrs);
         self.ensure_complete_parse(true);
         ret
     }
@@ -242,7 +236,7 @@ pub fn add_new_extension(cx: &mut ExtCtxt,
     };
 
     return MRDef(MacroDef {
-        name: token::get_ident(name).get().to_str(),
+        name: token::get_ident(name).to_str(),
         ext: NormalTT(exp, Some(sp))
     });
 }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index e9db0bd0bd2..933fbe3d566 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -109,15 +109,11 @@ fn lookup_cur_matched_by_matched(r: &TtReader, start: @NamedMatch)
             MatchedSeq(ref ads, _) => *ads.get(*idx)
         }
     }
-    let repeat_idx = r.repeat_idx.borrow();
-    repeat_idx.get().iter().fold(start, red)
+    r.repeat_idx.borrow().iter().fold(start, red)
 }
 
 fn lookup_cur_matched(r: &TtReader, name: Ident) -> @NamedMatch {
-    let matched_opt = {
-        let interpolations = r.interpolations.borrow();
-        interpolations.get().find_copy(&name)
-    };
+    let matched_opt = r.interpolations.borrow().find_copy(&name);
     match matched_opt {
         Some(s) => lookup_cur_matched_by_matched(r, s),
         None => {
@@ -178,19 +174,14 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
         sp: r.cur_span.get(),
     };
     loop {
-        {
-            let mut stack = r.stack.borrow_mut();
-            if stack.get().idx.get() < stack.get().forest.len() {
-                break;
-            }
+        if r.stack.borrow().idx.get() < r.stack.borrow().forest.len() {
+            break;
         }
 
         /* done with this set; pop or repeat? */
         if !r.stack.get().dotdotdoted || {
-                let repeat_idx = r.repeat_idx.borrow();
-                let repeat_len = r.repeat_len.borrow();
-                *repeat_idx.get().last().unwrap() ==
-                *repeat_len.get().last().unwrap() - 1
+                *r.repeat_idx.borrow().last().unwrap() ==
+                *r.repeat_len.borrow().last().unwrap() - 1
             } {
 
             match r.stack.get().up {
@@ -200,12 +191,8 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
               }
               Some(tt_f) => {
                 if r.stack.get().dotdotdoted {
-                    {
-                        let mut repeat_idx = r.repeat_idx.borrow_mut();
-                        let mut repeat_len = r.repeat_len.borrow_mut();
-                        repeat_idx.get().pop().unwrap();
-                        repeat_len.get().pop().unwrap();
-                    }
+                    r.repeat_idx.borrow_mut().pop().unwrap();
+                    r.repeat_len.borrow_mut().pop().unwrap();
                 }
 
                 r.stack.set(tt_f);
@@ -217,8 +204,8 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
             r.stack.get().idx.set(0u);
             {
                 let mut repeat_idx = r.repeat_idx.borrow_mut();
-                let last_repeat_idx = repeat_idx.get().len() - 1u;
-                *repeat_idx.get().get_mut(last_repeat_idx) += 1u;
+                let last_repeat_idx = repeat_idx.len() - 1u;
+                *repeat_idx.get_mut(last_repeat_idx) += 1u;
             }
             match r.stack.get().sep.clone() {
               Some(tk) => {
@@ -276,19 +263,15 @@ pub fn tt_next_token(r: &TtReader) -> TokenAndSpan {
                     r.stack.get().idx.set(r.stack.get().idx.get() + 1u);
                     return tt_next_token(r);
                 } else {
-                    {
-                        let mut repeat_idx = r.repeat_idx.borrow_mut();
-                        let mut repeat_len = r.repeat_len.borrow_mut();
-                        repeat_len.get().push(len);
-                        repeat_idx.get().push(0u);
-                        r.stack.set(@TtFrame {
-                            forest: tts,
-                            idx: Cell::new(0u),
-                            dotdotdoted: true,
-                            sep: sep,
-                            up: Some(r.stack.get())
-                        });
-                    }
+                    r.repeat_len.borrow_mut().push(len);
+                    r.repeat_idx.borrow_mut().push(0u);
+                    r.stack.set(@TtFrame {
+                        forest: tts,
+                        idx: Cell::new(0u),
+                        dotdotdoted: true,
+                        sep: sep,
+                        up: Some(r.stack.get())
+                    });
                 }
               }
             }