Implement ES6 Template Literals

src/preparser.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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 84 matching lines @@
   bool allow_arrow_functions() const { return allow_arrow_functions_; }
   bool allow_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_scoping() const { return scanner()->HarmonyScoping(); }
   bool allow_harmony_numeric_literals() const {
     return scanner()->HarmonyNumericLiterals();
   }
   bool allow_classes() const { return scanner()->HarmonyClasses(); }
   bool allow_harmony_object_literals() const {
     return allow_harmony_object_literals_;
   }
+  bool allow_harmony_templates() const { return scanner()->HarmonyTemplates(); }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   void set_allow_natives_syntax(bool allow) { allow_natives_syntax_ = allow; }
   void set_allow_arrow_functions(bool allow) { allow_arrow_functions_ = allow; }
   void set_allow_modules(bool allow) { scanner()->SetHarmonyModules(allow); }
   void set_allow_harmony_scoping(bool allow) {
     scanner()->SetHarmonyScoping(allow);
   }
   void set_allow_harmony_numeric_literals(bool allow) {
     scanner()->SetHarmonyNumericLiterals(allow);
   }
   void set_allow_classes(bool allow) { scanner()->SetHarmonyClasses(allow); }
   void set_allow_harmony_object_literals(bool allow) {
     allow_harmony_object_literals_ = allow;
   }
+  void set_allow_harmony_templates(bool allow) {
+    scanner()->SetHarmonyTemplates(allow);
+  }
 
  protected:
   enum AllowEvalOrArgumentsAsIdentifier {
     kAllowEvalOrArguments,
     kDontAllowEvalOrArguments
   };
 
   enum Mode {
     PARSE_LAZILY,
     PARSE_EAGERLY
@@ skipping 142 matching lines @@
   bool stack_overflow() const { return stack_overflow_; }
   void set_stack_overflow() { stack_overflow_ = true; }
   Mode mode() const { return mode_; }
   typename Traits::Type::Zone* zone() const { return zone_; }
 
   INLINE(Token::Value peek()) {
     if (stack_overflow_) return Token::ILLEGAL;
     return scanner()->peek();
   }
 
-  INLINE(Token::Value Next()) {
+  INLINE(Token::Value Next(Scanner::Mode mode = Scanner::None)) {
     if (stack_overflow_) return Token::ILLEGAL;
     {
       if (GetCurrentStackPosition() < stack_limit_) {
         // Any further calls to Next or peek will return the illegal token.
         // The current call must return the next token, which might already
         // have been peek'ed.
         stack_overflow_ = true;
       }
     }
-    return scanner()->Next();
+    return scanner()->Next(mode);
   }
 
   void Consume(Token::Value token) {
     Token::Value next = Next();
     USE(next);
     USE(token);
     DCHECK(next == token);
   }
 
   bool Check(Token::Value token) {
@@ skipping 184 matching lines @@
   ExpressionT ParseMemberExpression(bool* ok);
   ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
                                                 bool* ok);
   ExpressionT ParseArrowFunctionLiteral(int start_pos, ExpressionT params_ast,
                                         bool* ok);
   ExpressionT ParseClassLiteral(IdentifierT name,
                                 Scanner::Location function_name_location,
                                 bool name_is_strict_reserved, int pos,
                                 bool* ok);
 
+  void AddTemplateSpan();
+  void AddTemplateExpression(ExpressionT);
+
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
       Scanner::Location location, const char* message, bool* ok);
 
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
   // a type of object literal property. When parsing a property, its
@@ skipping 860 matching lines @@
   // Utility functions
   int DeclareArrowParametersFromExpression(PreParserExpression expression,
                                            PreParserScope* scope,
                                            Scanner::Location* dupe_loc,
                                            bool* ok) {
     // TODO(aperez): Detect duplicated identifiers in paramlists.
     *ok = expression.IsValidArrowParamList();
     return 0;
   }
 
+  struct TemplateLiteralState {};
+
+  TemplateLiteralState OpenTemplateLiteral() { return TemplateLiteralState(); }
+  void AddTemplateSpan(TemplateLiteralState* state) { USE(state); }
+  void AddTemplateExpression(TemplateLiteralState* state,
+                             PreParserExpression expression) {
+    USE(state);
+    USE(expression);
+  }
+  PreParserExpression CloseTemplateLiteral(TemplateLiteralState* state,
+                                           int pos) {
+    USE(state);
+    USE(pos);
+    return EmptyExpression();
+  }
+
   static AstValueFactory* ast_value_factory() { return NULL; }
 
   void CheckConflictingVarDeclarations(PreParserScope scope, bool* ok) {}
 
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
       PreParserIdentifier name, Scanner::Location function_name_location,
       bool name_is_strict_reserved, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
@@ skipping 349 matching lines @@
   //   'true'
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
   //   RegExpLiteral
   //   ClassLiteral
   //   '(' Expression ')'
+  //   TemplateLiteral
 
   int pos = peek_position();
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
       scope_->RecordThisUsage();
       result = this->ThisExpression(scope_, factory());
       break;
@@ skipping 75 matching lines @@
     }
 
     case Token::MOD:
       if (allow_natives_syntax() || extension_ != NULL) {
         result = this->ParseV8Intrinsic(CHECK_OK);
         break;
       }
       // If we're not allowing special syntax we fall-through to the
       // default case.
 
