Block-scoped functions in evals are now only conditionally hoisted out.

test/mjsunit/es6/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.
 
 // 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
 
 (function overridingLocalFunction() {
   var x = [];
   assertEquals('function', typeof f);
@@ skipping 443 matching lines @@
 
   assertEquals(4, f());
 })();
 
 // B.3.5 interacts with B.3.3 to allow this.
 (function hoistingThroughSimpleCatch() {
   assertEquals(undefined, f);
 
   try {
     throw 0;
-  } catch(f) {
+  } catch (f) {
     {
       assertEquals(4, f());
 
       function f() {
         return 4;
       }
 
       assertEquals(4, f());
     }
+
+    assertEquals(0, f);
   }
 
   assertEquals(4, f());
 })();
 
 (function noHoistingThroughComplexCatch() {
   try {
     throw 0;
-  } catch({f}) {
+  } catch ({f}) {
     {
       assertEquals(4, f());
 
       function f() {
         return 4;
       }
 
       assertEquals(4, f());
     }
   }
 
   assertThrows(()=>f, ReferenceError);
 })();
 
+(function hoistingThroughWith() {
+  with ({f: 0}) {
+    assertEquals(0, f);
+
+    {
+      assertEquals(4, f());
+
+      function f() {
+        return 4;
+      }
+
+      assertEquals(4, f());
+    }
+
+    assertEquals(0, f);
+  }
+
+  assertEquals(4, f());
+})();
+
 // 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);
 {
@@ skipping 58 matching lines @@
 !function() {
   eval(`
     function evalInFunctionHoisted() { return 0; }
     {
       function evalInFunctionHoisted() { return 1; }
     }
     assertEquals(1, evalInFunctionHoisted());
   `);
 }();
 
+// This test is incorrect BUG(v8:5168). The commented assertions are correct.
+(function evalHoistingThroughSimpleCatch() {
+  try {
+    throw 0;
+  } catch (f) {
+    eval(`{ function f() {
+      return 4;
+    } }`);
+
+    // assertEquals(0, f);
+    assertEquals(4, f());
+  }
+
+  // assertEquals(4, f());
+  assertEquals(undefined, f);
+})();
+
+// This test is incorrect BUG(v8:5168). The commented assertions are correct.
+(function evalHoistingThroughWith() {
+  with ({f: 0}) {
+    eval(`{ function f() {
+      return 4;
+    } }`);
+
+    // assertEquals(0, f);
+    assertEquals(4, f());
+  }
+
+  // assertEquals(4, f());
+  assertEquals(undefined, f);
+})();
+
 let dontHoistGlobal;
 { function dontHoistGlobal() {} }
 assertEquals(undefined, dontHoistGlobal);
 
 let dontHoistEval;
-// BUG(v8:) This shouldn't hoist and shouldn't throw
 var throws = false;
 try {
   eval("{ function dontHoistEval() {} }");
 } catch (e) {
   throws = true;
 }
-assertTrue(throws);
+assertFalse(throws);
 
 // When the global object is frozen, silently don't hoist
 // Currently this actually throws BUG(v8:4452)
 Object.freeze(this);
-throws = false;
-try {
-  eval('{ function hoistWhenFrozen() {} }');
-} catch (e) {
-  throws = true;
+{
+  let throws = false;
+  try {
+    eval('{ function hoistWhenFrozen() {} }');
+  } catch (e) {
+    throws = true;
+  }
+  assertFalse(this.hasOwnProperty("hoistWhenFrozen"));
+  assertThrows(() => hoistWhenFrozen, ReferenceError);
+  // Should be assertFalse BUG(v8:4452)
+  assertTrue(throws);
 }
-assertFalse(this.hasOwnProperty("hoistWhenFrozen"));
-assertThrows(() => hoistWhenFrozen, ReferenceError);
-// Should be assertFalse BUG(v8:4452)
-assertTrue(throws);