Fix value computation for multi-line strings (issue 22993)

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 3423 matching lines @@
    * `true` if this is the first token in a string literal. The flag [last] is
    * `true` if this is the last token in a string literal.
    */
   String _computeStringValue(String lexeme, bool first, bool last) {
     bool isRaw = false;
     int start = 0;
     if (first) {
       if (StringUtilities.startsWith4(lexeme, 0, 0x72, 0x22, 0x22, 0x22) ||
           StringUtilities.startsWith4(lexeme, 0, 0x72, 0x27, 0x27, 0x27)) {
         isRaw = true;
-        start += 4;
+        start = _skipInitialWhitespace(lexeme, start + 4);
       } else if (StringUtilities.startsWith2(lexeme, 0, 0x72, 0x22) ||
           StringUtilities.startsWith2(lexeme, 0, 0x72, 0x27)) {
         isRaw = true;
         start += 2;
       } else if (StringUtilities.startsWith3(lexeme, 0, 0x22, 0x22, 0x22) ||
           StringUtilities.startsWith3(lexeme, 0, 0x27, 0x27, 0x27)) {
-        start += 3;
+        start = _skipInitialWhitespace(lexeme, start + 3);
       } else if (StringUtilities.startsWithChar(lexeme, 0x22) ||
           StringUtilities.startsWithChar(lexeme, 0x27)) {
         start += 1;
       }
     }
     int end = lexeme.length;
     if (last) {
       if (StringUtilities.endsWith3(lexeme, 0x22, 0x22, 0x22) ||
           StringUtilities.endsWith3(lexeme, 0x27, 0x27, 0x27)) {
         end -= 3;
@@ skipping 12 matching lines @@
     }
     StringBuffer buffer = new StringBuffer();
     int index = start;
     while (index < end) {
       index = _translateCharacter(buffer, lexeme, index);
     }
     return buffer.toString();
   }
 
   /**
+   * Given the [lexeme] for a multi-line string whose content begins at the
+   * given [start] index, return the index of the first character that is
+   * included in the value of the string. According to the specification:
+   *
+   * If the first line of a multiline string consists solely of the whitespace
+   * characters defined by the production WHITESPACE 20.1), possibly prefixed
+   * by \, then that line is ignored, including the new line at its end.
+   */
+  int _skipInitialWhitespace(String lexeme, int start) {
+    int length = lexeme.length;
+    int index = start;
+    while (index < length) {
+      int currentChar = lexeme.codeUnitAt(index);
+      if (currentChar == 0x0D) {
+        if (index + 1 < length && lexeme.codeUnitAt(index) == 0x0A) {
+          return index + 2;
+        }
+        return index + 1;
+      } else if (currentChar == 0x0A) {
+        return index + 1;
+      } else if (currentChar != 0x09 && currentChar != 0x20 && currentChar != 0x5C) {

[Paul Berry, 2015/03/26 17:59:13]

As discussed in person, this doesn't match the VM behavior for some corner cases
(nor does the VM behavior match the spec).  The VM appears to decode the string
first, then strip out leading whitespace, then do string interpolation.  I
haven't investigated what dart2js does.

IMHO, it would be reasonable to land this CL as is for now, since it's going to
take some time to get clarification from Gilad & co. about what behavior is
actually intended for the corner cases.


Here are some of the corner cases I investigated, and how I believe the VM
currently interprets them:

'''\\
foo''' => '\\\nfoo'

'''\t
foo''' => 'foo'

r'''\
foo''' => '\\\nfoo'

r'''\t
foo''' => '\\t\nfoo'

'''\x20
foo''' => 'foo'

String x = ' ';
'''$x
foo''' => ' \nfoo'

+        return start;
+      }
+      index++;
+    }
+    return index;
+  }
+
+  /**
    * Convert the given [method] declaration into the nearest valid top-level
    * function declaration (that is, the function declaration that most closely
    * captures the components of the given method declaration).
    */
   FunctionDeclaration _convertToFunctionDeclaration(MethodDeclaration method) =>
       new FunctionDeclaration(method.documentationComment, method.metadata,
           method.externalKeyword, method.returnType, method.propertyKeyword,
           method.name, new FunctionExpression(method.parameters, method.body));
 
   /**
@@ skipping 7043 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }