Merge pull request RustPython#3898 from jopemachine/add-missing-method-mapping-proxy

Implement missing methods to `MappingProxy`

Author: youknowone

Lib/test/test_dataclasses.py

@@ -1769,8 +1769,6 @@ def from_file(cls, filename):
 
         self.assertEqual(C.from_file('filename').x, 20)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_field_metadata_default(self):
         # Make sure the default metadata is read-only and of
         #  zero length.
@@ -1784,8 +1782,6 @@ class C:
                                     'does not support item assignment'):
             fields(C)[0].metadata['test'] = 3
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_field_metadata_mapping(self):
         # Make sure only a mapping can be passed as metadata
         #  zero length.

Lib/test/test_enum.py

@@ -1533,8 +1533,6 @@ class SomeTuple(tuple, Enum):
         globals()['SomeTuple'] = SomeTuple
         test_pickle_dump_load(self.assertIs, SomeTuple.first)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_duplicate_values_give_unique_enum_items(self):
         class AutoNumber(Enum):
             first = ()
@@ -1555,8 +1553,6 @@ def __int__(self):
         self.assertEqual(AutoNumber.third.value, 3)
         self.assertIs(AutoNumber(1), AutoNumber.first)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_inherited_new_from_enhanced_enum(self):
         class AutoNumber(Enum):
             def __new__(cls):
@@ -1573,8 +1569,6 @@ class Color(AutoNumber):
         self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
         self.assertEqual(list(map(int, Color)), [1, 2, 3])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_inherited_new_from_mixed_enum(self):
         class AutoNumber(IntEnum):
             def __new__(cls):
@@ -1745,8 +1739,6 @@ def __new__(cls, value, period):
         self.assertTrue(Period.month_1 is Period.day_30)
         self.assertTrue(Period.week_4 is Period.day_28)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nonhash_value(self):
         class AutoNumberInAList(Enum):
             def __new__(cls):

Lib/test/test_types.py

@@ -999,8 +999,6 @@ class userdict(dict):
         self.assertRaises(TypeError, self.mappingproxy, ("a", "tuple"))
         self.assertRaises(TypeError, self.mappingproxy, ["a", "list"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_methods(self):
         attrs = set(dir(self.mappingproxy({}))) - set(dir(object()))
         self.assertEqual(attrs, {
@@ -1093,8 +1091,6 @@ def get(self, key, default=None):
         self.assertEqual(view.keys(), 'keys')
         self.assertEqual(view.values(), 'values')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_chainmap(self):
         d1 = {'x': 1}
         d2 = {'y': 2}
@@ -1140,8 +1136,6 @@ def test_views(self):
         self.assertEqual(list(values), ['value'])
         self.assertEqual(list(items), [('key', 'value')])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_len(self):
         for expected in range(6):
             data = dict.fromkeys('abcde'[:expected])
@@ -1159,8 +1153,6 @@ def test_iterators(self):
         self.assertEqual(set(view.values()), set(values))
         self.assertEqual(set(view.items()), set(items))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reversed(self):
         d = {'a': 1, 'b': 2, 'foo': 0, 'c': 3, 'd': 4}
         mp = self.mappingproxy(d)

vm/src/builtins/mappingproxy.rs

@@ -3,8 +3,8 @@ use crate::{
     class::PyClassImpl,
     convert::ToPyObject,
     function::{ArgMapping, OptionalArg},
-    protocol::{PyMapping, PyMappingMethods, PySequence, PySequenceMethods},
-    types::{AsMapping, AsSequence, Constructor, Iterable},
+    protocol::{PyMapping, PyMappingMethods, PyNumberMethods, PySequence, PySequenceMethods},
+    types::{AsMapping, AsNumber, AsSequence, Constructor, Iterable},
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
 };
 
@@ -154,11 +154,40 @@ impl PyMappingProxy {
     fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
         PyGenericAlias::new(cls, args, vm)
     }
+
+    #[pymethod(magic)]
+    fn len(&self, vm: &VirtualMachine) -> PyResult<usize> {
+        let obj = self.to_object(vm)?;
+        obj.length(vm)
+    }
+
+    #[pymethod(magic)]
+    fn reversed(&self, vm: &VirtualMachine) -> PyResult {
+        vm.call_method(
+            self.to_object(vm)?.as_object(),
+            identifier!(vm, __reversed__).as_str(),
+            (),
+        )
+    }
+
+    #[pymethod(magic)]
+    fn ior(&self, _args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_type_error(format!(
+            "\"'|=' is not supported by {}; use '|' instead\"",
+            Self::class(vm)
+        )))
+    }
+
+    #[pymethod(name = "__ror__")]
+    #[pymethod(magic)]
+    fn or(&self, args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._or(self.copy(vm)?.as_ref(), args.as_ref())
+    }
 }
 
 impl AsMapping for PyMappingProxy {
     const AS_MAPPING: PyMappingMethods = PyMappingMethods {
-        length: None,
+        length: Some(|mapping, vm| Self::mapping_downcast(mapping).len(vm)),
         subscript: Some(|mapping, needle, vm| {
             Self::mapping_downcast(mapping).getitem(needle.to_owned(), vm)
         }),
@@ -173,6 +202,14 @@ impl AsSequence for PyMappingProxy {
     };
 }
 
+impl AsNumber for PyMappingProxy {
+    const AS_NUMBER: PyNumberMethods = PyNumberMethods {
+        or: Some(|num, args, vm| Self::number_downcast(num).or(args.to_pyobject(vm), vm)),
+        inplace_or: Some(|num, args, vm| Self::number_downcast(num).ior(args.to_pyobject(vm), vm)),
+        ..PyNumberMethods::NOT_IMPLEMENTED
+    };
+}
+
 impl Iterable for PyMappingProxy {
     fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
         let obj = zelf.to_object(vm)?;