Make non-Module generators only context allocate parameters.

test/debugger/debug/debug-scopes-suspended-generators.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --ignition --turbo
 // The functions used for testing backtraces. They are at the top to make the
 // testing of source line/column easier.
 
 var Debug = debug.Debug;
 
@@ skipping 89 matching lines @@
 }
 
 // Simple empty closure scope.
 
 function *gen1() {
   yield 1;
   return 2;
 }
 
 var g = gen1();
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({}, 0, g);
 
 // Closure scope with a parameter.
 
 function *gen2(a) {
   yield a;
   return 2;
 }
 
 g = gen2(42);
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 42}, 0, g);
 
 // Closure scope with a parameter.
 
 function *gen3(a) {
   var b = 1
   yield a;
   return b;
 }
 
 g = gen3(0);
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 0, b: undefined}, 0, g);
 
 g.next();  // Create b.
 CheckScopeContent({a: 0, b: 1}, 0, g);
 
 // Closure scope with a parameter.
 
 function *gen4(a, b) {
   var x = 2;
   yield a;
   var y = 3;
+  yield a;
   return b;
 }
 
 g = gen4(0, 1);
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 0, b: 1, x: undefined, y: undefined}, 0, g);
 
 g.next();  // Create x.
 CheckScopeContent({a: 0, b: 1, x: 2, y: undefined}, 0, g);
 
 g.next();  // Create y.
 CheckScopeContent({a: 0, b: 1, x: 2, y: 3}, 0, g);
 
 // Closure introducing local variable using eval.
 
 function *gen5(a) {
   eval('var b = 2');
+  yield a;
   return b;
 }
 
 g = gen5(1);
 g.next();
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 1, b: 2}, 0, g);
 
 // Single empty with block.
 
 function *gen6() {
   with({}) {
     yield 1;
   }
   yield 2;
   return 3;
 }
 
 g = gen6();
 g.next();
 CheckScopeChain([debug.ScopeType.With,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({}, 0, g);
 
 g.next();
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 
 // Nested empty with blocks.
 
 function *gen7() {
   with({}) {
     with({}) {
       yield 1;
     }
     yield 2;
   }
   return 3;
 }
 
 g = gen7();
 g.next();
 CheckScopeChain([debug.ScopeType.With,
                  debug.ScopeType.With,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({}, 0, g);
 
 // Nested with blocks using in-place object literals.
 
 function *gen8() {
   with({a: 1,b: 2}) {
     with({a: 2,b: 1}) {
       yield a;
     }
     yield a;
   }
   return 3;
 }
 
 g = gen8();
 g.next();
 CheckScopeChain([debug.ScopeType.With,
                  debug.ScopeType.With,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 2, b: 1}, 0, g);
 
 g.next();
 CheckScopeContent({a: 1, b: 2}, 0, g);
 
 // Catch block.
 
 function *gen9() {
   try {
     throw 42;
   } catch (e) {
     yield e;
   }
   return 3;
 }
 
 g = gen9();
 g.next();
 CheckScopeChain([debug.ScopeType.Catch,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({e: 42}, 0, g);
 
 // For statement with block scope.
 
 function *gen10() {
   for (let i = 0; i < 42; i++) yield i;
   return 3;
 }
 
 g = gen10();
 g.next();
-CheckScopeChain([debug.ScopeType.Block,
+CheckScopeChain([// debug.ScopeType.Block,

[neis, 2017/05/24 10:39:37]

What's going on here?

[Jarin, 2017/05/24 12:32:21]

Forgotten scope. Now removed.

                  debug.ScopeType.Block,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({i: 0}, 0, g);
 
 g.next();
 CheckScopeContent({i: 1}, 0, g);
-CheckScopeContent({i: 0}, 1, g);  // Additional block scope with i = 0;
 
 // Nested generators.
 
 var gen12;
 function *gen11() {
+  var b = 2;
   gen12 = function*() {
     var a = 1;
     yield 1;
-    return 2;
+    return b;
   }();
 
   var a = 0;
   yield* gen12;
 }
 
 gen11().next();
 g = gen12;
 
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Closure,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 1}, 0, g);
-CheckScopeContent({a: 0}, 1, g);
+CheckScopeContent({b: 2}, 1, g);
 
 // Set a variable in an empty scope.
 
 function *gen13() {
   yield 1;
   return 2;
 }
 
 var g = gen13();
 assertThrows(() => Debug.generatorScope(g, 0).setVariableValue("a", 42));
@@ skipping 28 matching lines @@
     var e = 5;
   }
   yield e;
   return e;
 }
 
 var g = gen15();
 assertEquals(1, g.next().value);
 
 CheckScopeChain([debug.ScopeType.With,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({a: 1, b: 2}, 0, g);
 CheckScopeContent({c: 3, d: 4, e: undefined}, 1, g);
 
 // Variables don't exist in given scope.
 assertThrows(() => Debug.generatorScope(g, 0).setVariableValue("c", 42));
 assertThrows(() => Debug.generatorScope(g, 1).setVariableValue("a", 42));
 
 // Variables in with scope are immutable.
 assertThrows(() => Debug.generatorScope(g, 0).setVariableValue("a", 3));
 assertThrows(() => Debug.generatorScope(g, 0).setVariableValue("b", 3));
 
 Debug.generatorScope(g, 1).setVariableValue("c", 1);
 Debug.generatorScope(g, 1).setVariableValue("e", 42);
 
 CheckScopeContent({a: 1, b: 2}, 0, g);
 CheckScopeContent({c: 1, d: 4, e: 42}, 1, g);
 assertEquals(5, g.next().value);  // Initialized after set.
 
-CheckScopeChain([debug.ScopeType.Closure,
+CheckScopeChain([debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 
 Debug.generatorScope(g, 0).setVariableValue("e", 42);
 
 CheckScopeContent({c: 1, d: 4, e: 42}, 0, g);
 assertEquals(42, g.next().value);
 
 // Set a variable in nested with blocks using in-place object literals plus a
 // nested block scope.
 
 function *gen16() {
   var c = 3;
   with({a: 1,b: 2}) {
     let d = 4;
     yield a;
     let e = 5;
     yield d;
   }
   return 3;
 }
 
 var g = gen16();
 g.next();
 
 CheckScopeChain([debug.ScopeType.Block,
                  debug.ScopeType.With,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
-CheckScopeContent({d: 4}, 0, g);
+CheckScopeContent({d: 4, e: undefined}, 0, g);
 CheckScopeContent({a: 1, b: 2}, 1, g);
 CheckScopeContent({c: 3}, 2, g);
 
 Debug.generatorScope(g, 0).setVariableValue("d", 1);
-CheckScopeContent({d: 1}, 0, g);
+CheckScopeContent({d: 1, e: undefined}, 0, g);
 
 assertEquals(1, g.next().value);
 
 // Set variable in catch block.
 
 var yyzyzzyz = 4829;
 let xxxyyxxyx = 42284;
 function *gen17() {
   try {
     throw 42;
   } catch (e) {
     yield e;
     yield e;
   }
   return 3;
 }
 
 g = gen17();
 g.next();
 
 CheckScopeChain([debug.ScopeType.Catch,
-                 debug.ScopeType.Closure,
+                 debug.ScopeType.Local,
                  debug.ScopeType.Script,
                  debug.ScopeType.Global], g);
 CheckScopeContent({e: 42}, 0, g);
 CheckScopeContent({xxxyyxxyx: 42284,
                    printProtocolMessages : printProtocolMessages,
                    activeWrapper : activeWrapper,
                    DebugWrapper : DebugWrapper
                   }, 2, g);
 
 Debug.generatorScope(g, 0).setVariableValue("e", 1);
 CheckScopeContent({e: 1}, 0, g);
 
 assertEquals(1, g.next().value);
 
 // Script scope.
 Debug.generatorScope(g, 2).setVariableValue("xxxyyxxyx", 42);
 assertEquals(42, xxxyyxxyx);
 
 // Global scope.
 assertThrows(() => Debug.generatorScope(g, 3).setVariableValue("yyzyzzyz", 42));
 assertEquals(4829, yyzyzzyz);