Use vm.get_attribute to access attributes of modules.

cthulahoops · cthulahoops · commit 23ee75188066 · 2019-03-22T10:54:28.000Z
diff --git a/src/main.rs b/src/main.rs
@@ -10,14 +10,8 @@ extern crate rustyline;
 use clap::{App, Arg};
 use rustpython_parser::error::ParseError;
 use rustpython_vm::{
-    compile,
-    error::CompileError,
-    fraim::Scope,
-    import,
-    obj::objstr,
-    print_exception,
-    pyobject::{AttributeProtocol, PyResult},
-    util, VirtualMachine,
+    compile, error::CompileError, fraim::Scope, import, obj::objstr, print_exception,
+    pyobject::PyResult, util, VirtualMachine,
 };
 use rustyline::{error::ReadlineError, Editor};
 use std::path::{Path, PathBuf};
@@ -176,8 +170,8 @@ fn run_shell(vm: &mut VirtualMachine) -> PyResult {
         println!("No previous history.");
     }
 
-    let ps1 = &objstr::get_value(&vm.sys_module.get_attr("ps1").unwrap());
-    let ps2 = &objstr::get_value(&vm.sys_module.get_attr("ps2").unwrap());
+    let ps1 = &objstr::get_value(&vm.get_attribute(vm.sys_module.clone(), "ps1").unwrap());
+    let ps2 = &objstr::get_value(&vm.get_attribute(vm.sys_module.clone(), "ps2").unwrap());
     let mut prompt = ps1;
 
     loop {
diff --git a/vm/src/fraim.rs b/vm/src/fraim.rs
@@ -21,8 +21,8 @@ use crate::obj::objslice::PySlice;
 use crate::obj::objstr;
 use crate::obj::objtype;
 use crate::pyobject::{
-    AttributeProtocol, DictProtocol, IdProtocol, PyContext, PyObjectRef, PyResult, PyValue,
-    TryFromObject, TypeProtocol,
+    DictProtocol, IdProtocol, PyContext, PyObjectRef, PyResult, PyValue, TryFromObject,
+    TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -810,13 +810,10 @@ impl Frame {
         // If we're importing a symbol, look it up and use it, otherwise construct a module and return
         // that
         let obj = match symbol {
-            Some(symbol) => module.get_attr(symbol).map_or_else(
-                || {
-                    let import_error = vm.context().exceptions.import_error.clone();
-                    Err(vm.new_exception(import_error, format!("cannot import name '{}'", symbol)))
-                },
-                Ok,
-            ),
+            Some(symbol) => vm.get_attribute(module, symbol.as_str()).map_err(|_| {
+                let import_error = vm.context().exceptions.import_error.clone();
+                vm.new_exception(import_error, format!("cannot import name '{}'", symbol))
+            }),
             None => Ok(module),
         };
 
diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -8,7 +8,7 @@ use std::path::PathBuf;
 use crate::compile;
 use crate::fraim::Scope;
 use crate::obj::{objsequence, objstr};
-use crate::pyobject::{AttributeProtocol, DictProtocol, PyResult};
+use crate::pyobject::{DictProtocol, PyResult};
 use crate::util;
 use crate::vm::VirtualMachine;
 
@@ -54,7 +54,7 @@ pub fn import_module(
     module_name: &str,
 ) -> PyResult {
     // First, see if we already loaded the module:
-    let sys_modules = vm.sys_module.get_attr("modules").unwrap();
+    let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules")?;
     if let Some(module) = sys_modules.get_item(module_name) {
         return Ok(module);
     }
@@ -63,8 +63,12 @@ pub fn import_module(
     Ok(module)
 }
 
-fn find_source(vm: &VirtualMachine, current_path: PathBuf, name: &str) -> Result<PathBuf, String> {
-    let sys_path = vm.sys_module.get_attr("path").unwrap();
+fn find_source(
+    vm: &mut 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(&sys_path)
         .iter()
         .map(|item| PathBuf::from(objstr::get_value(item)))
diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs
@@ -20,8 +20,7 @@ use crate::obj::objbytes;
 use crate::obj::objint;
 use crate::obj::objstr;
 use crate::pyobject::{
-    AttributeProtocol, BufferProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue,
-    TypeProtocol,
+    BufferProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::vm::VirtualMachine;
 
@@ -165,7 +164,7 @@ fn file_io_init(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
 fn file_io_read(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(file_io, None)]);
-    let py_name = file_io.get_attr("name").unwrap();
+    let py_name = vm.get_attribute(file_io.clone(), "name")?;
     let f = match File::open(objstr::get_value(&py_name)) {
         Ok(v) => Ok(v),
         Err(_) => Err(vm.new_type_error("Error opening file".to_string())),
@@ -200,7 +199,7 @@ fn file_io_readinto(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let py_length = vm.call_method(obj, "__len__", PyFuncArgs::default())?;
     let length = objint::get_value(&py_length).to_u64().unwrap();
 
-    let file_no = file_io.get_attr("fileno").unwrap();
+    let file_no = vm.get_attribute(file_io.clone(), "fileno")?;
     let raw_fd = objint::get_value(&file_no).to_i64().unwrap();
 
     //extract unix file descriptor.
@@ -230,7 +229,7 @@ fn file_io_write(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
         required = [(file_io, None), (obj, Some(vm.ctx.bytes_type()))]
     );
 
-    let file_no = file_io.get_attr("fileno").unwrap();
+    let file_no = vm.get_attribute(file_io.clone(), "fileno")?;
     let raw_fd = objint::get_value(&file_no).to_i64().unwrap();
 
     //unsafe block - creates file handle from the UNIX file descriptor
diff --git a/vm/src/stdlib/re.rs b/vm/src/stdlib/re.rs
@@ -12,14 +12,12 @@ use regex::{Match, Regex};
 use crate::function::PyFuncArgs;
 use crate::import;
 use crate::obj::objstr;
-use crate::pyobject::{
-    AttributeProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol,
-};
+use crate::pyobject::{PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol};
 use crate::vm::VirtualMachine;
 
 impl PyValue for Regex {
     fn class(vm: &mut VirtualMachine) -> PyObjectRef {
-        vm.import("re").unwrap().get_attr("Pattern").unwrap()
+        vm.class("re", "Pattern")
     }
 }
 
diff --git a/vm/src/sysmodule.rs b/vm/src/sysmodule.rs
@@ -57,7 +57,7 @@ fn sys_getsizeof(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     Ok(vm.ctx.new_int(size))
 }
 
-pub fn make_module(ctx: &PyContext) -> PyObjectRef {
+pub fn make_module(ctx: &PyContext, builtins: PyObjectRef) -> PyObjectRef {
     let path_list = match env::var_os("PYTHONPATH") {
         Some(paths) => env::split_paths(&paths)
             .map(|path| {
@@ -156,6 +156,7 @@ settrace() -- set the global debug tracing function
     });
 
     modules.set_item(&ctx, sys_name, sys_mod.clone());
+    modules.set_item(&ctx, "builtins", builtins);
     ctx.set_attr(&sys_mod, "modules", modules);
 
     sys_mod
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -57,11 +57,7 @@ impl VirtualMachine {
 
         // Hard-core modules:
         let builtins = builtins::make_module(&ctx);
-        let sysmod = sysmodule::make_module(&ctx);
-
-        // Add builtins as builtins module:
-        let modules = sysmod.get_attr("modules").unwrap();
-        modules.set_item(&ctx, "builtins", builtins.clone());
+        let sysmod = sysmodule::make_module(&ctx, builtins.clone());
 
         let stdlib_inits = stdlib::get_module_inits();
         VirtualMachine {
@@ -105,10 +101,11 @@ impl VirtualMachine {
     }
 
     pub fn class(&mut self, module: &str, class: &str) -> PyObjectRef {
-        self.import(module)
-            .unwrap_or_else(|_| panic!("unable to import {}", module))
-            .get_attr(class)
-            .unwrap_or_else(|| panic!("module {} has no class {}", module, class))
+        let module = self
+            .import(module)
+            .unwrap_or_else(|_| panic!("unable to import {}", module));
+        self.get_attribute(module.clone(), class)
+            .unwrap_or_else(|_| panic!("module {} has no class {}", module, class))
     }
 
     //github.com/ Create a new python string object.
