Merge pull request RustPython#409 from skinny121/slice

Add slice type

Author: windelbouwman

tests/snippets/builtin_slice.py

@@ -0,0 +1,77 @@
+
+a = []
+assert a[:] == []
+assert a[:2**100] == []
+assert a[-2**100:] == []
+assert a[::2**100] == []
+assert a[10:20] == []
+assert a[-20:-10] == []
+
+b = [1, 2]
+
+assert b[:] == [1, 2]
+assert b[:2**100] == [1, 2]
+assert b[-2**100:] == [1, 2]
+assert b[2**100:] == []
+assert b[::2**100] == [1]
+assert b[-10:1] == [1]
+assert b[0:0] == []
+assert b[1:0] == []
+
+try:
+    _ = b[::0]
+except ValueError:
+    pass
+else:
+    assert False, "Zero step slice should raise ValueError"
+
+assert b[::-1] == [2, 1]
+assert b[1::-1] == [2, 1]
+assert b[0::-1] == [1]
+assert b[0:-5:-1] == [1]
+assert b[:0:-1] == [2]
+assert b[5:0:-1] == [2]
+
+c = list(range(10))
+
+assert c[9:6:-3] == [9]
+assert c[9::-3] == [9, 6, 3, 0]
+assert c[9::-4] == [9, 5, 1]
+assert c[8::-2**100] == [8]
+
+assert c[7:7:-2] == []
+assert c[7:8:-2] == []
+
+d = "123456"
+
+assert d[3::-1] == "4321"
+assert d[4::-3] == "52"
+
+
+slice_a = slice(5)
+assert slice_a.start is None
+assert slice_a.stop == 5
+assert slice_a.step is None
+
+slice_b = slice(1, 5)
+assert slice_b.start == 1
+assert slice_b.stop == 5
+assert slice_b.step is None
+
+slice_c = slice(1, 5, 2)
+assert slice_c.start == 1
+assert slice_c.stop == 5
+assert slice_c.step == 2
+
+
+class SubScript(object):
+    def __getitem__(self, item):
+        assert type(item) == slice
+
+    def __setitem__(self, key, value):
+        assert type(key) == slice
+
+
+ss = SubScript()
+_ = ss[:]
+ss[:1] = 1

vm/src/builtins.rs

@@ -677,6 +677,7 @@ pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     ctx.set_attr(&py_mod, "repr", ctx.new_rustfunc(builtin_repr));
     ctx.set_attr(&py_mod, "set", ctx.set_type());
     ctx.set_attr(&py_mod, "setattr", ctx.new_rustfunc(builtin_setattr));
+    ctx.set_attr(&py_mod, "slice", ctx.slice_type());
     ctx.set_attr(&py_mod, "staticmethod", ctx.staticmethod_type());
     ctx.set_attr(&py_mod, "str", ctx.str_type());
     ctx.set_attr(&py_mod, "sum", ctx.new_rustfunc(builtin_sum));

vm/src/frame.rs

@@ -20,7 +20,7 @@ use super::pyobject::{
     PyResult, TypeProtocol,
 };
 use super::vm::VirtualMachine;
