eclipseformat

Author: Michal Medvecky

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/compiler/bytecode_dsl/RootNodeCompiler.java

@@ -3699,7 +3699,9 @@ private void emitPatternNotImplemented(String kind) {
         }
 
         /**
-         * Saves subject of the pattern context into BytecodeLocal variable, to be restored eventually.
+         * Saves subject of the pattern context into BytecodeLocal variable, to be restored
+         * eventually.
+         * 
          * @param pc Pattern context, which subject needs to be saved.
          * @return Subject saved in local variable.
          */
@@ -3713,6 +3715,7 @@ private BytecodeLocal patternContextSubjectSave(PatternContext pc) {
 
         /**
          * Loads pattern context subject back into pattern context.
+         * 
          * @param pcSave Variable to restore pattern context subject from.
          * @param pc Pattern context into which the subject should be restored.
          */
@@ -3723,8 +3726,9 @@ private void patternContextSubjectLoad(BytecodeLocal pcSave, PatternContext pc)
         }
 
         /**
-         * Check if attribute and keyword attribute lengths match, or if there isn't too much patterns or attributes.
-         * Throws error on fail.
+         * Check if attribute and keyword attribute lengths match, or if there isn't too much
+         * patterns or attributes. Throws error on fail.
+         * 
          * @param patLen Patterns count
          * @param attrsLen Attributes count
          * @param kwdPatLen Keyword attributes count
@@ -3742,9 +3746,11 @@ private void classMatchLengthChecks(int patLen, int attrsLen, int kwdPatLen, Pat
         }
 
         /**
-         * Visits sub-patterns for class pattern matching. Regular, positional patterns are handled first, then the
-         * keyword patterns (e.g. the "class.attribute = [keyword] pattern"). Generates boolean value based on
-         * results of the subpatterns; values are evaluated using the AND operator.
+         * Visits sub-patterns for class pattern matching. Regular, positional patterns are handled
+         * first, then the keyword patterns (e.g. the "class.attribute = [keyword] pattern").
+         * Generates boolean value based on results of the subpatterns; values are evaluated using
+         * the AND operator.
+         * 
          * @param patterns Patterns to check as subpatterns.
          * @param kwdPatterns Keyword patterns to check as subpatterns.
          * @param attrsValueUnpacked Values to use as `pc.subject` in sub-pattern check.
@@ -3760,31 +3766,31 @@ private void classMatchVisitSubpatterns(PatternTy[] patterns, PatternTy[] kwdPat
             } else {
                 BytecodeLocal temp = b.createLocal();
                 b.beginStoreLocal(temp);
-                    b.beginPrimitiveBoolAnd();
-                    for (int i = 0; i < patLen; i++) {
-                        b.beginBlock();
-                        b.beginStoreLocal(pc.subject);
-                        b.beginArrayIndex(i);
-                        b.emitLoadLocal(attrsValueUnpacked);
-                        b.endArrayIndex();
-                        b.endStoreLocal();
+                b.beginPrimitiveBoolAnd();
+                for (int i = 0; i < patLen; i++) {
+                    b.beginBlock();
+                    b.beginStoreLocal(pc.subject);
+                    b.beginArrayIndex(i);
+                    b.emitLoadLocal(attrsValueUnpacked);
+                    b.endArrayIndex();
+                    b.endStoreLocal();
 
-                        visitSubpattern(patterns[i], pc);
-                        b.endBlock();
-                    }
+                    visitSubpattern(patterns[i], pc);
+                    b.endBlock();
+                }
 
-                    for (int i = 0, j = patLen; i < attrsLen; i++, j++) {
-                        b.beginBlock();
-                        b.beginStoreLocal(pc.subject);
-                        b.beginArrayIndex(j);
-                        b.emitLoadLocal(attrsValueUnpacked);
-                        b.endArrayIndex();
-                        b.endStoreLocal();
+                for (int i = 0, j = patLen; i < attrsLen; i++, j++) {
+                    b.beginBlock();
+                    b.beginStoreLocal(pc.subject);
+                    b.beginArrayIndex(j);
+                    b.emitLoadLocal(attrsValueUnpacked);
+                    b.endArrayIndex();
+                    b.endStoreLocal();
 
-                        visitSubpattern(kwdPatterns[i], pc);
-                        b.endBlock();
-                    }
-                    b.endPrimitiveBoolAnd();
+                    visitSubpattern(kwdPatterns[i], pc);
+                    b.endBlock();
+                }
+                b.endPrimitiveBoolAnd();
                 b.endStoreLocal();
 
                 patternContextSubjectLoad(pcSave, pc);
@@ -3866,7 +3872,9 @@ private void doVisitPattern(PatternTy.MatchClass node, PatternContext pc) {
         }
 
         /**
-         * Checks if keyword argument names aren't the same or if their name isn't forbidden. Raises error at fail.
+         * Checks if keyword argument names aren't the same or if their name isn't forbidden. Raises
+         * error at fail.
+         * 
          * @param attrs Attributes to check.
          * @param patterns Patterns for error source range.
          */
