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

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, 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 _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
     DEFERRED_LIBRARY_URIS,
@@ skipping 1848 matching lines @@
 
 class NullError extends Error implements NoSuchMethodError {
   final String _message;
   final String _method;
 
   NullError(this._message, match)
       : _method = match == null ? null : JS('', '#.method', match);
 
   String toString() {
     if (_method == null) return 'NullError: $_message';
-    return 'NullError: Cannot call "$_method" on null';
+    return "NullError: method not found: '$_method' on null";
   }
 }
 
 class JsNoSuchMethodError extends Error implements NoSuchMethodError {
   final String _message;
   final String _method;
   final String _receiver;
 
   JsNoSuchMethodError(this._message, match)
       : _method = match == null ? null : JS('String|Null', '#.method', match),
         _receiver =
             match == null ? null : JS('String|Null', '#.receiver', match);
 
   String toString() {
     if (_method == null) return 'NoSuchMethodError: $_message';
     if (_receiver == null) {
-      return 'NoSuchMethodError: Cannot call "$_method" ($_message)';
+      return "NoSuchMethodError: method not found: '$_method' ($_message)";
     }
-    return 'NoSuchMethodError: Cannot call "$_method" on "$_receiver" '
-        '($_message)';
+    return "NoSuchMethodError: "
+        "method not found: '$_method' on '$_receiver' ($_message)";
   }
 }
 
 class UnknownJsTypeError extends Error {
   final String _message;
 
   UnknownJsTypeError(this._message);
 
   String toString() => _message.isEmpty ? 'Error' : 'Error: $_message';
 }
@@ skipping 329 matching lines @@
     // for each computed prototype property:
     //   proto[property] = ...;
     // proto._init = BC;
     // var dynClosureConstructor =
     //     new Function('self', 'target', 'receiver', 'name',
     //                  'this._init(self, target, receiver, name)');
     // proto.constructor = dynClosureConstructor;
     // dynClosureConstructor.prototype = proto;
     // return dynClosureConstructor;
 
-    // We need to create a new subclass of either TearOffClosure or
-    // BoundClosure.  For this, we need to create an object whose prototype is
-    // the prototype is either TearOffClosure.prototype or
+    // We need to create a new subclass of TearOffClosure, one of StaticClosure
+    // or BoundClosure.  For this, we need to create an object whose prototype
+    // is the prototype is either StaticClosure.prototype or
     // BoundClosure.prototype, respectively in pseudo JavaScript code. The
     // simplest way to access the JavaScript construction function of a Dart
-    // class is to create an instance and access its constructor property.  The
-    // newly created instance could in theory be used directly as the
-    // prototype, but it might include additional fields that we don't need.
-    // So we only use the new instance to access the constructor property and
-    // use Object.create to create the desired prototype.
+    // class is to create an instance and access its constructor property.
+    // Creating an instance ensures that any lazy class initialization has taken
+    // place. The newly created instance could in theory be used directly as the
+    // prototype, but it might include additional fields that we don't need.  So
+    // we only use the new instance to access the constructor property and use
+    // Object.create to create the desired prototype.
+    //
+    // TODO(sra): Perhaps cache the prototype to avoid the allocation.
     var prototype = isStatic
-        ? JS('TearOffClosure', 'Object.create(#.constructor.prototype)',
-             new TearOffClosure())
+        ? JS('StaticClosure', 'Object.create(#.constructor.prototype)',
+             new StaticClosure())
         : JS('BoundClosure', 'Object.create(#.constructor.prototype)',
              new BoundClosure(null, null, null, null));
 
     JS('', '#.\$initialize = #', prototype, JS('', '#.constructor', prototype));
     var constructor = isStatic
         ? JS('', 'function(){this.\$initialize()}')
         : isCsp
             ? JS('', 'function(a,b,c,d) {this.\$initialize(a,b,c,d)}')
             : JS('',
-                 'new Function("a","b","c","d",'
-                     '"this.\$initialize(a,b,c,d);"+#)',
+                 'new Function("a,b,c,d", "this.\$initialize(a,b,c,d);" + #)',
                  functionCounter++);
 
     // It is necessary to set the constructor property, otherwise it will be
     // "Object".
     JS('', '#.constructor = #', prototype, constructor);
 
     JS('', '#.prototype = #', constructor, prototype);
 
     // Create a closure and "monkey" patch it with call stubs.
     var trampoline = function;
@@ skipping 282 matching lines @@
   }
 
   // The backend adds a special getter of the form
   //
   // Closure get call => this;
   //
   // to allow tearing off a closure from itself. We do this magically in the
   // backend rather than simply adding it here, as we do not want this getter
   // to be visible to resolution and the generation of extra stubs.
 
-  String toString() => "Closure";
+  String toString() {
+    String name = Primitives.objectTypeName(this);
+    return "Closure '$name'";
+  }
 }
 
 /// Called from implicit method getter (aka tear-off).
 closureFromTearOff(receiver,
                    functions,
                    reflectionInfo,
                    isStatic,
                    jsArguments,
                    name) {
   return Closure.fromTearOff(
       receiver,
       JSArray.markFixedList(functions),
       reflectionInfo is List ? JSArray.markFixedList(reflectionInfo)
                              : reflectionInfo,
       JS('bool', '!!#', isStatic),
       jsArguments,
       JS('String', '#', name));
 }
 
 /// Represents an implicit closure of a function.
-class TearOffClosure extends Closure {
+abstract class TearOffClosure extends Closure {
 }
 
-/// Represents a 'tear-off' closure, that is an instance method bound
-/// to a specific receiver (instance).
+class StaticClosure extends TearOffClosure {
+  String toString() {
+    String name = JS('String|Null', '#.\$name', this);
+    if (name == null) return "Closure of unknown static method";
+    return "Closure of static method '$name'";
+  }
+}
+
+/// Represents a 'tear-off' or property extraction closure of an instance
+/// method, that is an instance method bound to a specific receiver (instance).
 class BoundClosure extends TearOffClosure {
   /// The receiver or interceptor.
   // TODO(ahe): This could just be the interceptor, we always know if
   // we need the interceptor when generating the call method.
   final _self;
 
   /// The method.
   final _target;
 
   /// The receiver. Null if [_self] is not an interceptor.
@@ skipping 24 matching lines @@
       // use the hashCode method we define for those primitive types.
       receiverHashCode = _receiver.hashCode;
     } else {
       // A bound closure on an intercepted native class, just use the
       // identity hash code.
       receiverHashCode = Primitives.objectHashCode(_receiver);
     }
     return receiverHashCode ^ Primitives.objectHashCode(_target);
   }
 
+  toString() {
+    var receiver = _receiver == null ? _self : _receiver;
+    return "Closure '$_name' of ${Primitives.objectToString(receiver)}";
+  }
+
   @NoInline()
   static selfOf(BoundClosure closure) => closure._self;
 
   static targetOf(BoundClosure closure) => closure._target;
 
   @NoInline()
   static receiverOf(BoundClosure closure) => closure._receiver;
 
   static nameOf(BoundClosure closure) => closure._name;
 
@@ skipping 1423 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }