rustc_back: remove slice module in favor of std::slice::from_ref.

Author: irinagpopa

src/Cargo.lock

@@ -46,6 +46,7 @@
 #![feature(const_fn)]
 #![feature(core_intrinsics)]
 #![feature(drain_filter)]
+#![feature(from_ref)]
 #![feature(i128)]
 #![feature(i128_type)]
 #![feature(inclusive_range)]

src/librustc/lib.rs

@@ -26,7 +26,7 @@
 
 use self::TargetLint::*;
 
-use rustc_back::slice;
+use std::slice;
 use lint::{EarlyLintPassObject, LateLintPassObject};
 use lint::{Level, Lint, LintId, LintPass, LintBuffer};
 use lint::levels::{LintLevelSets, LintLevelsBuilder};
@@ -308,7 +308,7 @@ impl LintStore {
                     Some(ids) => CheckLintNameResult::Ok(&ids.0),
                 }
             }
-            Some(&Id(ref id)) => CheckLintNameResult::Ok(slice::ref_slice(id)),
+            Some(&Id(ref id)) => CheckLintNameResult::Ok(slice::from_ref(id)),
         }
     }
 }

src/librustc/lint/context.rs

@@ -31,7 +31,7 @@ use syntax_pos::Span;
 use errors::DiagnosticBuilder;
 use util::common::ErrorReported;
 use util::nodemap::{NodeMap, NodeSet, FxHashSet, FxHashMap, DefIdMap};
-use rustc_back::slice;
+use std::slice;
 
 use hir;
 use hir::intravisit::{self, Visitor, NestedVisitorMap};
@@ -530,7 +530,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
 
     fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) {
         if lifetime_ref.is_elided() {
-            self.resolve_elided_lifetimes(slice::ref_slice(lifetime_ref));
+            self.resolve_elided_lifetimes(slice::from_ref(lifetime_ref));
             return;
         }
         if lifetime_ref.is_static() {

src/librustc/middle/resolve_lifetime.rs

@@ -25,7 +25,7 @@ use ty::subst::{Subst, Substs};
 use ty::{self, AdtDef, ClosureSubsts, Region, Ty, TyCtxt, GeneratorInterior};
 use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use util::ppaux;
-use rustc_back::slice;
+use std::slice;
 use hir::{self, InlineAsm};
 use std::ascii;
 use std::borrow::{Cow};
@@ -754,28 +754,28 @@ impl<'tcx> TerminatorKind<'tcx> {
     pub fn successors(&self) -> Cow<[BasicBlock]> {
         use self::TerminatorKind::*;
         match *self {
-            Goto { target: ref b } => slice::ref_slice(b).into_cow(),
+            Goto { target: ref b } => slice::from_ref(b).into_cow(),
             SwitchInt { targets: ref b, .. } => b[..].into_cow(),
             Resume | GeneratorDrop => (&[]).into_cow(),
             Return => (&[]).into_cow(),
             Unreachable => (&[]).into_cow(),
             Call { destination: Some((_, t)), cleanup: Some(c), .. } => vec![t, c].into_cow(),
             Call { destination: Some((_, ref t)), cleanup: None, .. } =>
-                slice::ref_slice(t).into_cow(),
-            Call { destination: None, cleanup: Some(ref c), .. } => slice::ref_slice(c).into_cow(),
+                slice::from_ref(t).into_cow(),
+            Call { destination: None, cleanup: Some(ref c), .. } => slice::from_ref(c).into_cow(),
             Call { destination: None, cleanup: None, .. } => (&[]).into_cow(),
             Yield { resume: t, drop: Some(c), .. } => vec![t, c].into_cow(),
-            Yield { resume: ref t, drop: None, .. } => slice::ref_slice(t).into_cow(),
+            Yield { resume: ref t, drop: None, .. } => slice::from_ref(t).into_cow(),
             DropAndReplace { target, unwind: Some(unwind), .. } |
             Drop { target, unwind: Some(unwind), .. } => {
                 vec![target, unwind].into_cow()
             }
             DropAndReplace { ref target, unwind: None, .. } |
             Drop { ref target, unwind: None, .. } => {
-                slice::ref_slice(target).into_cow()
+                slice::from_ref(target).into_cow()
             }
             Assert { target, cleanup: Some(unwind), .. } => vec![target, unwind].into_cow(),
-            Assert { ref target, .. } => slice::ref_slice(target).into_cow(),
+            Assert { ref target, .. } => slice::from_ref(target).into_cow(),
             FalseEdges { ref real_target, ref imaginary_targets } => {
                 let mut s = vec![*real_target];
                 s.extend_from_slice(imaginary_targets);

src/librustc/mir/mod.rs

@@ -40,7 +40,6 @@ extern crate serialize as rustc_serialize; // used by deriving
 
 pub mod tempdir;
 pub mod target;
-pub mod slice;
 pub mod dynamic_lib;
 
 use std::str::FromStr;

src/librustc_back/lib.rs

@@ -15,6 +15,5 @@ syntax = { path = "../libsyntax" }
 syntax_pos = { path = "../libsyntax_pos" }
 graphviz = { path = "../libgraphviz" }
 rustc = { path = "../librustc" }
-rustc_back = { path = "../librustc_back" }
 rustc_mir = { path = "../librustc_mir" }
 rustc_errors = { path = "../librustc_errors" }

src/librustc_back/slice.rs

@@ -13,7 +13,7 @@ use rustc::hir::{self, HirId};
 use rustc::lint::builtin::UNUSED_MUT;
 use rustc::ty;
 use rustc::util::nodemap::{FxHashMap, FxHashSet};
-use rustc_back::slice;
+use std::slice;
 use syntax::ptr::P;
 
 use borrowck::BorrowckCtxt;
@@ -26,7 +26,7 @@ pub fn check<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, body: &'tcx hir::Body) {
     }.visit_expr(&body.value);
     let mut cx = UnusedMutCx { bccx, used_mut };
     for arg in body.arguments.iter() {
-        cx.check_unused_mut_pat(slice::ref_slice(&arg.pat));
+        cx.check_unused_mut_pat(slice::from_ref(&arg.pat));
     }
     cx.visit_expr(&body.value);
 }
@@ -101,7 +101,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnusedMutCx<'a, 'tcx> {
     }
 
     fn visit_local(&mut self, local: &hir::Local) {
-        self.check_unused_mut_pat(slice::ref_slice(&local.pat));
+        self.check_unused_mut_pat(slice::from_ref(&local.pat));
     }
 }
 

src/librustc_borrowck/Cargo.toml

@@ -15,14 +15,14 @@
 
 #![allow(non_camel_case_types)]
 
+#![feature(from_ref)]
 #![feature(match_default_bindings)]
 #![feature(quote)]
 
 #[macro_use] extern crate log;
 extern crate syntax;
 extern crate syntax_pos;
 extern crate rustc_errors as errors;
-extern crate rustc_back;
 
 // for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
 // refers to the borrowck-specific graphviz adapter traits.