/// Returns the string argument supplied to one of several matching options or `None`.
pub fn opts_str(&self, names: &[String]) -> Option<String> {
for nm in names {
- match self.opt_val(&nm[..]) {
- Some(Val(ref s)) => return Some(s.clone()),
- _ => (),
+ if let Some(Val(ref s)) = self.opt_val(&nm[..]) {
+ return Some(s.clone())
}
}
None
}
fn get_symbol_hash<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> String {
- match ccx.type_hashcodes().borrow().get(&t) {
- Some(h) => return h.to_string(),
- None => {}
+ if let Some(h) = ccx.type_hashcodes().borrow().get(&t) {
+ return h.to_string()
}
let mut symbol_hasher = ccx.symbol_hasher().borrow_mut();
push(&mut n, &data);
}
- match hash {
- Some(s) => push(&mut n, s),
- None => {}
+ if let Some(s) = hash {
+ push(&mut n, s)
}
n.push('E'); // End name-sequence.
pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
debug!("new InsnCtxt: {}", s);
TASK_LOCAL_INSN_KEY.with(|slot| {
- match slot.borrow_mut().as_mut() {
- Some(ctx) => ctx.push(s),
- None => {}
+ if let Some(ctx) = slot.borrow_mut().as_mut() {
+ ctx.push(s)
}
});
_InsnCtxt {
name: &str,
did: DefId)
-> ValueRef {
- match ccx.externs().borrow().get(name) {
- Some(n) => return *n,
- None => (),
+ if let Some(n) = ccx.externs().borrow().get(name) {
+ return *n;
}
let f = declare::declare_rust_fn(ccx, name, fn_ty);
-> ValueRef {
let name = ccx.sess().cstore.item_symbol(did);
let ty = type_of(ccx, t);
- match ccx.externs().borrow_mut().get(&name) {
- Some(n) => return *n,
- None => (),
+ if let Some(n) = ccx.externs().borrow_mut().get(&name) {
+ return *n;
}
// FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
// FIXME(nagisa): investigate whether it can be changed into define_global
pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
debug!("get_item_val(id=`{}`)", id);
- match ccx.item_vals().borrow().get(&id).cloned() {
- Some(v) => return v,
- None => {}
+ if let Some(v) = ccx.item_vals().borrow().get(&id).cloned() {
+ return v;
}
let item = ccx.tcx().map.get(id);
// our boxed-and-length-annotated strings.
pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
unsafe {
- match cx.const_cstr_cache().borrow().get(&s) {
- Some(&llval) => return llval,
- None => ()
+ if let Some(&llval) = cx.const_cstr_cache().borrow().get(&s) {
+ return llval;
}
let sc = llvm::LLVMConstStringInContext(cx.llcx(),
// recursive types. For example, enum types rely on this behavior.
pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
- match cx.llsizingtypes().borrow().get(&t).cloned() {
- Some(t) => return t,
- None => ()
+ if let Some(t) = cx.llsizingtypes().borrow().get(&t).cloned() {
+ return t;
}
debug!("sizing_type_of {:?}", t);
/// NB: If you update this, be sure to update `sizing_type_of()` as well.
pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
// Check the cache.
- match cx.lltypes().borrow().get(&t) {
- Some(&llty) => return llty,
- None => ()
+ if let Some(&llty) = cx.lltypes().borrow().get(&t) {
+ return llty;
}
debug!("type_of {:?}", t);
*s.borrow_mut() = analysis.take();
});
- match matches.opt_str("crate-name") {
- Some(name) => krate.name = name,
- None => {}
+ if let Some(name) = matches.opt_str("crate-name") {
+ krate.name = name
}
// Process all of the crate attributes, extracting plugin metadata along
type Iter = vec::IntoIter<SocketAddr>;
fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
// try to parse as a regular SocketAddr first
- match self.parse().ok() {
- Some(addr) => return Ok(vec![addr].into_iter()),
- None => {}
+ if let Some(addr) = self.parse().ok() {
+ return Ok(vec![addr].into_iter());
}
macro_rules! try_opt {
fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>])
-> Option<T> {
for pf in parsers {
- match self.read_atomically(|p: &mut Parser| pf(p)) {
- Some(r) => return Some(r),
- None => {}
+ if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {
+ return Some(r);
}
}
None
pub unsafe fn create(dtor: Option<Dtor>) -> Key {
let key = c::TlsAlloc();
assert!(key != c::TLS_OUT_OF_INDEXES);
- match dtor {
- Some(f) => register_dtor(key, f),
- None => {}
+ if let Some(f) = dtor {
+ register_dtor(key, f);
}
return key;
}