[GR-9663] OutOfMemoryError is thrown when a list is extend.

PullRequest: graalpython-open/30

Author: ppisl

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/datatype/ListTests.java

@@ -94,7 +94,8 @@ public void append() {
     @Test
     public void extend() {
         String source = "llist = [1,2]\n" + //
-                        "print(llist.extend([3, 4]))\n";
+                        "llist.extend([3, 4])\n" +
+                        "print(llist)\n";
 
         assertPrints("[1, 2, 3, 4]\n", source);
     }

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

@@ -256,24 +256,24 @@ def test_append(self):
         self.assertEqual(a, self.type2test([0, 1, 2]))
 
         self.assertRaises(TypeError, a.append)
-    '''
+    
     def test_extend(self):
         a1 = self.type2test([0])
         a2 = self.type2test((0, 1))
         a = a1[:]
         a.extend(a2)
         self.assertEqual(a, a1 + a2)
-
+        
         a.extend(self.type2test([]))
         self.assertEqual(a, a1 + a2)
-
+        
         a.extend(a)
         self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))
-
+        
         a = self.type2test("spam")
         a.extend("eggs")
         self.assertEqual(a, list("spameggs"))
-
+        
         self.assertRaises(TypeError, a.extend, None)
         self.assertRaises(TypeError, a.extend)
 
@@ -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)

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

@@ -280,13 +280,32 @@ def test_set_slice_generalize_storage(self):
         a[1:5] = [1.1, 2.2, 3.3]
         self.assertEqual([1,1.1, 2.2, 3.3], a)
 
+    def test_extend_spec(self):
+        a = [1,2]
+        a.extend(a)
+        self.assertEqual([1,2,1,2], a)
+        a = [923123123123]
+        a.extend(a)
+        self.assertEqual([923123123123,923123123123], a)
+        a = [1.1, 2.1]
+        a.extend(a)
+        self.assertEqual([1.1, 2.1, 1.1, 2.1], a)
+
+        a = []
+        a.extend(range(1,4))
+        self.assertEqual([1,2,3], a)
+
+        a = []
+        a.extend('ahoj')
+        self.assertEqual(['a','h','o','j'], a)
+
     def test_remove_spec(self):
         a = [1,2]
         a.remove(2);
         self.assertEqual([1], a)
         a.remove(1)
         self.assertEqual([], a)
-        
+
         a = [0,1,0,1,2]
         a.remove(True)
         self.assertEqual([0,0,1,2], a)
@@ -296,10 +315,10 @@ def test_remove_spec(self):
         a = list([LONG_NUMBER, LONG_NUMBER + 1])
         a.remove(LONG_NUMBER + 1)
         self.assertEqual([LONG_NUMBER], a)
-        
+
         class MyInt(int):
             pass
-        
+
         a = [1,2,3]
         a.remove(MyInt(2))
         self.assertEqual([1,3], a)

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

@@ -58,6 +58,7 @@
 import com.oracle.graal.python.builtins.objects.iterator.PIntegerSequenceIterator;
 import com.oracle.graal.python.builtins.objects.iterator.PLongSequenceIterator;
 import com.oracle.graal.python.builtins.objects.iterator.PSequenceIterator;
+import com.oracle.graal.python.builtins.objects.range.PRange;
 import com.oracle.graal.python.builtins.objects.slice.PSlice;
 import com.oracle.graal.python.builtins.objects.str.PString;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
@@ -486,24 +487,56 @@ protected boolean isKnownStorage(PList list) {
     @GenerateNodeFactory
     public abstract static class ListExtendNode extends PythonBuiltinNode {
 
-        @Specialization
-        public PList extend(PList list, Object source,
+        @Specialization(guards = {"isPSequenceWithStorage(source)"}, rewriteOn = {SequenceStoreException.class})
+        public PNone extendSequenceStore(PList list, Object source) throws SequenceStoreException {
+            SequenceStorage target = list.getSequenceStorage();
+            target.extend(((PSequence) source).getSequenceStorage());
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = {"isPSequenceWithStorage(source)"})
+        public PNone extendSequence(PList list, Object source) {
+            SequenceStorage eSource = ((PSequence) source).getSequenceStorage();
+            if (eSource.length() > 0) {
+                SequenceStorage target = list.getSequenceStorage();
+                try {
+                    target.extend(eSource);
+                } catch (SequenceStoreException e) {
+                    target = target.generalizeFor(eSource.getItemNormalized(0));
+                    list.setSequenceStorage(target);
+                    try {
+                        target.extend(eSource);
+                    } catch (SequenceStoreException e1) {
+                        throw new IllegalStateException();
+                    }
+                }
+            }
+            return PNone.NONE;
+        }
+
+        @Specialization(guards = "!isPSequenceWithStorage(source)")
+        public PNone extend(PList list, Object source,
                         @Cached("create()") GetIteratorNode getIterator,
                         @Cached("create()") GetNextNode next,
                         @Cached("createBinaryProfile()") ConditionProfile errorProfile) {
-
-            Object iterator = getIterator.executeWith(source);
+            Object workSource = list != source ? source : factory().createList(((PList) source).getSequenceStorage().copy());
+            Object iterator = getIterator.executeWith(workSource);
             while (true) {
                 Object value;
                 try {
                     value = next.execute(iterator);
                 } catch (PException e) {
                     e.expectStopIteration(getCore(), errorProfile);
-                    return list;
+                    return PNone.NONE;
                 }
                 list.append(value);
             }
         }
+
+        protected boolean isPSequenceWithStorage(Object source) {
+            return (source instanceof PSequence && !(source instanceof PTuple || source instanceof PRange));
+        }
+
     }
 
     // list.insert(i, x)