[GR-9908] There are not implemented inplace operations.

PullRequest: graalpython-open/58

Author: ppisl

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/grammar/BinaryArithTests.java

@@ -131,7 +131,7 @@ public void int64() {
     public void NonePlusInt() {
         String source = "a = None\n" + //
                         "a += 1\n";
-        assertLastLineError("TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'\n", source);
+        assertLastLineError("TypeError: unsupported operand type(s) for +=: 'NoneType' and 'int'\n", source);
     }
 
 }

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

@@ -541,7 +541,7 @@ def test_slice(self):
         u = self.type2test("spam")
         u[:2] = "h"
         self.assertEqual(u, list("ham"))
-    '''
+
     def test_iadd(self):
         super().test_iadd()
         u = self.type2test([0, 1])
@@ -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

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

@@ -0,0 +1,82 @@
+# Copyright (c) 2018, Oracle and/or its affiliates.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or data
+# (collectively the "Software"), free of charge and under any and all copyright
+# rights in the Software, and any and all patent rights owned or freely
+# licensable by each licensor hereunder covering either (i) the unmodified
+# Software as contributed to or provided by such licensor, or (ii) the Larger
+# Works (as defined below), to deal in both
+#
+# (a) the Software, and
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+#     one is included with the Software (each a "Larger Work" to which the
+#     Software is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import unittest
+
+class InplaceAssignmentTest(unittest.TestCase):
+    
+    def test_iadd_01(self):
+
+        class MyInt(int):
+            def __iadd__(self, value):
+                return 7
+            def __add__(self, value):
+                return 6
+
+        a = MyInt(10)
+        a += 4
+        self.assertEqual(a, 7)
+
+        a = MyInt(10)
+        a = a + 4
+        self.assertEqual(a, 6)
+
+    def test_iadd_02(self):
+
+        class MyInt(int):
+            def __add__(self, value):
+                return 6
+
+        a = MyInt(10)
+        a += 4
+        self.assertEqual(a, 6)
+
+        a = MyInt(10)
+        a = a + 4
+        self.assertEqual(a, 6)
+
+    def test_iadd_03(self):
+        
+        class MyInt(int):
+            def __new__(cls, value):
+                return int.__new__(cls, value)
+            def __iadd__(self, value):
+                return self + value + 1
+
+        a = MyInt(1)
+        a += 1
+        self.assertEqual(a, 3)

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

@@ -430,7 +430,7 @@ def __index__(self):
         a.insert(False, -1)
         self.assertEqual([-1,0,1], a)
 
-    def testStopIteration(self):
+    def test_StopIteration(self):
         l = [1.0]
         i = l.__iter__()
         i.__next__()
@@ -454,3 +454,28 @@ def testStopIteration(self):
         self.assertRaises(StopIteration, i.__next__)
         l.append(3)
         self.assertRaises(StopIteration, i.__next__)
+
+    def test_iadd_special(self):
+        a = [1]
+        a += (2,3)
+        self.assertEqual([1,2,3], a)
+
+        a += {'a' : 1, 'b' : 2}
+        self.assertEqual([1,2,3,'a','b'], a)
+        
+        a = [1]
+        a += range(2,5)
+        self.assertEqual([1,2,3,4], a)
+        self.assertRaises(TypeError, a.__iadd__, 1)
+
+        class MyList(list):
+            def __iadd__(self, value):
+                return super().__iadd__([100])
+
+        mya = MyList([1,2])
+        mya += [3]
+        self.assertEqual([1,2,100], mya)
+        
+        a = [1,2]
+        a += a 
+        self.assertEqual([1,2,1,2], a)

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

@@ -26,6 +26,7 @@
 package com.oracle.graal.python.builtins.objects.list;
 
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__ADD__;
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__IADD__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__BOOL__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__CONTAINS__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__DELITEM__;
@@ -487,6 +488,8 @@ protected boolean isKnownStorage(PList list) {
     @GenerateNodeFactory
     public abstract static class ListExtendNode extends PythonBuiltinNode {
 
+        public abstract PNone execute(PList list, Object source);
+
         @Specialization(guards = {"isPSequenceWithStorage(source)"}, rewriteOn = {SequenceStoreException.class})
         public PNone extendSequenceStore(PList list, Object source) throws SequenceStoreException {
             SequenceStorage target = list.getSequenceStorage();
@@ -1092,16 +1095,70 @@ PList doPList(PList left, PList right) {
             }
         }
 
-        protected boolean isList(Object o) {
-            return o instanceof PList;
-        }
-
         @Specialization(guards = "!isList(right)")
         Object doGeneric(@SuppressWarnings("unused") Object left, Object right) {
             throw raise(TypeError, "can only concatenate list (not \"%p\") to list", right);
         }
     }
 
+    @Builtin(name = __IADD__, fixedNumOfArguments = 2)
+    @GenerateNodeFactory
+    abstract static class IAddNode extends PythonBuiltinNode {
+
+        @Specialization(guards = "areBothIntStorage(left,right)")
+        PList doPListInt(PList left, PList right) {
+            IntSequenceStorage leftStore = (IntSequenceStorage) left.getSequenceStorage();
+            IntSequenceStorage rightStore = (IntSequenceStorage) right.getSequenceStorage();
+            leftStore.extendWithIntStorage(rightStore);
+            return left;
+        }
+
+        @Specialization(guards = "areBothLongStorage(left,right)")
+        PList doPListLong(PList left, PList right) {
+            LongSequenceStorage leftStore = (LongSequenceStorage) left.getSequenceStorage();
+            LongSequenceStorage rightStore = (LongSequenceStorage) right.getSequenceStorage();
+            leftStore.extendWithLongStorage(rightStore);
+            return left;
+        }
+
+        @Specialization(guards = "areBothDoubleStorage(left,right)")
+        PList doPListDouble(PList left, PList right) {
+            DoubleSequenceStorage leftStore = (DoubleSequenceStorage) left.getSequenceStorage();
+            DoubleSequenceStorage rightStore = (DoubleSequenceStorage) right.getSequenceStorage();
+            leftStore.extendWithDoubleStorage(rightStore);
+            return left;
+        }
+
+        @Specialization(guards = "areBothObjectStorage(left,right)")
+        PList doPListObject(PList left, PList right) {
+            ObjectSequenceStorage leftStore = (ObjectSequenceStorage) left.getSequenceStorage();
+            ObjectSequenceStorage rightStore = (ObjectSequenceStorage) right.getSequenceStorage();
+            leftStore.extend(rightStore);
+            return left;
+        }
+
+        @Specialization(guards = "isNotSameStorage(left, right)")
+        PList doPList(PList left, PList right) {
+            left.extend(right);
+            return left;
+        }
+
+        @Specialization(guards = "!isList(right)")
+        PList doPList(PList left, Object right,
+                        @Cached("createExtendNode()") ListExtendNode extendNode) {
+            extendNode.execute(left, right);
+            return left;
+        }
+
+        protected ListExtendNode createExtendNode() {
+            return ListBuiltinsFactory.ListExtendNodeFactory.create(new PNode[0]);
+        }
+
+        protected boolean isNotSameStorage(PList left, PList right) {
+            return !(PGuards.areBothIntStorage(right, left) || PGuards.areBothDoubleStorage(right, left) || PGuards.areBothLongStorage(right, left) || PGuards.areBothObjectStorage(right, left));
+        }
+    }
+
     @Builtin(name = __MUL__, fixedNumOfArguments = 2)
     @GenerateNodeFactory
     abstract static class MulNode extends PythonBuiltinNode {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/NodeFactory.java

@@ -61,6 +61,7 @@
 import com.oracle.graal.python.nodes.expression.BinaryArithmetic;
 import com.oracle.graal.python.nodes.expression.BinaryComparisonNode;
 import com.oracle.graal.python.nodes.expression.CastToBooleanNode;
+import com.oracle.graal.python.nodes.expression.InplaceArithmetic;
 import com.oracle.graal.python.nodes.expression.IsNode;
 import com.oracle.graal.python.nodes.expression.OrNode;
 import com.oracle.graal.python.nodes.expression.UnaryArithmetic;
@@ -310,6 +311,39 @@ public PNode createUnaryOperation(String string, PNode operand) {
         }
     }
 
+    public PNode createInplaceOperation(String string, PNode left, PNode right) {
+        switch (string) {
+            case "+=":
+                return InplaceArithmetic.IAdd.create(left, right);
+            case "-=":
+                return InplaceArithmetic.ISub.create(left, right);
+            case "*=":
+                return InplaceArithmetic.IMul.create(left, right);
+            case "/=":
+                return InplaceArithmetic.ITrueDiv.create(left, right);
+            case "//=":
+                return InplaceArithmetic.IFloorDiv.create(left, right);
+            case "%=":
+                return InplaceArithmetic.IMod.create(left, right);
+            case "**=":
+                return InplaceArithmetic.IPow.create(left, right);
+            case "<<=":
+                return InplaceArithmetic.ILShift.create(left, right);
+            case ">>=":
+                return InplaceArithmetic.IRShift.create(left, right);
+            case "&=":
+                return InplaceArithmetic.IAnd.create(left, right);
+            case "|=":
+                return InplaceArithmetic.IOr.create(left, right);
+            case "^=":
+                return InplaceArithmetic.IXor.create(left, right);
+            case "@=":
+                return InplaceArithmetic.IMatMul.create(left, right);
+            default:
+                throw new RuntimeException("unexpected operation: " + string);
+        }
+    }
+
     public PNode createBinaryOperation(String string, PNode left, PNode right) {
         switch (string) {
             case "+":

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PGuards.java

@@ -139,6 +139,10 @@ public static boolean isDoubleStorage(PList list) {
         return list.getSequenceStorage() instanceof DoubleSequenceStorage;
     }
 
+    public static boolean areBothDoubleStorage(PList first, PList second) {
+        return first.getSequenceStorage() instanceof DoubleSequenceStorage && second.getSequenceStorage() instanceof DoubleSequenceStorage;
+    }
+
     public static boolean isListStorage(PList list) {
         return list.getSequenceStorage() instanceof ListSequenceStorage;
     }
@@ -155,6 +159,10 @@ public static boolean areBothObjectStorage(PList first, PList second) {
         return first.getSequenceStorage() instanceof ObjectSequenceStorage && second.getSequenceStorage() instanceof ObjectSequenceStorage;
     }
 
+    public static boolean isList(Object o) {
+        return o instanceof PList;
+    }
+
     public static boolean isObjectStorageIterator(PSequenceIterator iterator) {
         if (!iterator.isPSequence()) {
             return false;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialMethodNames.java

@@ -120,6 +120,7 @@ public abstract class SpecialMethodNames {
     public static final String __IDIVMOD__ = "__idivmod__";
     public static final String __IPOW__ = "__ipow__";
     public static final String __ILSHIFT__ = "__ilshift__";
+    public static final String __IRSHIFT__ = "__irshift__";
     public static final String __IAND__ = "__iand__";
     public static final String __IXOR__ = "__ixor__";
     public static final String __IOR__ = "__ior__";