[GR-9955] List.__imul__ doesn't work as expected.

PullRequest: graalpython-open/60

Author: ppisl

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

@@ -554,7 +554,7 @@ def test_iadd(self):
         self.assertEqual(u, self.type2test("spameggs"))
 
         self.assertRaises(TypeError, u.__iadd__, None)
-    '''
+
     def test_imul(self):
         u = self.type2test([0, 1])
         u *= 3
@@ -565,7 +565,7 @@ def test_imul(self):
         oldid = id(s)
         s *= 10
         self.assertEqual(id(s), oldid)
-    '''
+
     def test_extendedslicing(self):
         #  subscript
         a = self.type2test([0,1,2,3,4])

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

@@ -479,3 +479,57 @@ def __iadd__(self, value):
         a = [1,2]
         a += a 
         self.assertEqual([1,2,1,2], a)
+
+    def test_imul_len(self):
+        a = [1]
+        a *= 0
+        self.assertEqual(0, len(a))
+
+        a = [1]
+        a *= 1
+        self.assertEqual(1, len(a))
+        
+        a = [1]
+        a *= -11
+        self.assertEqual(0, len(a))
+
+        a = [1]
+        a *= 10
+        self.assertEqual(10, len(a))
+
+        a = [1,2]
+        a *= 4
+        self.assertEqual(8, len(a))
+
+    def test_imul_01(self):
+        class My():
+            def __init__(self, value):
+                self.value = value
+            def __index__(self):
+                return self.value + 1;
+        l = [1]
+        ob = My(10)
+        l *= ob
+        self.assertEqual(11, len(l))
+
+    def test_imul_02(self):
+        class My():
+            def __init__(self, value):
+                self.value = value
+            def __index__(self):
+                return LONG_NUMBER*LONG_NUMBER
+        l = [1]
+        ob = My(10)
+        self.assertRaises(OverflowError, l.__imul__, ob)
+
+    def test_imul_03(self):
+        class My():
+            def __init__(self, value):
+                self.value = value
+            def __index__(self):
+                return 'Ahoj'
+        l = [1]
+        ob = My(10)
+        self.assertRaises(TypeError, l.__imul__, ob)
+
+

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

