RustPython · cthulahoops · Sep 7, 2018 · Sep 4, 2018 · Sep 5, 2018 · Sep 5, 2018
diff --git a/tests/snippets/ast_snippet.py b/tests/snippets/ast_snippet.py
@@ -0,0 +1,17 @@
+
+import ast
+print(ast)
+
+source = """
+def foo():
+    print('bar')
+"""
+n = ast.parse(source)
+print(n)
+print(n.body)
+print(n.body[0].name)
+assert n.body[0].name == 'foo'
+print(n.body[0].body)
+print(n.body[0].body[0])
+print(n.body[0].body[0].value.func.id)
+assert n.body[0].body[0].value.func.id == 'print'
diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -10,7 +10,7 @@ use std::path::PathBuf;
 
 use self::rustpython_parser::parser;
 use super::compile;
-use super::pyobject::{DictProtocol, PyObject, PyObjectKind, PyResult};
+use super::pyobject::{DictProtocol, PyObjectKind, PyResult};
 use super::vm::VirtualMachine;
 
 fn import_module(vm: &mut VirtualMachine, module: &String) -> PyResult {
@@ -50,28 +50,23 @@ fn import_module(vm: &mut VirtualMachine, module: &String) -> PyResult {
     };
 
     let builtins = vm.get_builtin_scope();
-    let scope = vm.context().new_scope(Some(builtins));
+    let scope = vm.ctx.new_scope(Some(builtins));
 
     match vm.run_code_obj(code_obj, scope.clone()) {
         Ok(_) => {}
         Err(value) => return Err(value),
     }
-    Ok(scope)
+    let py_module = vm.ctx.new_module(module, scope);
+    Ok(py_module)
 }
 
-pub fn import(vm: &mut VirtualMachine, module: &String, symbol: &Option<String>) -> PyResult {
-    let scope = import_module(vm, module)?;
+pub fn import(vm: &mut VirtualMachine, module_name: &String, symbol: &Option<String>) -> PyResult {
+    let module = import_module(vm, module_name)?;
     // 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) => scope.get_item(symbol).unwrap(),
-        None => PyObject::new(
-            PyObjectKind::Module {
-                name: module.clone(),
-                dict: scope.clone(),
-            },
-            vm.get_type(),
-        ),
+        Some(symbol) => module.get_item(symbol).unwrap(),
+        None => module,
     };
     Ok(obj)
 }

diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -62,6 +62,7 @@ pub struct PyContext {
     pub tuple_type: PyObjectRef,
     pub str_type: PyObjectRef,
     pub function_type: PyObjectRef,
+    pub module_type: PyObjectRef,
     pub bound_method_type: PyObjectRef,
     pub member_descriptor_type: PyObjectRef,
     pub object: PyObjectRef,
@@ -111,6 +112,7 @@ impl PyContext {
         objobject::create_object(type_type.clone(), object_type.clone(), dict_type.clone());
         objdict::create_type(type_type.clone(), object_type.clone(), dict_type.clone());
 
+        let module_type = create_type("module", &type_type, &object_type, &dict_type);
         let function_type = create_type("function", &type_type, &object_type, &dict_type);
         let bound_method_type = create_type("method", &type_type, &object_type, &dict_type);
         let member_descriptor_type =
@@ -145,6 +147,7 @@ impl PyContext {
             str_type: str_type,
             object: object_type,
             function_type: function_type,
+            module_type: module_type,
             bound_method_type: bound_method_type,
             member_descriptor_type: member_descriptor_type,
             type_type: type_type,
@@ -213,6 +216,15 @@ impl PyContext {
         self.object.clone()
     }
 
+    pub fn new_object(&self) -> PyObjectRef {
+        PyObject::new(
+            PyObjectKind::Instance {
+                dict: self.new_dict(),
+            },
+            self.object(),
+        )
+    }
+
     pub fn new_int(&self, i: i32) -> PyObjectRef {
         PyObject::new(PyObjectKind::Integer { value: i }, self.int_type())
     }
@@ -275,7 +287,7 @@ impl PyContext {
                 name: name.clone(),
                 dict: scope.clone(),
             },
-            self.type_type(),
+            self.module_type.clone(),
         )
     }