Disable Branch tests on DSL interpreter; look into most of remaining TODOs

Author: DSouzaM

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/generator/CommonGeneratorBuiltins.java

@@ -268,7 +268,6 @@ static Object genericBytecodeDSL(VirtualFrame frame, Node inliningTarget, PGener
                     arguments = prepareArguments(self);
                 } else {
                     // Subsequent invocations: call a continuation root node.
-                    // TODO: forward arguments into the continuation frame (e.g., exception state).
                     arguments = new Object[]{continuation.getFrame(), sendValue};
                 }
 

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

@@ -2399,6 +2399,10 @@ public Void visit(StmtTy.Assert node) {
 
         // --------------------- assign ------------------------
 
+        /**
+         * Generates code to store the value produced by {@link #generateValue} into the visited
+         * expression.
+         */
         public class StoreVisitor implements BaseBytecodeDSLVisitor<Void> {
             private final Builder b = StatementCompiler.this.b;
             private final Runnable generateValue;
@@ -2441,12 +2445,21 @@ public Void visit(ExprTy.Subscript node) {
                 return null;
             }
 
+            /**
+             * This method unpacks the rhs (a sequence/iterable) to the elements on the lhs
+             * (specified by {@code nodes}.
+             */
             private void visitIterableAssign(ExprTy[] nodes) {
                 b.beginBlock();
 
-                // TODO if it is a variable directly, use that variable instead of going to a temp
+                /**
+                 * The rhs should be fully evaluated and unpacked into the expected number of
+                 * elements before storing values into the lhs (e.g., if an lhs element is f().attr,
+                 * but computing or unpacking rhs throws, f() is not computed). Thus, the unpacking
+                 * step stores the unpacked values into intermediate variables, and then those
+                 * variables are copied into the lhs elements afterward.
+                 */
                 BytecodeLocal[] targets = new BytecodeLocal[nodes.length];
-
                 for (int i = 0; i < targets.length; i++) {
                     targets[i] = b.createLocal();
                 }
@@ -3838,7 +3851,6 @@ private ConstantValue foldConstantOp(ExprTy value) {
         private ConstantValue foldUnaryOpConstant(ExprTy.UnaryOp unaryOp) {
             assert unaryOp.op == UnaryOpTy.USub;
             assert unaryOp.operand instanceof ExprTy.Constant : unaryOp.operand;
-            // TODO: why does the version in Compiler.java save and restore locations?
             ExprTy.Constant c = (ExprTy.Constant) unaryOp.operand;
             ConstantValue ret = c.value.negate();
             assert ret != null;
@@ -3851,7 +3863,6 @@ private ConstantValue foldUnaryOpConstant(ExprTy.UnaryOp unaryOp) {
         private ConstantValue foldBinOpComplexConstant(ExprTy.BinOp binOp) {
             assert (binOp.left instanceof ExprTy.UnaryOp || binOp.left instanceof ExprTy.Constant) && binOp.right instanceof ExprTy.Constant : binOp.left + " " + binOp.right;
             assert binOp.op == OperatorTy.Sub || binOp.op == OperatorTy.Add;
-            // TODO: why does the version in Compiler.java save and restore locations?
             ConstantValue left;
             if (binOp.left instanceof ExprTy.UnaryOp) {
                 left = foldUnaryOpConstant((ExprTy.UnaryOp) binOp.left);

graalpython/lib-python/3/test/support/__init__.py

@@ -1056,6 +1056,17 @@ def impl_detail(msg=None, **guards):
         msg = msg.format(' or '.join(guardnames))
     return unittest.skip(msg)
 
+def bytecode_dsl_excluded(test):
+    """
+    Decorator for tests that don't apply to the Bytecode DSL interpreter.
+    """
+    try:
+        if sys.implementation.name == 'graalpy' and __graalpython__.is_bytecode_dsl_interpreter:
+            return unittest.skip("implementation detail not available on the Bytecode DSL interpreter")
+    except NameError:
+        pass
+    return test
+
 def _parse_guards(guards):
     # Returns a tuple ({platform_name: run_me}, default_value)
     if not guards:

graalpython/lib-python/3/test/test_sys_settrace.py

@@ -1869,6 +1869,7 @@ def no_jump_without_trace_function():
         raise AssertionError("Trace-function-less jump failed to fail")
 
 
+@support.bytecode_dsl_excluded
 class JumpTestCase(unittest.TestCase):
     def setUp(self):
         self.addCleanup(sys.settrace, sys.gettrace())