[parser] Lift template literal invalid escape restriction

src/parsing/scanner.cc

Index: src/parsing/scanner.cc
diff --git a/src/parsing/scanner.cc b/src/parsing/scanner.cc
index 86aadcff9fae2e74e7e6d11172ab2aac91d4f62a..2796ea177f86a87be8e9e0bb6dcf7959ff08b0e0 100644
--- a/src/parsing/scanner.cc
+++ b/src/parsing/scanner.cc
@@ -948,16 +948,12 @@ bool Scanner::ScanEscape() {
       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';
@@ -1039,6 +1035,12 @@ Token::Value Scanner::ScanTemplateSpan() {
   // 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();
@@ -1069,8 +1071,14 @@ Token::Value Scanner::ScanTemplateSpan() {
             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
@@ -1095,6 +1103,7 @@ Token::Value Scanner::ScanTemplateSpan() {
   literal.Complete();
   next_.location.end_pos = source_pos();
   next_.token = result;
+
   return result;
 }