dart2js: Avoid escaping in strings if it's not necessary.

pkg/compiler/lib/src/js_backend/constant_emitter.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 class ConstantEmitter {
   ConstantReferenceEmitter _referenceEmitter;
   ConstantLiteralEmitter _literalEmitter;
 
@@ skipping 216 matching lines @@
         return js("!0");
       } else {
         // Use !1 for false.
         return js("!1");
       }
     } else {
       return constant.isTrue ? js('true') : js('false');
     }
   }
 
+  /// Returns the escaped string for the given character [codeUnit].
+  ///
+  /// Returns `null` if the character doesn't need any escaping.
+  ///
+  /// Relevant sections of ECMA-262:
+  ///
+  ///     7.3 Line Terminators
+  ///       LineTerminator ::
+  ///          <LF>
+  ///          <CR>
+  ///          <LS>
+  ///          <PS>
+  ///
+  ///     7.8.4 String Literals
+  ///       StringLiteral ::
+  ///          " DoubleStringCharacters? "
+  ///          ' SingleStringCharacters? '
+  ///
+  ///       DoubleStringCharacters ::
+  ///          DoubleStringCharacter DoubleStringCharacters?
+  ///
+  ///       DoubleStringCharacter ::
+  ///          SourceCharacter but not one of " or \ or LineTerminator
+  ///          \ EscapeSequence
+  ///          LineContinuation
+  String _escapeChar(int codeUnit) {
+    switch (codeUnit) {
+      case $BACKSLASH: return r"\\";
+      case $DQ: return r'\"';
+      case $LF: return r'\n';
+      case $CR: return r'\r';
+      case $LS: return r'\u2028';
+      case $PS: return r'\u2029';
+      default: return null;
+    }
+  }
+
   /**
    * Write the contents of the quoted string to a [CodeBuffer] in
    * a form that is valid as JavaScript string literal content.
    * The string is assumed quoted by double quote characters.
    */
   @override
   jsAst.Expression visitString(StringConstantValue constant, [_]) {
-    StringBuffer sb = new StringBuffer();
-    writeJsonEscapedCharsOn(constant.primitiveValue.slowToString(), sb);
-    return new jsAst.LiteralString('"$sb"');
+    String str = constant.primitiveValue.slowToString();
+    int i = 0;

[sra1, 2015/02/17 20:03:53]

JsBuilder.escapedString already does this.
It is not quite right (no $LS or $PS), so better to fix it there than make
another copy of escaping code.

I think JsBuilder.escapedString could be reduced to one call to replaceAllMapped
with a static cached RegExp.  That should already be implemented efficiently for
the no-hit case.

The whole body of visitString should just be:

return js.escapedString(constant.primitiveValue.slowToString());

[floitsch, 2015/02/20 13:55:50]

Done.

+    String replacement;
+    while (i < str.length) {
+      replacement = _escapeChar(str.codeUnitAt(i++));
+      if (replacement != null) {
+        break;
+      }
+    }
+    // In the common case we don't need any escaping and will not enter the if.
+    if (replacement != null) {
+      StringBuffer sb = new StringBuffer(str.substring(0, i - 1));
+      sb.write(replacement);
+      while (i < str.length) {
+        int codeUnit = str.codeUnitAt(i++);
+        replacement = _escapeChar(codeUnit);
+        if (replacement != null) {
+          sb.write(replacement);
+        } else {
+          sb.writeCharCode(codeUnit);
+        }
+      }
+      str = sb.toString();
+    }
+    return new jsAst.LiteralString('"$str"');
   }
 
   @override
   jsAst.Expression visitList(ListConstantValue constant, [_]) {
     List<jsAst.Expression> elements = _array(constant.entries);
     jsAst.ArrayInitializer array = new jsAst.ArrayInitializer(elements);
     jsAst.Expression value = makeConstantListTemplate.instantiate([array]);
     return maybeAddTypeArguments(constant.type, value);
   }
 
@@ skipping 141 matching lines @@
                             [value, argumentList]);
     }
     return value;
   }
 
   @override
   jsAst.Expression visitDeferred(DeferredConstantValue constant, [_]) {
     return constantEmitter.reference(constant.referenced);
   }
 }