-use num_traits::ToPrimitive;
+use num_bigint::BigInt;
 
 #[derive(Clone, Debug)]
 enum Block {
@@ -262,22 +262,22 @@ impl Frame {
                 assert!(*size == 2 || *size == 3);
                 let elements = self.pop_multiple(*size);
 
-                let mut out: Vec<Option<i32>> = elements
+                let mut out: Vec<Option<BigInt>> = elements
                     .into_iter()
                     .map(|x| match x.borrow().payload {
-                        PyObjectPayload::Integer { ref value } => Some(value.to_i32().unwrap()),
+                        PyObjectPayload::Integer { ref value } => Some(value.clone()),
                         PyObjectPayload::None => None,
                         _ => panic!("Expect Int or None as BUILD_SLICE arguments, got {:?}", x),
                     })
                     .collect();
 
-                let start = out[0];
-                let stop = out[1];
-                let step = if out.len() == 3 { out[2] } else { None };
+                let start = out[0].take();
+                let stop = out[1].take();
+                let step = if out.len() == 3 { out[2].take() } else { None };
 
                 let obj = PyObject::new(
                     PyObjectPayload::Slice { start, stop, step },
-                    vm.ctx.type_type(),
+                    vm.ctx.slice_type(),
                 );
                 self.push_value(obj);
                 Ok(None)

vm/src/obj/mod.rs

@@ -22,6 +22,7 @@ pub mod objproperty;
 pub mod objrange;
 pub mod objsequence;
 pub mod objset;
+pub mod objslice;
 pub mod objstr;
 pub mod objsuper;
 pub mod objtuple;

vm/src/obj/objiter.rs

@@ -9,7 +9,6 @@ use super::super::vm::VirtualMachine;
 use super::objbool;
 // use super::objstr;
 use super::objtype; // Required for arg_check! to use isinstance
-use num_bigint::BigInt;
 
 /*
  * This helper function is called at multiple places. First, it is called
@@ -146,7 +145,7 @@ fn iter_next(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
             }
 
             PyObjectPayload::Range { ref range } => {
-                if let Some(int) = range.get(BigInt::from(*position)) {
+                if let Some(int) = range.get(*position) {
                     *position += 1;
                     Ok(vm.ctx.new_int(int))
                 } else {

vm/src/obj/objlist.rs

@@ -21,9 +21,12 @@ fn set_item(
 ) -> PyResult {
     if objtype::isinstance(&idx, &vm.ctx.int_type()) {
         let value = objint::get_value(&idx).to_i32().unwrap();
-        let pos_index = l.get_pos(value);
-        l[pos_index] = obj;
-        Ok(vm.get_none())
+        if let Some(pos_index) = l.get_pos(value) {
+            l[pos_index] = obj;
+            Ok(vm.get_none())
+        } else {
+            Err(vm.new_index_error("list index out of range".to_string()))
+        }
     } else {
         panic!(
             "TypeError: indexing type {:?} with index {:?} is not supported (yet?)",

vm/src/obj/objrange.rs

@@ -7,6 +7,7 @@ use super::objtype;
 use num_bigint::{BigInt, Sign};
 use num_integer::Integer;
 use num_traits::{One, Signed, ToPrimitive, Zero};
+use std::ops::Mul;
 
 #[derive(Debug, Clone)]
 pub struct RangeType {
@@ -77,8 +78,11 @@ impl RangeType {
     }
 
     #[inline]
-    pub fn get(&self, index: BigInt) -> Option<BigInt> {
-        let result = self.start.clone() + self.step.clone() * index;
+    pub fn get<'a, T>(&'a self, index: T) -> Option<BigInt>
+    where
+        &'a BigInt: Mul<T, Output = BigInt>,
+    {
+        let result = &self.start + &self.step * index;
 
         if (self.forward() && !self.is_empty() && result < self.end)
             || (!self.forward() && !self.is_empty() && result > self.end)
@@ -199,15 +203,19 @@ fn range_getitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
 
     match subscript.borrow().payload {
         PyObjectPayload::Integer { ref value } => {
-            if let Some(int) = zrange.get(value.clone()) {
+            if let Some(int) = zrange.get(value) {
                 Ok(vm.ctx.new_int(int))
             } else {
                 Err(vm.new_index_error("range object index out of range".to_string()))
             }
         }
-        PyObjectPayload::Slice { start, stop, step } => {
+        PyObjectPayload::Slice {
+            ref start,
+            ref stop,
+            ref step,
+        } => {
             let new_start = if let Some(int) = start {
-                if let Some(i) = zrange.get(int.into()) {
+                if let Some(i) = zrange.get(int) {
                     i
                 } else {
                     zrange.start.clone()
@@ -217,7 +225,7 @@ fn range_getitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
             };
 
             let new_end = if let Some(int) = stop {
-                if let Some(i) = zrange.get(int.into()) {
+                if let Some(i) = zrange.get(int) {
                     i
                 } else {
                     zrange.end
@@ -227,7 +235,7 @@ fn range_getitem(vm: &mut VirtualMachine, args: PyFuncArgs) -> PyResult {
             };
 
             let new_step = if let Some(int) = step {
-                (int as i64) * zrange.step
+                int * zrange.step
             } else {
                 zrange.step
             };