@@ -3891,8 +3899,8 @@ private static int lengthOrZero(Object[] p) {
         }
 
         /**
-         * Checks if keys in pattern are, if present, longer than keys in subject. If yes, pattern should fail,
-         * otherwise, we should continue with evaluation.
+         * Checks if keys in pattern are, if present, longer than keys in subject. If yes, pattern
+         * should fail, otherwise, we should continue with evaluation.
          *
          * Generates result of the comparison (boolean).
          *
@@ -3909,8 +3917,8 @@ private void checkPatternKeysLength(int keyLen, PatternContext pc) {
         }
 
         /**
-         * Will process pattern keys: Attributes evaluation and constant folding. Checks for duplicate keys and
-         * that only literals and attributes lookups are being matched.
+         * Will process pattern keys: Attributes evaluation and constant folding. Checks for
+         * duplicate keys and that only literals and attributes lookups are being matched.
          *
          * Generates array.
          *
@@ -3962,56 +3970,56 @@ private void mappingVisitSubpatterns(PatternTy[] patterns, BytecodeLocal values,
             int patLen = patterns.length;
 
             b.beginBlock();
-                // unpack values from pc.subject
-                BytecodeLocal valuesUnpacked = b.createLocal();
-                    b.beginStoreLocal(valuesUnpacked);
-                        b.beginUnpackSequence(patLen);
-                        b.emitLoadLocal(values);
-                    b.endUnpackSequence();
-                b.endStoreLocal();
-
-                // backup pc.subject, it will get replaced for sub-patterns
-                BytecodeLocal pcSave = patternContextSubjectSave(pc);
+            // unpack values from pc.subject
+            BytecodeLocal valuesUnpacked = b.createLocal();
+            b.beginStoreLocal(valuesUnpacked);
+            b.beginUnpackSequence(patLen);
+            b.emitLoadLocal(values);
+            b.endUnpackSequence();
+            b.endStoreLocal();
 
-                BytecodeLocal temp = b.createLocal();
-                b.beginStoreLocal(temp);
-                    b.beginPrimitiveBoolAnd();
-                        boolean hadNonWildcardPattern = false;
-                        for (int i = 0; i < patLen; i++) {
-                            if (wildcardCheck(patterns[i])) {
-                                continue;
-                            }
-                            hadNonWildcardPattern = true;
-                            b.beginBlock();
-                                b.beginStoreLocal(pc.subject);
-                                    b.beginArrayIndex(i);
-                                        b.emitLoadLocal(valuesUnpacked);
-                                    b.endArrayIndex();
-                                b.endStoreLocal();
+            // backup pc.subject, it will get replaced for sub-patterns
+            BytecodeLocal pcSave = patternContextSubjectSave(pc);
 
-                                visitSubpattern(patterns[i], pc);
-                            b.endBlock();
-                        }
-                        if (!hadNonWildcardPattern) {
-                            b.emitLoadConstant(true);
-                        }
-                    b.endPrimitiveBoolAnd();
+            BytecodeLocal temp = b.createLocal();
+            b.beginStoreLocal(temp);
+            b.beginPrimitiveBoolAnd();
+            boolean hadNonWildcardPattern = false;
+            for (int i = 0; i < patLen; i++) {
+                if (wildcardCheck(patterns[i])) {
+                    continue;
+                }
+                hadNonWildcardPattern = true;
+                b.beginBlock();
+                b.beginStoreLocal(pc.subject);
+                b.beginArrayIndex(i);
+                b.emitLoadLocal(valuesUnpacked);
+                b.endArrayIndex();
                 b.endStoreLocal();
 
-                patternContextSubjectLoad(pcSave, pc);
+                visitSubpattern(patterns[i], pc);
+                b.endBlock();
+            }
+            if (!hadNonWildcardPattern) {
+                b.emitLoadConstant(true);
+            }
+            b.endPrimitiveBoolAnd();
+            b.endStoreLocal();
 
-                b.emitLoadLocal(temp);
+            patternContextSubjectLoad(pcSave, pc);
+
+            b.emitLoadLocal(temp);
             b.endBlock();
         }
 
         private void doVisitPattern(PatternTy.MatchMapping node, PatternContext pc) {
             /**
-             * Mapping pattern match will take the keys and check, whether the keys in the pattern are
-             * present in the subject. This is good enough, since the pattern needs only to be a subset of the subject.
-             * Keys aren't evaluated as subpatterns.
+             * Mapping pattern match will take the keys and check, whether the keys in the pattern
+             * are present in the subject. This is good enough, since the pattern needs only to be a
+             * subset of the subject. Keys aren't evaluated as subpatterns.
              *
-             * After the key check, the values of the pattern are patterns as well and are evaluated as sub-patterns
-             * with values in the subject used as separate respective subjects.
+             * After the key check, the values of the pattern are patterns as well and are evaluated
+             * as sub-patterns with values in the subject used as separate respective subjects.
              */
             ExprTy[] keys = node.keys;
             PatternTy[] patterns = node.patterns;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/bytecode/CopyDictWithoutKeysNode.java

