Improve toString on mirrors and align VM and dart2js.

dart/runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
   return (value == null || value is num || value is String || value is bool);
 }
@@ skipping 231 matching lines @@
   static _invoke(ref, memberName, positionalArguments, async)
       native 'LocalObjectMirrorImpl_invoke';
 
   static _getField(ref, fieldName) // same for sync and async versions
       native 'LocalObjectMirrorImpl_getField';
 
   static _setField(ref, fieldName, value, async)
       native 'LocalObjectMirrorImpl_setField';
 }
 
-// Prints a string as it might appear in dart program text.
-// TODO(turnidge): Consider truncating.
-String _dartEscape(String str) {

[ahe, 2013/06/12 16:27:26]

I have requested something like this gets integrated in Error.safeToString:

https://code.google.com/p/dart/issues/detail?id=11250

-  bool isNice(int code) => (code >= 32 && code <= 126);
-
-  StringBuffer buf = new StringBuffer();
-  for (int i = 0; i < str.length; i++) {
-    var input = str[i];
-    String output;
-    switch (input) {
-      case '\\' :
-        output = r'\\';
-        break;
-      case "\'" :
-        output = r"\'";
-        break;
-      case '\n' :
-        output = r'\n';
-        break;
-      case '\r' :
-        output = r'\r';
-        break;
-      case '\f' :
-        output = r'\f';
-        break;
-      case '\b' :
-        output = r'\b';
-        break;
-      case '\t' :
-        output = r'\t';
-        break;
-      case '\v' :
-        output = r'\v';
-        break;
-      default:
-        // TODO(lrn): Someone decide if this should combine surrogate pairs.
-        int code = input.codeUnitAt(0);
-        if (isNice(code)) {
-          output = input;
-        } else {
-          output = '\\u{${code.toRadixString(16)}}';
-        }
-        break;
-    }
-    buf.write(output);
-  }
-  return buf.toString();
-}
-
 class _LocalInstanceMirrorImpl extends _LocalObjectMirrorImpl
     implements InstanceMirror {
   // TODO(ahe): This is a hack, see delegate below.
   static Function _invokeOnClosure;
 
   _LocalInstanceMirrorImpl(ref,
                            this._type,
                            this._reflectee) : super(ref) {}
 
   var _type;
@@ skipping 18 matching lines @@
       // private method does not work.
       _LocalInstanceMirrorImpl mirror =
           _Mirrors.makeLocalInstanceMirror(invocation);
       _invokeOnClosure =
           _LocalObjectMirrorImpl._getField(mirror.type, '_invokeOnClosure')
           .reflectee;
     }
     return _invokeOnClosure(reflectee, invocation);
   }
 
-  String toString() {
-    if (_isSimpleValue(_reflectee)) {
-      if (_reflectee is String) {
-        return "InstanceMirror on <'${_dartEscape(_reflectee)}'>";
-      } else {
-        return "InstanceMirror on <$_reflectee>";
-      }
-    } else {
-      return "InstanceMirror on instance of '${type.simpleName}'";
-    }
-  }
+  String toString() => 'InstanceMirror on ${Error.safeToString(_reflectee)}';
 }
 
 class _LocalClosureMirrorImpl extends _LocalInstanceMirrorImpl
     implements ClosureMirror {
   _LocalClosureMirrorImpl(ref,
                           type,
                           reflectee,
                           this.function) : super(ref, type, reflectee) {}
 
   final MethodMirror function;
@@ skipping 31 matching lines @@
     }
   }
 
   Future<InstanceMirror> findInContext(Symbol name) {
     throw new UnimplementedError(
         'ClosureMirror.findInContext() is not implemented');
   }
 
   static _apply(ref, positionalArguments, async)
       native 'LocalClosureMirrorImpl_apply';
