Support Dart debugger API directly

tools/dom/src/native_DOMImplementation.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 html;
 
+class _Property {
+  _Property(this.name) :
+      _hasValue = false,
+      writable = false,
+      isMethod = false,
+      isOwn = true,
+      wasThrown = false;
+
+  bool get hasValue => _hasValue;
+  get value => _value;
+  set value(v) {
+    _value = v;
+    _hasValue = true;
+  }
+
+  final String name;
+  Function setter;
+  Function getter;
+  var _value;
+  bool _hasValue;
+  bool writable;
+  bool isMethod;
+  bool isOwn;
+  bool wasThrown;
+}
+
 class _ConsoleVariables {
   Map<String, Object> _data = new Map<String, Object>();
 
   /**
    * Forward member accesses to the backing JavaScript object.
    */
   noSuchMethod(Invocation invocation) {
     String member = MirrorSystem.getName(invocation.memberName);
     if (invocation.isGetter) {
       return _data[member];
     } else if (invocation.isSetter) {
       assert(member.endsWith('='));
       member = member.substring(0, member.length - 1);
       _data[member] = invocation.positionalArguments[0];
     } else {
       return Function.apply(_data[member], invocation.positionalArguments, invocation.namedArguments);
     }
   }
 
   void clear() => _data.clear();
 
   /**
    * List all variables currently defined.
    */
   List variables() => _data.keys.toList(growable: false);
 }
 
