[strong] Simplify the classes-referring-to-classes check.

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 1150 matching lines @@
 
   // Allow references from methods to classes declared later, if we detect no
   // problematic dependency cycles. Note that we can be inside multiple methods
   // at the same time, and it's enough if we find one where the reference is
   // allowed.
   if (var->is_class() &&
       var->AsClassVariable()->declaration_group_start() >= 0) {
     for (scope = this; scope && scope != var->scope();
          scope = scope->outer_scope()) {
       ClassVariable* class_var = scope->ClassVariableForMethod();
-      if (class_var) {
-        // 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.
+      // 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:
+      // 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
+      // 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.
+      // 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.
+      if (class_var &&
+          class_var->declaration_group_start() ==
+              var->AsClassVariable()->declaration_group_start()) {
+        return true;
+      }
 
-        // This is needed because a class ("class Name { }") creates two
-        // bindings (one in the outer scope, and one in the class scope). The
-        // method is a function scope inside the inner scope (class scope). The
-        // consecutive class declarations are in the outer scope.
-        class_var = class_var->corresponding_outer_class_variable();
-        if (class_var &&
-            class_var->declaration_group_start() ==
-                var->AsClassVariable()->declaration_group_start()) {
-          return true;
-        }
+      // TODO(marja,rossberg): implement the dependency cycle detection. Here we
+      // undershoot the target and allow referring to any class in the same
+      // consectuive declaration group.
 
-        // TODO(marja,rossberg): implement the dependency cycle detection. Here
-        // we undershoot the target and allow referring to any class in the same
-        // consectuive declaration group.
-
-        // The cycle detection can work roughly like this: 1) detect init-time
-        // references here (they are free variables which are inside the class
-        // scope but not inside a method scope - no parser changes needed to
-        // detect them) 2) if we encounter an init-time reference here, allow
-        // it, but record it for a later dependency cycle check 3) also record
-        // non-init-time references here 4) after scope analysis is done,
-        // analyse the dependency cycles: an illegal cycle is one starting with
-        // an init-time reference and leading back to the starting point with
-        // either non-init-time and init-time references.
-      }
+      // The cycle detection can work roughly like this: 1) detect init-time
+      // references here (they are free variables which are inside the class
+      // scope but not inside a method scope - no parser changes needed to
+      // detect them) 2) if we encounter an init-time reference here, allow it,
+      // but record it for a later dependency cycle check 3) also record
+      // non-init-time references here 4) after scope analysis is done, analyse
+      // the dependency cycles: an illegal cycle is one starting with an
+      // init-time reference and leading back to the starting point with either
+      // non-init-time and init-time references.
     }
   }
 
   // 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();
@@ skipping 328 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