Don't wait unnecessarily.

compiler/java/com/google/dart/compiler/backend/isolate/DartIsolateStubGenerator.java

 // Copyright (c) 2011, 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.
 
 package com.google.dart.compiler.backend.isolate;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.Collection;
@@ skipping 81 matching lines @@
       return true;
     return false;
   }
   
   private static boolean isPromise(DartTypeNode x) {
     if (!(x.getIdentifier() instanceof DartIdentifier))
       return false;
     String name = ((DartIdentifier)x.getIdentifier()).getTargetName();
     return name.equals("Promise");
   }
+  
+  private String getPromiseType(DartTypeNode x) {
+    assert isPromise(x);
+    List<DartTypeNode> types = x.getTypeArguments();
+    assert types.size() == 1;
+    return ((DartIdentifier)types.get(0).getIdentifier()).getTargetName();
+  }
+  
+   private static boolean isPromiseForProxy(DartTypeNode x) {
+    if (!isPromise(x))
+      return false;
+    List<DartTypeNode> types = x.getTypeArguments();
+    if (types.size() != 1)
+      return false;
+    String name = ((DartIdentifier)types.get(0).getIdentifier()).getTargetName();
+    return name.endsWith("$Proxy");
+  }
 
   private static boolean isVoid(DartTypeNode x) {
     if (!isSimpleType(x))
       return false;
     return ((DartIdentifier)x.getIdentifier()).getTargetName().equals("void");
   }
 
   private static boolean isProxyType(DartTypeNode x) {
     if (!(x.getIdentifier() instanceof DartIdentifier))
       return false;
@@ skipping 152 matching lines @@
    *     return new Purse$ProxyImpl(this.call(["sproutPurse"]));
    *   }
    *
    *   void deposit(int amount, Purse$Proxy source) {
    *     this.send(["deposit", amount, source]);
    *   }
    * }
    */
   private void generateProxyClass(DartClass clazz) {
     String name = clazz.getClassName();
-    p("interface " + name + "$Proxy {");
+    p("interface " + name + "$Proxy extends Proxy {");
     printProxyInterfaceFunctions(clazz);
     p("}");
     nl();
     nl();
 
     p("class " + name + "$ProxyImpl extends ProxyImpl implements " + name + "$Proxy {");
     nl();
     p("  " + name + "$ProxyImpl(Promise<SendPort> port) : super.forReply(port) { }");
     nl();
     p("  " + name
@@ skipping 26 matching lines @@
           return false;
         p(" {");
         nl();
         p("    ");
         final DartFunction func = x.getFunction();
         final DartTypeNode returnTypeNode = func.getReturnTypeNode();
         final boolean isVoid = isVoid(returnTypeNode);
         final boolean isSimple = isSimpleType(returnTypeNode);
         final boolean isProxy = isProxyType(returnTypeNode);
         final boolean isPromise = isPromise(returnTypeNode);
-        if (!isVoid) {
-          p("return ");
-          if (!isSimple) {
-            p("new ");
-            accept(returnTypeNode);
-            if (!isProxy) {
-              p("$Proxy");
+        final boolean isPromiseForProxy = isPromiseForProxy(returnTypeNode);
+        if (isPromiseForProxy) {
+          String type = getPromiseType(returnTypeNode);
+          // This horrific unpacking is because a Proxy is, in effect, a Promise, but not quite, so
+          // a Promise<Proxy> ends up begin wrapped in two layers of SendPorts.
+          // FIXME(benl): unifying Promise and Proxy under Completable might well reduce the
+          // complexity here.
+          p("return new Promise<" + type + ">.fromValue(new " + type
+            + "Impl(new PromiseProxy<SendPort>(new PromiseProxy<SendPort>(");
+        } else {
+          if (!isVoid) {
+            p("return ");
+            if (!isSimple) {
+              p("new ");
+              accept(returnTypeNode);
+              if (!isProxy) {
+                p("$Proxy");
+              }
+              p("Impl(");
             }
-            p("Impl(");
           }
-        }
-        if (isProxy) {
-          // Note that Promises are Proxies.
-          p("new PromiseProxy");
-          if (isPromise) {
-            printTypeArguments(returnTypeNode);
-          } else {
-            p("<SendPort>");
+          if (isProxy) {
+            // Note that Promises are Proxies.
+            p("new PromiseProxy");
+            if (isPromise) {
+              printTypeArguments(returnTypeNode);
+            } else {
+              p("<SendPort>");
+            }
+            p("(");
           }
-          p("(");
         }
         p("this.");
         if (isVoid) {
           p("send");
         } else {
           p("call");
         }
         p("([\"");
         accept(x.getName());
         p("\"");
         DartVisitor params = new DartVisitor() {
           @Override
           public boolean visit(DartIdentifier x, DartContext ctx) {
             p(", ");
             p(x.getTargetName());
             return false;
           }
 
           @Override
           public boolean visit(DartParameter x, DartContext ctx) {
             accept(x.getName());
             return false;
           }
         };
         params.acceptList(func.getParams());
         p("])");
-        if (isProxy) {
-          p(")");
-        }
-        if (!isSimple) {
-          p(")");
+        if (isPromiseForProxy) {
+          p("))))");
+        } else {
+          if (isProxy) {
+            p(")");
+          }
+          if (!isSimple) {
+            p(")");
+          }
         }
         p(";");
         nl();
 
         p("  }");
         nl();
 
         return false;
       }
 
@@ skipping 22 matching lines @@
       if (first) {
         p("    ");
       } else {
         p(" else ");
       }
       p("if (command == \"");
       printFunctionName(member);
       p("\") {");
       nl();
       int proxies = unpackParams(member);
-      String extra = "";
       if (proxies != 0) {
-        p("      Promise done = new Promise();");
-        nl();
-        p("      done.waitFor(promises, " + proxies + ");");
-        nl();
-        p("      done.addCompleteHandler((_) {");
-        nl();
+        // FIXME(benl): we don't need to gather them anymore, could just pass them directly. Too
+        // lazy right now.
         gatherProxies(member);
-        extra = "  ";
       }
-      callTarget((DartMethodDefinition)member, extra);
-      if (proxies != 0) {
-        p("      });");
-        nl();
-      }
+      callTarget((DartMethodDefinition)member, "");
       p("    }");
       first = false;
     }
     p(" else {");
     nl();
     p("      // TODO(kasperl,benl): Somehow throw an exception instead.");
     nl();
     p("      reply(\"Exception: command '\" + command + \"' not understood by " + dispatcherName + ".\");");
     nl();
     p("    }");
@@ skipping 201 matching lines @@
           accept(param);
         }
         return false;
       }
 
       @Override
       public boolean visit(DartParameter x, DartContext ctx) {
         boolean isSimpleType = isSimpleType(x.getTypeNode());
 
         if (!isSimpleType) {
-          p("        ");
+          p("      ");
           accept(x.getTypeNode());
           p(" ");
           accept(x.getName());
           p(" = new ");
           accept(x.getTypeNode());
           p("Impl(promises[" + proxies + "]);");
           ++proxies;
           nl();
         }
         return false;
@@ skipping 185 matching lines @@
     }
     p(" ");
     visitor.accept(x.getName());
     p("(");
     printParams(func.getParams());
     p(")");
     
     return true;
   }
 }