@@ -47,10 +47,12 @@
 import com.oracle.graal.python.nodes.PNodeWithContext;
 import com.oracle.graal.python.runtime.object.PFactory;
 import com.oracle.truffle.api.CompilerAsserts;
+import com.oracle.truffle.api.bytecode.OperationProxy;
 import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.GenerateInline;
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.Frame;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/bytecode_dsl/PBytecodeDSLRootNode.java

@@ -310,6 +310,7 @@
 @OperationProxy(value = PyObjectIsNotTrueNode.class, name = "Not")
 @OperationProxy(value = ListNodes.AppendNode.class, name = "ListAppend")
 @OperationProxy(value = SetNodes.AddNode.class, name = "SetAdd")
+// @OperationProxy(value = CopyDictWithoutKeysNode.class, name = "CopyDictWithoutKeys")
 @ShortCircuitOperation(name = "BoolAnd", booleanConverter = PyObjectIsTrueNode.class, operator = Operator.AND_RETURN_VALUE)
 @ShortCircuitOperation(name = "BoolOr", booleanConverter = PyObjectIsTrueNode.class, operator = Operator.OR_RETURN_VALUE)
 @ShortCircuitOperation(name = "PrimitiveBoolAnd", operator = Operator.AND_RETURN_VALUE)
@@ -1147,7 +1148,8 @@ public static PDict perform(VirtualFrame frame, Object map, Object[] keys, @Cach
     @ConstantOperand(type = LocalAccessor.class)
     public static final class MatchClass {
         @Specialization
-        public static Object perform(VirtualFrame frame, LocalAccessor attributes, Object subject, Object type, int nargs, TruffleString[] kwArgs, @Bind BytecodeNode bytecodeNode, @Cached MatchClassNode node) {
+        public static Object perform(VirtualFrame frame, LocalAccessor attributes, Object subject, Object type, int nargs, TruffleString[] kwArgs, @Bind BytecodeNode bytecodeNode,
+                        @Cached MatchClassNode node) {
             Object attrs = node.execute(frame, subject, type, nargs, kwArgs);
             attributes.setObject(bytecodeNode, frame, attrs);
             return attrs != null;