+
+  String toString() => "ClosureMirror on '${Error.safeToString(_reflectee)}'";
 }
 
 class _LazyTypeMirror {
   _LazyTypeMirror(String this.libraryUrl, String typeName)
       : this.typeName = _s(typeName);
 
   TypeMirror resolve(MirrorSystem mirrors) {
     if (libraryUrl == null) {
       if (typeName == const Symbol('dynamic')) {
         return mirrors.dynamicType;
@@ skipping 146 matching lines @@
   bool get isOriginalDeclaration {
     throw new UnimplementedError(
         'ClassMirror.isOriginalDeclaration is not implemented');
   }
 
   ClassMirror get genericDeclaration {
     throw new UnimplementedError(
         'ClassMirror.originalDeclaration is not implemented');
   }
 
-  String toString() => "ClassMirror on '$simpleName'";
+  String toString() {
+    String prettyName = isClass ? 'ClassMirror' : 'TypeMirror';
+    return "$prettyName on '${_n(simpleName)}'";
+  }
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
     if (namedArguments != null) {
       throw new UnimplementedError(
           'named argument support is not implemented');
     }
     return _invokeConstructor(this,
                               _n(constructorName),
@@ skipping 60 matching lines @@
   var _returnType;
   TypeMirror get returnType {
     if (_returnType is! Mirror) {
       _returnType = _returnType.resolve(mirrors);
     }
     return _returnType;
   }
 
   final List<ParameterMirror> parameters;
 
-  String toString() => "FunctionTypeMirror on '$simpleName'";
+  String toString() => "FunctionTypeMirror on '${_n(simpleName)}'";
 }
 
 
 class _LazyTypeVariableMirror {
   _LazyTypeVariableMirror(String variableName, this._owner)
       : this._variableName = _s(variableName);
 
   TypeVariableMirror resolve(MirrorSystem mirrors) {
     ClassMirror owner = _owner.resolve(mirrors);
     return owner.typeVariables[_variableName];
@@ skipping 38 matching lines @@
   }
 
   var _upperBound;
   TypeMirror get upperBound {
     if (_upperBound is! Mirror) {
       _upperBound = _upperBound.resolve(mirrors);
     }
     return _upperBound;
   }
 
-  String toString() => "TypeVariableMirror on '$simpleName'";
+  String toString() => "TypeVariableMirror on '${_n(simpleName)}'";
 }
 
 
 class _LocalTypedefMirrorImpl extends _LocalMirrorImpl
     implements TypedefMirror {
   _LocalTypedefMirrorImpl(String simpleName,
                           this._owner,
                           this._referent)
       : this.simpleName = _s(simpleName);
 
@@ skipping 25 matching lines @@
   }
 
   var _referent;
   TypeMirror get referent {
     if (_referent is! Mirror) {
       _referent = _referent.resolve(mirrors);
     }
     return _referent;
   }
 
-  String toString() => "TypedefMirror on '$simpleName'";
+  String toString() => "TypedefMirror on '${_n(simpleName)}'";
 }
 
 
 class _LazyLibraryMirror {
   _LazyLibraryMirror(String this.libraryUrl);
 
   LibraryMirror resolve(MirrorSystem mirrors) {
     return mirrors.libraries[Uri.parse(libraryUrl)];
   }
 
@@ skipping 72 matching lines @@
   }
 
   Map<Symbol, VariableMirror> get variables {
     if (_variables == null) {
       _variables = _filterMap(members,
                               (key, value) => (value is VariableMirror));
     }
     return _variables;
   }
 
-  String toString() => "LibraryMirror on '$simpleName'";
+  String toString() => "LibraryMirror on '${_n(simpleName)}'";
 }
 
 class _LocalMethodMirrorImpl extends _LocalMirrorImpl
     implements MethodMirror {
   _LocalMethodMirrorImpl(String simpleName,
                          this._owner,
                          this.parameters,
                          this._returnType,
                          this.isStatic,
                          this.isAbstract,
@@ skipping 79 matching lines @@
       }
     }
     return _constructorName;
   }
 
   final bool isConstConstructor;
   final bool isGenerativeConstructor;
   final bool isRedirectingConstructor;
   final bool isFactoryConstructor;
 
-  String toString() => "MethodMirror on '$simpleName'";
+  String toString() => "MethodMirror on '${_n(simpleName)}'";
 }
 
 class _LocalVariableMirrorImpl extends _LocalMirrorImpl
     implements VariableMirror {
   _LocalVariableMirrorImpl(String simpleName,
                            this._owner,
                            this._type,
                            this.isStatic,
                            this.isFinal)
       : this.simpleName = _s(simpleName);
@@ skipping 33 matching lines @@
   TypeMirror get type {
     if (_type is! Mirror) {
       _type = _type.resolve(mirrors);
     }
     return _type;
   }
 
   final bool isStatic;
   final bool isFinal;
 
-  String toString() => "VariableMirror on '$simpleName'";
+  String toString() => "VariableMirror on '${_n(simpleName)}'";
 }
 
 class _LocalParameterMirrorImpl extends _LocalVariableMirrorImpl
     implements ParameterMirror {
   _LocalParameterMirrorImpl(type, this.isOptional)
       : super('<TODO:unnamed>', null, type, false, false) {}
 
   final bool isOptional;
 
   String get defaultValue {
@@ skipping 50 matching lines @@
   }
 
   // Creates a new local ClassMirror.
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
 
   static ClassMirror reflectClass(Type key) {
     return makeLocalClassMirror(key);
   }
 }