refactor ItemProtocol -> Object Protocol

Author: qingshi163

src/lib.rs

@@ -46,8 +46,8 @@ extern crate log;
 use clap::{App, AppSettings, Arg, ArgMatches};
 use rustpython_vm::{
     builtins::PyDictRef, builtins::PyInt, compile, match_class, scope::Scope, stdlib::sys,
-    InitParameter, Interpreter, ItemProtocol, PyObjectRef, PyResult, PySettings, TryFromObject,
-    TypeProtocol, VirtualMachine,
+    InitParameter, Interpreter, PyObjectRef, PyResult, PySettings, TryFromObject, TypeProtocol,
+    VirtualMachine,
 };
 
 use std::env;
@@ -645,7 +645,7 @@ fn run_module(vm: &VirtualMachine, module: &str) -> PyResult<()> {
 fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
     let path_importer_cache = vm.sys_module.clone().get_attr("path_importer_cache", vm)?;
     let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;
-    if let Some(importer) = path_importer_cache.get_item_option(path, vm)? {
+    if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {
         return Ok(Some(importer));
     }
     let path = vm.ctx.new_str(path);

src/shell/helper.rs

@@ -74,10 +74,7 @@ impl<'vm> ShellHelper<'vm> {
             // last: the last word, could be empty if it ends with a dot
             // parents: the words before the dot
 
-            let mut current = self
-                .globals
-                .get_item_option(first.as_str(), self.vm)
-                .ok()??;
+            let mut current = self.globals.get_item_opt(first.as_str(), self.vm).ok()??;
 
             for attr in parents {
                 current = current.clone().get_attr(attr.as_str(), self.vm).ok()?;

stdlib/src/array.rs

@@ -1239,35 +1239,26 @@ mod array {
         },
     };
 
+    impl PyArray {
+        const MAPPING_METHODS: PyMappingMethods = PyMappingMethods {
+            length: Some(|mapping, _vm| Ok(mapping.obj_as::<Self>().len())),
+            subscript: Some(|mapping, needle, vm| {
+                mapping.obj_as::<Self>().getitem(needle.to_owned(), vm)
+            }),
+            ass_subscript: Some(|mapping, needle, value, vm| {
+                let zelf = mapping.obj_as::<Self>();
+                if let Some(value) = value {
+                    Self::setitem(zelf.to_owned(), needle.to_owned(), value, vm)
+                } else {
+                    Self::delitem(zelf.to_owned(), needle.to_owned(), vm)
+                }
+            }),
+        };
+    }
+
     impl AsMapping for PyArray {
         fn as_mapping(_zelf: &PyObjectView<Self>, _vm: &VirtualMachine) -> PyMappingMethods {
-            PyMappingMethods {
-                length: Some(Self::length),
-                subscript: Some(Self::subscript),
-                ass_subscript: Some(Self::ass_subscript),
-            }
-        }
-
-        fn length(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-            Self::downcast_ref(&zelf, vm).map(|zelf| Ok(zelf.len()))?
-        }
-
-        fn subscript(zelf: PyObjectRef, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Self::downcast_ref(&zelf, vm).map(|zelf| zelf.getitem(needle, vm))?
-        }
-
-        fn ass_subscript(
-            zelf: PyObjectRef,
-            needle: PyObjectRef,
-            value: Option<PyObjectRef>,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            match value {
-                Some(value) => {
-                    Self::downcast(zelf, vm).map(|zelf| Self::setitem(zelf, needle, value, vm))?
-                }
-                None => Self::downcast(zelf, vm).map(|zelf| Self::delitem(zelf, needle, vm))?,
-            }
+            Self::MAPPING_METHODS
         }
     }
 

stdlib/src/bisect.rs

@@ -3,8 +3,7 @@ pub(crate) use _bisect::make_module;
 #[pymodule]
 mod _bisect {
     use crate::vm::{
-        function::OptionalArg, types::PyComparisonOp::Lt, ItemProtocol, PyObjectRef, PyResult,
-        VirtualMachine,
+        function::OptionalArg, types::PyComparisonOp::Lt, PyObjectRef, PyResult, VirtualMachine,
     };
 
     #[derive(FromArgs)]

stdlib/src/dis.rs

@@ -5,7 +5,7 @@ mod decl {
     use crate::vm::{
         builtins::{PyCode, PyDictRef, PyStrRef},
         bytecode::CodeFlags,
-        compile, ItemProtocol, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
+        compile, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
     };
 
     #[pyfunction]

stdlib/src/pyexpat.rs

@@ -35,8 +35,7 @@ mod _pyexpat {
         builtins::{PyStr, PyStrRef, PyTypeRef},
         function::ArgBytesLike,
         function::{IntoFuncArgs, OptionalArg},
-        ItemProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
-        VirtualMachine,
+        PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, VirtualMachine,
     };
     use rustpython_common::lock::PyRwLock;
     use std::io::Cursor;

vm/src/builtins/bytearray.rs

@@ -679,7 +679,7 @@ impl PyByteArray {
 
 impl PyByteArray {
     const MAPPING_METHODS: PyMappingMethods = PyMappingMethods {
-        length: Some(|mapping, vm| Ok(mapping.obj_as::<Self>().len())),
+        length: Some(|mapping, _vm| Ok(mapping.obj_as::<Self>().len())),
         subscript: Some(|mapping, needle, vm| {
             mapping.obj_as::<Self>().getitem(needle.to_owned(), vm)
         }),

vm/src/builtins/bytes.rs

@@ -525,7 +525,7 @@ impl PyBytes {
 
 impl PyBytes {
     const MAPPING_METHODS: PyMappingMethods = PyMappingMethods {
-        length: Some(|mapping, vm| Ok(mapping.obj_as::<Self>().len())),
+        length: Some(|mapping, _vm| Ok(mapping.obj_as::<Self>().len())),
         subscript: Some(|mapping, needle, vm| {
             mapping.obj_as::<Self>().getitem(needle.to_owned(), vm)
         }),