@@ -37,6 +37,7 @@
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__LEN__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__LT__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__MUL__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__IMUL__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__NE__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__REPR__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__RMUL__;
@@ -1162,6 +1163,8 @@ protected boolean isNotSameStorage(PList left, PList right) {
     @Builtin(name = __MUL__, fixedNumOfArguments = 2)
     @GenerateNodeFactory
     abstract static class MulNode extends PythonBuiltinNode {
+        public static String CANNOT_FIT_MESSAGE = "cannot fit 'int' into an index-sized integer";
+
         @Specialization
         PList doPListInt(PList left, boolean right,
                         @Cached("createClassProfile()") ValueProfile profile) {
@@ -1184,7 +1187,7 @@ PList doPListBigInt(PList left, long right,
             try {
                 return doPListInt(left, PInt.intValueExact(right), profile);
             } catch (ArithmeticException e) {
-                throw raise(OverflowError, "cannot fit 'int' into an index-sized integer");
+                throw raise(OverflowError, CANNOT_FIT_MESSAGE);
             }
         }
 
@@ -1194,7 +1197,7 @@ PList doPListBigInt(PList left, PInt right,
             try {
                 return doPListInt(left, right.intValueExact(), profile);
             } catch (ArithmeticException | OutOfMemoryError e) {
-                throw raise(OverflowError, "cannot fit 'int' into an index-sized integer");
+                throw raise(OverflowError, CANNOT_FIT_MESSAGE);
             }
         }
 
@@ -1205,6 +1208,257 @@ Object doGeneric(Object left, Object right) {
         }
     }
 
+    @Builtin(name = __IMUL__, fixedNumOfArguments = 2)
+    @GenerateNodeFactory
+    abstract static class IMulNode extends PythonBuiltinNode {
+
+        public abstract PList execute(PList list, Object value);
+
+        @Specialization(guards = "isEmptyStorage(list)")
+        PList doEmptyBoolean(PList list, @SuppressWarnings("unused") boolean right) {
+            return list;
+        }
+
+        @Specialization(guards = "isEmptyStorage(list)")
+        PList doEmptyInt(PList list, @SuppressWarnings("unused") int right) {
+            return list;
+        }
+
+        @Specialization(guards = "isEmptyStorage(list)")
+        PList doEmptyLong(PList list, long right) {
+            try {
+                PInt.intValueExact(right);
+                return list;
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isEmptyStorage(list)")
+        PList doEmptyPInt(PList list, PInt right) {
+            try {
+                right.intValueExact();
+                return list;
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isIntStorage(list)")
+        PList doIntBoolean(PList list, boolean right) {
+            return doIntInt(list, right ? 1 : 0);
+        }
+
+        @Specialization(guards = "isIntStorage(list)")
+        PList doIntInt(PList list, int right) {
+            IntSequenceStorage store = (IntSequenceStorage) list.getSequenceStorage();
+            if (right < 1) {
+                store.clear();
+                return list;
+            }
+            try {
+                IntSequenceStorage copy = (IntSequenceStorage) store.copy();
+                for (int i = 1; i < right; i++) {
+                    store.extendWithIntStorage(copy);
+                }
+                return list;
+            } catch (OutOfMemoryError e) {
+                throw raise(MemoryError);
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isIntStorage(list)")
+        PList doIntLong(PList list, long right) {
+            try {
+                return doIntInt(list, PInt.intValueExact(right));
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isIntStorage(list)")
+        PList doIntPInt(PList list, PInt right) {
+            try {
+                return doIntInt(list, right.intValueExact());
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        PList doLongBoolean(PList list, boolean right) {
+            return doLongInt(list, right ? 1 : 0);
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        PList doLongInt(PList list, int right) {
+            LongSequenceStorage store = (LongSequenceStorage) list.getSequenceStorage();
+            if (right < 1) {
+                store.clear();
+                return list;
+            }
+            try {
+                LongSequenceStorage copy = (LongSequenceStorage) store.copy();
+                for (int i = 1; i < right; i++) {
+                    store.extendWithLongStorage(copy);
+                }
+                return list;
+            } catch (OutOfMemoryError e) {
+                throw raise(MemoryError);
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        PList doLongLong(PList list, long right) {
+            try {
+                return doLongInt(list, PInt.intValueExact(right));
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isLongStorage(list)")
+        PList doLongPInt(PList list, PInt right) {
+            try {
+                return doLongInt(list, right.intValueExact());
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        PList doDoubleBoolean(PList list, boolean right) {
+            return doDoubleInt(list, right ? 1 : 0);
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        PList doDoubleInt(PList list, int right) {
+            DoubleSequenceStorage store = (DoubleSequenceStorage) list.getSequenceStorage();
+            if (right < 1) {
+                store.clear();
+                return list;
+            }
+            try {
+                DoubleSequenceStorage copy = (DoubleSequenceStorage) store.copy();
+                for (int i = 1; i < right; i++) {
+                    store.extendWithDoubleStorage(copy);
+                }
+                return list;
+            } catch (OutOfMemoryError e) {
+                throw raise(MemoryError);
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        PList doDoubleLong(PList list, long right) {
+            try {
+                return doDoubleInt(list, PInt.intValueExact(right));
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isDoubleStorage(list)")
+        PList doDoublePInt(PList list, PInt right) {
+            try {
+                return doLongInt(list, right.intValueExact());
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isObjectStorage(list)")
+        PList doObjectBoolean(PList list, boolean right) {
+            return doDoubleInt(list, right ? 1 : 0);
+        }
+
+        @Specialization(guards = "isObjectStorage(list)")
+        PList doObjectInt(PList list, int right) {
+            ObjectSequenceStorage store = (ObjectSequenceStorage) list.getSequenceStorage();
+            if (right < 1) {
+                store.clear();
+                return list;
+            }
+            try {
+                ObjectSequenceStorage copy = (ObjectSequenceStorage) store.copy();
+                for (int i = 1; i < right; i++) {
+                    store.extend(copy);
+                }
+                return list;
+            } catch (OutOfMemoryError e) {
+                throw raise(MemoryError);
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isObjectStorage(list)")
+        PList doObjectLong(PList list, long right) {
+            try {
+                return doObjectInt(list, PInt.intValueExact(right));
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = "isObjectStorage(list)")
+        PList doObjectPInt(PList list, PInt right) {
+            try {
+                return doObjectInt(list, right.intValueExact());
+            } catch (ArithmeticException e) {
+                throw raise(OverflowError, MulNode.CANNOT_FIT_MESSAGE);
+            }
+        }
+
+        @Specialization(guards = {"!isInt(right)"})
+        Object doGeneric(PList list, Object right,
+                        @Cached("create(__INDEX__)") LookupAndCallUnaryNode dispatchIndex,
+                        @Cached("createIMulNode()") IMulNode imulNode) {
+            Object index = dispatchIndex.executeObject(right);
+            if (index != PNone.NO_VALUE) {
+                int iIndex;
+                try {
+                    iIndex = convertToInt(index);
+                } catch (ArithmeticException e) {
+                    throw raise(OverflowError, "cannot fit '%p' into an index-sized integer", index);
+                }
+
+                return imulNode.execute(list, iIndex);
+            }
+            throw raise(TypeError, "can't multiply sequence by non-int of type '%p'", right);
+        }
+
+        private int convertToInt(Object value) throws ArithmeticException {
+            if (value instanceof Integer) {
+                return (Integer) value;
+            }
+            if (value instanceof Boolean) {
+                return (Boolean) value ? 0 : 1;
+            }
+            if (value instanceof Long) {
+                return PInt.intValueExact((Long) value);
+            }
+            if (value instanceof PInt) {
+                return ((PInt) value).intValueExact();
+            }
+            throw raise(TypeError, "can't multiply sequence by non-int of type '%p'", value);
+        }
+
+        protected IMulNode createIMulNode() {
+            return ListBuiltinsFactory.IMulNodeFactory.create(new PNode[0]);
+        }
+
+        protected boolean isInt(Object value) {
+            return value instanceof Boolean || value instanceof Integer || value instanceof Long || value instanceof PInt;
+        }
+    }
+
     @Builtin(name = __RMUL__, fixedNumOfArguments = 2)
     @GenerateNodeFactory
     abstract static class RMulNode extends MulNode {