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; }
-{
-  function globalUnhoisted() { return 1; }
-}
-assertEquals(0, globalUnhoisted());
-
 // 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);
 })(1);
@@ skipping 28 matching lines @@
   // assertEquals('function', typeof x);
 })(1);
 
 assertThrows(function notInDefaultScope(x = y) {
   {
     function y() {}
   }
   assertEquals('function', typeof y);
   assertEquals(x, undefined);
 }, ReferenceError);
+
+// Test that hoisting from blocks does happen in global scope
+function globalHoisted() { return 0; }
+{
+  function globalHoisted() { return 1; }
+}
+assertEquals(1, globalHoisted());
+
+// Also happens when not previously defined
+assertEquals(undefined, globalUndefinedHoisted);
+{
+  function globalUndefinedHoisted() { return 1; }
+}
+assertEquals(1, globalUndefinedHoisted());
+var globalUndefinedHoistedDescriptor =
+    Object.getOwnPropertyDescriptor(this, "globalUndefinedHoisted");
+// Configurablility is not set properly BUG(v8:4451#1)
+// assertTrue(globalUndefinedHoistedDescriptor.configurable);

[adamk, 2015/09/30 18:24:26]

Please leave this uncommented (with the current behavior) so that changes to the
code will require changes to the test.

[Dan Ehrenberg, 2015/09/30 23:06:55]

Done

+assertTrue(globalUndefinedHoistedDescriptor.writable);
+assertTrue(globalUndefinedHoistedDescriptor.enumerable);
+assertEquals(1, globalUndefinedHoistedDescriptor.value());
+
+// When a function property is hoisted, it should be
+// made enumerable.
+// BUG(v8:4451)
+Object.defineProperty(this, "globalNonEnumerable", {
+  value: false,
+  configurable: true,
+  writable: true,
+  enumerable: false
+});
+eval("{function globalNonEnumerable() { return 1; }}");
+var globalNonEnumerableDescriptor
+    = Object.getOwnPropertyDescriptor(this, "globalNonEnumerable");
+assertTrue(globalNonEnumerableDescriptor.configurable);
+assertTrue(globalNonEnumerableDescriptor.writable);
+// BUG(v8:4451)
+// assertTrue(globalNonEnumerableDescriptor.enumerable);

[adamk, 2015/09/30 18:24:26]

Same here.

[Dan Ehrenberg, 2015/09/30 23:06:55]

Done

+assertEquals(1, globalNonEnumerableDescriptor.value());
+
+// Test that hoisting from blocks does happen in an eval
+eval(`
+  function evalHoisted() { return 0; }
+  {
+    function evalHoisted() { return 1; }
+  }
+  assertEquals(1, evalHoisted());
+`);
+
+// Test that hoisting from blocks happens from eval in a function
+!function() {
+  eval(`
+    function evalInFunctionHoisted() { return 0; }
+    {
+      function evalInFunctionHoisted() { return 1; }
+    }
+    assertEquals(1, evalInFunctionHoisted());
+  `);
+}();
+
+// When the global object is frozen, silently don't hoist
+// Currently this actually throws BUG(v8:4452)

[adamk, 2015/09/30 18:24:26]

Ah, this throws because it goes through the defineProperty path instead of the
assignment path? I'm OK landing without this fix, since it's the same as the
pre-ES6 behavior.

[Dan Ehrenberg, 2015/09/30 23:06:55]

I guess it matches, but still, we eventually want to make the illusion that
functions are lexical, so this should eventually work. Still I don't know when
you'd freeze the global object and eval a function declaration in global scope
like this...

+// Object.freeze(this);
+// eval(`
+//   {
+//     function hoistWhenFrozen() {}
+//   }
+// `);
+// assertFalse(this.hasOwnProperty("hoistWhenFrozen"));
+assertThrows(() => hoistWhenFrozen, ReferenceError);
+
+let dontHoistGlobal;
+{ function dontHoistGlobal() {} }
+assertEquals(undefined, dontHoistGlobal);
+
+let dontHoistEval;
+// OK, this really needs to be fixed...

[adamk, 2015/09/30 18:24:26]

Yeah, this needs to be fixed before landing.

[Dan Ehrenberg, 2015/09/30 23:06:55]

We talked about this off-line and it sounded like maybe it can be fixed in a
follow-on patch. It'll be a bit of work to fix, and this path isn't staged
anymore.

+// eval("{ function dontHoistEval() {} }");
+// assertEquals(undefined, dontHoistEval);