Add tests for generator/debugger interaction

test/mjsunit/debug-scopes.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Flags: --expose-debug-as debug --allow-natives-syntax
+// Flags: --expose-debug-as debug --allow-natives-syntax --harmony-generators
 // The functions used for testing backtraces. They are at the top to make the
 // testing of source line/column easier.
 
 // Get the Debug object exposed from the debug context global object.
 var Debug = debug.Debug;
 
 var test_name;
 var listener_delegate;
 var listener_called;
 var exception;
@@ skipping 15 matching lines @@
   }
 }
 
 // Add the debug event listener.
 Debug.setListener(listener);
 
 
 // Initialize for a new test.
 function BeginTest(name) {
   test_name = name;
-  listener_delegate = null;
+  var keep_listener = name.match(/^Generator/);
+  if (!keep_listener)
+    listener_delegate = null;
   listener_called = false;
   exception = null;
   begin_test_count++;
 }
 
 
 // Check result of a test.
 function EndTest() {
-  assertTrue(listener_called, "listerner not called for " + test_name);
+  assertTrue(listener_called, "listener not called for " + test_name);
   assertNull(exception, test_name + " / " + exception);
   end_test_count++;
 }
 
 
 // Check that two scope are the same.
 function assertScopeMirrorEquals(scope1, scope2) {
   assertEquals(scope1.scopeType(), scope2.scopeType());
   assertEquals(scope1.frameIndex(), scope2.frameIndex());
   assertEquals(scope1.scopeIndex(), scope2.scopeIndex());
@@ skipping 131 matching lines @@
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
 };
 local_1();
 EndTest();
 
 
+BeginTest("Generator Local 1");
+function *generator_local_1() {
+  debugger;
+}
+generator_local_1().next();
+EndTest();
+
+
 // Local scope with a parameter.
 BeginTest("Local 2");
 
 function local_2(a) {
   debugger;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 0, exec_state);
 };
 local_2(1);
 EndTest();
 
 
+BeginTest("Generator Local 2");
+function *generator_local_2(a) {
+  debugger;
+}
+generator_local_2(1).next();
+EndTest();
+
+
 // Local scope with a parameter and a local variable.
 BeginTest("Local 3");
 
 function local_3(a) {
   var x = 3;
   debugger;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,x:3}, 0, exec_state);
 };
 local_3(1);
 EndTest();
 
 
+BeginTest("Generator Local 3");
+function *generator_local_3(a) {
+  var x = 3;
+  debugger;
+}
+generator_local_3(1).next();
+EndTest();
+
+
 // Local scope with parameters and local variables.
 BeginTest("Local 4");
 
 function local_4(a, b) {
   var x = 3;
   var y = 4;
   debugger;
 }
 
 listener_delegate = function(exec_state) {
@@ skipping 15 matching lines @@
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
 };
 local_5();
 EndTest();
 
 
+BeginTest("Generator Local 5");
+function *generator_local_5() {
+  eval('');
+  debugger;
+}
+generator_local_5().next();
+EndTest();
+
+
 // Local introducing local variable using eval.
 BeginTest("Local 6");
 
 function local_6() {
   eval('var i = 5');
   debugger;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({i:5}, 0, exec_state);
 };
 local_6();
 EndTest();
 
 
+BeginTest("Generator Local 6");
+function *generator_local_6() {
+  eval('var i = 5');
+  debugger;
+}
+generator_local_6().next();
+EndTest();
+
+
 // Local scope with parameters, local variables and local variable introduced
 // using eval.
 BeginTest("Local 7");
 
 function local_7(a, b) {
   var x = 3;
   var y = 4;
   eval('var i = 5');
   eval('var j = 6');
   debugger;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6}, 0, exec_state);
 };
 local_7(1, 2);
 EndTest();
 
 
+BeginTest("Generator Local 7");
+function *generator_local_7(a, b) {
+  var x = 3;
+  var y = 4;
+  eval('var i = 5');
+  eval('var j = 6');
+  debugger;
+}
+generator_local_7(1, 2).next();
+EndTest();
+
+
 // Single empty with block.
 BeginTest("With 1");
 
 function with_1() {
   with({}) {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
@@ skipping 22 matching lines @@
                    debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({}, 1, exec_state);
 };
 with_2();
 EndTest();
 
 
+BeginTest("Generator With 2");
+function *generator_with_2() {
+  with({}) {
+    with({}) {
+      debugger;
+    }
+  }
+}
+generator_with_2().next();
+EndTest();
+
+
 // With block using an in-place object literal.
 BeginTest("With 3");
 
 function with_3() {
   with({a:1,b:2}) {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
@@ skipping 94 matching lines @@
 };
 with_7();
 EndTest();
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments.
 BeginTest("Closure 1");
 
 function closure_1(a) {
-  function f() {
+  return function() {
     debugger;
     return a;
   };
-  return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
 };
 closure_1(1)();
 EndTest();
 
 
+BeginTest("Generator Closure 1");
+function *generator_closure_1(a) {
+  return function() {
+    debugger;
+    return a;
+  };
+}
+generator_closure_1(1).next().value();
+EndTest();
+
+
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments. Due to VM optimizations parts of the actual closure is
 // missing from the debugger information.
 BeginTest("Closure 2");
 
 function closure_2(a, b) {
   var x = a + 2;
   var y = b + 2;
   function f() {
     debugger;
@@ skipping 237 matching lines @@
   CheckScopeContent({a:15}, 1, exec_state);
   CheckScopeContent({x:14}, 2, exec_state);
   CheckScopeContent({j:13}, 3, exec_state);
   CheckScopeContent({a:1,b:2,x:9,y:10,i:11,j:12}, 4, exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6,f:function(){}}, 5, exec_state);
 };
 the_full_monty(1, 2)();
 EndTest();
 
 
+BeginTest("Generator the full monty");
+function* generator_the_full_monty(a, b) {
+  var x = 3;
+  var y = 4;
+  eval('var i = 5');
+  eval('var j = 6');
+  function f(a, b) {
+    var x = 9;
+    var y = 10;
+    eval('var i = 11');
+    eval('var j = 12');
+    with ({j:13}){
+      return function() {
+        var x = 14;
+        with ({a:15}) {
+          with ({b:16}) {
+            debugger;
+            some_global = a;
+            return f;
+          }
+        }
+      };
+    }
+  }
+  return f(a, b);
+}
+generator_the_full_monty(1, 2).next().value();
+EndTest();
+
+
 BeginTest("Closure inside With 1");
 function closure_in_with_1() {
   with({x:1}) {
     (function inner(x) {
       debugger;
     })(2);
   }
 }
 
 listener_delegate = function(exec_state) {
@@ skipping 100 matching lines @@
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
 };
 catch_block_1();
 EndTest();
 
 
+BeginTest("Generator catch block 1");
+function *generator_catch_block_1() {
+  try {
+    throw 'Exception';
+  } catch (e) {
+    debugger;
+  }
+};
+generator_catch_block_1().next();
+EndTest();
+
+
 BeginTest("Catch block 2");
 function catch_block_2() {
   try {
     throw 'Exception';
   } catch (e) {
     with({n:10}) {
       debugger;
     }
   }
 };
@@ skipping 118 matching lines @@
   CheckScopeContent({e:'Exception'}, 0, exec_state);
 };
 catch_block_7();
 EndTest();
 
 
 assertEquals(begin_test_count, break_count,
              'one or more tests did not enter the debugger');
 assertEquals(begin_test_count, end_test_count,
              'one or more tests did not have its result checked');