Parse 'super' keyword.

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 76 matching lines @@
   V(Throw)                                      \
   V(Property)                                   \
   V(Call)                                       \
   V(CallNew)                                    \
   V(CallRuntime)                                \
   V(UnaryOperation)                             \
   V(CountOperation)                             \
   V(BinaryOperation)                            \
   V(CompareOperation)                           \
   V(ThisFunction)                               \
+  V(SuperReference)                             \
   V(CaseClause)
 
 #define AST_NODE_LIST(V)                        \
   DECLARATION_NODE_LIST(V)                      \
   MODULE_NODE_LIST(V)                           \
   STATEMENT_NODE_LIST(V)                        \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
 class AstConstructionVisitor;
@@ skipping 1596 matching lines @@
   }
   bool IsUninitialized() { return !is_for_call_ && is_uninitialized_; }
   bool HasNoTypeInformation() {
     return is_uninitialized_;
   }
   void set_is_uninitialized(bool b) { is_uninitialized_ = b; }
   void set_is_string_access(bool b) { is_string_access_ = b; }
   void mark_for_call() { is_for_call_ = true; }
   bool IsForCall() { return is_for_call_; }
 
+  bool IsSuperAccess() {
+    return obj()->IsSuperReference();
+  }
+
   TypeFeedbackId PropertyFeedbackId() { return reuse(id()); }
 
   virtual int ComputeFeedbackSlotCount() { return FLAG_vector_ics ? 1 : 0; }
   virtual void SetFirstFeedbackSlot(int slot) {
     property_feedback_slot_ = slot;
   }
 
   int PropertyFeedbackSlot() const { return property_feedback_slot_; }
 
  protected:
@@ skipping 824 matching lines @@
 
 
 class ThisFunction V8_FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(ThisFunction)
 
  protected:
   explicit ThisFunction(Zone* zone, int pos): Expression(zone, pos) {}
 };
 
+
+class SuperReference V8_FINAL : public Expression {
+ public:
+  DECLARE_NODE_TYPE(SuperReference)
+
+  VariableProxy* this_var() const { return this_var_; }
+
+  TypeFeedbackId HomeObjectFeedbackId() { return reuse(id()); }
+
+ protected:
+  explicit SuperReference(Zone* zone, VariableProxy* this_var, int pos)
+      : Expression(zone, pos), this_var_(this_var) {
+      DCHECK(this_var->is_this());
+  }
+
+  VariableProxy* this_var_;
+};
+
+
 #undef DECLARE_NODE_TYPE
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
 
 class RegExpVisitor BASE_EMBEDDED {
  public:
   virtual ~RegExpVisitor() { }
@@ skipping 898 matching lines @@
     NativeFunctionLiteral* lit =
         new(zone_) NativeFunctionLiteral(zone_, name, extension, pos);
     VISIT_AND_RETURN(NativeFunctionLiteral, lit)
   }
 
   ThisFunction* NewThisFunction(int pos) {
     ThisFunction* fun = new(zone_) ThisFunction(zone_, pos);
     VISIT_AND_RETURN(ThisFunction, fun)
   }
 
+  SuperReference* NewSuperReference(VariableProxy* this_var, int pos) {
+    SuperReference* super = new (zone_) SuperReference(zone_, this_var, pos);
+    VISIT_AND_RETURN(SuperReference, super);
+  }
+
 #undef VISIT_AND_RETURN
 
  private:
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_