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

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,29 @@ 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)

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

@@ -502,17 +502,92 @@ public PList extend(PList list, Object source,
     @GenerateNodeFactory
     public abstract static class ListInsertNode extends PythonBuiltinNode {
 
-        @Specialization
-        public PList insert(PList list, int index, Object value) {
+        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();
+            index = normalizeIndex(index, list.len());
+            target.insertIntItem(index, value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        public PNone insertLongLong(PList list, int index, int value) {
+            LongSequenceStorage target = (LongSequenceStorage) list.getSequenceStorage();
+            index = normalizeIndex(index, list.len());
+            target.insertLongItem(index, value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        public PNone insertLongLong(PList list, int index, long value) {
+            LongSequenceStorage target = (LongSequenceStorage) list.getSequenceStorage();
+            index = normalizeIndex(index, list.len());
+            target.insertLongItem(index, value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        public PNone insertDoubleDouble(PList list, int index, double value) {
+            DoubleSequenceStorage target = (DoubleSequenceStorage) list.getSequenceStorage();
+            index = normalizeIndex(index, list.len());
+            target.insertDoubleItem(index, value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "isNotSpecialCase(list, value)")
+        public PNone insert(PList list, int index, Object value) {
+            index = normalizeIndex(index, list.len());
             list.insert(index, value);
-            return list;
+            return PNone.NONE;
         }
 
         @Specialization
+        public PNone insert(PList list, PInt index, Object value) {
+            int where = normalizeIndex(index.intValue(), list.len());
+            list.insert(where, value);
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = {"!isIntegerOrPInt(i)"})
         @SuppressWarnings("unused")
-        public PList insert(PList list, Object i, Object arg1) {
-            throw new RuntimeException("invalid arguments for insert()");
+        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);
+        }
+
+        private int normalizeIndex(int index, int len) {
+            if (index < 0) {
+                index += len;
+                if (index < 0) {
+                    index = 0;
+                }
+            }
+            if (index > len) {
+                index = len;
+            }
+            return index;
         }
+
+        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)