[strong] Allow mutually recursive classes.

src/scopes.cc

 // Copyright 2012 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
 #include "src/parser.h"
@@ skipping 1120 matching lines @@
   // always allow referencing functions (for now).
 
   // Allow referencing the class name from methods of that class, even though
   // the initializer position for class names is only after the body.
   Scope* scope = this;
   while (scope) {
     if (scope->ClassVariableForMethod() == var) return true;
     scope = scope->outer_scope();
   }
 
+  // Allow references from methods to classes declared later, if we detect no
+  // problematic dependency cycles.
+
+  if (ClassVariableForMethod() && var->is_class()) {
+    // A method is referring to some other class, possibly declared
+    // later. Referring to a class declared earlier is always OK and covered by
+    // the code outside this if. Here we only need to allow special cases for
+    // referring to a class which is declared later.
+
+    // Referring to a class C declared later is OK under the following
+    // circumstances:
+
+    // 1. The class declarations are in a consecutive group with no other
+    // declarations or statements in between, and
+
+    // 2. There is no dependency cycle where the first edge is an initialization
+    // time dependency (computed property name or extends clause) from C to
+    // something that depends on this class directly or transitively.
+
+    // TODO(marja,rossberg): implement these checks. Here we undershoot the
+    // target and allow referring to any class.
+    return true;
+  }
+
   // If both the use and the declaration are inside an eval scope (possibly
   // indirectly), or one of them is, we need to check whether they are inside
   // the same eval scope or different ones.
 
   // TODO(marja,rossberg): Detect errors across different evals (depends on the
   // future of eval in strong mode).
   const Scope* eval_for_use = NearestOuterEvalScope();
   const Scope* eval_for_declaration = var->scope()->NearestOuterEvalScope();
 
   if (proxy->position() != RelocInfo::kNoPosition &&
@@ skipping 313 matching lines @@
       (function_ != NULL && function_->proxy()->var()->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 } }  // namespace v8::internal