Don't wait unnecessarily.

tests/stub-generator/src/MintMakerFullyIsolatedTest-generatedTest.dart

Index: tests/stub-generator/src/MintMakerFullyIsolatedTest-generatedTest.dart
===================================================================
--- tests/stub-generator/src/MintMakerFullyIsolatedTest-generatedTest.dart	(revision 734)
+++ tests/stub-generator/src/MintMakerFullyIsolatedTest-generatedTest.dart	(working copy)
@@ -8,7 +8,7 @@
 
 /* class = Purse (tests/stub-generator/src/MintMakerFullyIsolatedTest.dart/MintMakerFullyIsolatedTest.dart: 9) */
 
-interface Purse$Proxy {
+interface Purse$Proxy extends Proxy {
   Promise<int> queryBalance();
 
   Purse$Proxy sproutPurse();
@@ -56,13 +56,9 @@
       int amount = message[1];
       List<Promise<SendPort>> promises = new List<Promise<SendPort>>();
       promises.add(new PromiseProxy<SendPort>(new Promise<SendPort>.fromValue(message[2])));
-      Promise done = new Promise();
-      done.waitFor(promises, 1);
-      done.addCompleteHandler((_) {
-        Purse$Proxy source = new Purse$ProxyImpl(promises[0]);
-        Promise<int> deposit = target.deposit(amount, source);
-        reply(deposit);
-      });
+      Purse$Proxy source = new Purse$ProxyImpl(promises[0]);
+      Promise<int> deposit = target.deposit(amount, source);
+      reply(deposit);
     } else {
       // TODO(kasperl,benl): Somehow throw an exception instead.
       reply("Exception: command '" + command + "' not understood by Purse.");
@@ -85,7 +81,7 @@
 
 /* class = PowerfulPurse (tests/stub-generator/src/MintMakerFullyIsolatedTest.dart/MintMakerFullyIsolatedTest.dart: 18) */
 
-interface PowerfulPurse$Proxy {
+interface PowerfulPurse$Proxy extends Proxy {
   void init(Mint$Proxy mint, int balance);
 
   Promise<int> grab(int amount);
@@ -127,12 +123,8 @@
       List<Promise<SendPort>> promises = new List<Promise<SendPort>>();
       promises.add(new PromiseProxy<SendPort>(new Promise<SendPort>.fromValue(message[1])));
       int balance = message[2];
-      Promise done = new Promise();
-      done.waitFor(promises, 1);
-      done.addCompleteHandler((_) {
-        Mint$Proxy mint = new Mint$ProxyImpl(promises[0]);
-        target.init(mint, balance);
-      });
+      Mint$Proxy mint = new Mint$ProxyImpl(promises[0]);
+      target.init(mint, balance);
     } else if (command == "grab") {
       int amount = message[1];
       int grab = target.grab(amount);
@@ -163,10 +155,10 @@
 
 /* class = Mint (tests/stub-generator/src/MintMakerFullyIsolatedTest.dart/MintMakerFullyIsolatedTest.dart: 28) */
 
-interface Mint$Proxy {
+interface Mint$Proxy extends Proxy {
   Purse$Proxy createPurse(int balance);
 
-  PowerfulPurse$Proxy promote(Purse$Proxy purse);
+  Promise<PowerfulPurse$Proxy> promote(Purse$Proxy purse);
 }
 
 class Mint$ProxyImpl extends ProxyImpl implements Mint$Proxy {
@@ -184,8 +176,8 @@
     return new Purse$ProxyImpl(new PromiseProxy<SendPort>(this.call(["createPurse", balance])));
   }
 
-  PowerfulPurse$Proxy promote(Purse$Proxy purse) {
-    return new PowerfulPurse$ProxyImpl(new PromiseProxy<SendPort>(this.call(["promote", purse])));
+  Promise<PowerfulPurse$Proxy> promote(Purse$Proxy purse) {
+    return new PromiseProxy<PowerfulPurse$Proxy>(this.call(["promote", purse]));
   }
 }
 
@@ -202,13 +194,9 @@
     } else if (command == "promote") {
       List<Promise<SendPort>> promises = new List<Promise<SendPort>>();
       promises.add(new PromiseProxy<SendPort>(new Promise<SendPort>.fromValue(message[1])));
-      Promise done = new Promise();
-      done.waitFor(promises, 1);
-      done.addCompleteHandler((_) {
-        Purse$Proxy purse = new Purse$ProxyImpl(promises[0]);
-        PowerfulPurse$Proxy promote = target.promote(purse);
-        reply(promote);
-      });
+      Purse$Proxy purse = new Purse$ProxyImpl(promises[0]);
+      Promise<PowerfulPurse$Proxy> promote = target.promote(purse);
+      reply(promote);
     } else {
       // TODO(kasperl,benl): Somehow throw an exception instead.
       reply("Exception: command '" + command + "' not understood by Mint.");
@@ -251,7 +239,7 @@
   Mint();
 
   Purse$Proxy createPurse(int balance);
-  PowerfulPurse$Proxy promote(Purse$Proxy purse);
+  Promise<PowerfulPurse$Proxy> promote(Purse$Proxy purse);
 }
 
 // Because promises can't be used as keys in maps until they have
@@ -259,13 +247,65 @@
 // resolve, then get()'s return may also fail to resolve.  Also,
 // although the logic is fine, this can't be used for a
 // ProxyMap. Perhaps both Proxy and Promise should inherit from
-// Completable?
-// NB: not tested and known to be buggy. Will fix in a future change.
-class PromiseMap<S extends Promise, T> {
+// Completable?  Also, not sure if implementing Collection is really
+// sustainable, we shall see.
+class ProxySet<T extends Proxy> implements Collection<T> {

[floitsch, 2011/10/27 16:16:54]

why not Set<T> ?

[Ben Laurie (Google), 2011/10/27 16:34:57]

Lazy :-)

I will fix.

 
-  PromiseMap() {
+  ProxySet() {
+    _set = new List<T>();
+  }
+
+  ProxySet.fromList(this._set);
+
+  void add (T t) {

[floitsch, 2011/10/27 16:16:54]

remove space.

+    for (T x in _set)

[floitsch, 2011/10/27 16:16:54]

use {}

[Ben Laurie (Google), 2011/10/27 16:34:57]

Sigh.

+      if (x === t)
+        return;

[floitsch, 2011/10/27 16:16:54]

either put "return" on the same line, or put {} around.

[Ben Laurie (Google), 2011/10/27 16:34:57]

Really? Is that official? I _hate_ that style (both of them).

+    if (t.hasValue())

[floitsch, 2011/10/27 16:16:54]

{}

+      for (T x in _set)

[floitsch, 2011/10/27 16:16:54]

{}

+        if (x.hasValue() && x == t)

[floitsch, 2011/10/27 16:16:54]

{} or same line.

+          return;
+    _set.add(t);
+    t.addCompleteHandler((_) {
+      _remove(t, 1);
+    });
+  }
+
+  void _remove(T t, int threshold) {
+    int count = 0;
+    for (int n = 0; n < _set.length; ++n)

[floitsch, 2011/10/27 16:16:54]

{}

+      if (_set[n].hasValue() && _set[n] == t)

[floitsch, 2011/10/27 16:16:54]

{}

+        if (++count > threshold) {
+          _set.removeRange(n, 1);
+          --n;
+        }
+  }
+
+  void remove(T t) {
+    t.addCompleteHandler((_) {
+      _remove(t, 0);
+    });
+  }
+
+  int get length() => _set.length;
+  void forEach(void f(T element)) { _set.forEach(f); }
+  ProxySet<T> filter(bool f(T element))

[floitsch, 2011/10/27 16:16:54]

convention is that => is only allowed on the same line.

[Ben Laurie (Google), 2011/10/27 16:34:57]

Done.

+    => new ProxySet<T>.fromList(_set.filter(f));
+  bool every(bool f(T element)) => _set.every(f);
+  bool some(bool f(T element)) => _set.some(f);
+  bool isEmpty() => _set.isEmpty();
+  Iterator<T> iterator() => _set.iterator();
+
+  List<T> _set;
+    
+} 
+
+
+class ProxyMap<S extends Proxy, T> {
+
+  ProxyMap() {
     _map = new Map<S, T>();
-    _incomplete = new Set<S>();
+    _incomplete = new ProxySet<S>();
   }
 
   T add(S s, T t) {
@@ -278,9 +318,12 @@
   }
 
   Promise<T> find(S s) {
-    T t = _map[s];
-    if (t != null)
-      return new Promise<T>.fromValue(t);
+    // premature optimisation?
+    if (s.hasValue()) {
+      T t = _map[s];
+      if (t != null)

[floitsch, 2011/10/27 16:16:54]

{} or same line.

[floitsch, 2011/10/27 16:16:54]

t !== null

[Ben Laurie (Google), 2011/10/27 16:34:57]

Really? I've been explcitly told === is not needed for null.

+        return new Promise<T>.fromValue(t);
+    }
     Promise<T> p = new Promise<T>();
     int counter = _incomplete.length;
     p.join(_incomplete, bool (S completed) {
@@ -297,17 +340,18 @@
     return p;
   }
 
-  Set<S> _incomplete;
+  ProxySet<S> _incomplete;
   Map<S, T> _map;
 
 }
 
+
 class MintImpl implements Mint {
 
   MintImpl() {
     //print('mint');
     if (_power == null)
-      _power = new Map<Purse$Proxy, PowerfulPurse$Proxy>();
+      _power = new ProxyMap<Purse$Proxy, PowerfulPurse$Proxy>();
   }
 
   Purse$Proxy createPurse(int balance) {
@@ -318,22 +362,22 @@
     purse.init(thisProxy, balance);
 
     Purse$Proxy weakPurse = purse.weak();
-    weakPurse.addCompleteHandler(() {
+    weakPurse.addCompleteHandler((_) {
       //print('cP1');
-      _power[weakPurse] = purse;
+      _power.add(weakPurse, purse);
       //print('cP2');
     });
     return weakPurse;
   }
 
-  PowerfulPurse$Proxy promote(Purse$Proxy purse) {
+  Promise<PowerfulPurse$Proxy> promote(Purse$Proxy purse) {
     // FIXME(benl): we should be using a PromiseMap here. But we get
     // away with it in this test for now.
     //print('promote $purse/${_power[purse]}');
-    return _power[purse];
+    return _power.find(purse);
   }
 
-  static Map<Purse$Proxy, PowerfulPurse$Proxy> _power;
+  static ProxyMap<Purse$Proxy, PowerfulPurse$Proxy> _power;
 }
 
 class PurseImpl implements PowerfulPurse {
@@ -359,14 +403,15 @@
 
   Promise<int> deposit(int amount, Purse$Proxy proxy) {
     //print('deposit');
-    Promise<int> grabbed = _mint.promote(proxy).grab(amount);
-    Promise<int> done = new Promise<int>();
-    grabbed.then((int) {
-      //print("deposit done");
+    Promise<PowerfulPurse$Proxy> powerful = _mint.promote(proxy);
+
+    return powerful.then(() {
+      powerful.value.grab(amount);
+      return amount;
+    }).then((int amount) {
       _balance += amount;
-      done.complete(_balance);
+      return _balance;
     });
-    return done;
   }
 
   int grab(int amount) {