Better toString and Error.toSafeString output for closures for dart2js.

sdk/lib/_internal/compiler/js_lib/core_patch.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.
 
 // Patch file for dart:core classes.
 import "dart:_internal" as _symbol_dev;
 import 'dart:_interceptors';
 import 'dart:_js_helper' show patch,
                               patch_new,
                               patch_old,
                               checkInt,
                               getRuntimeType,
                               jsonEncodeNative,
                               JSSyntaxRegExp,
                               Primitives,
                               ConstantMap,
                               stringJoinUnchecked,
-                              objectHashCode;
+                              objectHashCode,
+                              Closure;
 
 import 'dart:_native_typed_data' show NativeUint8List;
 
 String _symbolToString(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 _symbolMapToStringMap(Map<Symbol, dynamic> map) {
   if (map == null) return null;
   var result = new Map<String, dynamic>();
   map.forEach((Symbol key, value) {
     result[_symbolToString(key)] = value;
@@ skipping 115 matching lines @@
   static double parse(String source,
                             [double onError(String source)]) {
     return Primitives.parseDouble(source, onError);
   }
 }
 
 @patch
 class Error {
   @patch
   static String _objectToString(Object object) {
+    // Closures all have useful and safe toString methods.
+    if (object is Closure) return object.toString();
     return Primitives.objectToString(object);
   }
 
   @patch
   static String _stringToSafeString(String string) {
     return jsonEncodeNative(string);
   }
 
   @patch
   StackTrace get stackTrace => Primitives.extractStackTrace(this);
@@ skipping 287 matching lines @@
   static String _writeOne(String string, Object obj) {
     return Primitives.stringConcatUnchecked(string, '$obj');
   }
 }
 
 @patch
 class NoSuchMethodError {
   @patch
   String toString() {
     StringBuffer sb = new StringBuffer();
-    int i = 0;
+    String comma = '';
     if (_arguments != null) {
-      for (; i < _arguments.length; i++) {
-        if (i > 0) {
-          sb.write(", ");
-        }
-        sb.write(Error.safeToString(_arguments[i]));
+      for (var argument in _arguments) {

[floitsch, 2015/05/12 23:14:16]

maybe?:
sb.writeAll(_arguments.map(Error.safeToString), ", ")
...
if (_nameArguments != null) {
  if (_arguments != null) sb.write(", ");

[sra1, 2015/05/12 23:25:50]

if (_arguments != null && _arguments.isNotEmpty) ...

I has something like that but I was not quite happy with it.  I think this way
pulls in the fewest additional methods.

+        sb.write(comma);
+        sb.write(Error.safeToString(argument));
+        comma = ', ';
       }
     }
     if (_namedArguments != null) {
       _namedArguments.forEach((Symbol key, var value) {
-        if (i > 0) {
-          sb.write(", ");
-        }
+        sb.write(comma);
         sb.write(_symbolToString(key));
         sb.write(": ");
         sb.write(Error.safeToString(value));
-        i++;
+        comma = ', ';
       });
     }
+    String memberName = _symbolToString(_memberName);
+    String receiverText = Error.safeToString(_receiver);
+    String actualParameters = '$sb';
     if (_existingArgumentNames == null) {
-      return "NoSuchMethodError : method not found: '$_memberName'\n"
-          "Receiver: ${Error.safeToString(_receiver)}\n"
-          "Arguments: [$sb]";
+      return "NoSuchMethodError: method not found: '$memberName'\n"
+          "Receiver: ${receiverText}\n"
+          "Arguments: [$actualParameters]";
     } else {
-      String actualParameters = sb.toString();
-      sb = new StringBuffer();
-      for (int i = 0; i < _existingArgumentNames.length; i++) {
-        if (i > 0) {
-          sb.write(", ");
-        }
-        sb.write(_existingArgumentNames[i]);
-      }
-      String formalParameters = sb.toString();
+      String formalParameters = _existingArgumentNames.join(', ');
       return "NoSuchMethodError: incorrect number of arguments passed to "
-          "method named '$_memberName'\n"
-          "Receiver: ${Error.safeToString(_receiver)}\n"
-          "Tried calling: $_memberName($actualParameters)\n"
-          "Found: $_memberName($formalParameters)";
+          "method named '$memberName'\n"
+          "Receiver: ${receiverText}\n"
+          "Tried calling: $memberName($actualParameters)\n"
+          "Found: $memberName($formalParameters)";
     }
   }
 }
 
 @patch
 class Uri {
   @patch
   static bool get _isWindows => false;
 
   @patch
   static Uri get base {
     String uri = Primitives.currentUri();
     if (uri != null) return Uri.parse(uri);
     throw new UnsupportedError("'Uri.base' is not supported");
   }
 }