Library custom formatters

tool/input_sdk/private/debugger.dart

 // Copyright (c) 2015, 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 dart._debugger;
 
 import 'dart:_foreign_helper' show JS;
 import 'dart:_runtime' as dart;
 import 'dart:core';
 import 'dart:collection';
@@ skipping 128 matching lines @@
   /// maxPowerOfSubsetSize of 2, so the list will be broken up into 1
   /// 10000-length subset and 1 1-length subset.
   int get maxPowerOfSubsetSize =>
       (log(length - .5) / log(_maxSpanLength)).truncate();
   int get subsetSize => pow(_maxSpanLength, maxPowerOfSubsetSize);
 
   Map<int, dynamic> asMap() =>
       iterable.skip(start).take(length).toList().asMap();
 
   List<NameValuePair> children() {
-    var ret = <NameValuePair>[];
+    var children = <NameValuePair>[];
     if (length <= _maxSpanLength) {
       asMap().forEach((i, element) {
-        ret.add(
+        children.add(
             new NameValuePair(name: (i + start).toString(), value: element));
       });
     } else {
       for (var i = start; i < end; i += subsetSize) {
         var subSpan = new IterableSpan(i, min(end, subsetSize + i), iterable);
         if (subSpan.length == 1) {
-          ret.add(new NameValuePair(
+          children.add(new NameValuePair(
               name: i.toString(), value: iterable.elementAt(i)));
         } else {
-          ret.add(new NameValuePair(
+          children.add(new NameValuePair(
               name: '[${i}...${subSpan.end - 1}]',
               value: subSpan,
               hideName: true));
         }
       }
     }
-    return ret;
+    return children;
   }
 }
 
-class ClassMetadata {
-  ClassMetadata(this.object);
+class Library {
+  Library(this.name, this.object);
+
+  final String name;
+  final Object object;
+}
+
+class NamedConstructor {
+  NamedConstructor(this.object);
 
   final Object object;
 }
 
+class ClassMetadata {
+  ClassMetadata(this.object, {this.name});
+
+  final Object object;
+  final String name;
+
+  String get typeName =>
+      name ??
+      getTypeName(object is Type ? object : dart.getReifiedType(object));
+}
+
 class HeritageClause {
   HeritageClause(this.name, this.types);
 
   final String name;
   final List types;
 }
 
+Object safeGetProperty(Object protoChain, String name) {
+  try {
+    return JSNative.getProperty(protoChain, name);
+  } catch (e) {
+    return '<Exception thrown> $e';
+  }
+}
+
 /// Class to simplify building the JsonML objects expected by the
 /// Devtools Formatter API.
 class JsonMLElement {
   dynamic _attributes;
   List _jsonML;
 
   JsonMLElement(tagName) {
     _attributes = JS('', '{}');
     _jsonML = [tagName, _attributes];
   }
@@ skipping 130 matching lines @@
   bool accept(object);
   String preview(object);
   bool hasChildren(object);
   List<NameValuePair> children(object);
 }
 
 class DartFormatter {
   List<Formatter> _formatters;
 
   DartFormatter() {
-    // The order of formatters matters as formatters later in the list take
-    // precidence.
+    // The order of formatters matters as formatters earlier in the list take
+    // precedence.
     _formatters = [
+      new NamedConstructorFormatter(),
       new FunctionFormatter(),
       new MapFormatter(),
       new IterableFormatter(),
       new MapEntryFormatter(),
       new IterableSpanFormatter(),
       new ClassMetadataFormatter(),
       new HeritageClauseFormatter(),
+      new LibraryModuleFormatter(),
+      new LibraryFormatter(),
       new ObjectFormatter(),
     ];
   }
 
   String preview(object) {
     try {
       if (object == null ||
           object is num ||
           object is String ||
           isNativeJavaScriptObject(object)) {
@@ skipping 51 matching lines @@
 
   String preview(object) => getObjectTypeName(object);
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) {
     var properties = new LinkedHashSet<NameValuePair>();
     // Set of property names used to avoid duplicates.
     addMetadataChildren(object, properties);
 
-    /// Helper to add members walking up the prototype chain being careful
-    /// to avoid properties that are Dart methods.
+    var current = object;
+
     var protoChain = <Object>[];
-    var current = object;
     while (current != null &&
         !isNativeJavaScriptObject(current) &&
         JS("bool", "# !== Object.prototype", current)) {
       protoChain.add(current);
-      current = JSNative.getProperty(current, '__proto__');
+      current = safeGetProperty(current, '__proto__');
     }
 
     // We walk the prototype chain for symbol properties because they take
     // priority and are accessed instead of Dart properties according to Dart
     // calling conventions.
     // TODO(jacobr): where possible use the data stored by dart.setSignature
     // instead of walking the JavaScript object directly.
     for (current in protoChain) {
       for (var symbol in getOwnPropertySymbols(current)) {
         var dartName = symbolName(symbol);
         if (hasMethod(object, dartName)) {
           continue;
         }
         // TODO(jacobr): find a cleaner solution than checking for dartx
         String dartXPrefix = 'dartx.';
         if (dartName.startsWith(dartXPrefix)) {
           dartName = dartName.substring(dartXPrefix.length);
         } else if (!dartName.startsWith('_')) {
           // Dart method extension names should either be from dartx or should
           // start with an _
           continue;
         }
-        var value;
-        try {
-          value = JSNative.getProperty(object, symbol);
-        } catch (e) {
-          value = '<Exception thrown> $e';
-        }
+        var value = safeGetProperty(object, symbol);
         properties.add(new NameValuePair(name: dartName, value: value));
       }
     }
 
     for (current in protoChain) {
       // TODO(jacobr): optionally distinguish properties and fields so that
       // it is safe to expand untrusted objects without side effects.
       var className = dart.getReifiedType(current).name;
       for (var name in getOwnPropertyNames(current)) {
         if (_customNames.contains(name) || name == className) continue;
         if (hasMethod(object, name)) {
           continue;
         }
-        var value;
-        try {
-          value = JSNative.getProperty(object, name);
-        } catch (e) {
-          value = '<Exception thrown> $e';
-        }
+        var value = safeGetProperty(object, name);
         properties.add(new NameValuePair(name: name, value: value));
       }
     }
 
     return properties.toList();
   }
 
   addMetadataChildren(object, Set<NameValuePair> ret) {
-    ret.add(
-        new NameValuePair(name: '[[class]]', value: new ClassMetadata(object)));
+    var child = new ClassMetadata(object);
+    ret.add(new NameValuePair(name: child.typeName, value: child));
   }
 }
 
+/// Formatter for module Dart Library objects.
+class LibraryModuleFormatter extends ObjectFormatter {
+  String libraryName;
+
+  accept(object) {
+    libraryName = dart.getDartLibraryName(object);
+    return libraryName != null;
+  }
+
+  bool hasChildren(object) => true;
+
+  String preview(object) {
+    var libraryNames = libraryName.split('/');
+    // Library names are received with a repeat directory name, so strip the
+    // last directory entry here to make the path cleaner. For example, the
+    // library "third_party/dart/utf/utf" shoud display as
+    // "third_party/dart/utf/".
+    if (libraryNames.length > 1) {
+      libraryNames[libraryNames.length - 1] = '';
+    }
+    return 'Library Module: ${libraryNames.join('/')}';
+  }
+
+  List<NameValuePair> children(object) {
+    var children = new LinkedHashSet<NameValuePair>();
+    for (var name in getOwnPropertyNames(object)) {
+      var value = safeGetProperty(object, name);
+      // Replace __ with / to make file paths more readable. Then
+      // 'src__result__error' becomes 'src/result/error'.
+      name = '${name.replaceAll("__", "/")}.dart';
+      children.add(new NameValuePair(
+          name: name, value: new Library(name, value), hideName: true));
+    }
+    return children.toList();
+  }
+}
+
+/// Formatter for Dart Library objects.
+class LibraryFormatter extends ObjectFormatter {
+  String genericName;
+  String genericArguments;
+
+  accept(object) => object is Library;
+
+  bool hasChildren(object) => true;
+
+  String preview(object) => object.name;
+
+  List<NameValuePair> children(object) {
+    var children = new LinkedHashSet<NameValuePair>();
+    var entry = object.object;
+    for (var name in getOwnPropertyNames(entry)) {
+      var value = safeGetProperty(entry, name);
+      if (value != null) {
+        var genericTypeConstructor = dart.getGenericTypeCtor(value);
+        if (genericTypeConstructor != null) {
+          genericName = name;
+          // Using JS toString() eliminates the leading metadata that is generated
+          // with the toString function provided in operations.dart.
+          // Splitting by => and taking the first element gives the list of
+          // arguments in the constructor.
+          genericArguments =
+              JS('String', '#.toString()', genericTypeConstructor)
+                  .split(' =>')
+                  .first
+                  .replaceAll(new RegExp(r'[(|)]'), '');
+        } else if (value is Type) {
+          var typeName = getTypeName(value);
+          // Generic class names are generated with a $ at the end, so the
+          // corresponding non-generic class can be identified by adding $.
+          if ('$name\$' == genericName) {
+            typeName = '$typeName<$genericArguments>';
+          }
+          children.add(new NameValuePair(
+              name: typeName, value: new ClassMetadata(value, name: typeName)));
+        } else {
+          children.add(
+              new NameValuePair(name: name, value: new ClassMetadata(value)));
+        }
+      }
+    }
+    return children.toList();
+  }
+}
+
 /// Formatter for Dart Function objects.
 /// Dart functions happen to be regular JavaScript Function objects but
 /// we can distinguish them based on whether they have been tagged with
 /// runtime type information.
 class FunctionFormatter extends Formatter {
   accept(object) {
     if (_typeof(object) != 'function') return false;
     return dart.getReifiedType(object) != null;
   }
 
@@ skipping 53 matching lines @@
     }
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) {
     // TODO(jacobr): be lazier about enumerating contents of Iterables that
     // are not the built in Set or List types.
     // TODO(jacobr): handle large Iterables better.
     // TODO(jacobr): consider only using numeric indices
-    var ret = new LinkedHashSet<NameValuePair>();
-    ret.addAll((new IterableSpan(0, object.length, object)).children());
+    var children = new LinkedHashSet<NameValuePair>();
+    children.addAll(new IterableSpan(0, object.length, object).children());
     // TODO(jacobr): provide a link to show regular class properties here.
     // required for subclasses of iterable, etc.
-    addMetadataChildren(object, ret);
-    return ret.toList();
+    addMetadataChildren(object, children);
+    return children.toList();
   }
 }
 
 // This class does double duting displaying metadata for
 class ClassMetadataFormatter implements Formatter {
   accept(object) => object is ClassMetadata;
 
-  _getType(object) {
+  Object _getType(object) {
     if (object is Type) return object;
     return dart.getReifiedType(object);
   }
 
   String preview(object) {
     ClassMetadata entry = object;
-    return getTypeName(_getType(entry.object));
+    var type =
+        entry.object is Type ? entry.object : dart.getReifiedType(entry.object);
+    var implements = dart.getImplements(type);
+    if (implements != null) {
+      var typeNames = implements().map(getTypeName);
+      return '${entry.typeName} implements ${typeNames.join(", ")}';
+    } else {
+      return entry.typeName;
+    }
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) {
     ClassMetadata entry = object;
+    var classObject = entry.object;
     // TODO(jacobr): add other entries describing the class such as
     // links to the superclass, mixins, implemented interfaces, and methods.
-    var type = _getType(entry.object);
-    var ret = <NameValuePair>[];
-    var implements = dart.getImplements(type);
-    if (implements != null) {
-      ret.add(new NameValuePair(
-          name: '[[Implements]]',
-          value: new HeritageClause('implements', implements())));
-    }
+    var type = _getType(classObject);
+    var children = <NameValuePair>[];
+
     var mixins = dart.getMixins(type);
     if (mixins != null && mixins.isNotEmpty) {
-      ret.add(new NameValuePair(
+      children.add(new NameValuePair(
           name: '[[Mixins]]', value: new HeritageClause('mixins', mixins)));
     }
-    ret.add(new NameValuePair(
-        name: '[[JavaScript View]]',
-        value: entry.object,
-        config: JsonMLConfig.skipDart));
 
+    var hiddenProperties = ['length', 'name', 'prototype'];
+    // Addition of NameValuePairs for static variables and named constructors.
+    for (var name in getOwnPropertyNames(classObject)) {
+      // TODO(bmilligan): Perform more principled checks to filter out spurious
+      // members.
+      if (hiddenProperties.contains(name)) continue;
+      var value = safeGetProperty(classObject, name);
+      if (value != null && dart.getIsNamedConstructor(value) != null) {
+        value = new NamedConstructor(value);
+        name = '${entry.typeName}.$name';
+      }
+      children.add(new NameValuePair(name: name, value: value));
+    }
+
+    // TODO(bmilligan): Replace the hard coding of $identityHash.
+    var hiddenPrototypeProperties = ['constructor', 'new', r'$identityHash'];
+    // Addition of class methods.
+    var prototype = JS('var', '#["prototype"]', classObject);
+    if (prototype != null) {
+      for (var name in getOwnPropertyNames(prototype)) {
+        if (hiddenPrototypeProperties.contains(name)) continue;
+        // Simulate dart.bind by using dart.tag and tear off the function
+        // so it will be recognized by the FunctionFormatter.
+        var function = safeGetProperty(prototype, name);
+        var constructor = safeGetProperty(prototype, 'constructor');
+        var sigObj = dart.getMethodSig(constructor);
+        if (sigObj != null) {
+          var value = safeGetProperty(sigObj, name);
+          if (getTypeName(dart.getReifiedType(value)) != 'Null') {
+            dart.tag(function, value);
+            children.add(new NameValuePair(name: name, value: function));
+          }
+        }
+      }
+    }
     // TODO(jacobr): provide a link to the base class or perhaps the entire
     // base class hierarchy as a flat list.
+    // TODO(jacobr): add constructors, methods, extended class, and static
+    return children;
+  }
+}
 
-    if (entry.object is! Type) {
-      ret.add(new NameValuePair(
-          name: '[[JavaScript Constructor]]',
-          value: JSNative.getProperty(entry.object, 'constructor'),
-          config: JsonMLConfig.skipDart));
-      // TODO(jacobr): add constructors, methods, extended class, and static
-    }
-    return ret;
-  }
+class NamedConstructorFormatter implements Formatter {
+  accept(object) => object is NamedConstructor;
+
+  // TODO(bmilligan): Display the signature of the named constructor as the
+  // preview.
+  String preview(object) => 'Named Constructor';
+
+  bool hasChildren(object) => true;
+
+  List<NameValuePair> children(object) => <NameValuePair>[
+        new NameValuePair(
+            name: 'JavaScript Function',
+            value: object,
+            config: JsonMLConfig.skipDart)
+      ];
 }
 
 /// Formatter for synthetic MapEntry objects used to display contents of a Map
 /// cleanly.
 class MapEntryFormatter implements Formatter {
   accept(object) => object is MapEntry;
 
   String preview(object) {
     MapEntry entry = object;
     return '${safePreview(entry.key)} => ${safePreview(entry.value)}';
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) => <NameValuePair>[
         new NameValuePair(
             name: 'key', value: object.key, config: JsonMLConfig.keyToString),
         new NameValuePair(name: 'value', value: object.value)
       ];
 }
 
 /// Formatter for Dart Iterable objects including List and Set.
 class HeritageClauseFormatter implements Formatter {
   bool accept(object) => object is HeritageClause;
 
   String preview(object) {
     HeritageClause clause = object;
-    var typeNames = clause.types.map((type) => getTypeName(type));
+    var typeNames = clause.types.map(getTypeName);
     return '${clause.name} ${typeNames.join(", ")}';
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) {
     HeritageClause clause = object;
-    var ret = <NameValuePair>[];
+    var children = <NameValuePair>[];
     for (var type in clause.types) {
-      ret.add(new NameValuePair(value: new ClassMetadata(type)));
+      children.add(new NameValuePair(value: new ClassMetadata(type)));
     }
-    return ret;
+    return children;
   }
 }
 
 /// Formatter for synthetic IterableSpan objects used to display contents of
 /// an Iterable cleanly.
 class IterableSpanFormatter implements Formatter {
   accept(object) => object is IterableSpan;
 
   String preview(object) {
     return '[${object.start}...${object.end-1}]';
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) => object.children();
 }
 
 /// This entry point is automatically invoked by the code generated by
 /// Dart Dev Compiler
 registerDevtoolsFormatter() {
   var formatters = [_devtoolsFormatter];
   JS('', 'dart.global.devtoolsFormatters = #', formatters);
 }