Remove method 'SequenceStorage.extend'.

Author: fangerer

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/runtime/SequenceStorageTests.java

@@ -109,19 +109,6 @@ public void objectAppend() {
         assertEquals(7, store.length());
     }
 
-    @Test
-    public void objectExtend() {
-        ObjectSequenceStorage store = new ObjectSequenceStorage(getObjectValues());
-        ObjectSequenceStorage other = new ObjectSequenceStorage(getObjectValues());
-        store.extend(other);
-
-        for (int i = 6; i < 12; i++) {
-            assertEquals(i - 5, store.getItemNormalized(i));
-        }
-
-        assertEquals(12, store.length());
-    }
-
     /**
      * IntSequenceStorage tests.
      */
@@ -147,18 +134,6 @@ public void intGetSlice() {
         }
     }
 
-    @Test
-    public void intSetSlice() throws SequenceStoreException {
-        IntSequenceStorage store = new IntSequenceStorage(getIntValues());
-        IntSequenceStorage slice = new IntSequenceStorage(new int[]{42, 42, 42});
-
-        store.setSliceInBound(1, 4, 1, slice);
-
-        for (int i = 1; i < 4; i++) {
-            assertEquals(42, store.getItemNormalized(i));
-        }
-    }
-
     @Test
     public void intSetSliceOutOfBound() throws SequenceStoreException {
         IntSequenceStorage store = new IntSequenceStorage(getIntValues());
@@ -201,17 +176,4 @@ public void intAppend() throws SequenceStoreException {
         assertEquals(7, store.length());
     }
 
-    @Test
-    public void intExtend() throws SequenceStoreException {
-        IntSequenceStorage store = new IntSequenceStorage(getIntValues());
-        IntSequenceStorage other = new IntSequenceStorage(getIntValues());
-        store.extend(other);
-
-        for (int i = 6; i < 12; i++) {
-            assertEquals(i - 5, store.getItemNormalized(i));
-        }
-
-        assertEquals(12, store.length());
-    }
-
 }

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

@@ -299,28 +299,39 @@ def test_set_slice(self):
         a = [1, 2]
         a[1:2] = [7, 6, 5, 4]
         self.assertEqual([1, 7, 6, 5, 4], a)
+
         a = [1, 2, 3, 4]
         a[1:8] = [33]
         self.assertEqual([1, 33], a)
+
         a = [1, 2, 3, 4]
         a[1:8] = [33, 34, 35, 36, 37, 38]
         self.assertEqual([1, 33, 34, 35, 36, 37, 38], a)
+
         a = list(range(20))
         a[1:19] = [55, 55]
         self.assertEqual([0, 55, 55, 19], a)
+
         a = [1, 2, 3, 4]
         a[1:3] = [11]
         self.assertEqual([1, 11, 4], a)
+
         a = [1, 2, 3, 4]
         a[1:3] = [11, 12, 13, 14, 15, 16]
         self.assertEqual([1, 11, 12, 13, 14, 15, 16, 4], a)
+
         a = [1, 2]
         a[:] = (1, 2, 4, 5)
         self.assertEqual([1, 2, 4, 5], a)
+
         a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
         a[0:10:2] = [10, 30, 50, 70, 90]
         self.assertEqual([10, 2, 30, 4, 50, 6, 70, 8, 90, 10], a)
 
+        a = [1, 2, 3, 4, 5, 6]
+        a[1:4:1] = [42, 42, 42]
+        self.assertEqual([1, 42, 42, 42, 5, 6], a)
+
     def test_set_slice_class_iter(self):
 
         class MyIter():
@@ -396,6 +407,21 @@ def test_extend_spec(self):
         a.extend('ahoj')
         self.assertEqual(['a', 'h', 'o', 'j'], a)
 
+    def test_extend(self):
+        a = [1, 2, 3, 4, 5, 6]
+        b = [1, 2, 3, 4, 5, 6]
+        a.extend(b)
+        self.assertEqual([1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6], a)
+
+        a = ["a", "b", "c"]
+        b = ["a", "b", "c"]
+        a.extend(b)
+        self.assertEqual(["a", "b", "c", "a", "b", "c"], a)
+
+        a = []
+        a.extend([])
+        self.assertEqual([], a)
+
     def test_extend_bytes(self):
         l = []
         l.extend(b"asdf")

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/SequenceStorageNodes.java

@@ -81,6 +81,7 @@
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.GetItemNodeGen;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.GetItemScalarNodeGen;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.GetItemSliceNodeGen;
+import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.LenNodeGen;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.ListGeneralizationNodeGen;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.NoGeneralizationNodeGen;
 import com.oracle.graal.python.builtins.objects.common.SequenceStorageNodesFactory.NormalizeIndexNodeGen;