+    case Token::TEMPLATE_SPAN: {
+      typename Traits::TemplateLiteralState ts = Traits::OpenTemplateLiteral();
+      // Add TV / TRV
+      Consume(Token::TEMPLATE_SPAN);
+      int pos = position();
+      Traits::AddTemplateSpan(&ts);
+
+      for (;;) {
+        Token::Value next = peek();
+        if (next < 0) {
+          ReportMessage("unterminated_template");
+          *ok = false;
+          return Traits::EmptyExpression();
+        }
+
+        // Parse an Expression
+        ExpressionT expression = this->ParseExpression(false, CHECK_OK);
+        Traits::AddTemplateExpression(&ts, expression);
+
+        // If we didn't die parsing that expression, our next token should be a
+        // TEMPLATE_SPAN or
+        // TEMPLATE_TAIL.
+        next = Next(Scanner::TemplateLiteral);
+        if (next == Token::ILLEGAL || next < 0) {
+          ReportMessage("unterminated_template");
+          *ok = false;
+          return Traits::EmptyExpression();
+        }
+
+        CHECK(next == Token::TEMPLATE_SPAN || next == Token::TEMPLATE_TAIL);
+        Traits::AddTemplateSpan(&ts);
+
+        if (next == Token::TEMPLATE_TAIL) {
+          break;
+        }
+      }
+      result = Traits::CloseTemplateLiteral(&ts, pos);
+    } break;
+
+    case Token::TEMPLATE_TAIL: {
+      // Close TemplateLiteral
+      typename Traits::TemplateLiteralState ts = Traits::OpenTemplateLiteral();
+      Consume(Token::TEMPLATE_TAIL);
+      int pos = position();
+      Traits::AddTemplateSpan(&ts);
+      result = Traits::CloseTemplateLiteral(&ts, pos);
+    } break;
+
     default: {
       Next();
       ReportUnexpectedToken(token);
       *ok = false;
     }
   }
 
   return result;
 }
 
@@ skipping 583 matching lines @@
         // direct eval calls. These calls are all of the form eval(...), with
         // no explicit receiver.
         // These calls are marked as potentially direct eval calls. Whether
         // they are actually direct calls to eval is determined at run time.
         this->CheckPossibleEvalCall(result, scope_);
         result = factory()->NewCall(result, args, pos);
         if (fni_ != NULL) fni_->RemoveLastFunction();
         break;
       }
 
+      case Token::TEMPLATE_SPAN:
+      case Token::TEMPLATE_TAIL: {
+        ExpressionT templateLiteral = ParsePrimaryExpression(CHECK_OK);
+        USE(templateLiteral);
+        // TODO: Make sure we can invoke the tag with the expected parameters.
+        break;
+      }
+
       case Token::PERIOD: {
         Consume(Token::PERIOD);
         int pos = position();
         IdentifierT name = ParseIdentifierName(CHECK_OK);
         result = factory()->NewProperty(
             result, factory()->NewStringLiteral(name, pos), pos);
         if (fni_ != NULL) this->PushLiteralName(fni_, name);
         break;
       }
 
@@ skipping 375 matching lines @@
       DCHECK(IsAccessorAccessorConflict(old_type, type));
       // Both accessors of the same type.
       parser()->ReportMessage("accessor_get_set");
     }
     *ok = false;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H