Change reflective serialization rules to be able to take type literals

pkg/serialization/lib/serialization.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.
 
 /**
  * This provides a general-purpose serialization facility for Dart objects. A
  * [Serialization] is defined in terms of [SerializationRule]s and supports
  * reading and writing to different formats.
  *
  * ## Installing ##
@@ skipping 279 matching lines @@
    * will populate the rules from that data.
    */
   factory Serialization.blank()
     => new Serialization._(new List<SerializationRule>());
 
   Serialization._(List<SerializationRule> rules) :
     this._rules = rules,
     this.rules = new UnmodifiableListView(rules);
 
   /**
-   * Create a [BasicRule] rule for the type of
-   * [instanceOfType]. Optionally
+   * Create a [BasicRule] rule for [instanceOrType]. Normally this will be
+   * a type, but for backward compatibilty we also allow you to pass an
+   * instance (except an instance of Type), and the rule will be created
+   * for its runtimeType. Optionally
    * allows specifying a [constructor] name, the list of [constructorFields],
    * and the list of [fields] not used in the constructor. Returns the new
    * rule. Note that [BasicRule] uses reflection, and so will not work with the
    * current state of dartj2s. If you need to run there, consider using
    * [CustomRule] instead.
    *
    * If the optional parameters aren't specified, the default constructor will
    * be used, and the list of fields will be computed. Alternatively, you can
    * omit [fields] and provide [excludeFields], which will then compute the
    * list of fields specifically excluding those listed.
    *
    * The fields can be actual public fields, but can also be getter/setter
    * pairs or getters whose value is provided in the constructor. For the
    * [constructorFields] they can also be arbitrary objects. Anything that is
    * not a String will be treated as a constant value to be used in any
    * construction of these objects.
    *
    * If the list of fields is computed, fields from the superclass will be
    * included. However, each subclass needs its own rule, since the constructors
    * are not inherited, and so may need to be specified separately for each
    * subclass.
    */
-  // TODO(alanknight): Take a type rather than an instance. Issue 6282 and 6433.
   BasicRule addRuleFor(
-      instanceOfType,
+      instanceOrType,
       {String constructor,
         List constructorFields,
         List<String> fields,
         List<String> excludeFields}) {
 
     var rule = new BasicRule(
         turnInstanceIntoSomethingWeCanUse(
-            instanceOfType),
+            instanceOrType),
         constructor, constructorFields, fields, excludeFields);
     addRule(rule);
     return rule;
   }
 
   /** Set up the default rules, for lists and primitives. */
   void addDefaultRules() {
     addRule(new PrimitiveRule());
     addRule(new ListRule());
     // Both these rules apply to lists, so unless otherwise indicated,
@@ skipping 156 matching lines @@
 }
 
 /**
  * An exception class for errors during serialization.
  */
 class SerializationException implements Exception {
   final String message;
   const SerializationException(this.message);
   String toString() => "SerializationException($message)";
 }