[strong] Stricter check for referring to other classes inside methods.

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index fb52eef56382155d70889fa53efcc74ba8f5a700..1416f676abbfcb8c8c06b85ff0c32e4d91a9eb0e 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -1314,10 +1314,21 @@ Statement* Parser::ParseStatementListItem(bool* ok) {
   //    Statement
   //    Declaration
 
+  if (scope_->consecutive_class_declaration_group_start() >= 0 &&

[rossberg, 2015/04/21 13:30:02]

Isn't this extra condition redundant?

[marja, 2015/04/23 09:52:37]

Done.

+      peek() != Token::CLASS) {
+    // No more classes follow; reset the start position for the consecutive
+    // class declaration group.
+    scope_->set_consecutive_class_declaration_group_start(-1);
+  }
+
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(NULL, ok);
     case Token::CLASS:
+      if (scope_->consecutive_class_declaration_group_start() < 0) {
+        scope_->set_consecutive_class_declaration_group_start(
+            scanner()->peek_location().beg_pos);
+      }
       return ParseClassDeclaration(NULL, ok);
     case Token::CONST:
     case Token::VAR:
@@ -1944,14 +1955,19 @@ Variable* Parser::Declare(Declaration* declaration, bool resolve, bool* ok) {
     if (var == NULL) {
       // Declare the name.
       Variable::Kind kind = Variable::NORMAL;
+      int consecutive_declaration_group_start = -1;
       if (declaration->IsFunctionDeclaration()) {
         kind = Variable::FUNCTION;
       } else if (declaration->IsVariableDeclaration() &&
                  declaration->AsVariableDeclaration()->is_class_declaration()) {
         kind = Variable::CLASS;
+        consecutive_declaration_group_start =
+            declaration->AsVariableDeclaration()
+                ->consecutive_declaration_group_start();
       }
       var = declaration_scope->DeclareLocal(
-          name, mode, declaration->initialization(), kind, kNotAssigned);
+          name, mode, declaration->initialization(), kind, kNotAssigned,
+          consecutive_declaration_group_start);
     } else if (IsLexicalVariableMode(mode) ||
                IsLexicalVariableMode(var->mode()) ||
                ((mode == CONST_LEGACY || var->mode() == CONST_LEGACY) &&
@@ -2171,9 +2187,15 @@ Statement* Parser::ParseClassDeclaration(ZoneList<const AstRawString*>* names,
   VariableProxy* proxy = NewUnresolved(name, mode);
   const bool is_class_declaration = true;
   Declaration* declaration = factory()->NewVariableDeclaration(
-      proxy, mode, scope_, pos, is_class_declaration);
-  Declare(declaration, true, CHECK_OK);
+      proxy, mode, scope_, pos, is_class_declaration,
+      scope_->consecutive_class_declaration_group_start());
+  Variable* outer_class_variable = Declare(declaration, true, CHECK_OK);
   proxy->var()->set_initializer_position(position());
+  if (value->class_variable_proxy() && value->class_variable_proxy()->var()) {
+    value->class_variable_proxy()
+        ->var()
+        ->set_corresponding_outer_class_variable(outer_class_variable);
+  }
 
   Token::Value init_op =
       is_strong(language_mode()) ? Token::INIT_CONST : Token::INIT_LET;
@@ -4329,8 +4351,10 @@ ClassLiteral* Parser::ParseClassLiteral(const AstRawString* name,
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST);
-    Declaration* declaration =
-        factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
+    const bool is_class_declaration = true;
+    Declaration* declaration = factory()->NewVariableDeclaration(
+        proxy, CONST, block_scope, pos, is_class_declaration,
+        scope_->consecutive_class_declaration_group_start());
     Declare(declaration, true, CHECK_OK);
   }