+/**
+ * Base class for invocation trampolines used to closurize methods, getters
+ * and setters.
+ */
+abstract class _Trampoline implements Function {
+  final ObjectMirror _receiver;
+  final MethodMirror _methodMirror;
+  final Symbol _selector;
+
+  _Trampoline(this._receiver, this._methodMirror, this._selector);
+}
+
+class _MethodTrampoline extends _Trampoline {
+  _MethodTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :

[Leaf, 2014/05/07 01:47:27]

line width?

[Jacob, 2014/05/07 20:57:08]

Done.

+      super(receiver, methodMirror, selector);
+
+  noSuchMethod(Invocation msg) {
+    if (msg.memberName != #call) return super.noSuchMethod(msg);
+    return _receiver.invoke(_selector,
+                            msg.positionalArguments,
+                            msg.namedArguments).reflectee;
+  }
+}
+
+/**
+ * Invocation trampoline class used to closurize getters.
+ */
+class _GetterTrampoline extends _Trampoline {
+  _GetterTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :

[Leaf, 2014/05/07 01:47:27]

ditto

[Jacob, 2014/05/07 20:57:08]

Done.

+      super(receiver, methodMirror, selector);
+
+  call() => _receiver.getField(_selector).reflectee;
+}
+
+/**
+ * Invocation trampoline class used to closurize setters.
+ */
+class _SetterTrampoline extends _Trampoline {
+  _SetterTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :

[Leaf, 2014/05/07 01:47:27]

also

[Jacob, 2014/05/07 20:57:08]

Done.

+      super(receiver, methodMirror, selector);
+
+  call(value) {
+    _receiver.setField(_selector, value);
+  }
+}
+
 class _Utils {
   static double dateTimeToDouble(DateTime dateTime) =>
       dateTime.millisecondsSinceEpoch.toDouble();
   static DateTime doubleToDateTime(double dateTime) {
     try {
       return new DateTime.fromMillisecondsSinceEpoch(dateTime.toInt());
     } catch(_) {
       // TODO(antonnm): treat exceptions properly in bindings and
       // find out how to treat NaNs.
       return null;
@@ skipping 93 matching lines @@
     var map = {};
     for (int i = 0; i < localVariables.length; i+=2) {
       map[stripMemberName(localVariables[i])] = localVariables[i+1];
     }
     return map;
   }
 
   static _ConsoleVariables _consoleTempVariables = new _ConsoleVariables();
 
   /**
-   * Header passed in from the Dartium Developer Tools when an expression is
-   * evaluated in the console as opposed to the watch window or another context
-   * that does not expect REPL support.
-   */
-  static const _CONSOLE_API_SUPPORT_HEADER =
-      'with ((console && console._commandLineAPI) || { __proto__: null }) {\n';
-  static bool expectsConsoleApi(String expression) {
-    return expression.indexOf(_CONSOLE_API_SUPPORT_HEADER) == 0;;
-  }
-
-  /**
    * Takes an [expression] and a list of [local] variable and returns an
    * expression for a closure with a body matching the original expression
    * where locals are passed in as arguments. Returns a list containing the
    * String expression for the closure and the list of arguments that should
    * be passed to it. The expression should then be evaluated using
    * Dart_EvaluateExpr which will generate a closure that should be invoked
    * with the list of arguments passed to this method.
    *
    * For example:
    * <code>
    * _consoleTempVariables = {'a' : someValue, 'b': someOtherValue}
-   * wrapExpressionAsClosure("${_CONSOLE_API_SUPPORT_HEADER}foo + bar + a",
-   *                         ["bar", 40, "foo", 2])
+   * wrapExpressionAsClosure("foo + bar + a", ["bar", 40, "foo", 2], true)
    * </code>
    * will return:
    * <code>
    * ["""(final $consoleVariables, final bar, final foo, final a, final b) =>
    * (foo + bar + a
    * )""",
    * [_consoleTempVariables, 40, 2, someValue, someOtherValue]]
    * </code>
    */
-  static List wrapExpressionAsClosure(String expression, List locals) {
-    // FIXME: dartbug.com/10434 find a less fragile way to determine whether
-    // we need to strip off console API support added by InjectedScript.
+  static List wrapExpressionAsClosure(String expression, List locals,
+      bool includeCommandLineAPI) {
     var args = {};
     var sb = new StringBuffer("(");
     addArg(arg, value) {
       arg = stripMemberName(arg);
       if (args.containsKey(arg)) return;
       // We ignore arguments with the name 'this' rather than throwing an
       // exception because Dart_GetLocalVariables includes 'this' and it
       // is more convenient to filter it out here than from C++ code.
       // 'this' needs to be handled by calling Dart_EvaluateExpr with
       // 'this' as the target rather than by passing it as an argument.
       if (arg == 'this') return;
       if (args.isNotEmpty) {
         sb.write(", ");
       }
       sb.write("final $arg");
       args[arg] = value;
     }
 
-    if (expectsConsoleApi(expression)) {
-      expression = expression.substring(expression.indexOf('\n') + 1);
-      expression = expression.substring(0, expression.lastIndexOf('\n'));
-
+    if (includeCommandLineAPI) {
       addArg("\$consoleVariables", _consoleTempVariables);
 
       // FIXME: use a real Dart tokenizer. The following regular expressions
       // only allow setting variables at the immediate start of the expression
       // to limit the number of edge cases we have to handle.
 
       // Match expressions that start with "var x"
       final _VARIABLE_DECLARATION = new RegExp("^(\\s*)var\\s+(\\w+)");
       // Match expressions that start with "someExistingConsoleVar ="
       final _SET_VARIABLE = new RegExp("^(\\s*)(\\w+)(\\s*=)");
@@ skipping 36 matching lines @@
 
     // TODO(jacobr): remove the parentheses around the expresson once
     // dartbug.com/13723 is fixed. Currently we wrap expression in parentheses
     // to ensure only valid Dart expressions are allowed. Otherwise the DartVM
     // quietly ignores trailing Dart statements resulting in user confusion
     // when part of an invalid expression they entered is ignored.
     sb..write(') => (\n$expression\n)');
     return [sb.toString(), args.values.toList(growable: false)];
   }
 
-  /**
-   * TODO(jacobr): this is a big hack to get around the fact that we are still
-   * passing some JS expression to the evaluate method even when in a Dart
-   * context.
-   */
-  static bool isJsExpression(String expression) =>
-    expression.startsWith("(function getCompletions");
-
-  /**
-   * Returns a list of completions to use if the receiver is o.
-   */
-  static List<String> getCompletions(o) {
-    MirrorSystem system = currentMirrorSystem();
-    var completions = new Set<String>();
-    addAll(Map<Symbol, dynamic> map, bool isStatic) {
-      map.forEach((symbol, mirror) {
-        if (mirror.isStatic == isStatic && !mirror.isPrivate) {
+  static String _getShortSymbolName(Symbol symbol,
+                                    DeclarationMirror declaration) {
+    var name = MirrorSystem.getName(symbol);
+    if (declaration is MethodMirror) {
+      if (declaration.isSetter && name[name.length-1] == "=") {
+        return name.substring(0, name.length-1);
+      }
+      if (declaration.isConstructor) {
+        return name.substring(name.indexOf('.') + 1);
+      }
+    }
+    return name;
+  }
+
+  /**
+   * Adds all candidate String completitions from [declarations] to [output]
+   * filtering based on [staticContext] and [includePrivate].
+   */
+  static void _getCompletionsHelper(ClassMirror classMirror,
+      bool staticContext, bool includePrivate, Set<String> output) {
+    classMirror.declarations.forEach((symbol, declaration) {
+      if (!includePrivate && declaration.isPrivate) return;
+      if (declaration is VariableMirror) {
+        if (staticContext != declaration.isStatic) return;
+      } else if (declaration is MethodMirror) {
+        if (staticContext != declaration.isStatic) return;

[rmacnak, 2014/05/06 21:14:43]

Should do this check after considering constructors because generative
constructors are !isStatic but factory constructors are isStatic.

[Jacob, 2014/05/07 00:05:24]

Good catch! I added a test (see utils.dart in the related CL) and fixed this
special case.

+        if (declaration.isOperator) return;

[rmacnak, 2014/05/06 21:14:43]

Because the completions assume dot notation?

[Jacob, 2014/05/07 00:05:24]

Correct. Completions are after a dot.

+        if (declaration.isConstructor) {
+          var name = MirrorSystem.getName(declaration.constructorName);
+          if (name.isNotEmpty) output.add(name);
+          return;
+        }
+      } else if (declaration is TypeMirror) {
+        return;
+      }
+      output.add(_getShortSymbolName(symbol, declaration));
+    });
+  }
+
+  static void _getLibraryCompletionsHelper(
+      LibraryMirror library, bool includePrivate, Set<String> output) {
+    library.declarations.forEach((symbol, declaration) {

[rmacnak, 2014/05/06 21:14:43]

Add the prefixed imports (but not their declarations) ?

[Jacob, 2014/05/07 00:05:24]

Correct. Interesting idea to show all completions. That could be what the user
wants in some cases. E.g. if i've imported the js library with prefix js, it
would be nice to see all the dart:js methods after I type j. For other cases it
would be less than useful though. For example, dart:html would have hundreds of
entries so you don't really want to show that huge list when I type h.

+      if (!includePrivate && declaration.isPrivate) return;
+      output.add(_getShortSymbolName(symbol, declaration));
+    });
+  }
+
+  static LibraryMirror getLibraryMirror(String url) =>
+      currentMirrorSystem().libraries[Uri.parse(url)];
+
+  /**
+   * Get code completions for [o] only showing privates from [libraryUrl].
+   */
+  static List<String> getObjectCompletions(o, String libraryUrl) {
+    var classMirror;
+    bool staticContext;
+    if (o is Type) {
+      classMirror = reflectClass(o);
+      staticContext = true;
+    } else {
+      classMirror = reflect(o).type;
+      staticContext = false;
+    }
+    var names = new Set<String>();
+    getClassCompletions(classMirror, names, staticContext, libraryUrl);
+    return names.toList()..sort();
+  }
+
+  static void getClassCompletions(ClassMirror classMirror, Set<String> names,
+      bool staticContext, String libraryUrl) {
+    LibraryMirror libraryMirror = getLibraryMirror(libraryUrl);
+    if (!staticContext) {
+      for (var interface in classMirror.superinterfaces) {

[rmacnak, 2014/05/06 21:14:43]

Interfaces declared on superclasses?

[Jacob, 2014/05/07 00:05:24]

Fixed.

+        _getCompletionsHelper(interface, staticContext,
+            libraryMirror == interface.owner, names);
+      }
+    }
+    while (classMirror != null) {
+      _getCompletionsHelper(classMirror, staticContext,
+          libraryMirror == classMirror.owner, names);
+      // Do not walk up the superclass tree when displaying statics.
+      if (staticContext) break;
+      classMirror = classMirror.superclass;
+    }
+  }
+
+  static List<String> getLibraryCompletions(String url) {
+    var names = new Set<String>();
+    _getLibraryCompletionsHelper(getLibraryMirror(url), true, names);
+    return names.toList();
+  }
+
+  /**
+   * Get valid code completitions from within a library and all libraries
+   * imported by that library.
+   */
+  static List<String> getLibraryCompletionsIncludingImports(String url) {
+    var names = new Set<String>();
+    var libraryMirror = getLibraryMirror(url);
+    _getLibraryCompletionsHelper(libraryMirror, true, names);
+    for (var dependency in libraryMirror.libraryDependencies) {
+      if (dependency.isImport) {
+        if (dependency.prefix == null) {
+          _getLibraryCompletionsHelper(dependency.targetLibrary, false, names);
+        } else {
+          names.add(MirrorSystem.getName(dependency.prefix));
+        }
+      }
+    }
+    return names.toList();
+  }
+
+  /**
+   * For parity with the JavaScript debugger, we treat some getters as if
+   * they are fields so that users can see their values immediately.
+   * This matches JavaScript's behavior for getters on DOM objects.
+   * In the future we should consider adding an annotation to tag getters
+   * in user libraries as side effect free.
+   */
+  static bool _isSideEffectFreeGetter(MethodMirror methodMirror) {
+    var owner = methodMirror.owner;
+    var libraryMirror;
+    if (owner is ClassMirror) {
+      libraryMirror = owner.owner;

[Leaf, 2014/05/07 01:47:27]

Does this do the right thing if the class is produced by a mixin?  I think in
that case owner.owner might not be the library.

[rmacnak, 2014/05/07 16:59:51]

A class's owner will always be a library.

[Jacob, 2014/05/07 20:57:08]

yep.

+    } else if (owner is LibraryMirror) {
+      libraryMirror = owner;
+    }
+    if (libraryMirror != null) {
+      var libraryUrl = MirrorSystem.getName(libraryMirror.qualifiedName);

[rmacnak, 2014/05/06 21:14:43]

You're not comparing the url here. The qualified name might collide with user
code (though that is willful abuse on the user's part).

[Jacob, 2014/05/07 00:05:24]

Tweaked to actually use the URI instead.

+      // This matches JavaScript behavior. We should consider displaying
+      // getters for all dart platform libraries rather than just dart.dom.

[rmacnak, 2014/05/06 21:14:43]

I wouldn't do this for all Dart platform libraries. It seems unlikely they would
all be fast and side-effect free. For instance DeclarationMirror.metadata might
trigger a compilation error if the metadata is being accessed for the first
time.

[Jacob, 2014/05/07 00:05:24]

Makes sense.  I think the right solution is to provide an annotation that can be
used to indicate which getters should be shown automatically and whitelisting
all of dart.dom until then.  JS is already showing all DOM getters automatically
due to limitations in how native getters are shown in JS and I haven't heard of
anyone complain about issues debugging JS due to it.

+      if (libraryUrl.startsWith("dart.dom."))
+          return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Whether we should treat a property as a field for the purposes of the
+   * debugger.
+   */
+  static bool treatPropertyAsField(MethodMirror methodMirror) =>
+      (methodMirror.isGetter || methodMirror.isSetter) &&
+          (methodMirror.isSynthetic || _isSideEffectFreeGetter(methodMirror));
+
+  // TODO(jacobr): generate more concise function descriptions instead of
+  // dumping the entire function source.
+  static String describeFunction(function) {
+    if (function is _Trampoline) return function._methodMirror.source;
+    try {
+      return reflect(function).function.source;
+    } catch (e) {
+      return function.toString();
+    }
+  }
+
+  static List getInvocationTrampolineDetails(_Trampoline method) {
+    var loc = method._methodMirror.location;
+    return [loc.line, loc.column, loc.sourceUri.toString(),
+        MirrorSystem.getName(method._selector)];
+  }
+
+  static List getLibraryProperties(String libraryUrl, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var libraryMirror = getLibraryMirror(libraryUrl);
+    _addInstanceMirrors(libraryMirror, libraryMirror,
+        libraryMirror.declarations,
+        ownProperties, accessorPropertiesOnly, false, false,
+        properties);
+    if (!accessorPropertiesOnly) {
+      // We need to add class properties for all classes in the library.
+      libraryMirror.declarations.forEach((symbol, declarationMirror) {
+        if (declarationMirror is ClassMirror) {
           var name = MirrorSystem.getName(symbol);
-          if (mirror is MethodMirror && mirror.isSetter)
-            name = name.substring(0, name.length - 1);
-          completions.add(name);
+          if (declarationMirror.hasReflectedType
+              && !properties.containsKey(name)) {
+            properties[name] = new _Property(name)
+                ..value = declarationMirror.reflectedType;

[Leaf, 2014/05/07 01:47:27]

Is this idiomatic in Dart?  I'm presuming that this is parsed as (new
_Property(name))..setValue(etc.) but at least to new Dart eyes this is pretty
egregiously confusing (and requires knowledge of the relative precedence of ..
and =).   Maybe better to just have a constructor for _Property that takes a
value as well as a name? 

[Jacob, 2014/05/07 20:57:08]

This is the idiomatic way to use Dart cascades.  As you mention it is a little
bit ugly as it only works due to precedence rules. I think 60% of the Dart team
would say this is good idiomatic dart, 40% would say it is ugly.

[Leaf, 2014/05/08 04:04:01]

Ok, I'll get used to it.

On 2014/05/07 20:57:08, Jacob wrote:

+          }
         }
       });
     }
-
-    addForClass(ClassMirror mirror, bool isStatic) {
-      if (mirror == null)
+    return packageProperties(properties);
+  }
+
+  static List getObjectProperties(o, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var names = new Set<String>();
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    _addInstanceMirrors(objectMirror, classMirror.owner,

[Leaf, 2014/05/07 01:47:27]

Same question as before about class mirror owners in the presence of mixins.

[Jacob, 2014/05/07 20:57:08]

Same answer as before. the owner is a library.

+        classMirror.instanceMembers,
+        ownProperties, accessorPropertiesOnly, false, true,
+        properties);
+    return packageProperties(properties);
+  }
+
+  static List getObjectClassProperties(o, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    _addInstanceMirrors(objectMirror, classMirror.owner,

[Leaf, 2014/05/07 01:47:27]

ditto

[Jacob, 2014/05/07 20:57:08]

same answer as other case.

+        classMirror.instanceMembers,
+        ownProperties, accessorPropertiesOnly, true, false,
+        properties);
+    _addStatics(classMirror, properties, accessorPropertiesOnly);
+    return packageProperties(properties);
+  }
+
+  static List getClassProperties(Type t, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var classMirror = reflectClass(t);
+    _addStatics(classMirror, properties, accessorPropertiesOnly);
+    return packageProperties(properties);
+  }
+
+  static void _addStatics(ClassMirror classMirror,
+                          Map<String, _Property> properties,
+                          bool accessorPropertiesOnly) {
+    classMirror.declarations.forEach((symbol, declaration) {
+      var name = _getShortSymbolName(symbol, declaration);
+      if (declaration is VariableMirror) {
+        if (accessorPropertiesOnly) return;
+        if (!declaration.isStatic) return;
+        properties.putIfAbsent(name, () => new _Property(name))
+            ..value = classMirror.getField(symbol).reflectee
+            ..writable = declaration.isFinal && !declaration.isConst;

[Leaf, 2014/05/07 01:47:27]

I don't understand this line (possibly my fault).  Why is a non-final, non-const
variable not considered writable?

[Jacob, 2014/05/07 20:57:08]

I don't understand what I was thinking either. The only thing that makes sense
is
!declaration.isFinal && !declaration.isConst

+      } else if (declaration is MethodMirror) {
+        MethodMirror methodMirror = declaration;
+        // FIXMEDART: should we display constructors?
+        if (methodMirror.isConstructor) return;
+        if (!methodMirror.isStatic) return;
+        if (accessorPropertiesOnly) {
+          if (methodMirror.isRegularMethod ||
+              treatPropertyAsField(methodMirror)) {
+            return;
+          }
+        } else if (!methodMirror.isRegularMethod &&
+            !treatPropertyAsField(methodMirror)) {
+          return;
+        }
+        var property = properties.putIfAbsent(name, () => new _Property(name));

[Leaf, 2014/05/07 01:47:27]

I'm not sure I get why this is right.  If I understand the way things work (and
I may not), a static field x will induce a static getter method x and a static
setter method x=, both of which I think will get mapped to the name "x" by your
_getShortSymbolName function, along with the field itself (I think).  Won't
these all collide in the properties map?  And if so, I think you'll fill in the
property with different values depending on the order in which you hit them.

[rmacnak, 2014/05/07 16:59:51]

Implicit getters and setters are not part of ClassMirror.declarations.

[Jacob, 2014/05/07 20:57:08]

Correct. That is why I have to add these cases.

+        if (methodMirror.isRegularMethod) {
+          property
+              ..value = new _MethodTrampoline(classMirror, methodMirror, symbol)
+              ..isMethod = true;
+        } else if (methodMirror.isGetter) {
+          if (treatPropertyAsField(methodMirror)) {
+            try {
+              property.value = classMirror.getField(symbol).reflectee;
+            } catch (e) {
+              property
+                ..wasThrown = true
+                ..value = e;
+            }
+          } else if (accessorPropertiesOnly) {
+            property.getter = new _GetterTrampoline(classMirror,
+                methodMirror, symbol);
+          }
+        } else if (methodMirror.isSetter) {
+          if (accessorPropertiesOnly && !treatPropertyAsField(methodMirror)) {
+            property.setter = new _SetterTrampoline(classMirror,
+                methodMirror, classMirror.owner);
+          }
+          property.writable = true;
+        }
+      }
+    });
+  }
+
+  /**
+   * Helper method that handles collecting up properties from classes
+   * or libraries using the filters [ownProperties], [accessorPropertiesOnly],
+   * [hideFields], and [hideMethods] to determine which properties are
+   * collected. [accessorPropertiesOnly] specifies whether all properties
+   * should be returned or just accessors. [hideFields] specifies whether
+   * fields should be hidden. hideMethods specifies whether methods should be
+   * shown or hidden. [ownProperties] is not currently used but is part of the
+   * Blink devtools API for enumerating properties.
+   */
+  static void _addInstanceMirrors(
+      ObjectMirror objectMirror,
+      LibraryMirror libraryMirror,
+      Map<Symbol, Mirror> declarations,
+      bool ownProperties, bool accessorPropertiesOnly,
+      bool hideFields, bool hideMethods,
+      Map<String, _Property> properties) {
+    declarations.forEach((Symbol symbol, Mirror declaration) {
+      if (declaration is TypedefMirror || declaration is ClassMirror) return;
+      var name = _getShortSymbolName(symbol, declaration);
+      bool isField = declaration is VariableMirror ||
+          (declaration is MethodMirror && treatPropertyAsField(declaration));
+      if ((isField && hideFields) || (hideMethods && !isField)) return;
+      if (accessorPropertiesOnly) {
+        if (declaration is ClassMirror || declaration is VariableMirror ||

[Leaf, 2014/05/07 01:47:27]

declaration is known not to be ClassMirror here.

[Jacob, 2014/05/07 20:57:08]

Fixed. I originally tried to use this method for both libraries and classes but
the soup of special cases got ugly so I separated the two. The references to
ClassMirror here are left over from that.

+            declaration.isRegularMethod || isField) {
+          return;
+        }
+      } else if (declaration is MethodMirror &&
+          (declaration.isGetter || declaration.isSetter) &&
+          !treatPropertyAsField(declaration)) {
         return;
-      addAll(mirror.declarations, isStatic);
-      if (mirror.superclass != null)
-        addForClass(mirror.superclass, isStatic);
-      for (var interface in mirror.superinterfaces) {
-        addForClass(interface, isStatic);
-      }
-    }
-
-    if (o is Type) {
-      addForClass(reflectClass(o), true);
-    } else {
-      addForClass(reflect(o).type, false);
-    }
-    return completions.toList(growable: false);
-  }
-
-  /**
+      }
+      var property = properties.putIfAbsent(name, () => new _Property(name));
+      if (declaration is VariableMirror) {
+        property.value = objectMirror.getField(symbol).reflectee;
+        property.writable = !declaration.isFinal && !declaration.isConst;
+      } else if (declaration is ClassMirror) {

[Leaf, 2014/05/07 01:47:27]

Again, known to be false.

[Jacob, 2014/05/07 20:57:08]

Done.

+        property.value = declaration.runtimeType;
+      } else if (declaration.isRegularMethod) {

[Leaf, 2014/05/07 01:47:27]

The section from here to the end is pretty close to identical to part of
_addStatics above.  Is there a useful way to factor this into one place?

[Jacob, 2014/05/07 20:57:08]

Done.

+        property.value = new _MethodTrampoline(objectMirror,
+            declaration, symbol);
+        property.isMethod = true;
+      } else if (declaration.isGetter) {
+        if (treatPropertyAsField(declaration)) {
+          try {
+            property.value = objectMirror.getField(symbol).reflectee;
+          } catch (e) {
+            property
+                ..wasThrown = true
+                ..value = e;
+          }
+        } else if (accessorPropertiesOnly) {
+          property.getter = new _GetterTrampoline(objectMirror,
+              declaration, symbol);
+        }
+      } else if (declaration.isSetter) {
+        property.writable = true;
+        if (accessorPropertiesOnly && !treatPropertyAsField(declaration)) {
+          property.setter = new _SetterTrampoline(objectMirror,
+              declaration, MirrorSystem.getSymbol(name, libraryMirror));
+        }
+      }
+    });
+  }
+
+  /**
+   * Flatten down the properties data structure into a List that is easy to
+   * access from native code.
+   */
+  static List packageProperties(Map<String, _Property> properties) {
+    var ret = [];
+    for (var property in properties.values) {
+      ret.addAll([property.name,
+                  property.setter,
+                  property.getter,
+                  property.value,
+                  property.hasValue,
+                  property.writable,
+                  property.isMethod,
+                  property.isOwn,
+                  property.wasThrown]);
+    }
+    return ret;
+  }
+  
+  /**
+   * Get a property, returning null if the property does not exist.
+   * For private property names, we attempt to resolve the property in the
+   * context of each library that the property name could be associated with.
+   */
+  static getObjectPropertySafe(o, String propertyName) {
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    if (propertyName.startsWith("_")) {
+      var attemptedLibraries = new Set<LibraryMirror>(); 
+      while (classMirror != null) {
+        LibraryMirror library = classMirror.owner;
+        if (!attemptedLibraries.contains(library)) {
+          try {
+            return objectMirror.getField(
+                MirrorSystem.getSymbol(propertyName, library)).reflectee;
+          } catch (e) { }
+          attemptedLibraries.add(library);
+        }
+        classMirror = classMirror.superclass;
+      }
+      return null;     
+    }
+    try {
+      return objectMirror.getField(
+          MirrorSystem.getSymbol(propertyName)).reflectee;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
    * Convenience helper to get the keys of a [Map] as a [List].
    */
   static List getMapKeyList(Map map) => map.keys.toList();
 
  /**
    * Returns the keys of an arbitrary Dart Map encoded as unique Strings.
    * Keys that are strings are left unchanged except that the prefix ":" is
    * added to disambiguate keys from other Dart members.
    * Keys that are not strings have # followed by the index of the key in the map
    * prepended to disambuguate. This scheme is simplistic but easy to encode and
@@ skipping 280 matching lines @@
   _scheduleImmediateHelper._schedule(callback);
 };
 
 get _pureIsolateScheduleImmediateClosure => ((void callback()) =>
   throw new UnimplementedError("scheduleMicrotask in background isolates "
                                "are not supported in the browser"));
 
 void _initializeCustomElement(Element e) {
   _Utils.initializeCustomElement(e);
 }