Implement ES6 Template Literals

src/ast-value-factory.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 120 matching lines @@
   virtual void Internalize(Isolate* isolate) OVERRIDE;
 
  private:
   friend class AstValueFactory;
 
   const AstString* left_;
   const AstString* right_;
 };
 
 
+class AstTemplateSpan {
+ public:
+  AstTemplateSpan(const AstString* value, const AstString* rawValue)
+      : tv_(value), trv_(rawValue) {}
+
+  Handle<String> value() const { return tv_->string(); }
+
+  Handle<String> rawValue() const { return trv_->string(); }
+
+ private:
+  friend class AstValueFactory;
+
+  const AstString* tv_;
+  const AstString* trv_;
+};
+
+
 // AstValue is either a string, a number, a string array, a boolean, or a
 // special value (null, undefined, the hole).
 class AstValue : public ZoneObject {
  public:
   bool IsString() const {
     return type_ == STRING;
   }
 
   bool IsNumber() const {
     return type_ == NUMBER || type_ == SMI;
@@ skipping 143 matching lines @@
 
   const AstRawString* GetOneByteString(Vector<const uint8_t> literal);
   const AstRawString* GetOneByteString(const char* string) {
     return GetOneByteString(Vector<const uint8_t>(
         reinterpret_cast<const uint8_t*>(string), StrLength(string)));
   }
   const AstRawString* GetTwoByteString(Vector<const uint16_t> literal);
   const AstRawString* GetString(Handle<String> literal);
   const AstConsString* NewConsString(const AstString* left,
                                      const AstString* right);
-
+  const AstTemplateSpan* NewTemplateSpan(const AstString* value,
+                                         const AstString* rawValue);
   void Internalize(Isolate* isolate);
   bool IsInternalized() {
     return isolate_ != NULL;
   }
 
 #define F(name, str)                                                    \
   const AstRawString* name##_string() {                                 \
     if (name##_string_ == NULL) {                                       \
       const char* data = str;                                           \
       name##_string_ = GetOneByteString(                                \
@@ skipping 43 matching lines @@
 
 bool AstRawString::IsArguments(AstValueFactory* ast_value_factory) const {
   return ast_value_factory->arguments_string() == this;
 }
 } }  // namespace v8::internal
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_VALUE_FACTORY_H_