Autoderef in librustc_metadata

diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs
index cdbb6844703148d871bbba334ac99b231bff26e6..3a0bd3aa2059d35c3d7ad2b281c2de96eddd2aad 100644 (file)
--- a/src/librustc_metadata/astencode.rs
+++ b/src/librustc_metadata/astencode.rs
@@ -173,7 +173,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata,
         match *ii {
           InlinedItem::Item(ref i) => {
             debug!(">>> DECODED ITEM >>>\n{}\n<<< DECODED ITEM <<<",
-                   ::rustc_front::print::pprust::item_to_string(&**i));
+                   ::rustc_front::print::pprust::item_to_string(&i));
           }
           _ => { }
         }
@@ -1404,8 +1404,8 @@ fn new_int_alist<B>() -> alist<isize, B> {
     ).unwrap())));
     match (item_out, item_exp) {
       (InlinedItem::Item(item_out), InlinedItem::Item(item_exp)) => {
-        assert!(pprust::item_to_string(&*item_out) ==
-                pprust::item_to_string(&*item_exp));
+        assert!(pprust::item_to_string(&item_out) ==
+                pprust::item_to_string(&item_exp));
       }
       _ => panic!()
     }

diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs
index 52456251f962b18404d441c596589d1d31ae0a04..35d7a0d4b9c27640be03ffd9839eecd49a2af58f 100644 (file)
--- a/src/librustc_metadata/creader.rs
+++ b/src/librustc_metadata/creader.rs
@@ -264,7 +264,7 @@ fn verify_rustc_version(&self,
                          incompatible with this version of rustc",
                         name,
                         crate_rustc_version
-                            .as_ref().map(|s|&**s)
+                            .as_ref().map(|s| &**s)
                             .unwrap_or("an old version of rustc")
             );
         }
@@ -494,7 +494,7 @@ pub fn read_exported_macros(&mut self, item: &ast::Item) -> Vec<ast::MacroDef> {
         let source_name = format!("<{} macros>", item.ident);
         let mut macros = vec![];
         decoder::each_exported_macro(ekrate.metadata.as_slice(),
-                                     &*self.cstore.intr,
+                                     &self.cstore.intr,
             |name, attrs, span, body| {
                 // NB: Don't use parse::parse_tts_from_source_str because it parses with
                 // quote_depth > 0.

diff --git a/src/librustc_metadata/csearch.rs b/src/librustc_metadata/csearch.rs
index 5eade3bc0a54ed7c82152832cccac8bad11fb60f..9b534df075bef5dc5a1a751fb9680c23ff48642f 100644 (file)
--- a/src/librustc_metadata/csearch.rs
+++ b/src/librustc_metadata/csearch.rs
@@ -40,64 +40,64 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     fn stability(&self, def: DefId) -> Option<attr::Stability>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_stability(&*cdata, def.index)
+        decoder::get_stability(&cdata, def.index)
     }
 
     fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_deprecation(&*cdata, def.index)
+        decoder::get_deprecation(&cdata, def.index)
     }
 
     fn closure_kind(&self, _tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureKind
     {
         assert!(!def_id.is_local());
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::closure_kind(&*cdata, def_id.index)
+        decoder::closure_kind(&cdata, def_id.index)
     }
 
     fn closure_ty(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx>
     {
         assert!(!def_id.is_local());
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::closure_ty(&*cdata, def_id.index, tcx)
+        decoder::closure_ty(&cdata, def_id.index, tcx)
     }
 
     fn item_variances(&self, def: DefId) -> ty::ItemVariances {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_item_variances(&*cdata, def.index)
+        decoder::get_item_variances(&cdata, def.index)
     }
 
     fn repr_attrs(&self, def: DefId) -> Vec<attr::ReprAttr> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_repr_attrs(&*cdata, def.index)
+        decoder::get_repr_attrs(&cdata, def.index)
     }
 
     fn item_type(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                  -> ty::TypeScheme<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_type(&*cdata, def.index, tcx)
+        decoder::get_type(&cdata, def.index, tcx)
     }
 
     fn item_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                        -> ty::GenericPredicates<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_predicates(&*cdata, def.index, tcx)
+        decoder::get_predicates(&cdata, def.index, tcx)
     }
 
     fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                              -> ty::GenericPredicates<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_super_predicates(&*cdata, def.index, tcx)
+        decoder::get_super_predicates(&cdata, def.index, tcx)
     }
 
     fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>
     {
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::get_item_attrs(&*cdata, def_id.index)
+        decoder::get_item_attrs(&cdata, def_id.index)
     }
 
     fn item_symbol(&self, def: DefId) -> String