@@ -148,6 +149,8 @@ abstract static class SequenceStorageBaseNode extends PBaseNode {
 
         protected static final int DEFAULT_CAPACITY = 8;
 
+        protected static final int MAX_SEQUENCE_STORAGES = 12;
+
         protected static boolean isByteStorage(NativeSequenceStorage store) {
             return store.getElementType() == ListStorageType.Byte;
         }
@@ -2079,6 +2082,8 @@ public static ExtendNode create(Supplier<GeneralizationNode> genNodeProvider) {
     }
 
     public abstract static class RepeatNode extends SequenceStorageBaseNode {
+        private static final String ERROR_MSG = "can't multiply sequence by non-int of type '%p'";
+
         @Child private SetItemScalarNode setItemNode;
         @Child private GetItemScalarNode getItemNode;
         @Child private GetItemScalarNode getRightItemNode;
@@ -2090,14 +2095,19 @@ public abstract static class RepeatNode extends SequenceStorageBaseNode {
 
         public abstract SequenceStorage execute(SequenceStorage left, int times);
 
+        @Specialization
+        SequenceStorage doEmpty(EmptySequenceStorage s, @SuppressWarnings("unused") int times) {
+            return s;
+        }
+
         @Specialization(guards = "times <= 0")
-        SequenceStorage doGeneric(SequenceStorage s, @SuppressWarnings("unused") int times,
+        SequenceStorage doZeroRepeat(SequenceStorage s, @SuppressWarnings("unused") int times,
                         @Cached("createClassProfile()") ValueProfile storageTypeProfile) {
             return storageTypeProfile.profile(s).createEmpty(0);
         }
 
-        @Specialization(limit = "2", guards = {"!isNative(s)", "s.getClass() == cachedClass"})
-        SequenceStorage doManaged(SequenceStorage s, int times,
+        @Specialization(limit = "2", guards = {"times > 0", "!isNative(s)", "s.getClass() == cachedClass"})
+        SequenceStorage doManaged(BasicSequenceStorage s, int times,
                         @Cached("create()") BranchProfile outOfMemProfile,
                         @Cached("s.getClass()") Class<? extends SequenceStorage> cachedClass) {
             try {
@@ -2115,18 +2125,20 @@ SequenceStorage doManaged(SequenceStorage s, int times,
             }
         }
 
-        @Specialization(replaces = "doManaged")
+        @Specialization(replaces = "doManaged", limit = "2", guards = {"times > 0", "s.getClass() == cachedClass"})
         SequenceStorage doGeneric(SequenceStorage s, int times,
-                        @Cached("create()") BranchProfile outOfMemProfile) {
+                        @Cached("create()") BranchProfile outOfMemProfile,
+                        @Cached("s.getClass()") Class<? extends SequenceStorage> cachedClass) {
             try {
-                int len = s.length();
+                SequenceStorage profiled = cachedClass.cast(s);
+                int len = profiled.length();
 
                 ObjectSequenceStorage repeated = new ObjectSequenceStorage(Math.multiplyExact(len, times));
 
                 // TODO avoid temporary array
                 Object[] values = new Object[len];
                 for (int i = 0; i < len; i++) {
-                    values[i] = getGetItemNode().execute(s, i);
+                    values[i] = getGetItemNode().execute(profiled, i);
                 }
 
                 Object destArr = repeated.getInternalArrayObject();
@@ -2138,10 +2150,11 @@ SequenceStorage doGeneric(SequenceStorage s, int times,
             }
         }
 
-        @Fallback
-        SequenceStorage doGeneric(SequenceStorage s, Object times) {
+        @Specialization(guards = "!isInt(times)")
+        SequenceStorage doNonInt(SequenceStorage s, Object times) {
             int i = toIndex(times);
             if (recursive == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
                 recursive = insert(RepeatNodeGen.create());
             }
             return recursive.execute(s, i);
@@ -2162,6 +2175,10 @@ private static void repeat(Object dest, Object src, int len, int times) {
             }
         }
 
+        protected static boolean isInt(Object times) {
+            return times instanceof Integer;
+        }
+
         private int toIndex(Object times) {
             if (isIndexNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
@@ -2170,11 +2187,11 @@ private int toIndex(Object times) {
             if (isIndexNode.execute(times)) {
                 if (castToindexNode == null) {
                     CompilerDirectives.transferToInterpreterAndInvalidate();
-                    castToindexNode = insert(CastToIndexNode.create());
+                    castToindexNode = insert(CastToIndexNode.createOverflow());
                 }
                 return castToindexNode.execute(times);
             }
-            throw raise(TypeError, "can't multiply sequence by non-int of type '%p'", times);
+            throw raise(TypeError, ERROR_MSG, times);
         }
 
         public static RepeatNode create() {
@@ -2590,7 +2607,7 @@ EmptySequenceStorage doEmpty(EmptySequenceStorage s, @SuppressWarnings("unused")
             return s;
         }
 
-        @Specialization(limit = "9", guards = "s.getClass() == cachedClass")
+        @Specialization(limit = "MAX_SEQUENCE_STORAGES", guards = "s.getClass() == cachedClass")
         BasicSequenceStorage doManaged(BasicSequenceStorage s, int cap,
                         @Cached("create()") BranchProfile overflowErrorProfile,
                         @Cached("s.getClass()") Class<? extends BasicSequenceStorage> cachedClass) {
@@ -2616,4 +2633,19 @@ public static EnsureCapacityNode create() {
         }
 
     }
+
+    public abstract static class LenNode extends SequenceStorageBaseNode {
+
+        public abstract int execute(SequenceStorage s);
+
+        @Specialization(limit = "MAX_SEQUENCE_STORAGES", guards = "s.getClass() == cachedClass")
+        int doSpecial(SequenceStorage s,
+                        @Cached("s.getClass()") Class<? extends SequenceStorage> cachedClass) {
+            return cachedClass.cast(s).length();
+        }
+
+        public static LenNode create() {
+            return LenNodeGen.create();
+        }
+    }
 }