pkg/serialization: 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.
 /**
@@ skipping 528 matching lines @@
   bool containsValue(x) => _inflated.containsValue(x);
   Iterable get values => _inflated.values;
   void forEach(f) => _inflated.forEach(f);
 
   // These operations are all invalid
   _throw() {
     throw new UnsupportedError("Not modifiable");
   }
   operator []=(x, y) => _throw();
   putIfAbsent(x, y) => _throw();
-  remove(x) => _throw();
-  clear() => _throw();
+  bool remove(x) => _throw();
+  void clear() => _throw();

[Alan Knight, 2013/06/21 22:47:46]

You can't declare things void and use the => syntax. Which I find annoying. See
https://code.google.com/p/dart/issues/detail?id=11291

In this case it's rather moot that the function would throw in checked mode,
because it will throw anyway. Although since _throw is also void, presumably if
used in an expression its return value is null, which would then get past
checked mode. But if we're to consider void incompatible with lambda syntax we
probably shouldn't do it. 

[kevmoo-old, 2013/06/21 22:57:32]

It's more about incompatible return types.

If _throw returned int, this would blow up.

As is, it works fine...even in checked mode.

[Alan Knight, 2013/06/21 23:15:20]

Since _throw never returns, it's moot anyway. But the feedback I got offline was
that void functions should be considered incompatible with lambda syntax. To me
void means "doesn't return a value", and the fact that null is considered
compatible with that is a little odd. But it's moot anyway.

+  void addAll(Map other) => _throw();
 }
 
 /**
  * This provides an implementation of List that wraps a list which may
  * contain references to (potentially) non-inflated objects. If these
  * are accessed it will inflate them. This allows us to pass something that
  * looks like it's just a list of objects to a [CustomRule] without needing
  * to inflate all the references in advance.
  */
-class _LazyList extends IterableBase implements List {
+class _LazyList extends IterableBase with ListMixin implements List {
   _LazyList(this._raw, this._reader);
 
   final List _raw;
   final Reader _reader;
 
-  // This is the only operation that really matters.
-  operator [](x) => _reader.inflateReference(_raw[x]);
+  operator [](int x) => _reader.inflateReference(_raw[x]);
+  int get length => _raw.length;

[Alan Knight, 2013/06/21 22:47:46]

Nice to be able to get rid of all that boilerplate. Thanks.

[kevmoo-old, 2013/06/21 22:57:32]

Yup yup

 
-  int get length => _raw.length;
-  bool get isEmpty => _raw.isEmpty;
-  get first => _reader.inflateReference(_raw.first);
-  get last => _reader.inflateReference(_raw.last);
+  void set length(int value) => _throw();
 
-  // These operations, and other inherited methods that iterate over the whole
-  // list will work, but may be expensive, and are probably
-  // best avoided.
-  Iterable get _inflated => _raw.map(_reader.inflateReference);
-  Iterator get iterator => _inflated.iterator;
-  indexOf(x, [pos = 0]) => _inflated.toList().indexOf(x);
-  lastIndexOf(x, [pos]) => _inflated.toList().lastIndexOf(x);
-  sublist(start, [end]) => _inflated.sublist(start, end);
+  void operator []=(int index, value) => _throw();
 
-  Map<int, dynamic> asMap() => _inflated.asMap();
-
-  // These operations are all invalid
-  _throw() {
+  void _throw() {
     throw new UnsupportedError("Not modifiable");
   }
-  operator []=(x, y) => _throw();
-  add(x) => _throw();
-  addAll(x) => _throw();
-  sort([f]) => _throw();
-  clear() => _throw();
-  insert(x, y) => _throw();
-  insertAll(x, y) => _throw();
-  fillRange(x, y, [z]) => _throw();
-  removeAt(x) => _throw();
-  remove(x) => _throw();
-  removeLast() => _throw();
-  removeAll(x) => _throw();
-  retainAll(x) => _throw();
-  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();
 }