Fallout from collection conventions

Author: Gankra

src/libgreen/lib.rs

@@ -417,7 +417,7 @@ impl SchedPool {
         }
 
         // Jettison the task away!
-        self.handles.get_mut(idx).send(TaskFromFriend(task));
+        self.handles[idx].send(TaskFromFriend(task));
     }
 
     /// Spawns a new scheduler into this M:N pool. A handle is returned to the

src/libgreen/sched.rs

@@ -502,7 +502,7 @@ impl Scheduler {
         let len = work_queues.len();
         let start_index = self.rng.gen_range(0, len);
         for index in range(0, len).map(|i| (i + start_index) % len) {
-            match work_queues.get_mut(index).steal() {
+            match work_queues[index].steal() {
                 deque::Data(task) => {
                     rtdebug!("found task by stealing");
                     return Some(task)

src/librustc/back/link.rs

@@ -220,7 +220,7 @@ fn symbol_hash(tcx: &ty::ctxt,
 }
 
 fn get_symbol_hash(ccx: &CrateContext, t: ty::t) -> String {
-    match ccx.type_hashcodes().borrow().find(&t) {
+    match ccx.type_hashcodes().borrow().get(&t) {
         Some(h) => return h.to_string(),
         None => {}
     }

src/librustc/driver/session.rs

@@ -127,7 +127,7 @@ impl Session {
                     msg: String) {
         let lint_id = lint::LintId::of(lint);
         let mut lints = self.lints.borrow_mut();
-        match lints.find_mut(&id) {
+        match lints.get_mut(&id) {
             Some(arr) => { arr.push((lint_id, sp, msg)); return; }
             None => {}
         }

src/librustc/lint/builtin.rs

@@ -403,7 +403,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                                    libc::c_uint or libc::c_ulong should be used");
             }
             def::DefTy(..) => {
-                let tty = match self.cx.tcx.ast_ty_to_ty_cache.borrow().find(&ty_id) {
+                let tty = match self.cx.tcx.ast_ty_to_ty_cache.borrow().get(&ty_id) {
                     Some(&ty::atttce_resolved(t)) => t,
                     _ => panic!("ast_ty_to_ty_cache was incomplete after typeck!")
                 };
@@ -994,7 +994,7 @@ impl LintPass for NonSnakeCase {
     fn check_pat(&mut self, cx: &Context, p: &ast::Pat) {
         match &p.node {
             &ast::PatIdent(_, ref path1, _) => {
-                match cx.tcx.def_map.borrow().find(&p.id) {
+                match cx.tcx.def_map.borrow().get(&p.id) {
                     Some(&def::DefLocal(_)) => {
                         self.check_snake_case(cx, "variable", path1.node, p.span);
                     }
@@ -1051,7 +1051,7 @@ impl LintPass for NonUpperCaseGlobals {
 
     fn check_pat(&mut self, cx: &Context, p: &ast::Pat) {
         // Lint for constants that look like binding identifiers (#7526)
-        match (&p.node, cx.tcx.def_map.borrow().find(&p.id)) {
+        match (&p.node, cx.tcx.def_map.borrow().get(&p.id)) {
             (&ast::PatIdent(_, ref path1, _), Some(&def::DefConst(..))) => {
                 let s = token::get_ident(path1.node);
                 if s.get().chars().any(|c| c.is_lowercase()) {
@@ -1211,7 +1211,7 @@ impl LintPass for NonShorthandFieldPatterns {
             ast::PatStruct(_, ref v, _) => {
                 for fieldpat in v.iter()
                                  .filter(|fieldpat| !fieldpat.node.is_shorthand)
-                                 .filter(|fieldpat| def_map.find(&fieldpat.node.pat.id)
+                                 .filter(|fieldpat| def_map.get(&fieldpat.node.pat.id)
                                     == Some(&def::DefLocal(fieldpat.node.pat.id))) {
                     match fieldpat.node.pat.node {
                         ast::PatIdent(_, ident, None) if ident.node.as_str()
@@ -1368,7 +1368,7 @@ impl LintPass for UnusedAllocation {
             _ => return
         }
 
-        match cx.tcx.adjustments.borrow().find(&e.id) {
+        match cx.tcx.adjustments.borrow().get(&e.id) {
             Some(adjustment) => {
                 match *adjustment {
                     ty::AdjustDerefRef(ty::AutoDerefRef { ref autoref, .. }) => {
@@ -1637,15 +1637,15 @@ impl LintPass for Stability {
 
         let id = match e.node {
             ast::ExprPath(..) | ast::ExprStruct(..) => {
-                match cx.tcx.def_map.borrow().find(&e.id) {
+                match cx.tcx.def_map.borrow().get(&e.id) {
                     Some(&def) => def.def_id(),
                     None => return
                 }
             }
             ast::ExprMethodCall(i, _, _) => {
                 span = i.span;
                 let method_call = typeck::MethodCall::expr(e.id);
-                match cx.tcx.method_map.borrow().find(&method_call) {
+                match cx.tcx.method_map.borrow().get(&method_call) {
                     Some(method) => {
                         match method.origin {
                             typeck::MethodStatic(def_id) => {

src/librustc/lint/context.rs

@@ -84,7 +84,7 @@ enum TargetLint {
 
 impl LintStore {
     fn get_level_source(&self, lint: LintId) -> LevelSource {
-        match self.levels.find(&lint) {
+        match self.levels.get(&lint) {
             Some(&s) => s,
             None => (Allow, Default),
         }
@@ -124,7 +124,7 @@ impl LintStore {
             self.lints.push((*lint, from_plugin));
 
             let id = LintId::of(*lint);
-            if !self.by_name.insert(lint.name_lower(), Id(id)) {
+            if self.by_name.insert(lint.name_lower(), Id(id)).is_some() {
                 let msg = format!("duplicate specification of lint {}", lint.name_lower());
                 match (sess, from_plugin) {
                     // We load builtin lints first, so a duplicate is a compiler bug.
@@ -147,7 +147,7 @@ impl LintStore {
     pub fn register_group(&mut self, sess: Option<&Session>,
                           from_plugin: bool, name: &'static str,
                           to: Vec<LintId>) {
-        let new = self.lint_groups.insert(name, (to, from_plugin));
+        let new = self.lint_groups.insert(name, (to, from_plugin)).is_none();
 
         if !new {
             let msg = format!("duplicate specification of lint group {}", name);
@@ -437,11 +437,11 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
     /// Get the level of `lint` at the current position of the lint
     /// traversal.
     pub fn current_level(&self, lint: &'static Lint) -> Level {
-        self.lints.levels.find(&LintId::of(lint)).map_or(Allow, |&(lvl, _)| lvl)
+        self.lints.levels.get(&LintId::of(lint)).map_or(Allow, |&(lvl, _)| lvl)
     }
 
     fn lookup_and_emit(&self, lint: &'static Lint, span: Option<Span>, msg: &str) {
-        let (level, src) = match self.lints.levels.find(&LintId::of(lint)) {
+        let (level, src) = match self.lints.levels.get(&LintId::of(lint)) {
             None => return,
             Some(&(Warn, src)) => {
                 let lint_id = LintId::of(builtin::WARNINGS);
@@ -750,7 +750,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
 // Output any lints that were previously added to the session.
 impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> {
     fn visit_id(&mut self, id: ast::NodeId) {
-        match self.tcx.sess.lints.borrow_mut().pop(&id) {
+        match self.tcx.sess.lints.borrow_mut().remove(&id) {
             None => {}
             Some(lints) => {
                 for (lint_id, span, msg) in lints.into_iter() {

src/librustc/metadata/cstore.rs

@@ -213,7 +213,7 @@ impl CStore {
 
     pub fn find_extern_mod_stmt_cnum(&self, emod_id: ast::NodeId)
                                      -> Option<ast::CrateNum> {
-        self.extern_mod_crate_map.borrow().find(&emod_id).map(|x| *x)
+        self.extern_mod_crate_map.borrow().get(&emod_id).map(|x| *x)
     }
 }
 

src/librustc/metadata/decoder.rs

@@ -1209,7 +1209,7 @@ pub fn translate_def_id(cdata: Cmd, did: ast::DefId) -> ast::DefId {
         return ast::DefId { krate: cdata.cnum, node: did.node };
     }
 
-    match cdata.cnum_map.find(&did.krate) {
+    match cdata.cnum_map.get(&did.krate) {
         Some(&n) => {
             ast::DefId {
                 krate: n,
@@ -1321,7 +1321,7 @@ pub fn get_dylib_dependency_formats(cdata: Cmd)
         let cnum = spec.split(':').nth(0).unwrap();
         let link = spec.split(':').nth(1).unwrap();
         let cnum = from_str(cnum).unwrap();
-        let cnum = match cdata.cnum_map.find(&cnum) {
+        let cnum = match cdata.cnum_map.get(&cnum) {
             Some(&n) => n,
             None => panic!("didn't find a crate in the cnum_map")
         };

src/librustc/metadata/encoder.rs

@@ -253,7 +253,7 @@ fn encode_symbol(ecx: &EncodeContext,
                  rbml_w: &mut Encoder,
                  id: NodeId) {
     rbml_w.start_tag(tag_items_data_item_symbol);
-    match ecx.item_symbols.borrow().find(&id) {
+    match ecx.item_symbols.borrow().get(&id) {
         Some(x) => {
             debug!("encode_symbol(id={}, str={})", id, *x);
             rbml_w.writer.write(x.as_bytes());
@@ -397,7 +397,7 @@ fn encode_reexported_static_base_methods(ecx: &EncodeContext,
                                          exp: &middle::resolve::Export2)
                                          -> bool {
     let impl_items = ecx.tcx.impl_items.borrow();
-    match ecx.tcx.inherent_impls.borrow().find(&exp.def_id) {
+    match ecx.tcx.inherent_impls.borrow().get(&exp.def_id) {
         Some(implementations) => {
             for base_impl_did in implementations.iter() {
                 for &method_did in (*impl_items)[*base_impl_did].iter() {
@@ -426,7 +426,7 @@ fn encode_reexported_static_trait_methods(ecx: &EncodeContext,
                                           rbml_w: &mut Encoder,
                                           exp: &middle::resolve::Export2)
                                           -> bool {
-    match ecx.tcx.trait_items_cache.borrow().find(&exp.def_id) {
+    match ecx.tcx.trait_items_cache.borrow().get(&exp.def_id) {
         Some(trait_items) => {
             for trait_item in trait_items.iter() {
                 match *trait_item {
@@ -531,7 +531,7 @@ fn encode_reexports(ecx: &EncodeContext,
                     id: NodeId,
                     path: PathElems) {
     debug!("(encoding info for module) encoding reexports for {}", id);
-    match ecx.reexports2.find(&id) {
+    match ecx.reexports2.get(&id) {
         Some(ref exports) => {
             debug!("(encoding info for module) found reexports for {}", id);
             for exp in exports.iter() {
@@ -978,7 +978,7 @@ fn should_inline(attrs: &[Attribute]) -> bool {
 fn encode_inherent_implementations(ecx: &EncodeContext,
                                    rbml_w: &mut Encoder,
                                    def_id: DefId) {
-    match ecx.tcx.inherent_impls.borrow().find(&def_id) {
+    match ecx.tcx.inherent_impls.borrow().get(&def_id) {
         None => {}
         Some(implementations) => {
             for &impl_def_id in implementations.iter() {
@@ -994,7 +994,7 @@ fn encode_inherent_implementations(ecx: &EncodeContext,
 fn encode_extension_implementations(ecx: &EncodeContext,
                                     rbml_w: &mut Encoder,
                                     trait_def_id: DefId) {
-    match ecx.tcx.trait_impls.borrow().find(&trait_def_id) {
+    match ecx.tcx.trait_impls.borrow().get(&trait_def_id) {
         None => {}
         Some(implementations) => {
             for &impl_def_id in implementations.borrow().iter() {
@@ -1987,7 +1987,7 @@ fn encode_crate_triple(rbml_w: &mut Encoder, triple: &str) {
 
 fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) {
     rbml_w.start_tag(tag_dylib_dependency_formats);
-    match ecx.tcx.dependency_formats.borrow().find(&config::CrateTypeDylib) {
+    match ecx.tcx.dependency_formats.borrow().get(&config::CrateTypeDylib) {
         Some(arr) => {
             let s = arr.iter().enumerate().filter_map(|(i, slot)| {
                 slot.map(|kind| (format!("{}:{}", i + 1, match kind {

src/librustc/metadata/tydecode.rs

@@ -675,16 +675,16 @@ fn parse_builtin_bounds(st: &mut PState, _conv: conv_did) -> ty::BuiltinBounds {
     loop {
         match next(st) {
             'S' => {
-                builtin_bounds.add(ty::BoundSend);
+                builtin_bounds.insert(ty::BoundSend);
             }
             'Z' => {
-                builtin_bounds.add(ty::BoundSized);
+                builtin_bounds.insert(ty::BoundSized);
             }
             'P' => {
-                builtin_bounds.add(ty::BoundCopy);
+                builtin_bounds.insert(ty::BoundCopy);
             }
             'T' => {
-                builtin_bounds.add(ty::BoundSync);
+                builtin_bounds.insert(ty::BoundSync);
             }
             '.' => {
                 return builtin_bounds;