[GR-9160] Change scope parsing to single-pass-and-fixup

PullRequest: graalpython/151

Author: lukasstadler

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

@@ -0,0 +1,48 @@
+# Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# 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.
+
+def test_lambda_simple():
+    l = lambda x : x * 2
+    v = l(5)
+    assert v == 10
+
+def test_lambda_condition_special():
+    v = [a for a in (1,2,3) if lambda x : x*2]
+    assert v == [1,2,3]
+

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

@@ -27,7 +27,6 @@
 
 import java.math.BigInteger;
 import java.util.List;
-import java.util.Set;
 
 import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.objects.complex.PComplex;
@@ -274,7 +273,7 @@ public PNode createListLiteral(PNode[] values) {
         return ListLiteralNode.create(values);
     }
 
-    public PNode createSetLiteral(Set<PNode> values) {
+    public PNode createSetLiteral(List<PNode> values) {
         PNode[] convertedValues = values.toArray(new PNode[values.size()]);
         return new SetLiteralNode(convertedValues);
     }
@@ -524,7 +523,7 @@ public PNode createSetAttribute(PNode object, String key, PNode rhs) {
         return SetAttributeNode.create(key, object, rhs);
     }
 
-    public PNode createDestructuringAssignment(PNode rhs, List<ReadNode> slots, int starredIndex, PNode[] assignments) {
+    public PNode createDestructuringAssignment(PNode rhs, ReadNode[] slots, int starredIndex, PNode[] assignments) {
         return DestructuringAssignmentNode.create(rhs, slots, starredIndex, assignments);
     }
 

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

@@ -45,6 +45,9 @@
 @ImportStatic({PGuards.class, PythonOptions.class, SpecialMethodNames.class, SpecialAttributeNames.class, BuiltinNames.class})
 @GenerateWrapper
 public abstract class PNode extends PBaseNode implements InstrumentableNode {
+
+    public static final PNode[] EMPTY_ARRAY = new PNode[0];
+
     @CompilationFinal private SourceSection sourceSection;
     @CompilationFinal private boolean isStmt = false;
     @CompilationFinal private boolean isRoot = false;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/DestructuringAssignmentNode.java

@@ -32,7 +32,6 @@
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.SyntaxError;
 
 import java.util.Arrays;
-import java.util.List;
 
 import com.oracle.graal.python.builtins.modules.BuiltinFunctions;
 import com.oracle.graal.python.builtins.modules.BuiltinFunctionsFactory;
@@ -68,18 +67,18 @@ public final class DestructuringAssignmentNode extends PNode implements WriteNod
     private final ConditionProfile errorProfile2 = ConditionProfile.createBinaryProfile();
     private final int starredIndex;
 
-    public DestructuringAssignmentNode(PNode rhs, List<ReadNode> slots, int starredIndex, PNode[] assignments) {
+    public DestructuringAssignmentNode(PNode rhs, ReadNode[] slots, int starredIndex, PNode[] assignments) {
         this.rhs = rhs;
         this.starredIndex = starredIndex;
         this.assignments = assignments;
-        this.slots = new WriteNode[slots.size()];
-        for (int i = 0; i < slots.size(); i++) {
-            this.slots[i] = (WriteNode) slots.get(i).makeWriteNode(null);
+        this.slots = new WriteNode[slots.length];
+        for (int i = 0; i < slots.length; i++) {
+            this.slots[i] = (WriteNode) slots[i].makeWriteNode(null);
         }
         this.lenNode = starredIndex == -1 ? null : BuiltinFunctionsFactory.LenNodeFactory.create();
     }
 
-    public static PNode create(PNode rhs, List<ReadNode> slots, int starredIndex, PNode[] assignments) {
+    public static PNode create(PNode rhs, ReadNode[] slots, int starredIndex, PNode[] assignments) {
         return new DestructuringAssignmentNode(rhs, slots, starredIndex, assignments);
     }
 

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/frame/FrameSlotIDs.java

@@ -27,5 +27,4 @@
 
 public abstract class FrameSlotIDs {
     public static final String RETURN_SLOT_ID = "<return_val>";
-    public static final String LIST_COMPREHENSION_SLOT_ID = "<list_comp_val>";
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/function/BuiltinFunctionRootNode.java

@@ -145,7 +145,7 @@ public Object execute(VirtualFrame frame) {
     }
 
     public BuiltinFunctionRootNode(PythonLanguage language, Builtin builtin, NodeFactory<? extends PythonBuiltinBaseNode> factory, boolean declaresExplicitSelf) {
-        super(language, null);
+        super(language);
         this.builtin = builtin;
         this.factory = factory;
         this.declaresExplicitSelf = declaresExplicitSelf;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/parser/AssignmentTranslator.java

@@ -59,10 +59,10 @@ public class AssignmentTranslator extends Python3BaseVisitor<PNode> {
 
     private final NodeFactory factory;
     private final TranslationEnvironment environment;
-    private final PythonBaseTreeTranslator<?> translator;
+    private final PythonTreeTranslator translator;
     private final PythonCore core;
 
-    public AssignmentTranslator(PythonCore core, TranslationEnvironment environment, PythonBaseTreeTranslator<?> translator) {
+    public AssignmentTranslator(PythonCore core, TranslationEnvironment environment, PythonTreeTranslator translator) {
         this.core = core;
         this.factory = core.getLanguage().getNodeFactory();
         this.environment = environment;
@@ -103,37 +103,37 @@ private PNode createAssignment(PNode lhs, PNode rhs) {
     }
 
     private PNode createDestructuringAssignment(PNode[] leftHandSides, PNode rhs) {
-        List<PNode> statements = new ArrayList<>();
-        List<ReadNode> temps = new ArrayList<>();
+        PNode[] statements = new PNode[leftHandSides.length];
+        ReadNode[] temps = new ReadNode[leftHandSides.length];
         int starredIndex = -1;
         for (int i = 0; i < leftHandSides.length; i++) {
             ReadNode tempRead = environment.makeTempLocalVariable();
-            temps.add(tempRead);
+            temps[i] = tempRead;
             if (leftHandSides[i] instanceof StarredExpressionNode) {
                 if (starredIndex != -1) {
                     throw core.raise(SyntaxError, "two starred expressions in assignment");
                 }
                 starredIndex = i;
-                statements.add(createAssignment(((StarredExpressionNode) leftHandSides[i]).getValue(), (PNode) tempRead));
+                statements[i] = createAssignment(((StarredExpressionNode) leftHandSides[i]).getValue(), (PNode) tempRead);
             } else {
-                statements.add(createAssignment(leftHandSides[i], (PNode) tempRead));
+                statements[i] = createAssignment(leftHandSides[i], (PNode) tempRead);
             }
         }
-        return factory.createDestructuringAssignment(rhs, temps, starredIndex, statements.toArray(new PNode[0]));
+        return factory.createDestructuringAssignment(rhs, temps, starredIndex, statements);
     }
 
     private PNode createMultiAssignment(List<NormassignContext> normassign, PNode mostRhs, PNode mostLhs) {
         ReadNode tmp = environment.makeTempLocalVariable();
         PNode tmpWrite = tmp.makeWriteNode(mostRhs);
-        List<PNode> assignments = new ArrayList<>();
-        assignments.add(tmpWrite);
-        assignments.add(createAssignment(mostLhs, (PNode) tmp));
+        PNode[] assignments = new PNode[normassign.size() + 1];
+        assignments[0] = tmpWrite;
+        assignments[1] = createAssignment(mostLhs, (PNode) tmp);
         for (int i = 0; i < normassign.size() - 1; i++) {
             NormassignContext normassignContext = normassign.get(i);
             if (normassignContext.yield_expr() != null) {
                 throw core.raise(SyntaxError, "assignment to yield expression not possible");
             }
-            assignments.add(createAssignment(normassignContext.accept(this), (PNode) tmp));
+            assignments[i + 2] = createAssignment(normassignContext.accept(this), (PNode) tmp);
         }
         return factory.createBlock(assignments);
     }