Extend Annex B 3.3 sloppy-mode block-scoped hoisting to scripts, eval

test/mjsunit/harmony/block-sloppy-function.js

 // Copyright 2015 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: --no-legacy-const --harmony-sloppy --harmony-sloppy-let
 // Flags: --harmony-sloppy-function --harmony-destructuring
 // Flags: --harmony-rest-parameters
 
 // Test Annex B 3.3 semantics for functions declared in blocks in sloppy mode.
 // http://www.ecma-international.org/ecma-262/6.0/#sec-block-level-function-declarations-web-legacy-compatibility-semantics
@@ skipping 128 matching lines @@
   }
   assertEquals(2, f());
   L: {
     assertEquals(3, f());
     break L;
     function f() { return 3; }
   }
   assertEquals(2, f());
 })();
 
-// Test that hoisting from blocks doesn't happen in global scope
-function globalUnhoisted() { return 0; }
+// Test that hoisting from blocks does happen in global scope

[adamk, 2015/09/29 23:23:15]

More tests, please:

- Negative cases: does not hoist if there's a lexical in global scope (and test
the same in the eval case).

- Cases where there's no overlapping function already in the global; in that
case, add assertions that the property is created on the global (to make sure
the binding went in the right place), and with the expected attributes.

- Also add tests with a frozen global (does not hoist, does not throw).

- Finally, tests where you set up a global property with different attributes
from what you expect, and assertions of the actual current behavior (with a TODO
to fix).

Given how much of this is global, you might have to put some of these in
separate files...

+function globalHoisted() { return 0; }
 {
-  function globalUnhoisted() { return 1; }
+  function globalHoisted() { return 1; }
 }
-assertEquals(0, globalUnhoisted());
+assertEquals(1, globalHoisted());
+
+// Test that hoisting from blocks does happen in an eval
+eval(`
+  function evalHoisted() { return 0; }
+  {
+    function evalHoisted() { return 1; }
+  }
+  assertEquals(1, evalHoisted());
+`);
 
 // Test that shadowing arguments is fine
 (function shadowArguments(x) {
   assertArrayEquals([1], arguments);
   {
     assertEquals('function', typeof arguments);
     function arguments() {}
     assertEquals('function', typeof arguments);
   }
   assertEquals('function', typeof arguments);
@@ skipping 29 matching lines @@
   // assertEquals('function', typeof x);
 })(1);
 
 assertThrows(function notInDefaultScope(x = y) {
   {
     function y() {}
   }
   assertEquals('function', typeof y);
   assertEquals(x, undefined);
 }, ReferenceError);