q!

Merge branch 'master' of https://github.com/RustPython/RustPython into break-continue-fix

Author: chwoda1

tests/snippets/bytearray.py

@@ -29,3 +29,7 @@
 
 assert bytearray(b'Is Title Case').istitle()
 assert not bytearray(b'is Not title casE').istitle()
+
+a = bytearray(b'abcd')
+a.clear()
+assert len(a) == 0

tests/snippets/dict.py

@@ -14,3 +14,6 @@ def dict_eq(d1, d2):
 c['a']['g'] = 2
 assert dict_eq(a, {'g': 2})
 assert dict_eq(b, {'a': a, 'd': 9})
+
+a.clear()
+assert len(a) == 0

vm/src/macros.rs

@@ -1,3 +1,4 @@
+// count number of tokens given as arguments.
 // see: https://danielkeep.github.io/tlborm/book/blk-counting.html
 macro_rules! replace_expr {
     ($_t:tt $sub:expr) => {
@@ -44,9 +45,11 @@ macro_rules! arg_check {
     ( $vm: ident, $args:ident, required=[$( ($arg_name:ident, $arg_type:expr) ),*], optional=[$( ($optional_arg_name:ident, $optional_arg_type:expr) ),*] ) => {
         let mut arg_count = 0;
 
+        // use macro magic to compile-time count number of required and optional arguments
         let minimum_arg_count = count_tts!($($arg_name)*);
         let maximum_arg_count = minimum_arg_count + count_tts!($($optional_arg_name)*);
 
+        // verify that the number of given arguments is right
         if $args.args.len() < minimum_arg_count || $args.args.len() > maximum_arg_count {
             let expected_str = if minimum_arg_count == maximum_arg_count {
                 format!("{}", minimum_arg_count)
@@ -60,6 +63,9 @@ macro_rules! arg_check {
             )));
         };
 
+        // for each required parameter:
+        //  check if the type matches. If not, return with error
+        //  assign the arg to a variable
         $(
             type_check!($vm, $args, arg_count, $arg_name, $arg_type);
             let $arg_name = &$args.args[arg_count];
@@ -69,6 +75,9 @@ macro_rules! arg_check {
             }
         )*
 
+        // for each optional parameter, if there are enough positional arguments:
+        //  check if the type matches. If not, return with error
+        //  assign the arg to a variable
         $(
             let $optional_arg_name = if arg_count < $args.args.len() {
                 type_check!($vm, $args, arg_count, $optional_arg_name, $optional_arg_type);

vm/src/obj/objbytearray.rs

@@ -95,6 +95,11 @@ pub fn init(context: &PyContext) {
         "istitle",
         context.new_rustfunc(bytearray_istitle),
     );
+    context.set_attr(
+        &bytearray_type,
+        "clear",
+        context.new_rustfunc(bytearray_clear),
+    );
 }
 
 fn bytearray_new(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
@@ -261,3 +266,15 @@ fn bytearray_repr(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     let data = String::from_utf8(value.to_vec()).unwrap();
     Ok(vm.new_str(format!("bytearray(b'{}')", data)))
 }
+
+fn bytearray_clear(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(zelf, Some(vm.ctx.bytearray_type()))]);
+    let mut mut_obj = zelf.borrow_mut();
+    match mut_obj.payload {
+        PyObjectPayload::Bytes { ref mut value } => {
+            value.clear();
+            Ok(vm.get_none())
+        }
+        _ => panic!("Bytearray has incorrect payload."),
+    }
+}

vm/src/obj/objdict.rs

@@ -244,6 +244,12 @@ fn dict_delitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     }
 }
 
+fn dict_clear(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
+    arg_check!(vm, args, required = [(dict, Some(vm.ctx.dict_type()))]);
+    get_mut_elements(dict).clear();
+    Ok(vm.get_none())
+}
+
 /// When iterating over a dictionary, we iterate over the keys of it.
 fn dict_iter(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
     arg_check!(vm, args, required = [(dict, Some(vm.ctx.dict_type()))]);
@@ -337,4 +343,5 @@ pub fn init(context: &PyContext) {
         "__setitem__",
         context.new_rustfunc(dict_setitem),
     );
+    context.set_attr(&dict_type, "clear", context.new_rustfunc(dict_clear));
 }