Simplify template literal raw string creation

src/scanner.cc

 // Copyright 2011 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.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include <stdint.h>
 
 #include <cmath>
 
@@ skipping 16 matching lines @@
   }
   return isolate->factory()->InternalizeTwoByteString(two_byte_literal());
 }
 
 
 // ----------------------------------------------------------------------------
 // Scanner
 
 Scanner::Scanner(UnicodeCache* unicode_cache)
     : unicode_cache_(unicode_cache),
+      capturing_raw_literal_(false),
       octal_pos_(Location::invalid()),
       harmony_scoping_(false),
       harmony_modules_(false),
       harmony_numeric_literals_(false),
       harmony_classes_(false),
       harmony_templates_(false) {}
 
 
 void Scanner::Initialize(Utf16CharacterStream* source) {
   source_ = source;
@@ skipping 349 matching lines @@
     PushBack('-');  // undo Advance()
   }
   PushBack('!');  // undo Advance()
   DCHECK(c0_ == '!');
   return Token::LT;
 }
 
 
 void Scanner::Scan() {
   next_.literal_chars = NULL;
+  next_.raw_literal_chars = NULL;
   Token::Value token;
   do {
     // Remember the position of the next token
     next_.location.beg_pos = source_pos();
 
     switch (c0_) {
       case ' ':
       case '\t':
         Advance();
         token = Token::WHITESPACE;
@@ skipping 379 matching lines @@
     // After parsing an Expression, the source position is incorrect due to
     // having scanned the brace. Push the RBRACE back into the stream.
     PushBack('}');
   }
 
   next_.location.beg_pos = source_pos();
   Token::Value result = Token::TEMPLATE_SPAN;
   DCHECK(c0_ == '`' || c0_ == '}');
   Advance();  // Consume ` or }
 
-  LiteralScope literal(this);
+  LiteralScope literal(this, true);
+
   while (true) {
     uc32 c = c0_;
     Advance();
     if (c == '`') {
       result = Token::TEMPLATE_TAIL;
+      ReduceRawLiteralLength(1);
       break;
     } else if (c == '$' && c0_ == '{') {
       Advance();  // Consume '{'
+      ReduceRawLiteralLength(2);
       break;
     } else if (c == '\\') {
       if (unicode_cache_->IsLineTerminator(c0_)) {
         // The TV of LineContinuation :: \ LineTerminatorSequence is the empty
         // code unit sequence.
         uc32 lastChar = c0_;
         Advance();
-        if (lastChar == '\r' && c0_ == '\n') Advance();
+        if (lastChar == '\r') {
+          ReduceRawLiteralLength(1);  // Remove \r
+          if (c0_ == '\n') {
+            Advance();  // Adds \n
+          } else {
+            AddRawLiteralChar('\n');
+          }
+        }
       } else if (c0_ == '0') {
         Advance();
         AddLiteralChar('0');
       } else {
         ScanEscape();
       }
     } else if (c < 0) {
       // Unterminated template literal
       PushBack(c);
       break;
     } else {
       // The TRV of LineTerminatorSequence :: <CR> is the CV 0x000A.
       // The TRV of LineTerminatorSequence :: <CR><LF> is the sequence
       // consisting of the CV 0x000A.
       if (c == '\r') {
-        if (c0_ == '\n') Advance();
+        ReduceRawLiteralLength(1);  // Remove \r
+        if (c0_ == '\n') {
+          Advance();  // Adds \n
+        } else {
+          AddRawLiteralChar('\n');
+        }
         c = '\n';
       }
       AddLiteralChar(c);
     }
   }
   literal.Complete();
   next_.location.end_pos = source_pos();
   next_.token = result;
   return result;
 }
@@ skipping 393 matching lines @@
 
 
 const AstRawString* Scanner::NextSymbol(AstValueFactory* ast_value_factory) {
   if (is_next_literal_one_byte()) {
     return ast_value_factory->GetOneByteString(next_literal_one_byte_string());
   }
   return ast_value_factory->GetTwoByteString(next_literal_two_byte_string());
 }
 
 
+const AstRawString* Scanner::CurrentRawSymbol(
+    AstValueFactory* ast_value_factory) {
+  if (is_raw_literal_one_byte()) {
+    return ast_value_factory->GetOneByteString(raw_literal_one_byte_string());
+  }
+  return ast_value_factory->GetTwoByteString(raw_literal_two_byte_string());
+}
+
+
 double Scanner::DoubleValue() {
   DCHECK(is_literal_one_byte());
   return StringToDouble(
       unicode_cache_,
       literal_one_byte_string(),
       ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY);
 }
 
 
 int Scanner::FindNumber(DuplicateFinder* finder, int value) {
@@ skipping 142 matching lines @@
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 } }  // namespace v8::internal