Fixes in smoke, which in turn should fix todomvc.

pkg/smoke/lib/smoke.dart

 // Copyright (c) 2014, 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.
 
 /// Collects services that can be used to access objects dynamically, inspect
 /// type information, and convert between symbols and strings.
 library smoke;
 
 import 'src/implementation.dart' as implementation;
 
@@ skipping 24 matching lines @@
 /// Invoke [method] in [receiver] with [args]. The [receiver] can be either an
 /// object (to invoke instance methods) or a type (to invoke static methods).
 /// This function optionally [adjust]s the list of arguments to match the number
 /// of formal parameters by either adding nulls for missing arguments, or by
 /// truncating the list.
 invoke(receiver, Symbol method, List args,
     {Map namedArgs, bool adjust: false}) =>
     implementation.objectAccessor.invoke(
         receiver, method, args, namedArgs: namedArgs, adjust: adjust);
 
+/// Tells whether [type] is transitively a subclass of [supertype].
+bool isSubclassOf(Type type, Type supertype) =>
+    implementation.typeInspector.isSubclassOf(type, supertype);
+
+// TODO(sigmund): consider adding also:
+// * isImplementationOf(type, subtype) to tells whether [type] declares that it
+//   implements the [supertype] interface.
+// * isSubtypeOf(type, subtype): Tells whether [type]'s interface is a sybtype
+//   of [supertype]. That is, whether it is a subclass or if [type] implements
+//   [supertype].
+
 /// Tells whether [type] has a field or getter for [field].
 bool hasGetter(Type type, Symbol field) =>
     implementation.typeInspector.hasGetter(type, field);
 
 /// Tells whether [type] has a field or setter for [field].
 bool hasSetter(Type type, Symbol field) =>
     implementation.typeInspector.hasSetter(type, field);
 
 /// Tells whether [type] or a superclass (other than [Object]) defines
 /// `noSuchMethod`.
@@ skipping 33 matching lines @@
   final bool includeFields;
 
   /// Whether to include getters and setters (default is true). Note that to
   /// include fields you also need to enable [includeFields].
   final bool includeProperties;
 
   /// Whether to include symbols from the given type and its superclasses
   /// (except [Object]).
   final bool includeInherited;
 
+  /// If [includeInherited], walk up the type hierarchy up to this type
+  /// (defaults to [Object]).
+  final Type includeUpTo;
+
   /// Whether to include final fields and getter-only properties.
   final bool excludeFinal;
 
   /// Whether to include methods (default is false).
   final bool includeMethods;
 
   /// If [withAnnotation] is not null, then it should be a list of types, so
   /// only symbols that are annotated with instances of those types are
   /// included.
   final List withAnnotations;
 
   const QueryOptions({
       this.includeFields: true,
       this.includeProperties: true,
       this.includeInherited: true,
+      this.includeUpTo: Object,
       this.excludeFinal: false,
       this.includeMethods: false,
       this.withAnnotations: null});
 }
 
 /// Information associated with a symbol declaration (like a property or
 /// method).
 class Declaration {
   /// Name of the property or method
   final Symbol name;
@@ skipping 67 matching lines @@
   /// Invoke [method] in [object] with [args]. It optionally [adjust]s the list
   /// of arguments to match the number of formal parameters by either adding
   /// nulls for missing arguments, or by truncating the list.
   invoke(Object object, Symbol method, List args,
       {Map namedArgs, bool adjust: false});
 }
 
 
 /// A service that provides partial inspection into Dart types.
 abstract class TypeInspectorService {
+  /// Tells whether [type] is transitively a subclass of [supertype].
+  bool isSubclassOf(Type type, Type supertype);
+
   /// Tells whether [type] has a field or getter for [name].
   bool hasGetter(Type type, Symbol name);
 
   /// Tells whether [type] has a field or setter for [name].
   bool hasSetter(Type type, Symbol name);
 
   /// Tells whether [type] has a specific instance [method].
   bool hasInstanceMethod(Type type, Symbol method);
 
   /// Tells whether [type] has a specific static [method].
   bool hasStaticMethod(Type type, Symbol method);
 
   /// Get the declaration associated with field [name] in [type].
   Declaration getDeclaration(Type type, Symbol name);
 
   /// Retrieve all symbols of [type] that match [options].
   List<Declaration> query(Type type, QueryOptions options);
 }
 
 
 /// A service that converts between [Symbol]s and [String]s. 
 abstract class SymbolConverterService {
   /// Returns the name associated with a [symbol].
   String symbolToName(Symbol symbol);
 
   /// Returns the symbol associated with a [name].
   Symbol nameToSymbol(String name);
 }