ES6 template literals should not use legacy octal strings

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 679 matching lines @@
     // This function is only called to seek to the location
     // of the end of a function (at the "}" token). It doesn't matter
     // whether there was a line terminator in the part we skip.
     has_line_terminator_before_next_ = false;
     has_multiline_comment_before_next_ = false;
   }
   Scan();
 }
 
 
-template <bool capture_raw>
+template <bool capture_raw, bool in_template_literal>
 bool Scanner::ScanEscape() {
   uc32 c = c0_;
   Advance<capture_raw>();
 
   // Skip escaped newlines.
-  if (c0_ >= 0 && unicode_cache_->IsLineTerminator(c)) {
+  if (!in_template_literal && c0_ >= 0 && unicode_cache_->IsLineTerminator(c)) {
     // Allow CR+LF newlines in multiline string literals.
     if (IsCarriageReturn(c) && IsLineFeed(c0_)) Advance<capture_raw>();
     // Allow LF+CR newlines in multiline string literals.
     if (IsLineFeed(c) && IsCarriageReturn(c0_)) Advance<capture_raw>();
     return true;
   }
 
   switch (c) {
     case '\'':  // fall through
     case '"' :  // fall through
     case '\\': break;
     case 'b' : c = '\b'; break;
     case 'f' : c = '\f'; break;
     case 'n' : c = '\n'; break;
     case 'r' : c = '\r'; break;
     case 't' : c = '\t'; break;
     case 'u' : {
       c = ScanUnicodeEscape<capture_raw>();
       if (c < 0) return false;
       break;
     }
-    case 'v' : c = '\v'; break;
-    case 'x' : {
+    case 'v':
+      c = '\v';
+      break;
+    case 'x': {
       c = ScanHexNumber<capture_raw>(2);
       if (c < 0) return false;
       break;
     }
-    case '0' :  // fall through
-    case '1' :  // fall through
-    case '2' :  // fall through
-    case '3' :  // fall through
-    case '4' :  // fall through
-    case '5' :  // fall through
-    case '6' :  // fall through
+    case '0':
+      if (in_template_literal) {
+        // \ 0 DecimalDigit is never allowed in templates.
+        if (IsDecimalDigit(c0_)) {
+          Advance<capture_raw>();  // Advance to include the problematic char.
+          return false;
+        }
+
+        // The TV of TemplateCharacter :: \ EscapeSequence is the CV of
+        //     EscapeSequence.
+        // The CV of EscapeSequence :: 0 is the code unit value 0.
+        c = 0;
+        break;
+      }
+    // Fall through.
+    case '1':  // fall through
+    case '2':  // fall through
+    case '3':  // fall through
+    case '4':  // fall through
+    case '5':  // fall through
+    case '6':  // fall through
     case '7':
-      c = ScanOctalEscape<capture_raw>(c, 2);
-      break;
+      if (!in_template_literal) {
+        c = ScanOctalEscape<capture_raw>(c, 2);
+        break;
+      }
+    // Fall through
+    case '8':
+    case '9':
+      if (in_template_literal) return false;
   }
 
   // According to ECMA-262, section 7.8.4, characters not covered by the
   // above cases should be illegal, but they are commonly handled as
   // non-escaped characters by JS VMs.
   AddLiteralChar(c);
   return true;
 }
 
 
@@ skipping 26 matching lines @@
 Token::Value Scanner::ScanString() {
   uc32 quote = c0_;
   Advance();  // consume quote
 
   LiteralScope literal(this);
   while (c0_ != quote && c0_ >= 0
          && !unicode_cache_->IsLineTerminator(c0_)) {
     uc32 c = c0_;
     Advance();
     if (c == '\\') {
-      if (c0_ < 0 || !ScanEscape<false>()) return Token::ILLEGAL;
+      if (c0_ < 0 || !ScanEscape<false, false>()) return Token::ILLEGAL;
     } else {
       AddLiteralChar(c);
     }
   }
   if (c0_ != quote) return Token::ILLEGAL;
   literal.Complete();
 
   Advance();  // consume quote
   return Token::STRING;
 }
@@ skipping 10 matching lines @@
   //   | } LiteralChar* `
   //
   // A TEMPLATE_SPAN should always be followed by an Expression, while a
   // TEMPLATE_TAIL terminates a TemplateLiteral and does not need to be
   // followed by an Expression.
 
   Token::Value result = Token::TEMPLATE_SPAN;
   LiteralScope literal(this);
   StartRawLiteral();
   const bool capture_raw = true;
+  const bool in_template_literal = true;
 
   while (true) {
     uc32 c = c0_;
     Advance<capture_raw>();
     if (c == '`') {
       result = Token::TEMPLATE_TAIL;
       ReduceRawLiteralLength(1);
       break;
     } else if (c == '$' && c0_ == '{') {
       Advance<capture_raw>();  // 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<capture_raw>();
         if (lastChar == '\r') {
           ReduceRawLiteralLength(1);  // Remove \r
           if (c0_ == '\n') {
             Advance<capture_raw>();  // Adds \n
           } else {
             AddRawLiteralChar('\n');
           }
         }
-      } else if (c0_ == '0') {
-        Advance<capture_raw>();
-        AddLiteralChar('0');
-      } else {
-        ScanEscape<true>();
+      } else if (!ScanEscape<capture_raw, in_template_literal>()) {
+        return Token::ILLEGAL;
       }
     } 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') {
@@ skipping 616 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