move resolve_path to helpers module

src/fn_call.rs

@@ -1,11 +1,9 @@
 use rustc::ty;
 use rustc::ty::layout::{Align, LayoutOf, Size};
-use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc::hir::def_id::DefId;
 use rustc::mir;
 use syntax::attr;
 
-use std::mem;
-
 use super::*;
 
 pub trait EvalContextExt<'tcx, 'mir> {
@@ -19,8 +17,6 @@ pub trait EvalContextExt<'tcx, 'mir> {
         ret: mir::BasicBlock,
     ) -> EvalResult<'tcx>;
 
-    fn resolve_path(&self, path: &[&str]) -> EvalResult<'tcx, ty::Instance<'tcx>>;
-
     /// Emulate a function that should have MIR but does not.
     /// This is solely to support execution without full MIR.
     /// Fail if emulating this function is not supported.
@@ -638,40 +634,6 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for EvalContext<'a, '
         Ok(())
     }
 
-    /// Get an instance for a path.
-    fn resolve_path(&self, path: &[&str]) -> EvalResult<'tcx, ty::Instance<'tcx>> {
-        self.tcx
-            .crates()
-            .iter()
-            .find(|&&krate| self.tcx.original_crate_name(krate) == path[0])
-            .and_then(|krate| {
-                let krate = DefId {
-                    krate: *krate,
-                    index: CRATE_DEF_INDEX,
-                };
-                let mut items = self.tcx.item_children(krate);
-                let mut path_it = path.iter().skip(1).peekable();
-
-                while let Some(segment) = path_it.next() {
-                    for item in mem::replace(&mut items, Default::default()).iter() {
-                        if item.ident.name == *segment {
-                            if path_it.peek().is_none() {
-                                return Some(ty::Instance::mono(self.tcx.tcx, item.def.def_id()));
-                            }
-
-                            items = self.tcx.item_children(item.def.def_id());
-                            break;
-                        }
-                    }
-                }
-                None
-            })
-            .ok_or_else(|| {
-                let path = path.iter().map(|&s| s.to_owned()).collect();
-                EvalErrorKind::PathNotFound(path).into()
-            })
-    }
-
     fn emulate_missing_fn(
         &mut self,
         path: String,

src/helpers.rs

@@ -1,13 +1,18 @@
-use super::{Scalar, ScalarMaybeUndef, EvalResult};
+use std::mem;
 
-pub trait FalibleScalarExt {
+use rustc::ty;
+use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
+
+use super::*;
+
+pub trait ScalarExt {
     /// HACK: this function just extracts all bits if `defined != 0`
     /// Mainly used for args of C-functions and we should totally correctly fetch the size
     /// of their arguments
     fn to_bytes(self) -> EvalResult<'static, u128>;
 }
 
-impl FalibleScalarExt for Scalar {
+impl ScalarExt for Scalar {
     fn to_bytes(self) -> EvalResult<'static, u128> {
         match self {
             Scalar::Bits { bits, size } => {
@@ -19,8 +24,49 @@ impl FalibleScalarExt for Scalar {
     }
 }
 
-impl FalibleScalarExt for ScalarMaybeUndef {
+impl ScalarExt for ScalarMaybeUndef {
     fn to_bytes(self) -> EvalResult<'static, u128> {
         self.not_undef()?.to_bytes()
     }
 }
+
+pub trait EvalContextExt<'tcx> {
+    fn resolve_path(&self, path: &[&str]) -> EvalResult<'tcx, ty::Instance<'tcx>>;
+}
+
+
+impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super::Evaluator<'tcx>> {
+    /// Get an instance for a path.
+    fn resolve_path(&self, path: &[&str]) -> EvalResult<'tcx, ty::Instance<'tcx>> {
+        self.tcx
+            .crates()
+            .iter()
+            .find(|&&krate| self.tcx.original_crate_name(krate) == path[0])
+            .and_then(|krate| {
+                let krate = DefId {
+                    krate: *krate,
+                    index: CRATE_DEF_INDEX,
+                };
+                let mut items = self.tcx.item_children(krate);
+                let mut path_it = path.iter().skip(1).peekable();
+
+                while let Some(segment) = path_it.next() {
+                    for item in mem::replace(&mut items, Default::default()).iter() {
+                        if item.ident.name == *segment {
+                            if path_it.peek().is_none() {
+                                return Some(ty::Instance::mono(self.tcx.tcx, item.def.def_id()));
+                            }
+
+                            items = self.tcx.item_children(item.def.def_id());
+                            break;
+                        }
+                    }
+                }
+                None
+            })
+            .ok_or_else(|| {
+                let path = path.iter().map(|&s| s.to_owned()).collect();
+                EvalErrorKind::PathNotFound(path).into()
+            })
+    }
+}

src/intrinsic.rs

@@ -7,7 +7,7 @@ use rustc_mir::interpret::{EvalContext, PlaceTy, OpTy};
 
 use super::{
     Value, Scalar, ScalarMaybeUndef,
-    FalibleScalarExt, OperatorEvalContextExt
+    ScalarExt, OperatorEvalContextExt
 };
 
 pub trait EvalContextExt<'tcx> {

src/lib.rs

@@ -43,7 +43,8 @@ use operator::EvalContextExt as OperatorEvalContextExt;
 use intrinsic::EvalContextExt as IntrinsicEvalContextExt;
 use tls::{EvalContextExt as TlsEvalContextExt, TlsData};
 use range_map::RangeMap;
-use helpers::FalibleScalarExt;
+#[allow(unused_imports)] // FIXME rustc bug https://github.com/rust-lang/rust/issues/53682
+use helpers::{ScalarExt, EvalContextExt as HelpersEvalContextExt};
 use mono_hash_map::MonoHashMap;
 
 pub fn create_ecx<'a, 'mir: 'a, 'tcx: 'mir>(