new classes: implement new.target passing to superclass constructor.

src/scopes.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_SCOPES_H_
 #define V8_SCOPES_H_
 
 #include "src/ast.h"
 #include "src/zone.h"
 
@@ skipping 70 matching lines @@
   static bool Analyze(CompilationInfo* info);
 
   static Scope* DeserializeScopeChain(Isolate* isolate, Zone* zone,
                                       Context* context, Scope* script_scope);
 
   // The scope name is only used for printing/debugging.
   void SetScopeName(const AstRawString* scope_name) {
     scope_name_ = scope_name;
   }
 
-  void Initialize(bool uninitialized_this = false);
+  void Initialize(bool subclass_constructor = false);
 
   // Checks if the block scope is redundant, i.e. it does not contain any
   // block scoped declarations. In that case it is removed from the scope
   // tree and its children are reparented.
   Scope* FinalizeBlockScope();
 
   Isolate* isolate() const { return isolate_; }
   Zone* zone() const { return zone_; }
 
   // ---------------------------------------------------------------------------
@@ skipping 235 matching lines @@
 
   // ---------------------------------------------------------------------------
   // Accessors.
 
   // The type of this scope.
   ScopeType scope_type() const { return scope_type_; }
 
   // The language mode of this scope.
   LanguageMode language_mode() const { return language_mode_; }
 
-  // The variable corresponding the 'this' value.
+  // The variable corresponding to the 'this' value.
   Variable* receiver() { return receiver_; }
 
+  // The variable corresponding to the 'new.target' value.
+  Variable* new_target_var() { return new_target_; }
+
   // The variable holding the function literal for named function
   // literals, or NULL.  Only valid for function scopes.
   VariableDeclaration* function() const {
     DCHECK(is_function_scope());
     return function_;
   }
 
   // Parameters. The left-most parameter has index 0.
   // Only valid for function scopes.
   Variable* parameter(int index) const {
@@ skipping 153 matching lines @@
   // Variables that must be looked up dynamically.
   DynamicScopePart* dynamics_;
   // Unresolved variables referred to from this scope.
   ZoneList<VariableProxy*> unresolved_;
   // Declarations.
   ZoneList<Declaration*> decls_;
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   VariableDeclaration* function_;
+  // new.target variable, function scopes only.
+  Variable* new_target_;
   // Convenience variable; function scopes only.
   Variable* arguments_;
   // Interface; module scopes only.
   Interface* interface_;
 
   // Illegal redeclaration.
   Expression* illegal_redecl_;
 
   // Scope-specific information computed during parsing.
   //
@@ skipping 169 matching lines @@
                    Scope* outer_scope,
                    Handle<ScopeInfo> scope_info);
 
   AstValueFactory* ast_value_factory_;
   Zone* zone_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCOPES_H_