[parser] Lift template literal invalid escape restriction

src/parsing/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 "src/parsing/scanner.h"
 
 #include <stdint.h>
 
@@ skipping 930 matching lines @@
     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;
   }
 
-  // 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.
+  // Other escaped characters are interpreted as their non-escaped version.
   AddLiteralChar(c);
   return true;
 }
 
 
-// Octal escapes of the forms '\0xx' and '\xxx' are not a part of
-// ECMA-262. Other JS VMs support them.
 template <bool capture_raw>
 uc32 Scanner::ScanOctalEscape(uc32 c, int length) {
   uc32 x = c - '0';
   int i = 0;
   for (; i < length; i++) {
     int d = c0_ - '0';
     if (d < 0 || d > 7) break;
     int nx = x * 8 + d;
     if (nx >= 256) break;
     x = nx;
@@ skipping 61 matching lines @@
   //   | } LiteralChars* ${
   //
   // TEMPLATE_TAIL ::
   //     ` LiteralChars* `
   //   | } 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.
 
+  DCHECK(!has_error());
   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;
@@ skipping 10 matching lines @@
         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 (!ScanEscape<capture_raw, in_template_literal>()) {
-        return Token::ILLEGAL;
+      } else {
+        ScanEscape<capture_raw, in_template_literal>();

[vogelheim, 2017/02/17 16:33:53]

In a template w/ two invalid escapes, this would record the position of the last
one, right?

[bakkot1, 2017/02/17 20:42:18]

It would. Fixed.

Octal literals actually have the same issue currently: we report the location of
the *last* octal literal in a string or template literal. With this patch, we
report the last in a string the first in a template literal.

Actually, that exposes a bug, which I'll document elsewhere.

+        if (has_error()) {
+          // For templates, invalid escape sequence checking is handled in the
+          // parser.
+          invalid_template_escape_message_ = scanner_error_;
+          invalid_template_escape_location_ = scanner_error_location_;
+          scanner_error_ = MessageTemplate::kNone;
+          scanner_error_location_ = Location();
+        }
       }
     } 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 605 matching lines @@
   // 2, reset the source to the desired position,
   source_->Seek(position);
   // 3, re-scan, by scanning the look-ahead char + 1 token (next_).
   c0_ = source_->Advance();
   Next();
   DCHECK_EQ(next_.location.beg_pos, static_cast<int>(position));
 }
 
 }  // namespace internal
 }  // namespace v8