Remove old import

palaviv · palaviv · commit 019388b7c72d · 2019-07-03T19:06:36.000+03:00
diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -2,13 +2,10 @@
  * Import mechanics
  */
 
-use std::path::PathBuf;
-
 use crate::bytecode::CodeObject;
 use crate::frame::Scope;
-use crate::obj::{objcode, objsequence, objstr};
+use crate::obj::objcode;
 use crate::pyobject::{ItemProtocol, PyResult, PyValue};
-use crate::util;
 use crate::vm::VirtualMachine;
 #[cfg(feature = "rustpython-compiler")]
 use rustpython_compiler::compile;
@@ -46,39 +43,6 @@ pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
         })
 }
 
-pub fn import_module(vm: &VirtualMachine, current_path: PathBuf, module_name: &str) -> PyResult {
-    // Cached modules:
-    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap();
-
-    // First, see if we already loaded the module:
-    if let Ok(module) = sys_modules.get_item(module_name.to_string(), vm) {
-        Ok(module)
-    } else if vm.frozen.borrow().contains_key(module_name) {
-        import_frozen(vm, module_name)
-    } else if vm.stdlib_inits.borrow().contains_key(module_name) {
-        import_builtin(vm, module_name)
-    } else if cfg!(feature = "rustpython-compiler") {
-        let notfound_error = &vm.ctx.exceptions.module_not_found_error;
-        let import_error = &vm.ctx.exceptions.import_error;
-
-        // Time to search for module in any place:
-        let file_path = find_source(vm, current_path, module_name)
-            .map_err(|e| vm.new_exception(notfound_error.clone(), e))?;
-        let source = util::read_file(file_path.as_path())
-            .map_err(|e| vm.new_exception(import_error.clone(), e.to_string()))?;
-
-        import_file(
-            vm,
-            module_name,
-            file_path.to_str().unwrap().to_string(),
-            source,
-        )
-    } else {
-        let notfound_error = &vm.ctx.exceptions.module_not_found_error;
-        Err(vm.new_exception(notfound_error.clone(), module_name.to_string()))
-    }
-}
-
 #[cfg(feature = "rustpython-compiler")]
 pub fn import_file(
     vm: &VirtualMachine,
@@ -115,29 +79,3 @@ pub fn import_codeobj(
     )?;
     Ok(module)
 }
-
-fn find_source(vm: &VirtualMachine, current_path: PathBuf, name: &str) -> Result<PathBuf, String> {
-    let sys_path = vm.get_attribute(vm.sys_module.clone(), "path").unwrap();
-    let mut paths: Vec<PathBuf> = objsequence::get_elements_list(&sys_path)
-        .iter()
-        .map(|item| PathBuf::from(objstr::get_value(item)))
-        .collect();
-
-    paths.insert(0, current_path);
-
-    let rel_name = name.replace('.', "/");
-    let suffixes = [".py", "/__init__.py"];
-    let mut file_paths = vec![];
-    for path in paths {
-        for suffix in suffixes.iter() {
-            let mut file_path = path.clone();
-            file_path.push(format!("{}{}", rel_name, suffix));
-            file_paths.push(file_path);
-        }
-    }
-
-    match file_paths.iter().find(|p| p.exists()) {
-        Some(path) => Ok(path.to_path_buf()),
-        None => Err(format!("No module named '{}'", name)),
-    }
-}
diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs
@@ -6,14 +6,11 @@ use std::io::prelude::*;
 use std::io::Cursor;
 use std::io::SeekFrom;
 
-use std::path::PathBuf;
-
 use num_bigint::ToBigInt;
 use num_traits::ToPrimitive;
 
 use super::os;
 use crate::function::{OptionalArg, PyFuncArgs};
-use crate::import;
 use crate::obj::objbytearray::PyByteArray;
 use crate::obj::objbytes;
 use crate::obj::objbytes::PyBytes;
@@ -532,7 +529,7 @@ pub fn io_open(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
         }
     };
 
-    let io_module = import::import_module(vm, PathBuf::default(), "io").unwrap();
+    let io_module = vm.import("_io", &vm.ctx.new_tuple(vec![]), 0)?;
 
     // Construct a FileIO (subclass of RawIOBase)
     // This is subsequently consumed by a Buffered Class.
diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs
@@ -2,10 +2,8 @@
 /// support threading
 use super::super::pyobject::PyObjectRef;
 use crate::function::PyFuncArgs;
-use crate::import;
 use crate::pyobject::PyResult;
 use crate::vm::VirtualMachine;
-use std::path::PathBuf;
 
 fn rlock_acquire(vm: &VirtualMachine, _args: PyFuncArgs) -> PyResult {
     Ok(vm.get_none())
@@ -38,7 +36,7 @@ fn get_ident(_vm: &VirtualMachine) -> u32 {
 }
 
 fn allocate_lock(vm: &VirtualMachine) -> PyResult {
-    let module = import::import_module(vm, PathBuf::default(), "_thread")?;
+    let module = vm.import("_thread", &vm.ctx.new_tuple(vec![]), 0)?;
     let lock_class = vm.get_attribute(module.clone(), "RLock")?;
     vm.invoke(lock_class, vec![])
 }