@@ -109,13 +109,13 @@ fn item_symbol(&self, def: DefId) -> String
     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_trait_def(&*cdata, def.index, tcx)
+        decoder::get_trait_def(&cdata, def.index, tcx)
     }
 
     fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_adt_def(&self.intr, &*cdata, def.index, tcx)
+        decoder::get_adt_def(&self.intr, &cdata, def.index, tcx)
     }
 
     fn method_arg_names(&self, did: DefId) -> Vec<String>
@@ -126,7 +126,7 @@ fn method_arg_names(&self, did: DefId) -> Vec<String>
 
     fn item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::get_item_path(&*cdata, def.index);
+        let path = decoder::get_item_path(&cdata, def.index);
 
         cdata.with_local_path(|cpath| {
             let mut r = Vec::with_capacity(cpath.len() + path.len());
@@ -138,7 +138,7 @@ fn item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
 
     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::get_item_path(&*cdata, def.index);
+        let path = decoder::get_item_path(&cdata, def.index);
 
         let mut r = Vec::with_capacity(path.len() + 1);
         let crate_name = hir_map::PathMod(token::intern(&cdata.name));
@@ -157,7 +157,7 @@ fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>
     {
         let mut result = vec![];
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::each_inherent_implementation_for_type(&*cdata, def_id.index,
+        decoder::each_inherent_implementation_for_type(&cdata, def_id.index,
                                                        |iid| result.push(iid));
         result
     }
@@ -177,53 +177,53 @@ fn provided_trait_methods(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                               -> Vec<Rc<ty::Method<'tcx>>>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_provided_trait_methods(self.intr.clone(), &*cdata, def.index, tcx)
+        decoder::get_provided_trait_methods(self.intr.clone(), &cdata, def.index, tcx)
     }
 
     fn trait_item_def_ids(&self, def: DefId)
                           -> Vec<ty::ImplOrTraitItemId>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_trait_item_def_ids(&*cdata, def.index)
+        decoder::get_trait_item_def_ids(&cdata, def.index)
     }
 
     fn impl_items(&self, impl_def_id: DefId) -> Vec<ty::ImplOrTraitItemId>
     {
         let cdata = self.get_crate_data(impl_def_id.krate);
-        decoder::get_impl_items(&*cdata, impl_def_id.index)
+        decoder::get_impl_items(&cdata, impl_def_id.index)
     }
 
     fn impl_polarity(&self, def: DefId) -> Option<hir::ImplPolarity>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_impl_polarity(&*cdata, def.index)
+        decoder::get_impl_polarity(&cdata, def.index)
     }
 
     fn impl_trait_ref(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                       -> Option<ty::TraitRef<'tcx>>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_impl_trait(&*cdata, def.index, tcx)
+        decoder::get_impl_trait(&cdata, def.index, tcx)
     }
 
     fn custom_coerce_unsized_kind(&self, def: DefId)
                                   -> Option<ty::adjustment::CustomCoerceUnsized>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_custom_coerce_unsized_kind(&*cdata, def.index)
+        decoder::get_custom_coerce_unsized_kind(&cdata, def.index)
     }
 
     // FIXME: killme
     fn associated_consts(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                          -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_associated_consts(self.intr.clone(), &*cdata, def.index, tcx)
+        decoder::get_associated_consts(self.intr.clone(), &cdata, def.index, tcx)
     }
 
     fn trait_of_item(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> Option<DefId>
     {
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::get_trait_of_item(&*cdata, def_id.index, tcx)
+        decoder::get_trait_of_item(&cdata, def_id.index, tcx)
     }
 
     fn impl_or_trait_item(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
@@ -232,7 +232,7 @@ fn impl_or_trait_item(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
         let cdata = self.get_crate_data(def.krate);
         decoder::get_impl_or_trait_item(
             self.intr.clone(),
-            &*cdata,
+            &cdata,
             def.index,
             tcx)
     }
@@ -246,29 +246,29 @@ fn is_const_fn(&self, did: DefId) -> bool
     fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool
     {
         let cdata = self.get_crate_data(trait_def_id.krate);
-        decoder::is_defaulted_trait(&*cdata, trait_def_id.index)
+        decoder::is_defaulted_trait(&cdata, trait_def_id.index)
     }
 
     fn is_impl(&self, did: DefId) -> bool
     {
         let cdata = self.get_crate_data(did.krate);
-        decoder::is_impl(&*cdata, did.index)
+        decoder::is_impl(&cdata, did.index)
     }
 
     fn is_default_impl(&self, impl_did: DefId) -> bool {
         let cdata = self.get_crate_data(impl_did.krate);
-        decoder::is_default_impl(&*cdata, impl_did.index)
+        decoder::is_default_impl(&cdata, impl_did.index)
     }
 
     fn is_extern_item(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool {
         let cdata = self.get_crate_data(did.krate);
-        decoder::is_extern_item(&*cdata, did.index, tcx)
+        decoder::is_extern_item(&cdata, did.index, tcx)
     }
 
     fn is_static_method(&self, def: DefId) -> bool
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::is_static_method(&*cdata, def.index)
+        decoder::is_static_method(&cdata, def.index)
     }
 
     fn is_statically_included_foreign_item(&self, id: ast::NodeId) -> bool
@@ -278,7 +278,7 @@ fn is_statically_included_foreign_item(&self, id: ast::NodeId) -> bool
 
     fn is_typedef(&self, did: DefId) -> bool {
         let cdata = self.get_crate_data(did.krate);
-        decoder::is_typedef(&*cdata, did.index)
+        decoder::is_typedef(&cdata, did.index)
     }
 
     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
@@ -292,7 +292,7 @@ fn lang_items(&self, cnum: ast::CrateNum) -> Vec<(DefIndex, usize)>
     {
         let mut result = vec![];
         let crate_data = self.get_crate_data(cnum);
-        decoder::each_lang_item(&*crate_data, |did, lid| {
+        decoder::each_lang_item(&crate_data, |did, lid| {
             result.push((did, lid)); true
         });
         result
@@ -302,7 +302,7 @@ fn missing_lang_items(&self, cnum: ast::CrateNum)
                           -> Vec<lang_items::LangItem>
     {
         let cdata = self.get_crate_data(cnum);
-        decoder::get_missing_lang_items(&*cdata)
+        decoder::get_missing_lang_items(&cdata)
     }
 
     fn is_staged_api(&self, cnum: ast::CrateNum) -> bool
@@ -339,7 +339,7 @@ fn crate_hash(&self, cnum: ast::CrateNum) -> Svh
     fn crate_struct_field_attrs(&self, cnum: ast::CrateNum)
                                 -> FnvHashMap<DefId, Vec<ast::Attribute>>
     {
-        decoder::get_struct_field_attrs(&*self.get_crate_data(cnum))
+        decoder::get_struct_field_attrs(&self.get_crate_data(cnum))
     }
 
     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
@@ -354,19 +354,19 @@ fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
     fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>
     {
         let cdata = self.get_crate_data(cnum);
-        decoder::get_native_libraries(&*cdata)
+        decoder::get_native_libraries(&cdata)
     }
 
     fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec<DefId>
     {
         let cdata = self.get_crate_data(cnum);
-        decoder::get_reachable_ids(&*cdata)
+        decoder::get_reachable_ids(&cdata)
     }
 
     fn def_path(&self, def: DefId) -> hir_map::DefPath
     {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::def_path(&*cdata, def.index);
+        let path = decoder::def_path(&cdata, def.index);
         let local_path = cdata.local_def_path();
         local_path.into_iter().chain(path).collect()
     }
@@ -385,13 +385,13 @@ fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
     fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
     {
         let cdata = self.get_crate_data(did.krate);
-        decoder::get_tuple_struct_definition_if_ctor(&*cdata, did.index)
+        decoder::get_tuple_struct_definition_if_ctor(&cdata, did.index)
     }
 
     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_struct_field_names(&self.intr, &*cdata, def.index)
+        decoder::get_struct_field_names(&self.intr, &cdata, def.index)
     }
 
     fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
@@ -400,7 +400,7 @@ fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
         let crate_data = self.get_crate_data(def_id.krate);
         let get_crate_data = |cnum| self.get_crate_data(cnum);
         decoder::each_child_of_item(
-            self.intr.clone(), &*crate_data,
+            self.intr.clone(), &crate_data,
             def_id.index, get_crate_data,
             |def, name, vis| result.push(ChildItem {
                 def: def,
@@ -416,7 +416,7 @@ fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec<ChildItem>
         let crate_data = self.get_crate_data(cnum);
         let get_crate_data = |cnum| self.get_crate_data(cnum);
         decoder::each_top_level_item_of_crate(
-            self.intr.clone(), &*crate_data, get_crate_data,
+            self.intr.clone(), &crate_data, get_crate_data,
             |def, name, vis| result.push(ChildItem {
                 def: def,
                 name: name,
@@ -430,18 +430,18 @@ fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId)
     {
         let cdata = self.get_crate_data(def.krate);
         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
-        decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
+        decoder::maybe_get_item_ast(&cdata, tcx, def.index, decode_inlined_item)
     }
 
     fn maybe_get_item_mir(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                           -> Option<Mir<'tcx>> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::maybe_get_item_mir(&*cdata, tcx, def.index)
+        decoder::maybe_get_item_mir(&cdata, tcx, def.index)
     }
 
     fn is_item_mir_available(&self, def: DefId) -> bool {
         let cdata = self.get_crate_data(def.krate);
-        decoder::is_item_mir_available(&*cdata, def.index)
+        decoder::is_item_mir_available(&cdata, def.index)
     }
 
     fn crates(&self) -> Vec<ast::CrateNum>

diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs
index b0eef29467ba21b4db5faade747da69189d898bd..a96da6bf4d66aaf85025f0dd98ff15d6f9775c6c 100644 (file)
--- a/src/librustc_metadata/cstore.rs
+++ b/src/librustc_metadata/cstore.rs
@@ -138,7 +138,7 @@ pub fn iter_crate_data_origins<I>(&self, mut i: I) where
         for (&k, v) in self.metas.borrow().iter() {
             let origin = self.opt_used_crate_source(k);
             origin.as_ref().map(|cs| { assert!(k == cs.cnum); });
-            i(k, &**v, origin);
+            i(k, &v, origin);
         }
     }
 

diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
index 8409a0c74b869eb05ea34623345b0feaa498f44e..8295ffebda3e6508b62bcd20a509064abb2a0871 100644 (file)
--- a/src/librustc_metadata/decoder.rs
+++ b/src/librustc_metadata/decoder.rs
@@ -655,7 +655,7 @@ fn each_child_of_item_or_crate<F, G>(intr: Rc<IdentInterner>,
             None => {}
             Some(child_item_doc) => {
                 // Hand off the item to the callback.
-                let child_name = item_name(&*intr, child_item_doc);
+                let child_name = item_name(&intr, child_item_doc);
                 let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id);
                 let visibility = item_visibility(child_item_doc);
                 callback(def_like, child_name, visibility);
@@ -677,7 +677,7 @@ fn each_child_of_item_or_crate<F, G>(intr: Rc<IdentInterner>,
                 if let Some(impl_method_doc) = cdata.get_item(impl_item_def_id.index) {
                     if let StaticMethod = item_family(impl_method_doc) {
                         // Hand off the static method to the callback.
-                        let static_method_name = item_name(&*intr, impl_method_doc);
+                        let static_method_name = item_name(&intr, impl_method_doc);
                         let static_method_def_like = item_to_def_like(cdata, impl_method_doc,
                                                                       impl_item_def_id);
                         callback(static_method_def_like,
@@ -938,7 +938,7 @@ pub fn get_trait_name(intr: Rc<IdentInterner>,
                       id: DefIndex)
                       -> ast::Name {
     let doc = cdata.lookup_item(id);
-    item_name(&*intr, doc)
+    item_name(&intr, doc)
 }
 
 pub fn is_static_method(cdata: Cmd, id: DefIndex) -> bool {
@@ -967,7 +967,7 @@ pub fn get_impl_or_trait_item<'tcx>(intr: Rc<IdentInterner>,
         _ => ImplContainer(container_id),
     };
 
-    let name = item_name(&*intr, item_doc);
+    let name = item_name(&intr, item_doc);
     let vis = item_visibility(item_doc);
 
     match item_sort(item_doc) {
@@ -1622,7 +1622,7 @@ fn doc_generics<'tcx>(base_doc: rbml::Doc,
     for rp_doc in reader::tagged_docs(doc, tag_region_param_def) {
         let ident_str_doc = reader::get_doc(rp_doc,
                                             tag_region_param_def_ident);
-        let name = item_name(&*token::get_ident_interner(), ident_str_doc);
+        let name = item_name(&token::get_ident_interner(), ident_str_doc);
         let def_id_doc = reader::get_doc(rp_doc,
                                          tag_region_param_def_def_id);
         let def_id = translated_def_id(cdata, def_id_doc);

diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 6375f82b2c5ed878c745c8c808f8c7657d01b064..207a680a13d80a5b48618acd1b48a704a169e1a8 100644 (file)
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -964,7 +964,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
         encode_visibility(rbml_w, vis);
         encode_stability(rbml_w, stab);
         encode_deprecation(rbml_w, depr);
-        encode_method_argument_names(rbml_w, &**decl);
+        encode_method_argument_names(rbml_w, &decl);
         rbml_w.end_tag();
       }
       hir::ItemMod(ref m) => {
@@ -1173,7 +1173,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
                     encode_info_for_associated_const(ecx,
                                                      rbml_w,
                                                      index,
-                                                     &*associated_const,
+                                                     &associated_const,
                                                      path.clone(),
                                                      item.id,
                                                      ast_item)
@@ -1182,7 +1182,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
                     encode_info_for_method(ecx,
                                            rbml_w,
                                            index,
-                                           &**method_type,
+                                           &method_type,
                                            path.clone(),
                                            false,
                                            item.id,
@@ -1192,7 +1192,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
                     encode_info_for_associated_type(ecx,
                                                     rbml_w,
                                                     index,
-                                                    &**associated_type,
+                                                    &associated_type,
                                                     path.clone(),
                                                     item.id,
                                                     ast_item)
@@ -1290,7 +1290,7 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
                 ty::MethodTraitItem(method_ty) => {
                     let method_def_id = item_def_id.def_id();
 
-                    encode_method_ty_fields(ecx, rbml_w, index, &*method_ty);
+                    encode_method_ty_fields(ecx, rbml_w, index, &method_ty);
 
                     let elem = ast_map::PathName(method_ty.name);
                     encode_path(rbml_w,
@@ -1396,13 +1396,13 @@ fn encode_info_for_foreign_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
         if abi == Abi::RustIntrinsic || abi == Abi::PlatformIntrinsic {
             encode_inlined_item(ecx, rbml_w, InlinedItemRef::Foreign(nitem));
         }
-        encode_attributes(rbml_w, &*nitem.attrs);
+        encode_attributes(rbml_w, &nitem.attrs);
         let stab = stability::lookup_stability(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id));
         let depr = stability::lookup_deprecation(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id));
         encode_stability(rbml_w, stab);
         encode_deprecation(rbml_w, depr);
         encode_symbol(ecx, rbml_w, nitem.id);
-        encode_method_argument_names(rbml_w, &*fndecl);
+        encode_method_argument_names(rbml_w, &fndecl);
       }
       hir::ForeignItemStatic(_, mutbl) => {
         if mutbl {
@@ -1411,7 +1411,7 @@ fn encode_info_for_foreign_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
             encode_family(rbml_w, 'c');
         }
         encode_bounds_and_type_for_item(rbml_w, ecx, index, nitem.id);
-        encode_attributes(rbml_w, &*nitem.attrs);
+        encode_attributes(rbml_w, &nitem.attrs);
         let stab = stability::lookup_stability(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id));
         let depr = stability::lookup_deprecation(ecx.tcx, ecx.tcx.map.local_def_id(nitem.id));
         encode_stability(rbml_w, stab);
@@ -1561,7 +1561,7 @@ fn encode_meta_item(rbml_w: &mut Encoder, mi: &ast::MetaItem) {
         rbml_w.start_tag(tag_meta_item_list);
         rbml_w.wr_tagged_str(tag_meta_item_name, name);
         for inner_item in items {
-            encode_meta_item(rbml_w, &**inner_item);
+            encode_meta_item(rbml_w, &inner_item);
         }
         rbml_w.end_tag();
       }
@@ -1573,7 +1573,7 @@ fn encode_attributes(rbml_w: &mut Encoder, attrs: &[ast::Attribute]) {
     for attr in attrs {
         rbml_w.start_tag(tag_attribute);
         rbml_w.wr_tagged_u8(tag_attribute_is_sugared_doc, attr.node.is_sugared_doc as u8);
-        encode_meta_item(rbml_w, &*attr.node.value);
+        encode_meta_item(rbml_w, &attr.node.value);
         rbml_w.end_tag();
     }
     rbml_w.end_tag();