[strong] Fix scoping related errors for methods.

src/parser.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/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1791 matching lines @@
   // variable and also set its mode. In any case, a Declaration node
   // will be added to the scope so that the declaration can be added
   // to the corresponding activation frame at runtime if necessary.
   // For instance declarations inside an eval scope need to be added
   // to the calling function context.
   // Similarly, strict mode eval scope does not leak variable declarations to
   // the caller's scope so we declare all locals, too.
   if (declaration_scope->is_function_scope() ||
       declaration_scope->is_strict_eval_scope() ||
       declaration_scope->is_block_scope() ||
+      declaration_scope->is_class_scope() ||
       declaration_scope->is_module_scope() ||
       declaration_scope->is_script_scope()) {
     // Declare the variable in the declaration scope.
     var = declaration_scope->LookupLocal(name);
     if (var == NULL) {
       // Declare the name.
       var = declaration_scope->DeclareLocal(
           name, mode, declaration->initialization(),
           declaration->IsFunctionDeclaration() ? Variable::FUNCTION
                                                : Variable::NORMAL,
@@ skipping 2264 matching lines @@
     ReportMessageAt(class_name_location, "unexpected_strict_reserved");
     *ok = false;
     return NULL;
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, "strict_eval_arguments");
     *ok = false;
     return NULL;
   }
 
-  Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
-  BlockState block_state(&scope_, block_scope);
+  Scope* class_scope = NewScope(scope_, CLASS_SCOPE);
+  BlockState block_state(&scope_, class_scope);
   scope_->SetLanguageMode(
       static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
   scope_->SetScopeName(name);
 
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST);
     Declaration* declaration =
-        factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
+        factory()->NewVariableDeclaration(proxy, CONST, class_scope, pos);
     Declare(declaration, true, CHECK_OK);
   }
 
   Expression* extends = NULL;
   if (Check(Token::EXTENDS)) {
-    block_scope->set_start_position(scanner()->location().end_pos);
+    class_scope->set_start_position(scanner()->location().end_pos);
     extends = ParseLeftHandSideExpression(CHECK_OK);
   } else {
-    block_scope->set_start_position(scanner()->location().end_pos);
+    class_scope->set_start_position(scanner()->location().end_pos);
   }
 
 
   ClassLiteralChecker checker(this);
   ZoneList<ObjectLiteral::Property*>* properties = NewPropertyList(4, zone());
   FunctionLiteral* constructor = NULL;
   bool has_seen_constructor = false;
 
   Expect(Token::LBRACE, CHECK_OK);
 
@@ skipping 20 matching lines @@
       fni_->Infer();
       fni_->Leave();
     }
   }
 
   Expect(Token::RBRACE, CHECK_OK);
   int end_pos = scanner()->location().end_pos;
 
   if (constructor == NULL) {
     constructor =
-        DefaultConstructor(extends != NULL, block_scope, pos, end_pos);
+        DefaultConstructor(extends != NULL, class_scope, pos, end_pos);
   }
 
-  block_scope->set_end_position(end_pos);
-  block_scope = block_scope->FinalizeBlockScope();
+  class_scope->set_end_position(end_pos);
 
   if (name != NULL) {
     DCHECK_NOT_NULL(proxy);
-    DCHECK_NOT_NULL(block_scope);
     proxy->var()->set_initializer_position(end_pos);
+  } else {
+    // Unnamed classes should not have scopes (the class scope will be empty).

[arv (Not doing code reviews), 2015/03/03 15:36:28]

Unnamed classed do not need to have a scope.

[marja, 2015/03/03 15:52:14]

Clarification: this comment was b/c some places rely on unnamed classes not
having a scope. The places which rely on that are:

AstGraphBuilder::VisitClassLiteral
AstGraphBuilder::VisitClassLiteralContents
FullCodeGenerator::VisitClassLiteral calling EnterBlockScopeIfNeeded
FullCodeGenerator::VisitClassLiteral deciding whether to EmitVariableAssignment

+    DCHECK(class_scope->num_var_or_const() == 0);
+    class_scope = nullptr;
   }
 
-  return factory()->NewClassLiteral(name, block_scope, proxy, extends,
+  return factory()->NewClassLiteral(name, class_scope, proxy, extends,
                                     constructor, properties, pos, end_pos);
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
@@ skipping 1264 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal