Auto merge of #29744 - sanxiyn:modernize, r=nrc

bors · bors · commit b53020a5f4e0 · 2015-11-11T05:47:13.000Z
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
@@ -67,7 +67,7 @@ pub trait AttrMetaMethods {
     /// containing a string, otherwise None.
     fn value_str(&self) -> Option<InternedString>;
     /// Gets a list of inner meta items from a list MetaItem type.
-    fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]>;
+    fn meta_item_list(&self) -> Option<&[P<MetaItem>]>;
 
     fn span(&self) -> Span;
 }
@@ -84,7 +84,7 @@ impl AttrMetaMethods for Attribute {
     fn value_str(&self) -> Option<InternedString> {
         self.meta().value_str()
     }
-    fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
+    fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {
         self.node.value.meta_item_list()
     }
     fn span(&self) -> Span { self.meta().span }
@@ -111,7 +111,7 @@ impl AttrMetaMethods for MetaItem {
         }
     }
 
-    fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
+    fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {
         match self.node {
             MetaList(_, ref l) => Some(&l[..]),
             _ => None
@@ -124,22 +124,22 @@ impl AttrMetaMethods for MetaItem {
 impl AttrMetaMethods for P<MetaItem> {
     fn name(&self) -> InternedString { (**self).name() }
     fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
-    fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
+    fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {
         (**self).meta_item_list()
     }
     fn span(&self) -> Span { (**self).span() }
 }
 
 
 pub trait AttributeMethods {
-    fn meta<'a>(&'a self) -> &'a MetaItem;
+    fn meta(&self) -> &MetaItem;
     fn with_desugared_doc<T, F>(&self, f: F) -> T where
         F: FnOnce(&Attribute) -> T;
 }
 
 impl AttributeMethods for Attribute {
     /// Extract the MetaItem from inside this Attribute.
-    fn meta<'a>(&'a self) -> &'a MetaItem {
+    fn meta(&self) -> &MetaItem {
         &*self.node.value
     }
 
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
@@ -86,7 +86,7 @@ fn filter_foreign_item<F>(cx: &mut Context<F>,
                           -> Option<P<ast::ForeignItem>> where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    if foreign_item_in_cfg(cx, &*item) {
+    if foreign_item_in_cfg(cx, &item) {
         Some(item)
     } else {
         None
@@ -109,7 +109,7 @@ fn fold_foreign_mod<F>(cx: &mut Context<F>,
 fn fold_item<F>(cx: &mut Context<F>, item: P<ast::Item>) -> SmallVector<P<ast::Item>> where
     F: FnMut(&[ast::Attribute]) -> bool
 {
-    if item_in_cfg(cx, &*item) {
+    if item_in_cfg(cx, &item) {
         SmallVector::one(item.map(|i| cx.fold_item_simple(i)))
     } else {
         SmallVector::zero()
@@ -189,7 +189,7 @@ fn retain_stmt<F>(cx: &mut Context<F>, stmt: &ast::Stmt) -> bool where
         ast::StmtDecl(ref decl, _) => {
             match decl.node {
                 ast::DeclItem(ref item) => {
-                    item_in_cfg(cx, &**item)
+                    item_in_cfg(cx, item)
                 }
                 _ => true
             }
@@ -203,7 +203,7 @@ fn fold_block<F>(cx: &mut Context<F>, b: P<ast::Block>) -> P<ast::Block> where
 {
     b.map(|ast::Block {id, stmts, expr, rules, span}| {
         let resulting_stmts: Vec<P<ast::Stmt>> =
-            stmts.into_iter().filter(|a| retain_stmt(cx, &**a)).collect();
+            stmts.into_iter().filter(|a| retain_stmt(cx, a)).collect();
         let resulting_stmts = resulting_stmts.into_iter()
             .flat_map(|stmt| cx.fold_stmt(stmt).into_iter())
             .collect();
@@ -263,7 +263,7 @@ fn in_cfg(diagnostic: &SpanHandler, cfg: &[P<ast::MetaItem>], attrs: &[ast::Attr
             return true;
         }
 
-        attr::cfg_matches(diagnostic, cfg, &*mis[0],
+        attr::cfg_matches(diagnostic, cfg, &mis[0],
                           feature_gated_cfgs)
     })
 }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -881,7 +881,7 @@ impl SyntaxEnv {
         self.chain.pop();
     }
 
-    fn find_escape_frame<'a>(&'a mut self) -> &'a mut MapChainFrame {
+    fn find_escape_frame(&mut self) -> &mut MapChainFrame {
         for (i, frame) in self.chain.iter_mut().enumerate().rev() {
             if !frame.info.macros_escape || i == 0 {
                 return frame
@@ -904,7 +904,7 @@ impl SyntaxEnv {
         self.find_escape_frame().map.insert(k, Rc::new(v));
     }
 
-    pub fn info<'a>(&'a mut self) -> &'a mut BlockInfo {
+    pub fn info(&mut self) -> &mut BlockInfo {
         let last_chain_index = self.chain.len() - 1;
         &mut self.chain[last_chain_index].info
     }
diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs
@@ -33,7 +33,7 @@ pub fn expand_cfg<'cx>(cx: &mut ExtCtxt,
         return DummyResult::expr(sp);
     }
 
-    let matches_cfg = attr::cfg_matches(&cx.parse_sess.span_diagnostic, &cx.cfg, &*cfg,
+    let matches_cfg = attr::cfg_matches(&cx.parse_sess.span_diagnostic, &cx.cfg, &cfg,
                                         cx.feature_gated_cfgs);
     MacEager::expr(cx.expr_bool(sp, matches_cfg))
 }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
@@ -547,7 +547,7 @@ fn expand_non_macro_stmt(Spanned {node, span: stmt_span}: Stmt, fld: &mut MacroE
                     // names, as well... but that should be okay, as long as
                     // the new names are gensyms for the old ones.
                     // generate fresh names, push them to a new pending list
-                    let idents = pattern_bindings(&*expanded_pat);
+                    let idents = pattern_bindings(&expanded_pat);
                     let mut new_pending_renames =
                         idents.iter().map(|ident| (*ident, fresh_name(*ident))).collect();
                     // rewrite the pattern using the new names (the old
@@ -634,7 +634,7 @@ fn rename_in_scope<X, F>(pats: Vec<P<ast::Pat>>,
 {
     // all of the pats must have the same set of bindings, so use the
     // first one to extract them and generate new names:
-    let idents = pattern_bindings(&*pats[0]);
+    let idents = pattern_bindings(&pats[0]);
     let new_renames = idents.into_iter().map(|id| (id, fresh_name(id))).collect();
     // apply the renaming, but only to the PatIdents:
     let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
@@ -659,7 +659,7 @@ impl<'v> Visitor<'v> for PatIdentFinder {
                 self.ident_accumulator.push(path1.node);
                 // visit optional subpattern of PatIdent:
                 if let Some(ref subpat) = *inner {
-                    self.visit_pat(&**subpat)
+                    self.visit_pat(subpat)
                 }
             }
             // use the default traversal for non-PatIdents
@@ -679,7 +679,7 @@ fn pattern_bindings(pat: &ast::Pat) -> Vec<ast::Ident> {
 fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec<ast::Ident> {
     let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()};
     for arg in &fn_decl.inputs {
-        pat_idents.visit_pat(&*arg.pat);
+        pat_idents.visit_pat(&arg.pat);
     }
     pat_idents.ident_accumulator
 }
@@ -1078,7 +1078,7 @@ fn expand_and_rename_fn_decl_and_block(fn_decl: P<ast::FnDecl>, block: P<ast::Bl
                                        fld: &mut MacroExpander)
                                        -> (P<ast::FnDecl>, P<ast::Block>) {
     let expanded_decl = fld.fold_fn_decl(fn_decl);
-    let idents = fn_decl_arg_bindings(&*expanded_decl);
+    let idents = fn_decl_arg_bindings(&expanded_decl);
     let renames =
         idents.iter().map(|id| (*id,fresh_name(*id))).collect();
     // first, a renamer for the PatIdents, for the fn_decl:
@@ -1807,7 +1807,7 @@ foo_module!();
     fn pat_idents(){
         let pat = string_to_pat(
             "(a,Foo{x:c @ (b,9),y:Bar(4,d)})".to_string());
-        let idents = pattern_bindings(&*pat);
+        let idents = pattern_bindings(&pat);
         assert_eq!(idents, strs_to_idents(vec!("a","c","b","d")));
     }
 
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
@@ -289,7 +289,7 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
     };
 
     for lhs in &lhses {
-        check_lhs_nt_follows(cx, &**lhs, def.span);
+        check_lhs_nt_follows(cx, lhs, def.span);
     }
 
     let rhses = match **argument_map.get(&rhs_nm.name).unwrap() {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
@@ -673,7 +673,7 @@ pub fn noop_fold_interpolated<T: Folder>(nt: token::Nonterminal, fld: &mut T)
             token::NtIdent(Box::new(fld.fold_ident(*id)), is_mod_name),
         token::NtMeta(meta_item) => token::NtMeta(fld.fold_meta_item(meta_item)),
         token::NtPath(path) => token::NtPath(Box::new(fld.fold_path(*path))),
-        token::NtTT(tt) => token::NtTT(P(fld.fold_tt(&*tt))),
+        token::NtTT(tt) => token::NtTT(P(fld.fold_tt(&tt))),
         token::NtArm(arm) => token::NtArm(fld.fold_arm(arm)),
         token::NtImplItem(arm) =>
             token::NtImplItem(fld.fold_impl_item(arm)
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
@@ -53,7 +53,7 @@ pub fn stmt_ends_with_semi(stmt: &ast::Stmt_) -> bool {
                 ast::DeclItem(_) => false
             }
         }
-        ast::StmtExpr(ref e, _) => { expr_requires_semi_to_be_stmt(&**e) }
+        ast::StmtExpr(ref e, _) => { expr_requires_semi_to_be_stmt(e) }
         ast::StmtSemi(..) => { false }
         ast::StmtMac(..) => { false }
     }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
@@ -446,10 +446,10 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
         Some(suf) => {
             if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
                 // if it looks like a width, lets try to be helpful.
-                sd.span_err(sp, &*format!("invalid width `{}` for float literal", &suf[1..]));
+                sd.span_err(sp, &format!("invalid width `{}` for float literal", &suf[1..]));
                 sd.fileline_help(sp, "valid widths are 32 and 64");
             } else {
-                sd.span_err(sp, &*format!("invalid suffix `{}` for float literal", suf));
+                sd.span_err(sp, &format!("invalid suffix `{}` for float literal", suf));
                 sd.fileline_help(sp, "valid suffixes are `f32` and `f64`");
             }
 
@@ -619,11 +619,11 @@ pub fn integer_lit(s: &str,
                 // i<digits> and u<digits> look like widths, so lets
                 // give an error message along those lines
                 if looks_like_width_suffix(&['i', 'u'], suf) {
-                    sd.span_err(sp, &*format!("invalid width `{}` for integer literal",
-                                              &suf[1..]));
+                    sd.span_err(sp, &format!("invalid width `{}` for integer literal",
+                                             &suf[1..]));
                     sd.fileline_help(sp, "valid widths are 8, 16, 32 and 64");
                 } else {
-                    sd.span_err(sp, &*format!("invalid suffix `{}` for numeric literal", suf));
+                    sd.span_err(sp, &format!("invalid suffix `{}` for numeric literal", suf));
                     sd.fileline_help(sp, "the suffix must be one of the integral types \
                                       (`u32`, `isize`, etc)");
                 }
diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs
@@ -58,7 +58,7 @@ impl<T> SmallVector<T> {
         SmallVector { repr: Many(vs) }
     }
 
-    pub fn as_slice<'a>(&'a self) -> &'a [T] {
+    pub fn as_slice(&self) -> &[T] {
         match self.repr {
             Zero => {
                 let result: &[T] = &[];
@@ -105,7 +105,7 @@ impl<T> SmallVector<T> {
         }
     }
 
-    pub fn get<'a>(&'a self, idx: usize) -> &'a T {
+    pub fn get(&self, idx: usize) -> &T {
         match self.repr {
             One(ref v) if idx == 0 => v,
             Many(ref vs) => &vs[idx],

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ pub trait AttrMetaMethods {`
`67`	`67`	`/// containing a string, otherwise None.`
`68`	`68`	`fn value_str(&self) -> Option<InternedString>;`
`69`	`69`	`/// Gets a list of inner meta items from a list MetaItem type.`
`70`		`- fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]>;`
	`70`	`+ fn meta_item_list(&self) -> Option<&[P<MetaItem>]>;`
`71`	`71`
`72`	`72`	`fn span(&self) -> Span;`
`73`	`73`	`}`
`@@ -84,7 +84,7 @@ impl AttrMetaMethods for Attribute {`
`84`	`84`	`fn value_str(&self) -> Option<InternedString> {`
`85`	`85`	`self.meta().value_str()`
`86`	`86`	`}`
`87`		`- fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {`
	`87`	`+ fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {`
`88`	`88`	`self.node.value.meta_item_list()`
`89`	`89`	`}`
`90`	`90`	`fn span(&self) -> Span { self.meta().span }`
`@@ -111,7 +111,7 @@ impl AttrMetaMethods for MetaItem {`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`- fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {`
	`114`	`+ fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {`
`115`	`115`	`match self.node {`
`116`	`116`	`MetaList(_, ref l) => Some(&l[..]),`
`117`	`117`	`_ => None`
`@@ -124,22 +124,22 @@ impl AttrMetaMethods for MetaItem {`
`124`	`124`	`impl AttrMetaMethods for P<MetaItem> {`
`125`	`125`	`fn name(&self) -> InternedString { (**self).name() }`
`126`	`126`	`fn value_str(&self) -> Option<InternedString> { (**self).value_str() }`
`127`		`- fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {`
	`127`	`+ fn meta_item_list(&self) -> Option<&[P<MetaItem>]> {`
`128`	`128`	`(**self).meta_item_list()`
`129`	`129`	`}`
`130`	`130`	`fn span(&self) -> Span { (**self).span() }`
`131`	`131`	`}`
`132`	`132`
`133`	`133`
`134`	`134`	`pub trait AttributeMethods {`
`135`		`- fn meta<'a>(&'a self) -> &'a MetaItem;`
	`135`	`+ fn meta(&self) -> &MetaItem;`
`136`	`136`	`fn with_desugared_doc<T, F>(&self, f: F) -> T where`
`137`	`137`	`F: FnOnce(&Attribute) -> T;`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`impl AttributeMethods for Attribute {`
`141`	`141`	`/// Extract the MetaItem from inside this Attribute.`
`142`		`- fn meta<'a>(&'a self) -> &'a MetaItem {`
	`142`	`+ fn meta(&self) -> &MetaItem {`
`143`	`143`	`&*self.node.value`
`144`	`144`	`}`
`145`	`145`
Original file line number	Diff line number	Diff line change
`@@ -881,7 +881,7 @@ impl SyntaxEnv {`
`881`	`881`	`self.chain.pop();`
`882`	`882`	`}`
`883`	`883`
`884`		`- fn find_escape_frame<'a>(&'a mut self) -> &'a mut MapChainFrame {`
	`884`	`+ fn find_escape_frame(&mut self) -> &mut MapChainFrame {`
`885`	`885`	`for (i, frame) in self.chain.iter_mut().enumerate().rev() {`
`886`	`886`	`if !frame.info.macros_escape \|\| i == 0 {`
`887`	`887`	`return frame`
`@@ -904,7 +904,7 @@ impl SyntaxEnv {`
`904`	`904`	`self.find_escape_frame().map.insert(k, Rc::new(v));`
`905`	`905`	`}`
`906`	`906`
`907`		`- pub fn info<'a>(&'a mut self) -> &'a mut BlockInfo {`
	`907`	`+ pub fn info(&mut self) -> &mut BlockInfo {`
`908`	`908`	`let last_chain_index = self.chain.len() - 1;`
`909`	`909`	`&mut self.chain[last_chain_index].info`
`910`	`910`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ pub fn expand_cfg<'cx>(cx: &mut ExtCtxt,`
`33`	`33`	`return DummyResult::expr(sp);`
`34`	`34`	`}`
`35`	`35`
`36`		`- let matches_cfg = attr::cfg_matches(&cx.parse_sess.span_diagnostic, &cx.cfg, &*cfg,`
	`36`	`+ let matches_cfg = attr::cfg_matches(&cx.parse_sess.span_diagnostic, &cx.cfg, &cfg,`
`37`	`37`	`cx.feature_gated_cfgs);`
`38`	`38`	`MacEager::expr(cx.expr_bool(sp, matches_cfg))`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -289,7 +289,7 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,`
`289`	`289`	`};`
`290`	`290`
`291`	`291`	`for lhs in &lhses {`
`292`		`- check_lhs_nt_follows(cx, &**lhs, def.span);`
	`292`	`+ check_lhs_nt_follows(cx, lhs, def.span);`
`293`	`293`	`}`
`294`	`294`
`295`	`295`	`let rhses = match **argument_map.get(&rhs_nm.name).unwrap() {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ pub fn stmt_ends_with_semi(stmt: &ast::Stmt_) -> bool {`
`53`	`53`	`ast::DeclItem(_) => false`
`54`	`54`	`}`
`55`	`55`	`}`
`56`		`- ast::StmtExpr(ref e, _) => { expr_requires_semi_to_be_stmt(&**e) }`
	`56`	`+ ast::StmtExpr(ref e, _) => { expr_requires_semi_to_be_stmt(e) }`
`57`	`57`	`ast::StmtSemi(..) => { false }`
`58`	`58`	`ast::StmtMac(..) => { false }`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ impl<T> SmallVector<T> {`
`58`	`58`	`SmallVector { repr: Many(vs) }`
`59`	`59`	`}`
`60`	`60`
`61`		`- pub fn as_slice<'a>(&'a self) -> &'a [T] {`
	`61`	`+ pub fn as_slice(&self) -> &[T] {`
`62`	`62`	`match self.repr {`
`63`	`63`	`Zero => {`
`64`	`64`	`let result: &[T] = &[];`
`@@ -105,7 +105,7 @@ impl<T> SmallVector<T> {`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`- pub fn get<'a>(&'a self, idx: usize) -> &'a T {`
	`108`	`+ pub fn get(&self, idx: usize) -> &T {`
`109`	`109`	`match self.repr {`
`110`	`110`	`One(ref v) if idx == 0 => v,`
`111`	`111`	`Many(ref vs) => &vs[idx],`