From 186e42d088bb485c156cef93f2d27aa461523fad Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 19 Oct 2018 09:51:04 +0200
Subject: [PATCH] move resolve_path to helpers module

---
 src/fn_call.rs   | 40 +----------------------------------
 src/helpers.rs   | 54 ++++++++++++++++++++++++++++++++++++++++++++----
 src/intrinsic.rs |  2 +-
 src/lib.rs       |  3 ++-
 4 files changed, 54 insertions(+), 45 deletions(-)

diff --git a/src/fn_call.rs b/src/fn_call.rs
index 812df49b0b..ce5b17e7b5 100644
--- a/src/fn_call.rs
+++ b/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,
diff --git a/src/helpers.rs b/src/helpers.rs
index 27b2109d18..1c63316f60 100644
--- a/src/helpers.rs
+++ b/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()
+            })
+    }
+}
diff --git a/src/intrinsic.rs b/src/intrinsic.rs
index 19c4f04f48..9e209af98e 100644
--- a/src/intrinsic.rs
+++ b/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> {
diff --git a/src/lib.rs b/src/lib.rs
index 0bebe40d52..ec2bc4a69f 100644
--- a/src/lib.rs
+++ b/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>(