anchor.diff:  /// The [OrdinalSortKey] compares itself with other [OrdinalSortKey]s
   /// to sort based on the order it is given.
   ///
  -/// The ordinal value `order` is typically an integer, though it can be
  -/// fractional, e.g. in order to fit between two other consecutive integers. The
  -/// value must be finite (it cannot be a NaN value or infinity).
  +/// The ordinal value `order` is typically a whole number, though it can be
  +/// fractional, e.g. in order to fit between two other consecutive whole
  +/// numbers. The value must be finite (it cannot be [double.nan],
  +/// [double.infinity], or [double.negativeInfinity]).
   ///
   /// See also:
   ///
   ///  * [SemanticsSortOrder] which manages a list of sort keys.
   class OrdinalSortKey extends SemanticsSortKey {
  -  /// Creates a semantics sort key that uses a double as its key value.
  +  /// Creates a semantics sort key that uses a [double] as its key value.
     ///
     /// The [order] must be a finite number.
     const OrdinalSortKey(
       this.order, {
       String name,
     }) : assert(order != null),
  -       assert(order > double.NEGATIVE_INFINITY),
  -       assert(order < double.INFINITY),
  +       assert(order != double.nan),
  +       assert(order > double.negativeInfinity),
  +       assert(order < double.infinity),
          super(name: name);
   
  -  /// A double which describes the order in which this node is traversed by the
  -  /// platform's accessibility services. Lower values will be traversed first.
  +  /// Determines the placement of this key in a sequence of keys that defines
  +  /// the order in which this node is traversed by the platform's accessibility
  +  /// services.
  +  ///
  +  /// Lower values will be traversed first.
     final double order;
   
     @override
  
positive.code: 
    /// The implementation of [compareTo].
    ///
    /// The argument is guaranteed to be the same type as this object.
    ///
    /// The method should return a negative number of this object is earlier in
    /// the sort order than the argument; and a positive number if it comes later
    /// in the sort order. Returning zero causes the system to default to
    /// comparing the geometry of the nodes.
  
negative.code:   /// `keys: <SemanticsSortKey>[key]`.
    ///
    /// If [discardParentOrder] is set to true, then the [SemanticsSortOrder.keys]
    /// will _replace_ the list of keys from the parents when merged. Otherwise,
    /// the child's keys are appended at the end of the parent's keys.
    SemanticsSortOrder({
      SemanticsSortKey key,
      List<SemanticsSortKey> keys,
  