[strong] Allow mutually recursive classes.

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 15 matching lines @@
 }
 
 (function DeclarationAfterUse() {
   // Note that these tests only test cases where the declaration is found but is
   // after the use. In particular, we cannot yet detect cases where the use can
   // possibly bind to a global variable.
   assertThrowsHelper("x; let x = 0;");
   assertThrowsHelper("function f() { x; let x = 0; }");
   assertThrowsHelper("function f() { x; } let x = 0;");
 
+  assertThrowsHelper("x; const x = 0;");
+  assertThrowsHelper("function f() { x; const x = 0; }");
+  assertThrowsHelper("function f() { x; } const x = 0;");
+
   // These tests needs to be done a bit more manually, since var is not allowed
   // in strong mode:
   assertThrows(
       `(function outer() {
         function f() { 'use strong'; if (false) { x; } } var x = 0; f();
       })()`,
       ReferenceError);
   assertDoesNotThrow(
       "(function outer() {\n" +
       "  function f() { if (false) { x; } } var x = 0; f(); \n" +
@@ skipping 25 matching lines @@
   assertThrowsHelper("for (const x = x; ; ) { }");
   assertThrowsHelper("for (let x = y, y; ; ) { }");
   assertThrowsHelper("for (const x = y, y = 0; ; ) { }");
 
   // Computed property names
   assertThrowsHelper("let o = { 'a': 'b', [o.a]: 'c'};");
 })();
 
 
 (function DeclarationAfterUseInClasses() {
+  // Referring to a variable declared later
+  assertThrowsHelper("class C { m() { x; } } let x = 0;");
+  assertThrowsHelper("class C { static m() { x; } } let x = 0;");
+  assertThrowsHelper("class C { [x]() { } } let x = 0;");
+
+  assertThrowsHelper("class C { m() { x; } } const x = 0;");
+  assertThrowsHelper("class C { static m() { x; } } const x = 0;");
+  assertThrowsHelper("class C { [x]() { } } const x = 0;");
+
+  // Referring to the class name.
   assertThrowsHelper("class C extends C { }");
   assertThrowsHelper("let C = class C2 extends C { }");
   assertThrowsHelper("let C = class C2 extends C2 { }");
 
   assertThrowsHelper("let C = class C2 { constructor() { C; } }");
   assertThrowsHelper("let C = class C2 { method() { C; } }");
   assertThrowsHelper("let C = class C2 { *generator_method() { C; } }");
 
   assertThrowsHelper(
       `let C = class C2 {
@@ skipping 144 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();
 })();