Update handling of multiline strings to specification.

pkg/front_end/lib/src/fasta/quote.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.quote;
 
 import 'errors.dart' show inputError, internalError;
 
 import 'scanner/characters.dart'
     show
@@ skipping 40 matching lines @@
   if (first.startsWith("r'")) return Quote.RawSingle;
   return internalError("Unexpected string literal: $first");
 }
 
 // Note: based on [StringValidator.quotingFromString]
 // (pkg/compiler/lib/src/string_validator.dart).
 int lengthOfOptionalWhitespacePrefix(String first, int start) {
   List<int> codeUnits = first.codeUnits;
   for (int i = start; i < codeUnits.length; i++) {
     int code = codeUnits[i];
     if (code == $BACKSLASH) {

[Lasse Reichstein Nielsen, 2017/04/28 06:34:28]

I REALLY think we should disallow quoting leading whitespace. It makes *no*
sense.
Why is `\ ` ignored but `\x20` not? 
WHY?!?

ahem.

[ahe, 2017/04/28 07:39:00]

Acknowledged.

       i++;
       if (i < codeUnits.length) {
         code = codeUnits[i];
       } else {
         break;
       }
     }
     if (code == $TAB || code == $SPACE) continue;
     if (code == $CR) {
-      if (i + 1 < codeUnits.length && codeUnits[i] == $LF) {
+      if (i + 1 < codeUnits.length && codeUnits[i + 1] == $LF) {
         i++;
       }
       return i + 1;
     }
     if (code == $LF) {
       return i + 1;
     }
     break; // Not a white-space character.
   }
   return start;
@@ skipping 51 matching lines @@
   return unescape(
       string.substring(firstQuoteLength(string, quote),
           string.length - lastQuoteLength(quote)),
       quote);
 }
 
 String unescape(String string, Quote quote) {
   switch (quote) {
     case Quote.Single:
     case Quote.Double:
+      return !string.contains("\\")
+          ? string
+          : unescapeCodeUnits(string.codeUnits, false);
+
     case Quote.MultiLineSingle:
     case Quote.MultiLineDouble:
-      break;
+      return !string.contains("\\") && !string.contains("\r")
+          ? string
+          : unescapeCodeUnits(string.codeUnits, false);
 
     case Quote.RawSingle:
     case Quote.RawDouble:
+      return string;
+
     case Quote.RawMultiLineSingle:
     case Quote.RawMultiLineDouble:
-      return string;
+      return !string.contains("\r")
+          ? string
+          : unescapeCodeUnits(string.codeUnits, true);
   }
-  return !string.contains("\\") ? string : unescapeCodeUnits(string.codeUnits);
 }
 
 const String incompleteSequence = "Incomplete escape sequence.";
 
 const String invalidCharacter = "Invalid character in escape sequence.";
 
 const String invalidCodePoint = "Invalid code point.";
 
 // Note: based on
 // [StringValidator.validateString](pkg/compiler/lib/src/string_validator.dart).
-String unescapeCodeUnits(List<int> codeUnits) {
+String unescapeCodeUnits(List<int> codeUnits, bool isRaw) {
   // Can't use Uint8List or Uint16List here, the code units may be larger.
   List<int> result = new List<int>(codeUnits.length);
   int resultOffset = 0;
   error(int offset, String message) {
     inputError(null, null, message);
   }
 
   for (int i = 0; i < codeUnits.length; i++) {
     int code = codeUnits[i];
-    if (code == $BACKSLASH) {
+    if (code == $CR) {
+      if (i + 1 < codeUnits.length && codeUnits[i + 1] == $LF) {
+        i++;
+      }
+      code = $LF;
+    } else if (!isRaw && code == $BACKSLASH) {
       if (codeUnits.length == ++i) return error(i, incompleteSequence);
       code = codeUnits[i];
 
       /// `\n` for newline, equivalent to `\x0A`.
       /// `\r` for carriage return, equivalent to `\x0D`.
       /// `\f` for form feed, equivalent to `\x0C`.
       /// `\b` for backspace, equivalent to `\x08`.
       /// `\t` for tab, equivalent to `\x09`.
       /// `\v` for vertical tab, equivalent to `\x0B`.
       /// `\xXX` for hex escape.
@@ skipping 45 matching lines @@
         }
       } else {
         // Nothing, escaped character is passed through;
       }
       if (code > 0x10FFFF) return error(i, invalidCodePoint);
     }
     result[resultOffset++] = code;
   }
   return new String.fromCharCodes(result, 0, resultOffset);
 }