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

src/ast.h

 // 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.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 552 matching lines @@
 class VariableDeclaration FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(VariableDeclaration)
 
   InitializationFlag initialization() const OVERRIDE {
     return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
   }
 
   bool is_class_declaration() const { return is_class_declaration_; }
 
+  // VariableDeclarations can be grouped into consecutive declaration
+  // batches. Each VariableDeclaration is associated with the start position of
+  // the batch it belongs to. The positions are used for strong mode scope
+  // checks for classes and functions.
+  int consecutive_declaration_batch_start() const {

[rossberg, 2015/04/20 11:15:25]

Nit: Let's call this class_declaration_group_start (we probably will want to use
a separate one for function groups).

[marja, 2015/04/20 15:58:22]

batch -> group done

But I don't need a separate one for class here afaics, I was intending to use
the same one! If the VariableDeclaration is for a function, it'll be the
function group start position, if the VariableDeclaration is a class, it'll be
the class group start position.

(Other places need to distinguish between them though, and they have _class_ in
the name.)

+    return consecutive_declaration_batch_start_;
+  }
+
  protected:
   VariableDeclaration(Zone* zone, VariableProxy* proxy, VariableMode mode,
-                      Scope* scope, int pos, bool is_class_declaration = false)
+                      Scope* scope, int pos, bool is_class_declaration = false,
+                      int consecutive_declaration_batch_start = -1)
       : Declaration(zone, proxy, mode, scope, pos),
-        is_class_declaration_(is_class_declaration) {}
+        is_class_declaration_(is_class_declaration),
+        consecutive_declaration_batch_start_(
+            consecutive_declaration_batch_start) {}
 
   bool is_class_declaration_;
+  int consecutive_declaration_batch_start_;
 };
 
 
 class FunctionDeclaration FINAL : public Declaration {
  public:
   DECLARE_NODE_TYPE(FunctionDeclaration)
 
   FunctionLiteral* fun() const { return fun_; }
   InitializationFlag initialization() const OVERRIDE {
     return kCreatedInitialized;
@@ skipping 2621 matching lines @@
 // AstNode factory
 
 class AstNodeFactory FINAL BASE_EMBEDDED {
  public:
   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
       : zone_(ast_value_factory->zone()),
         ast_value_factory_(ast_value_factory) {}
 
   VariableDeclaration* NewVariableDeclaration(
       VariableProxy* proxy, VariableMode mode, Scope* scope, int pos,
-      bool is_class_declaration = false) {
+      bool is_class_declaration = false,
+      int consecutive_declaration_batch_start = -1) {
     return new (zone_) VariableDeclaration(zone_, proxy, mode, scope, pos,
-                                           is_class_declaration);
+                                           is_class_declaration,
+                                           consecutive_declaration_batch_start);
   }
 
   FunctionDeclaration* NewFunctionDeclaration(VariableProxy* proxy,
                                               VariableMode mode,
                                               FunctionLiteral* fun,
                                               Scope* scope,
                                               int pos) {
     return new (zone_) FunctionDeclaration(zone_, proxy, mode, fun, scope, pos);
   }
 
@@ skipping 348 matching lines @@
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_