[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.
 
+  // These scoped helpers save and restore the original error state, so that we
+  // can specially treat invalid escape sequences in templates (which are
+  // handled by the parser).
+  ErrorState scanner_error_state(&scanner_error_, &scanner_error_location_);
+  ErrorState octal_error_state(&octal_message_, &octal_pos_);
+
   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/22 10:03:02]

Maybe: 
  bool success = ScanEscape<...>
  DCHECK_EQ(!success, has_error());

(Not sure this adds much... I was briefly irritated why we ignore the return
value. It's correct, of course, because we expect the return value to signal the
same as the error state. If so, it might make sense to DCHECK this.)

[bakkot1, 2017/02/22 20:23:53]

Seems worthwhile; done.

[bakkot1, 2017/02/22 20:41:13]

Update: undone, since having `success` not be used in release causes a
compile failure. Going to leave it out instead of wrapping the
`bool success = ` in an IFDEF or making the check unconditional.

+        // For templates, invalid escape sequence checking is handled in the
+        // parser.
+        scanner_error_state.MoveErrorTo(&invalid_template_escape_message_,
+                                        &invalid_template_escape_location_);
+        octal_error_state.MoveErrorTo(&invalid_template_escape_message_,
+                                      &invalid_template_escape_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') {
         ReduceRawLiteralLength(1);  // Remove \r
         if (c0_ == '\n') {
           Advance<capture_raw>();  // Adds \n
         } else {
           AddRawLiteralChar('\n');
         }
         c = '\n';
       }
       AddLiteralChar(c);
     }
   }
   literal.Complete();
   next_.location.end_pos = source_pos();
   next_.token = result;
+
   return result;
 }
 
 
 Token::Value Scanner::ScanTemplateStart() {
   DCHECK(next_next_.token == Token::UNINITIALIZED);
   DCHECK(c0_ == '`');
   next_.location.beg_pos = source_pos();
   Advance();  // Consume `
   return ScanTemplateSpan();
@@ skipping 583 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