Stack allocating block scoped variables.

test/mjsunit/harmony/debug-blockscopes.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
@@ skipping 291 matching lines @@
   CheckScopeChain([debug.ScopeType.Block,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x:6,y:7}, 0, exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
 };
 local_6(1);
 EndTest();
 
 
-// Two variables in a block scope.
+// A variable in a block scope within an unallocated block.
 BeginTest("Local 7");
 
 function local_7(a) {
   {
     {
       let x = 8;
       debugger;
     }
   }
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Block,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x:8}, 0, exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
 };
 local_7(1);
 EndTest();
 
 
+// Function and block scopes with stack allocated variables.
+BeginTest("Local 8");
+
+function local_8(a) {
+  let z = 10;
+  {
+    let y = 20;
+    {
+      let x = 8;
+      debugger;
+    }
+  }
+}
+
+listener_delegate = function(exec_state) {
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.Block,
+                   debug.ScopeType.Local,
+                   debug.ScopeType.Global], exec_state);
+  CheckScopeContent({x:8}, 0, exec_state);
+  CheckScopeContent({y:20}, 1, exec_state);
+  CheckScopeContent({a:1,z:10}, 2, exec_state);
+};
+local_8(1);
+EndTest();
+
+
 // Simple closure formed by returning an inner function referering to an outer
 // block local variable and an outer function's parameter.
 BeginTest("Closure 1");
 
 function closure_1(a) {
   var x = 2;
   let y = 3;
   if (true) {
     let z = 4;
-    function f() {
-      debugger;
-      return a + x + y + z;
-    };
-    return f;
+    { // Stack allocated block
+      function f() {
+        debugger;
+        return a + x + y + z;
+      };
+      return f;
+    }
   }
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Block,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
+  CheckScopeContent({z:4}, 1, exec_state);
   CheckScopeContent({a:1,x:2,y:3}, 2, exec_state);
 };
 closure_1(1)();
 EndTest();
 
 
 // Simple for-in loop over the keys of an object.
 BeginTest("For loop 1");
 
 function for_loop_1() {
@@ skipping 93 matching lines @@
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Block,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x:3,y:5}, 0, exec_state);
   CheckScopeContent({}, 1, exec_state);
 };
 for_loop_5();
 EndTest();
+
+
+// Nested scoped block in global code.
+BeginTest("Global block 1");
+listener_delegate = function(exec_state) {
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.Global], exec_state);
+  CheckScopeContent({e:10}, 0, exec_state);
+};
+
+{
+  let e = 10;
+  debugger;
+}
+EndTest();