[GR-23215] Make test_dictcomps pass.

PullRequest: graalpython/991

Author: tomasstupka

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

@@ -37,6 +37,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+import unittest
 
 def assert_raises(err, fn, *args, **kwargs):
     raised = False
@@ -117,3 +118,30 @@ def __init__(self):
         id(a) # id is stored in a HiddenKey
 
     return
+
+class IllegaAssigmentTest(unittest.TestCase):
+    def test_illegal_assignment(self):
+        with self.assertRaisesRegex(SyntaxError, "assign to function call"):
+            compile("a() = 1", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to function call"):
+            compile("a() += 1", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to function call"):
+            str = "def set() :\n\tprint(42)\n\nset() = 5"
+            compile(str, "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to function call"):
+            compile("a(), b, c = (1, 2, 3)", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to function call"):
+            compile("a, b(), c = (1, 2, 3)", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to dict comprehension"):
+            compile("{s:s for s in [1]}, b, c = (1, 2, 3)", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to set comprehension"):
+            compile("{s for s in [1]}, b, c = (1, 2, 3)", "<test>", "exec")
+
+        with self.assertRaisesRegex(SyntaxError, "assign to list comprehension"):
+            compile("[s for s in [1]], b, c = (1, 2, 3)", "<test>", "exec")

graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/test_dictcomps.txt

@@ -1,6 +1,7 @@
 *DictComprehensionTest.test_basics
 *DictComprehensionTest.test_evaluation_order
 *DictComprehensionTest.test_global_visibility
+*DictComprehensionTest.test_illegal_assignment
 *DictComprehensionTest.test_local_visibility
 *DictComprehensionTest.test_scope_isolation
 *DictComprehensionTest.test_scope_isolation_from_global

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/parser/sst/FactorySSTVisitor.java

@@ -60,6 +60,7 @@
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.complex.PComplex;
 import com.oracle.graal.python.builtins.objects.function.Signature;
+import com.oracle.graal.python.nodes.BuiltinNames;
 import com.oracle.graal.python.nodes.EmptyNode;
 import com.oracle.graal.python.nodes.NoValueNode;
 import com.oracle.graal.python.nodes.NodeFactory;
@@ -244,6 +245,7 @@ public PNode visit(AssignmentSSTNode node) {
         ExpressionNode[] lhs = new ExpressionNode[node.lhs.length];
         for (int i = 0; i < node.lhs.length; i++) {
             SSTNode sstLhs = node.lhs[i];
+            checkCannotAssignTo(sstLhs);
             lhs[i] = (ExpressionNode) sstLhs.accept(this);
         }
         ExpressionNode rhs = (ExpressionNode) node.rhs.accept(this);
@@ -268,6 +270,7 @@ public PNode visit(AssignmentSSTNode node) {
 
     @Override
     public PNode visit(AugAssignmentSSTNode node) {
+        checkCannotAssignTo(node.lhs);
         ExpressionNode lhs = (ExpressionNode) node.lhs.accept(this);
         if (!(lhs instanceof ReadNode)) {
             throw errors.raiseInvalidSyntax(source, createSourceSection(node.startOffset, node.endOffset), "illegal expression for augmented assignment");
@@ -280,6 +283,36 @@ public PNode visit(AugAssignmentSSTNode node) {
         return result;
     }
 
+    private void checkCannotAssignTo(SSTNode lhs) throws RuntimeException {
+        if (lhs instanceof ForComprehensionSSTNode) {
+            String calleeName;
+            switch (((ForComprehensionSSTNode) lhs).resultType) {
+                case PList:
+                    calleeName = BuiltinNames.LIST;
+                    break;
+                case PSet:
+                    calleeName = BuiltinNames.SET;
+                    break;
+                case PDict:
+                    calleeName = BuiltinNames.DICT;
+                    break;
+                default:
+                    calleeName = null;
+            }
+            if (calleeName == null) {
+                throw errors.raiseInvalidSyntax(source, createSourceSection(lhs.startOffset, lhs.endOffset), "cannot assign to comprehension");
+            } else {
+                throw errors.raiseInvalidSyntax(source, createSourceSection(lhs.startOffset, lhs.endOffset), "cannot assign to %s comprehension", calleeName);
+            }
+        } else if (lhs instanceof CallSSTNode) {
+            throw errors.raiseInvalidSyntax(source, createSourceSection(lhs.startOffset, lhs.endOffset), "cannot assign to function call");
+        } else if (lhs instanceof CollectionSSTNode) {
+            for (SSTNode n : ((CollectionSSTNode) lhs).getValues()) {
+                checkCannotAssignTo(n);
+            }
+        }
+    }
+
     @Override
     public PNode visit(BinaryArithmeticSSTNode node) {
         ExpressionNode left = (ExpressionNode) node.left.accept(this);