[strong] Implement static restrictions on direct eval

test/mjsunit/strong/declaration-after-use.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: --strong-mode --harmony_rest_parameters --harmony_arrow_functions --harmony_classes --harmony_computed-property_names
 
 // Note that it's essential for these tests that the reference is inside dead
 // code (because we already produce ReferenceErrors for run-time unresolved
 // variables and don't want to confuse those with strong mode errors). But the
 // errors should *not* be inside lazy, unexecuted functions, since lazy parsing
@@ skipping 37 matching lines @@
   assertThrows(
       "(function outer() {\n" +
       "  function f() { 'use strong'; if (false) { x; } } var x; f(); \n" +
       "})()",
       ReferenceError);
   assertDoesNotThrow(
       "(function outer() {\n" +
       "  function f() { if (false) { x; } } var x; f(); \n" +
       "})()");
 
-  // Errors are also detected when the declaration and the use are in the same
-  // eval scope.
-  assertThrows("'use strong'; eval('if (false) { x; let x = 0;}')",

[arv (Not doing code reviews), 2015/04/13 14:14:06]

Change to use a closure?

[conradw, 2015/04/13 14:36:33]

See other comment on propagating strong mode through eval.

-               ReferenceError);
-  assertDoesNotThrow("'use strict'; eval('if (false) { x; let x = 0; }')");
-
   // Use occurring in the initializer of the declaration:
   assertThrowsHelper("let x = x + 1;");
   assertThrowsHelper("let x = x;");
   assertThrowsHelper("let x = y, y = 4;");
   assertThrowsHelper("let x = function() { x; }");
   assertThrowsHelper("let x = a => { x; }");
   assertThrowsHelper("function f(x) { return x; }; let x = f(x);");
   assertThrowsHelper("const x = x;");
   assertThrowsHelper("const x = function() { x; }");
   assertThrowsHelper("const x = a => { x; }");
@@ skipping 134 matching lines @@
   let func5 = (p1, p2) => { p1; p2; };
   func5();
 
   let func5b = p1 => p1;
   func5b();
 
   function func6() {
     var1, var2a, var2b, var2c;
   }
 
-  (function eval1() {
-    let var7 = 0; // Declaration position will be something large.
-    // But use position will be something small, however, this is not an error,
-    // since the use is inside an eval scope.
-    eval("var7;");
-  })();
-
-
   class C1 { constructor() { C1; } }; new C1();
   let C2 = class C3 { constructor() { C3; } }; new C2();
 
   class C4 { method() { C4; } *generator_method() { C4; } }; new C4();
   let C5 = class C6 { method() { C6; } *generator_method() { C6; } }; new C5();
 
   class C7 { static method() { C7; } }; new C7();
   let C8 = class C9 { static method() { C9; } }; new C8();
 
   class C10 { get x() { C10; } }; new C10();
@@ skipping 13 matching lines @@
       }
       return new CInner();
     }
   }
   (new COuter()).m().n();
 
   // Making sure the check which is supposed to prevent "object literal inside
   // computed property name references the class name" is not too generic:
   class C14 { m() { let obj = { n() { C14 } }; obj.n(); } }; (new C14()).m();
 })();