[es6] Super call in arrows and eval

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 69 matching lines @@
   V(Property)                   \
   V(Call)                       \
   V(CallNew)                    \
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(Spread)                     \
   V(ThisFunction)               \
-  V(SuperReference)             \
+  V(SuperPropertyReference)     \
+  V(SuperCallReference)         \
   V(CaseClause)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstNodeFactory;
 class AstVisitor;
@@ skipping 1652 matching lines @@
     bit_field_ = KeyTypeField::update(bit_field_, key_type);
   }
   void set_inline_cache_state(InlineCacheState state) {
     bit_field_ = InlineCacheStateField::update(bit_field_, state);
   }
   void mark_for_call() {
     bit_field_ = IsForCallField::update(bit_field_, true);
   }
   bool is_for_call() const { return IsForCallField::decode(bit_field_); }
 
-  bool IsSuperAccess() {
-    return obj()->IsSuperReference();
-  }
+  bool IsSuperAccess() { return obj()->IsSuperPropertyReference(); }
 
   virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
       Isolate* isolate, const ICSlotCache* cache) override {
     return FeedbackVectorRequirements(0, 1);
   }
   void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
                               ICSlotCache* cache) override {
     property_feedback_slot_ = slot;
   }
   Code::Kind FeedbackICSlotKind(int index) override {
@@ skipping 1008 matching lines @@
 
 class ThisFunction final : public Expression {
  public:
   DECLARE_NODE_TYPE(ThisFunction)
 
  protected:
   ThisFunction(Zone* zone, int pos) : Expression(zone, pos) {}
 };
 
 
-class SuperReference final : public Expression {
+class SuperPropertyReference final : public Expression {
  public:
-  DECLARE_NODE_TYPE(SuperReference)
+  DECLARE_NODE_TYPE(SuperPropertyReference)
 
   VariableProxy* this_var() const { return this_var_; }
   VariableProxy* home_object_var() const { return home_object_var_; }
 
  protected:
-  SuperReference(Zone* zone, VariableProxy* this_var,
-                 VariableProxy* home_object_var, int pos)
+  SuperPropertyReference(Zone* zone, VariableProxy* this_var,
+                         VariableProxy* home_object_var, int pos)
       : Expression(zone, pos),
         this_var_(this_var),
         home_object_var_(home_object_var) {
     DCHECK(this_var->is_this());
     DCHECK(home_object_var->raw_name()->IsOneByteEqualTo(".home_object"));
   }
 
  private:
   VariableProxy* this_var_;
   VariableProxy* home_object_var_;
 };
 
 
+class SuperCallReference final : public Expression {
+ public:
+  DECLARE_NODE_TYPE(SuperCallReference)
+
+  VariableProxy* this_var() const { return this_var_; }
+  VariableProxy* new_target_var() const { return new_target_var_; }
+  VariableProxy* this_function_var() const { return this_function_var_; }
+
+ protected:
+  SuperCallReference(Zone* zone, VariableProxy* this_var,
+                     VariableProxy* new_target_var,
+                     VariableProxy* this_function_var, int pos)
+      : Expression(zone, pos),
+        this_var_(this_var),
+        new_target_var_(new_target_var),
+        this_function_var_(this_function_var) {
+    DCHECK(this_var->is_this());
+    DCHECK(new_target_var->raw_name()->IsOneByteEqualTo("new.target"));
+    DCHECK(this_function_var->raw_name()->IsOneByteEqualTo(".this_function"));
+  }
+
+ private:
+  VariableProxy* this_var_;
+  VariableProxy* new_target_var_;
+  VariableProxy* this_function_var_;
+};
+
+
 #undef DECLARE_NODE_TYPE
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
 class RegExpVisitor BASE_EMBEDDED {
  public:
   virtual ~RegExpVisitor() { }
@@ skipping 747 matching lines @@
   NativeFunctionLiteral* NewNativeFunctionLiteral(const AstRawString* name,
                                                   v8::Extension* extension,
                                                   int pos) {
     return new (zone_) NativeFunctionLiteral(zone_, name, extension, pos);
   }
 
   ThisFunction* NewThisFunction(int pos) {
     return new (zone_) ThisFunction(zone_, pos);
   }
 
-  SuperReference* NewSuperReference(VariableProxy* this_var,
-                                    VariableProxy* home_object_var, int pos) {
-    return new (zone_) SuperReference(zone_, this_var, home_object_var, pos);
+  SuperPropertyReference* NewSuperPropertyReference(
+      VariableProxy* this_var, VariableProxy* home_object_var, int pos) {
+    return new (zone_)
+        SuperPropertyReference(zone_, this_var, home_object_var, pos);
+  }
+
+  SuperCallReference* NewSuperCallReference(VariableProxy* this_var,
+                                            VariableProxy* new_target_var,
+                                            VariableProxy* this_function_var,
+                                            int pos) {
+    return new (zone_) SuperCallReference(zone_, this_var, new_target_var,
+                                          this_function_var, pos);
   }
 
  private:
   Zone* zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_