pkg/serialization types cleanup

pkg/serialization/lib/src/serialization_rule.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 serialization;
 
 // TODO(alanknight): We should have an example and tests for subclassing
 // serialization rule rather than using the hard-coded ClosureToMap rule. And
 // possibly an abstract superclass that's designed to be subclassed that way.
 /**
  * The abstract superclass for serialization rules.
  */
 abstract class SerializationRule {
   /**
    * Rules belong uniquely to a particular Serialization instance, and can
    * be identified within it by number.
    */
   int _number;
 
   /**
    * Rules belong uniquely to a particular Serialization instance, and can
    * be identified within it by number.
    */
   int get number => _number;
 
   /**
    * Rules belong uniquely to a particular Serialization instance, and can
    * be identified within it by number.
    */
-  void set number(x) {
-    if (_number != null && _number != x) throw
+  void set number(int value) {
+    if (_number != null && _number != value) throw
         new SerializationException("Rule numbers cannot be changed, once set");
-    _number = x;
+    _number = value;
   }
 
   /**
    * Return true if this rule applies to this object, in the context
    * where we're writing it, false otherwise.
    */
   bool appliesTo(object, Writer writer);
 
   /**
    * This extracts the state from the object, calling [f] for each value
@@ skipping 40 matching lines @@
    * also want to have multiple different rules that might exclusively apply
    * to the same object. So, we want either ListRule or ListRuleEssential, and
    * only one of them can be there. But on the other hand, we may want both
    * ListRule and BasicRule. So we identify the kinds of rules that can share.
    * If mustBePrimary returns true, then this rule will only be chosen if no
    * other rule has been found yet. This means that the ordering of rules in
    * the serialization is significant, which is unpleasant, but we'll have
    * to see how bad it is.
    */
   // TODO(alanknight): Reconsider whether this should be handled differently.
-  get mustBePrimary => false;
+  bool get mustBePrimary => false;
 
   /**
    * Create the new object corresponding to [state] using the rules
    * from [reader]. This may involve recursively inflating "essential"
    * references in the state, which are those that are required for the
    * object's constructor. It is up to the rule what state is considered
    * essential.
    */
   inflateEssential(state, Reader reader);
 
@@ skipping 472 matching lines @@
   removeWhere(x) => _throw();
   retainWhere(x) => _throw();
   replaceRange(x, y, z) => _throw();
   getRange(x, y) => _throw();
   setRange(x, y, z, [a = 0]) => _throw();
   setAll(x, y) => _throw();
   removeRange(x, y) => _throw();
   get reversed => _throw();
   void set length(x) => _throw();
 }