use syntax::parse::token::InternedString;
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use getopts::{optopt, optmulti, optflag, optflagopt};
use getopts;
use std::cell::{RefCell};
Some(s) => s,
None => early_error("--extern value must be of the format `foo=bar`"),
};
- let locs = externs.find_or_insert(name.to_string(), Vec::new());
- locs.push(location.to_string());
+
+ match externs.entry(name.to_string()) {
+ Vacant(entry) => { entry.set(vec![location.to_string()]); },
+ Occupied(mut entry) => { entry.get_mut().push(location.to_string()); },
+ }
}
let crate_name = matches.opt_str("crate-name");
use std::cmp;
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use std::slice;
use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
use syntax::abi;
fn check_unused_mut_pat(&self, cx: &Context, pats: &[P<ast::Pat>]) {
// collect all mutable pattern and group their NodeIDs by their Identifier to
// avoid false warnings in match arms with multiple patterns
+
let mut mutables = HashMap::new();
for p in pats.iter() {
pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| {
match mode {
ast::BindByValue(ast::MutMutable) => {
if !token::get_ident(ident).get().starts_with("_") {
- mutables.insert_or_update_with(ident.name.uint(),
- vec!(id), |_, old| { old.push(id); });
+ match mutables.entry(ident.name.uint()) {
+ Vacant(entry) => { entry.set(vec![id]); },
+ Occupied(mut entry) => { entry.get_mut().push(id); },
+ }
}
}
_ => {
use std::rc::Rc;
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use syntax::ast;
use syntax::abi;
use syntax::attr;
fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) {
let mut map = HashMap::new();
cstore.iter_crate_data(|cnum, data| {
- map.find_or_insert_with(data.name(), |_| Vec::new()).push(cnum);
+ match map.entry(data.name()) {
+ Vacant(entry) => { entry.set(vec![cnum]); },
+ Occupied(mut entry) => { entry.get_mut().push(cnum); },
+ }
});
for (name, dupes) in map.into_iter() {
use std::string;
use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
use flate;
use time;
return FileDoesntMatch
};
info!("lib candidate: {}", path.display());
- let slot = candidates.find_or_insert_with(hash.to_string(), |_| {
- (HashSet::new(), HashSet::new())
- });
+
+ let slot = match candidates.entry(hash.to_string()) {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.set((HashSet::new(), HashSet::new())),
+ };
let (ref mut rlibs, ref mut dylibs) = *slot;
if rlib {
rlibs.insert(fs::realpath(path).unwrap());
} else {
dylibs.insert(fs::realpath(path).unwrap());
}
+
FileMatches
});
use syntax::{ast, ast_map, ast_util};
use std::rc::Rc;
+use std::collections::hashmap::Vacant;
//
// This pass classifies expressions by their constant-ness.
ExprCall(ref callee, ref args) => {
let def = tcx.def_map.borrow().get_copy(&callee.id);
- tcx.def_map.borrow_mut().find_or_insert(expr.id, def);
+ match tcx.def_map.borrow_mut().entry(expr.id) {
+ Vacant(entry) => { entry.set(def); }
+ _ => {}
+ };
let path = match def {
def::DefStruct(def_id) => def_to_path(tcx, def_id),
def::DefVariant(_, variant_did, _) => def_to_path(tcx, variant_did),
use syntax::visit::Visitor;
use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
use std::cell::{Cell, RefCell};
use std::gc::GC;
use std::mem::replace;
let is_public = import_directive.is_public;
let mut import_resolutions = module_.import_resolutions.borrow_mut();
- let dest_import_resolution = import_resolutions.find_or_insert_with(name, |_| {
- // Create a new import resolution from this child.
- ImportResolution::new(id, is_public)
- });
+ let dest_import_resolution = match import_resolutions.entry(name) {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => {
+ // Create a new import resolution from this child.
+ entry.set(ImportResolution::new(id, is_public))
+ }
+ };
debug!("(resolving glob import) writing resolution `{}` in `{}` \
to `{}`",
assert!(match lp {LastImport{..} => false, _ => true},
"Import should only be used for `use` directives");
self.last_private.insert(node_id, lp);
- self.def_map.borrow_mut().insert_or_update_with(node_id, def, |_, old_value| {
+
+ match self.def_map.borrow_mut().entry(node_id) {
// Resolve appears to "resolve" the same ID multiple
// times, so here is a sanity check it at least comes to
// the same conclusion! - nmatsakis
- if def != *old_value {
+ Occupied(entry) => if def != *entry.get() {
self.session
.bug(format!("node_id {:?} resolved first to {:?} and \
then {:?}",
node_id,
- *old_value,
+ *entry.get(),
def).as_slice());
- }
- });
+ },
+ Vacant(entry) => { entry.set(def); },
+ }
}
fn enforce_default_binding_mode(&mut self,
use std::ops;
use std::rc::Rc;
use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
use arena::TypedArena;
use syntax::abi;
use syntax::ast::{CrateNum, DefId, FnStyle, Ident, ItemTrait, LOCAL_CRATE};
node_id_to_type(tcx, id.node)
} else {
let mut tcache = tcx.tcache.borrow_mut();
- let pty = tcache.find_or_insert_with(id, |_| {
- csearch::get_field_type(tcx, struct_id, id)
- });
+ let pty = match tcache.entry(id) {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.set(csearch::get_field_type(tcx, struct_id, id)),
+ };
pty.ty
};
t.subst(tcx, substs)
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use std::mem::replace;
use std::rc::Rc;
use std::slice;
*/
let mut region_obligations = self.inh.region_obligations.borrow_mut();
- let v = region_obligations.find_or_insert_with(self.body_id,
- |_| Vec::new());
- v.push(RegionObligation { sub_region: r,
+ let region_obligation = RegionObligation { sub_region: r,
sup_type: ty,
- origin: origin });
+ origin: origin };
+
+ match region_obligations.entry(self.body_id) {
+ Vacant(entry) => { entry.set(vec![region_obligation]); },
+ Occupied(mut entry) => { entry.get_mut().push(region_obligation); },
+ }
}
pub fn add_obligations_for_parameters(&self,
use syntax::ast;
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use util::ppaux::Repr;
// Helper functions related to manipulating region types.
debug!("region r={}", r.to_string());
match r {
ty::ReLateBound(s, br) if s == fn_sig.binder_id => {
- *map.find_or_insert_with(br, |_| mapf(br))
+ * match map.entry(br) {
+ Vacant(entry) => entry.set(mapf(br)),
+ Occupied(entry) => entry.into_mut(),
+ }
}
_ => r
}
//! both occur before the crate is rendered.
use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
use std::fmt;
use std::io::fs::PathExtensions;
use std::io::{fs, File, BufferedWriter, MemWriter, BufferedReader};
clean::ImplItem(ref i) => {
match i.trait_ {
Some(clean::ResolvedPath{ did, .. }) => {
- let v = self.implementors.find_or_insert_with(did, |_| {
- Vec::new()
- });
+ let v = match self.implementors.entry(did) {
+ Vacant(entry) => entry.set(Vec::with_capacity(1)),
+ Occupied(entry) => entry.into_mut(),
+ };
v.push(Implementor {
def_id: item.def_id,
generics: i.generics.clone(),
match did {
Some(did) => {
- let v = self.impls.find_or_insert_with(did, |_| {
- Vec::new()
- });
+ let v = match self.impls.entry(did) {
+ Vacant(entry) => entry.set(Vec::with_capacity(1)),
+ Occupied(entry) => entry.into_mut(),
+ };
v.push(Impl {
impl_: i,
dox: dox,
None => continue,
Some(ref s) => s.to_string(),
};
- let v = map.find_or_insert_with(short.to_string(), |_| Vec::new());
+ let v = match map.entry(short.to_string()) {
+ Vacant(entry) => entry.set(Vec::with_capacity(1)),
+ Occupied(entry) => entry.into_mut(),
+ };
v.push(myname);
}
use std::io;
use std::io::{File, MemWriter};
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use serialize::{json, Decodable, Encodable};
use externalfiles::ExternalHtml;
return Err("--extern value must be of the format `foo=bar`".to_string());
}
};
- let locs = externs.find_or_insert(name.to_string(), Vec::new());
+ let locs = match externs.entry(name.to_string()) {
+ Vacant(entry) => entry.set(Vec::with_capacity(1)),
+ Occupied(entry) => entry.into_mut(),
+ };
locs.push(location.to_string());
}
Ok(externs)
use std::cell::RefCell;
use std::rc::Rc;
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
/// The SCTable contains a table of SyntaxContext_'s. It
/// represents a flattened tree structure, to avoid having
/// Extend a syntax context with a given mark and sctable (explicit memoization)
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));
-
- *table.mark_memo.borrow_mut().find_or_insert_with(key, new_ctxt)
+ * match table.mark_memo.borrow_mut().entry(key) {
+ Vacant(entry) => entry.set(idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt))),
+ Occupied(entry) => entry.into_mut(),
+ }
}
/// Extend a syntax context with a given rename
ctxt: SyntaxContext,
table: &SCTable) -> SyntaxContext {
let key = (ctxt, id, to);
- let new_ctxt = |_: &(SyntaxContext, Ident, Name)|
- idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt));
- *table.rename_memo.borrow_mut().find_or_insert_with(key, new_ctxt)
+ * match table.rename_memo.borrow_mut().entry(key) {
+ Vacant(entry) => entry.set(idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt))),
+ Occupied(entry) => entry.into_mut(),
+ }
}
/// Apply a list of renamings to a context
#![allow(missing_doc)]
use std::collections::hashmap;
+use std::collections::hashmap::{Occupied, Vacant};
use std::fmt::Show;
use std::hash::Hash;
use std::io;
pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hashmap::HashMap<U, uint> {
let mut map: hashmap::HashMap<U,uint> = hashmap::HashMap::new();
for elem in iter {
- map.insert_or_update_with(elem, 1, |_, count| *count += 1);
+ match map.entry(elem) {
+ Occupied(mut entry) => { *entry.get_mut() += 1; },
+ Vacant(entry) => { entry.set(1); },
+ }
}
map
}
#![feature(default_type_params)]
use std::collections::HashMap;
+use std::collections::hashmap::{Occupied, Vacant};
use std::fmt;
use std::from_str::FromStr;
use std::hash;
key: String,
value: String) {
if key.len() > 0 && value.len() > 0 {
- let values = map.find_or_insert_with(key, |_| vec!());
- values.push(value);
+ match map.entry(key) {
+ Vacant(entry) => { entry.set(vec![value]); },
+ Occupied(mut entry) => { entry.get_mut().push(value); },
+ }
}
}