Implement ES6 Template Literals

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 78 matching lines @@
   V(Property)                   \
   V(Call)                       \
   V(CallNew)                    \
   V(CallRuntime)                \
   V(UnaryOperation)             \
   V(CountOperation)             \
   V(BinaryOperation)            \
   V(CompareOperation)           \
   V(ThisFunction)               \
   V(SuperReference)             \
-  V(CaseClause)
+  V(CaseClause)                 \
+  V(TemplateLiteral)
 
 #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;
 template<class> class AstNodeFactory;
@@ skipping 1315 matching lines @@
       : Expression(zone, position), value_(value) {}
   static int parent_num_ids() { return Expression::num_ids(); }
 
  private:
   int local_id(int n) const { return base_id() + parent_num_ids() + n; }
 
   const AstValue* value_;
 };
 
 
+class TemplateLiteral FINAL : public Expression {
+ public:
+  DECLARE_NODE_TYPE(TemplateLiteral)
+
+  const ZoneList<Expression*>* cooked() const { return &cooked_; }
+  const ZoneList<Expression*>* raw() const { return &raw_; }
+  const ZoneList<Expression*>* expressions() const { return &expressions_; }
+
+  void AddTemplateSpan(Literal* cooked, Literal* raw, Zone* zone) {
+    DCHECK(cooked != NULL);
+    DCHECK(raw != NULL);
+    cooked_.Add(cooked, zone);
+    raw_.Add(raw, zone);
+  }
+
+  void AddExpression(Expression* expression, Zone* zone) {
+    DCHECK(expression != NULL);
+    expressions_.Add(expression, zone);
+  }
+
+  static int num_ids() { return parent_num_ids() + 1; }
+
+ private:
+  TemplateLiteral(Zone* zone, int pos)
+      : Expression(zone, pos),
+        cooked_(8, zone),
+        raw_(8, zone),
+        expressions_(8, zone) {
+  }
+
+  static int parent_num_ids() { return Expression::num_ids(); }
+
+  int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+
+  ZoneList<Expression*> cooked_;
+  ZoneList<Expression*> raw_;
+  ZoneList<Expression*> expressions_;
+};
+
+
 // Base class for literals that needs space in the corresponding JSFunction.
 class MaterializedLiteral : public Expression {
  public:
   virtual MaterializedLiteral* AsMaterializedLiteral() { return this; }
 
   int literal_index() { return literal_index_; }
 
   int depth() const {
     // only callable after initialization.
     DCHECK(depth_ >= 1);
@@ skipping 1937 matching lines @@
     CaseClause* clause = new (zone_) CaseClause(zone_, label, statements, pos);
     VISIT_AND_RETURN(CaseClause, clause)
   }
 
   Literal* NewStringLiteral(const AstRawString* string, int pos) {
     Literal* lit =
         new (zone_) Literal(zone_, ast_value_factory_->NewString(string), pos);
     VISIT_AND_RETURN(Literal, lit)
   }
 
+  TemplateLiteral* NewTemplateLiteral(int pos) {
+    TemplateLiteral* lit =
+        new (zone_) TemplateLiteral(zone_, pos);
+    VISIT_AND_RETURN(TemplateLiteral, lit);
+  }
+
   // A JavaScript symbol (ECMA-262 edition 6).
   Literal* NewSymbolLiteral(const char* name, int pos) {
     Literal* lit =
         new (zone_) Literal(zone_, ast_value_factory_->NewSymbol(name), pos);
     VISIT_AND_RETURN(Literal, lit)
   }
 
   Literal* NewNumberLiteral(double number, int pos) {
     Literal* lit =
         new (zone_) Literal(zone_, ast_value_factory_->NewNumber(number), pos);
@@ skipping 247 matching lines @@
  private:
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_