From c2b3aa99390213cc41f4a7a001963fa49e1ee509 Mon Sep 17 00:00:00 2001 From: ljedrz Date: Tue, 2 Oct 2018 18:05:06 +0200 Subject: [PATCH] rustc/middle: improve some patterns --- src/librustc/middle/dead.rs | 6 +-- src/librustc/middle/dependency_format.rs | 2 +- src/librustc/middle/exported_symbols.rs | 8 +--- src/librustc/middle/expr_use_visitor.rs | 6 +-- src/librustc/middle/intrinsicck.rs | 2 +- src/librustc/middle/lang_items.rs | 9 ++--- src/librustc/middle/liveness.rs | 50 +++++++++--------------- src/librustc/middle/region.rs | 12 ++---- src/librustc/middle/resolve_lifetime.rs | 41 ++++++++----------- src/librustc/middle/stability.rs | 15 +++---- 10 files changed, 56 insertions(+), 95 deletions(-) diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 66305ae8836e..575d32dd401f 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -131,12 +131,10 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> { fn mark_live_symbols(&mut self) { let mut scanned = FxHashSet(); - while !self.worklist.is_empty() { - let id = self.worklist.pop().unwrap(); - if scanned.contains(&id) { + while let Some(id) = self.worklist.pop() { + if !scanned.insert(id) { continue } - scanned.insert(id); if let Some(ref node) = self.tcx.hir.find(id) { self.live_symbols.insert(id); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 14551261819a..12b304298c15 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -253,7 +253,7 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } } - return ret; + ret } fn add_library(tcx: TyCtxt<'_, '_, '_>, diff --git a/src/librustc/middle/exported_symbols.rs b/src/librustc/middle/exported_symbols.rs index 6a254f1a189b..44572a1977ab 100644 --- a/src/librustc/middle/exported_symbols.rs +++ b/src/librustc/middle/exported_symbols.rs @@ -35,12 +35,8 @@ impl_stable_hash_for!(enum self::SymbolExportLevel { impl SymbolExportLevel { pub fn is_below_threshold(self, threshold: SymbolExportLevel) -> bool { - if threshold == SymbolExportLevel::Rust { - // We export everything from Rust dylibs - true - } else { - self == SymbolExportLevel::C - } + threshold == SymbolExportLevel::Rust // export everything from Rust dylibs + || self == SymbolExportLevel::C } } diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 1a86dc4027e8..e18a1d825856 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -801,10 +801,8 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> { self.walk_pat(discr_cmt.clone(), &pat, mode); } - if let Some(ref guard) = arm.guard { - match guard { - hir::Guard::If(ref e) => self.consume_expr(e), - } + if let Some(hir::Guard::If(ref e)) = arm.guard { + self.consume_expr(e) } self.consume_expr(&arm.body); diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index 8058f3dde668..d53d5fdb97d4 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -107,7 +107,7 @@ impl<'a, 'tcx> ExprVisitor<'a, 'tcx> { } Err(LayoutError::Unknown(bad)) => { if bad == ty { - "this type's size can vary".to_string() + "this type's size can vary".to_owned() } else { format!("size can vary because of {}", bad) } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index ef70a4cc45d5..ccfac3140929 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -145,8 +145,8 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { fn collect_item(&mut self, item_index: usize, item_def_id: DefId) { // Check for duplicates. - match self.items.items[item_index] { - Some(original_def_id) if original_def_id != item_def_id => { + if let Some(original_def_id) = self.items.items[item_index] { + if original_def_id != item_def_id { let name = LangItem::from_u32(item_index as u32).unwrap().name(); let mut err = match self.tcx.hir.span_if_local(item_def_id) { Some(span) => struct_span_err!( @@ -169,9 +169,6 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { } err.emit(); } - _ => { - // OK. - } } // Matched. @@ -194,7 +191,7 @@ pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { } } - return None; + None } pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> LanguageItems { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index ff4b1fc2921b..56f67328458d 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -170,7 +170,7 @@ fn live_node_kind_to_string(lnk: LiveNodeKind, tcx: TyCtxt<'_, '_, '_>) -> Strin VarDefNode(s) => { format!("Var def node [{}]", cm.span_to_string(s)) } - ExitNode => "Exit node".to_string(), + ExitNode => "Exit node".to_owned(), } } @@ -330,7 +330,7 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> { Local(LocalInfo { name, .. }) | Arg(_, name) => { name.to_string() }, - CleanExit => "".to_string() + CleanExit => "".to_owned() } } @@ -1049,12 +1049,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { // the construction of a closure itself is not important, // but we have to consider the closed over variables. - let caps = match self.ir.capture_info_map.get(&expr.id) { - Some(caps) => caps.clone(), - None => { - span_bug!(expr.span, "no registered caps"); - } - }; + let caps = self.ir.capture_info_map.get(&expr.id).cloned().unwrap_or_else(|| + span_bug!(expr.span, "no registered caps")); + caps.iter().rev().fold(succ, |succ, cap| { self.init_from_succ(cap.ln, succ); let var = self.variable(cap.var_hid, expr.span); @@ -1114,15 +1111,12 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { self.init_empty(ln, succ); let mut first_merge = true; for arm in arms { - let body_succ = - self.propagate_through_expr(&arm.body, succ); - let guard_succ = - self.propagate_through_opt_expr( - arm.guard.as_ref().map(|g| - match g { - hir::Guard::If(e) => &**e, - }), - body_succ); + let body_succ = self.propagate_through_expr(&arm.body, succ); + + let guard_succ = self.propagate_through_opt_expr( + arm.guard.as_ref().map(|hir::Guard::If(e)| &**e), + body_succ + ); // only consider the first pattern; any later patterns must have // the same bindings, and we also consider the first pattern to be // the "authoritative" set of ids @@ -1146,10 +1140,9 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { let target = match label.target_id { Ok(node_id) => self.break_ln.get(&node_id), Err(err) => span_bug!(expr.span, "loop scope error: {}", err), - }.map(|x| *x); - // Now that we know the label we're going to, // look it up in the break loop nodes table + }.cloned(); match target { Some(b) => self.propagate_through_opt_expr(opt_expr.as_ref().map(|e| &**e), b), @@ -1159,18 +1152,13 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { hir::ExprKind::Continue(label) => { // Find which label this expr continues to - let sc = match label.target_id { - Ok(node_id) => node_id, - Err(err) => span_bug!(expr.span, "loop scope error: {}", err), - }; + let sc = label.target_id.unwrap_or_else(|err| + span_bug!(expr.span, "loop scope error: {}", err)); // Now that we know the label we're going to, // look it up in the continue loop nodes table - - match self.cont_ln.get(&sc) { - Some(&b) => b, - None => span_bug!(expr.span, "continue to unknown label") - } + self.cont_ln.get(&sc).cloned().unwrap_or_else(|| + span_bug!(expr.span, "continue to unknown label")) } hir::ExprKind::Assign(ref l, ref r) => { @@ -1450,8 +1438,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { self.propagate_through_expr(&cond, ln) } }; - assert!(cond_ln == new_cond_ln); - assert!(body_ln == self.propagate_through_block(body, cond_ln)); + assert_eq!(cond_ln, new_cond_ln); + assert_eq!(body_ln, self.propagate_through_block(body, cond_ln)); } cond_ln @@ -1576,7 +1564,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn should_warn(&self, var: Variable) -> Option { let name = self.ir.variable_name(var); - if name.is_empty() || name.as_bytes()[0] == ('_' as u8) { + if name.is_empty() || name.as_bytes()[0] == b'_' { None } else { Some(name) diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 01b0d2c27a14..3e07902aad30 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -515,10 +515,8 @@ impl<'tcx> ScopeTree { /// Returns the lifetime of the local variable `var_id` pub fn var_scope(&self, var_id: hir::ItemLocalId) -> Scope { - match self.var_map.get(&var_id) { - Some(&r) => r, - None => { bug!("no enclosing scope for id {:?}", var_id); } - } + self.var_map.get(&var_id).cloned().unwrap_or_else(|| + bug!("no enclosing scope for id {:?}", var_id)) } pub fn temporary_scope(&self, expr_id: hir::ItemLocalId) -> Option { @@ -828,10 +826,8 @@ fn resolve_block<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>, blk: fn resolve_arm<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>, arm: &'tcx hir::Arm) { visitor.terminating_scopes.insert(arm.body.hir_id.local_id); - if let Some(ref g) = arm.guard { - match g { - hir::Guard::If(ref expr) => visitor.terminating_scopes.insert(expr.hir_id.local_id), - }; + if let Some(hir::Guard::If(ref expr)) = arm.guard { + visitor.terminating_scopes.insert(expr.hir_id.local_id); } intravisit::walk_arm(visitor, arm); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index c41c6f3cbe59..5bfae5a8c33c 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -1872,18 +1872,15 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { node: hir::TraitItemKind::Method(_, ref m), .. }) => { - match self.tcx + if let hir::ItemKind::Trait(.., ref trait_items) = self.tcx .hir .expect_item(self.tcx.hir.get_parent(parent)) .node { - hir::ItemKind::Trait(.., ref trait_items) => { - assoc_item_kind = trait_items - .iter() - .find(|ti| ti.id.node_id == parent) - .map(|ti| ti.kind); - } - _ => {} + assoc_item_kind = trait_items + .iter() + .find(|ti| ti.id.node_id == parent) + .map(|ti| ti.kind); } match *m { hir::TraitMethod::Required(_) => None, @@ -1895,19 +1892,16 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { node: hir::ImplItemKind::Method(_, body), .. }) => { - match self.tcx + if let hir::ItemKind::Impl(.., ref self_ty, ref impl_items) = self.tcx .hir .expect_item(self.tcx.hir.get_parent(parent)) .node { - hir::ItemKind::Impl(.., ref self_ty, ref impl_items) => { - impl_self = Some(self_ty); - assoc_item_kind = impl_items - .iter() - .find(|ii| ii.id.node_id == parent) - .map(|ii| ii.kind); - } - _ => {} + impl_self = Some(self_ty); + assoc_item_kind = impl_items + .iter() + .find(|ii| ii.id.node_id == parent) + .map(|ii| ii.kind); } Some(body) } @@ -2541,15 +2535,12 @@ fn insert_late_bound_lifetimes( appears_in_where_clause.visit_generics(generics); for param in &generics.params { - match param.kind { - hir::GenericParamKind::Lifetime { .. } => { - if !param.bounds.is_empty() { - // `'a: 'b` means both `'a` and `'b` are referenced - appears_in_where_clause - .regions.insert(hir::LifetimeName::Param(param.name.modern())); - } + if let hir::GenericParamKind::Lifetime { .. } = param.kind { + if !param.bounds.is_empty() { + // `'a: 'b` means both `'a` and `'b` are referenced + appears_in_where_clause + .regions.insert(hir::LifetimeName::Param(param.name.modern())); } - hir::GenericParamKind::Type { .. } => {} } } diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index b7b149ea0298..0e4989937cd3 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -523,15 +523,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { Some(Def::Method(_)) | Some(Def::AssociatedTy(_)) | Some(Def::AssociatedConst(_)) => { - match self.associated_item(def_id).container { - ty::TraitContainer(trait_def_id) => { - // Trait methods do not declare visibility (even - // for visibility info in cstore). Use containing - // trait instead, so methods of pub traits are - // themselves considered pub. - def_id = trait_def_id; - } - _ => {} + if let ty::TraitContainer(trait_def_id) = self.associated_item(def_id).container { + // Trait methods do not declare visibility (even + // for visibility info in cstore). Use containing + // trait instead, so methods of pub traits are + // themselves considered pub. + def_id = trait_def_id; } } _ => {}