[GR-9677] Method insert of list returns wrong time and raise IndexOutOfBound.

PullRequest: graalpython-open/31

Author: ppisl

graalpython/com.oracle.graal.python.test/src/tests/list_tests.py

@@ -288,7 +288,7 @@ def __length_hint__(self):
         a = self.type2test([1,2,3,4])
         a.extend(CustomIter())
         self.assertEqual(a, [1,2,3,4])
-    
+    '''
     def test_insert(self):
         a = self.type2test([0, 1, 2])
         a.insert(0, -2)
@@ -298,12 +298,12 @@ def test_insert(self):
 
         b = a[:]
         b.insert(-2, "foo")
-        b.insert(-200, "left")e
-        b.intert(200, "right")
+        b.insert(-200, "left")
+        b.insert(200, "right")
         self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))
 
         self.assertRaises(TypeError, a.insert)
-    '''
+    
     def test_pop(self):
         a = self.type2test([-1, 0, 1])
         a.pop()

graalpython/com.oracle.graal.python.test/src/tests/test_list.py

@@ -279,3 +279,36 @@ def test_set_slice_generalize_storage(self):
         a = [1,2]
         a[1:5] = [1.1, 2.2, 3.3]
         self.assertEqual([1,1.1, 2.2, 3.3], a)
+
+    def test_insert_spec(self):
+        a = [1,2]
+        self.assertRaises(TypeError, a.insert, [1,2,3], 1)
+
+        class MyInt(int):
+            pass
+
+        a = [2,4]
+        a.insert(MyInt(1),3)
+        self.assertEqual([2,3,4], a)
+
+        class MyIndex():
+            def __index__(self):
+                return 2
+
+        a.insert(MyIndex(), 7)
+        self.assertEqual([2,3,7,4], a)
+
+        class SecondIndex(int):
+            def __index__(self):
+                return self + 3;
+
+        a = [0,0,0,0,0]
+        a.insert(SecondIndex(1), 1)
+        self.assertEqual([0,1,0,0,0,0], a)
+
+        a = [0]
+        a.insert(LONG_NUMBER, 1)
+        self.assertEqual([0,1], a)
+
+        a.insert(False, -1)
+        self.assertEqual([-1,0,1], a)

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/list/ListBuiltins.java

@@ -502,17 +502,110 @@ public PList extend(PList list, Object source,
     @GenerateNodeFactory
     public abstract static class ListInsertNode extends PythonBuiltinNode {
 
+        public abstract PNone execute(PList list, Object index, Object value);
+
+        @Specialization(guards = "isIntStorage(list)")
+        public PNone insertIntInt(PList list, int index, int value) {
+            IntSequenceStorage target = (IntSequenceStorage) list.getSequenceStorage();
+            target.insertIntItem(normalizeIndex(index, list.len()), value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        public PNone insertLongLong(PList list, int index, int value) {
+            LongSequenceStorage target = (LongSequenceStorage) list.getSequenceStorage();
+            target.insertLongItem(normalizeIndex(index, list.len()), value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        public PNone insertLongLong(PList list, int index, long value) {
+            LongSequenceStorage target = (LongSequenceStorage) list.getSequenceStorage();
+            target.insertLongItem(normalizeIndex(index, list.len()), value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        public PNone insertDoubleDouble(PList list, int index, double value) {
+            DoubleSequenceStorage target = (DoubleSequenceStorage) list.getSequenceStorage();
+            target.insertDoubleItem(normalizeIndex(index, list.len()), value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isNotSpecialCase(list, value)")
+        public PNone insert(PList list, int index, Object value) {
+            list.insert(normalizeIndex(index, list.len()), value);
+            return PNone.NONE;
+        }
+
         @Specialization
-        public PList insert(PList list, int index, Object value) {
-            list.insert(index, value);
-            return list;
+        public PNone insertLongIndex(PList list, long index, Object value,
+                        @Cached("createListInsertNode()") ListInsertNode insertNode) {
+            int where = index < Integer.MIN_VALUE ? 0 : index > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) index;
+            where = normalizeIndex(where, list.len());
+            return insertNode.execute(list, where, value);
         }
 
         @Specialization
-        @SuppressWarnings("unused")
-        public PList insert(PList list, Object i, Object arg1) {
-            throw new RuntimeException("invalid arguments for insert()");
+        public PNone insertPIntIndex(PList list, PInt index, Object value,
+                        @Cached("createListInsertNode()") ListInsertNode insertNode) {
+            int where = normalizePIntForIndex(index);
+            where = normalizeIndex(where, list.len());
+            return insertNode.execute(list, where, value);
+        }
+
+        @Specialization(guards = {"!isIntegerOrPInt(i)"})
+        public PNone insert(PList list, Object i, Object value,
+                        @Cached("create(__INDEX__)") LookupAndCallUnaryNode indexNode,
+                        @Cached("createListInsertNode()") ListInsertNode insertNode) {
+            Object indexValue = indexNode.executeObject(i);
+            if (PNone.NO_VALUE == indexValue) {
+                throw raise(TypeError, "'%p' object cannot be interpreted as an integer", i);
+            }
+            return insertNode.execute(list, indexValue, value);
+        }
+
+        @TruffleBoundary
+        private static int normalizePIntForIndex(PInt index) {
+            int where = 0;
+            BigInteger bigIndex = index.getValue();
+            if (bigIndex.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) == -1) {
+                where = 0;
+            } else if (bigIndex.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) == 1) {
+                where = Integer.MAX_VALUE;
+            } else {
+                where = bigIndex.intValue();
+            }
+            return where;
+        }
+
+        private static int normalizeIndex(int index, int len) {
+            int idx = index;
+            if (idx < 0) {
+                idx += len;
+                if (idx < 0) {
+                    idx = 0;
+                }
+            }
+            if (idx > len) {
+                idx = len;
+            }
+            return idx;
+        }
+
+        protected boolean isNotSpecialCase(PList list, Object value) {
+            return !((PGuards.isIntStorage(list) && value instanceof Integer) || (PGuards.isLongStorage(list) && PGuards.isInteger(value)) ||
+                            (PGuards.isDoubleStorage(list) && value instanceof Double));
         }
+
+        protected boolean isIntegerOrPInt(Object index) {
+            return index instanceof Integer || index instanceof PInt;
+        }
+
+        protected ListInsertNode createListInsertNode() {
+            return ListBuiltinsFactory.ListInsertNodeFactory.create(new PNode[0]);
+        }
+
     }
 
     // list.remove(x)