Add experimental expando support.

tests/corelib/expando_test.dart

Index: tests/corelib/expando_test.dart
diff --git a/tests/corelib/expando_test.dart b/tests/corelib/expando_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..73a65a411ecf4f5135748a8cbaa825fc0cbf164d
--- /dev/null
+++ b/tests/corelib/expando_test.dart
@@ -0,0 +1,110 @@
+// 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.
+
+final Expando<int> visits = const Expando<int>('visits');
+
+main() {
+  var legal = [ new Object(),
+                new List(), [1,2,3], const [1,2,3],
+                new Map(), {'x':1,'y':2}, const {'x':1,'y':2},
+                new Expando(), new Expando('horse') ];
+  for (var object in legal) {
+    testNamedExpando(object);
+    testUnnamedExpando(object);
+    testConstExpando(object);
+  }
+  for (var object in legal) {
+    Expect.equals(3, visits[object]);
+  }
+  testIllegal();
+}
+
+visit(object) {
+  int count = visits[object];
+  count = (count === null) ? 1 : count + 1;
+  visits[object] = count;
+}
+
+testNamedExpando(object) {
+  Expando<int> expando = new Expando<int>('myexpando');
+  Expect.equals('myexpando', expando.name);
+  Expect.isTrue(expando.toString().startsWith('Expando:myexpando'));
+  testExpando(expando, object);
+}
+
+testUnnamedExpando(object) {
+  Expando<int> expando = new Expando<int>();
+  Expect.isNull(expando.name);
+  Expect.isTrue(expando.toString().startsWith('Expando:'));
+  testExpando(expando, object);
+}
+
+testExpando(Expando<int> expando, object) {
+  visit(object);
+
+  Expect.isNull(expando[object]);
+  expando[object] = 42;
+  Expect.equals(42, expando[object]);
+  expando[object] = null;
+  Expect.isNull(expando[object]);
+
+  Expando<int> alternative = new Expando('myexpando');
+  Expect.isNull(alternative[object]);
+  alternative[object] = 87;
+  Expect.isNull(expando[object]);
+  expando[object] = 99;
+  Expect.equals(99, expando[object]);
+  Expect.equals(87, alternative[object]);
+}
+
+testConstExpando(object) {
+  visit(object);
+
+  var e0 = const Expando<int>('horse');

[sra1, 2012/06/12 07:10:26]

Add 'difficult' names:
'prototype'
'toString'
'__proto__'

+  var e1 = const Expando<int>('horse');
+  var e2 = new Expando<int>('horse');
+  var e3 = new Expando<int>('horse');
+
+  e0[object] = 0;
+  Expect.equals(0, e0[object]);
+
+  e1[object] = 1;
+  Expect.equals(1, e0[object]);
+  Expect.equals(1, e1[object]);
+
+  e2[object] = 2;
+  Expect.equals(1, e0[object]);
+  Expect.equals(1, e1[object]);
+  Expect.equals(2, e2[object]);
+
+  e3[object] = 3;
+  Expect.equals(1, e0[object]);
+  Expect.equals(1, e1[object]);
+  Expect.equals(2, e2[object]);
+  Expect.equals(3, e3[object]);
+
+  e0[object] = null;
+  Expect.isNull(e0[object]);
+  Expect.isNull(e1[object]);
+  Expect.equals(2, e2[object]);
+  Expect.equals(3, e3[object]);
+}
+
+testIllegal() {

[sra1, 2012/06/12 07:10:26]

Illegal cases make the Expando API difficult to use.

My use case for dart:html is to walk the object graph and translate general
forms of List<T> and Map<K,V> to base representations.  I need a private
'visited' flag, for which an Expando is the only feasible solution to date.  How
do I know when I should use and when I should avoid my 'visited' Expando?

Please add a public legality predicate so that general object graph traversal
can be written without knowledge of implementation details.

+  Expando<int> expando = new Expando<int>();
+  Expect.throws(() => expando[null], (exception)
+      => exception is NullPointerException);
+  Expect.throws(() => expando['string'], (exception)
+      => exception is IllegalArgumentException);
+  Expect.throws(() => expando['string'], (exception)
+      => exception is IllegalArgumentException);
+  Expect.throws(() => expando[42], (exception)
+      => exception is IllegalArgumentException);
+  Expect.throws(() => expando[42.87], (exception)
+      => exception is IllegalArgumentException);
+  Expect.throws(() => expando[true], (exception)
+      => exception is IllegalArgumentException);
+  Expect.throws(() => expando[false], (exception)
+      => exception is IllegalArgumentException);
+}