fixes #221, initial sync*, async, async* implementation

test/codegen/language/async_throw_in_catch_test.dart

Index: test/codegen/language/async_throw_in_catch_test.dart
diff --git a/test/codegen/language/async_throw_in_catch_test.dart b/test/codegen/language/async_throw_in_catch_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..6117a2605792ed195bfe395426c34dd8cf442d4d
--- /dev/null
+++ b/test/codegen/language/async_throw_in_catch_test.dart
@@ -0,0 +1,476 @@
+// Copyright (c) 2015, 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.
+
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+class Tracer {
+  final String expected;
+  final String name;
+  int counter = 0;
+
+  Tracer(this.expected, [this.name]);
+
+  void trace(msg) {
+    if (name != null) {
+      print("Tracing $name: $msg");
+    }
+    Expect.equals(expected[counter], msg);
+    counter++;
+  }
+
+  void done() {
+    Expect.equals(expected.length, counter, "Received too few traces");
+  }
+}
+
+foo1(Tracer tracer) async {
+  try {
+    tracer.trace("a");
+    // This await forces dart2js to rewrite the try into a state machine
+    // instead of relying on the existing structure.
+    await new Future.value(3); /// forceAwait: ok
+    tracer.trace("b");
+    throw "Error";
+  } catch (error) {
+    tracer.trace("c");
+    Expect.equals("Error", error);
+    throw "Error2";
+    tracer.trace("d");
+  } finally {
+    tracer.trace("e");
+  }
+  tracer.trace("f");
+}
+
+foo2(Tracer tracer) async {
+  try {
+    tracer.trace("a");
+    await new Future.value(3); /// forceAwait: continued
+    tracer.trace("b");
+    throw "Error";
+    tracer.trace("c");
+  } catch (error) {
+    tracer.trace("d");
+    Expect.equals("Error", error);
+    await new Future.error("Error2");
+  } finally {
+    tracer.trace("e");
+  }
+  tracer.trace("f");
+}
+
+foo3(Tracer tracer) async {
+  try {
+    tracer.trace("a");
+    await new Future.value(3); /// forceAwait: continued
+    tracer.trace("b");
+    throw "Error";
+    tracer.trace("c");
+  } catch (error) {
+    Expect.equals("Error", error);
+    tracer.trace("d");
+    return;
+  } finally {
+    tracer.trace("e");
+  }
+  tracer.trace("f");
+}
+
+foo4(Tracer tracer) async {
+  try {
+    try {
+      await new Future.value(3); /// forceAwait: continued
+      tracer.trace("a");
+      throw "Error";
+    } catch(error) {
+      tracer.trace("b");
+      Expect.equals("Error", error);
+      throw "Error2";
+    }
+  } catch(error) {
+    Expect.equals("Error2", error);
+    tracer.trace("c");
+  }
+  tracer.trace("d");
+
+}
+
+foo5(Tracer tracer) async {
+  try {
+    tracer.trace("a");
+    try {
+      await new Future.value(3); /// forceAwait: continued
+      tracer.trace("b");
+      throw "Error";
+    } catch(error) {
+      tracer.trace("c");
+      Expect.equals("Error", error);
+      throw "Error2";
+    }
+  } finally {
+    tracer.trace("d");
+  }
+  tracer.trace("e");
+
+}
+
+foo6(Tracer tracer) async {
+  try {
+    try {
+      await new Future.value(3); /// forceAwait: continued
+      tracer.trace("a");
+      throw "Error";
+    } catch(error) {
+      tracer.trace("b");
+      Expect.equals("Error", error);
+      throw "Error2";
+    } finally {
+      tracer.trace("c");
+      throw "Error3";
+    }
+  } catch(error) {
+    tracer.trace("d");
+    Expect.equals("Error3", error);
+  }
+  tracer.trace("e");
+}
+
+foo7(Tracer tracer) async {
+  try {
+    try {
+      await new Future.value(3); /// forceAwait: continued
+      tracer.trace("a");
+      throw "Error";
+    } catch(error) {
+      Expect.equals("Error", error);
+      tracer.trace("b");
+      throw "Error2";
+    } finally {
+      tracer.trace("c");
+      throw "Error3";
+    }
+  } finally {
+    tracer.trace("d");
+  }
+  tracer.trace("e");
+}
+
+foo8(Tracer tracer) async {
+  try {
+    try {
+      await new Future.value(3); /// forceAwait: continued
+      tracer.trace("a");
+      throw "Error";
+    } catch(error) {
+      Expect.equals("Error", error);
+      tracer.trace("b");
+      return;
+    } finally {
+      tracer.trace("c");
+      throw "Error3";
+    }
+  } finally {
+    tracer.trace("d");
+  }
+  tracer.trace("e");
+}
+
+foo9(Tracer tracer) async {
+  try {
+    while(true) {
+      try {
+        await new Future.value(3); /// forceAwait: continued
+        tracer.trace("a");
+        throw "Error";
+      } catch(error) {
+        Expect.equals("Error", error);
+        tracer.trace("b");
+        return;
+      } finally {
+        tracer.trace("c");
+        break;
+      }
+      tracer.trace("d");
+    }
+  } finally {
+    tracer.trace("e");
+  }
+  tracer.trace("f");
+}
+
+foo10(Tracer tracer) async {
+  try {
+    int i = 0;
+    while (true) {
+      try {
+        try {
+          tracer.trace("a");
+          throw "Error";
+        } catch (error) {
+          tracer.trace("b");
+          try {
+            await new Future.value(3);  /// forceAwait: continued
+            throw "Error2";
+          } catch(error) {
+            tracer.trace("c");
+          } finally {
+            tracer.trace("d");
+          }
+          tracer.trace("e");
+          throw "Error3";
+        } finally {
+          tracer.trace("f");
+          // Continue and breaks 'eats' Error3.
+          if (i == 0) continue;
+          if (i == 1) break;
+        }
+      } finally {
+        tracer.trace("g");
+        i++;
+      }
+    }
+  } finally {
+    tracer.trace("h");
+  }
+  tracer.trace("i");
+}
+
+foo11(Tracer tracer) async {
+  try {
+    bool firstTime = true;
+    while(true) {
+      tracer.trace("a");
+      if (firstTime) {
+        try {
+          await new Future.value(3); /// forceAwait: continued
+          tracer.trace("b");
+          throw "Error";
+        } catch(error) {
+          Expect.equals("Error", error);
+          tracer.trace("c");
+          firstTime = false;
+          continue;
+        } finally {
+          tracer.trace("d");
+        }
+      } else {
+        tracer.trace("e");
+        return;
+      }
+    }
+  } finally {
+    tracer.trace("f");
+  }
+  tracer.trace("g");
+}
+
+foo12(Tracer tracer) async {
+  try {
+    bool firstTime = true;
+    while(true) {
+      tracer.trace("a");
+      if (firstTime) {
+        try {
+          await new Future.value(3); /// forceAwait: continued
+          tracer.trace("b");
+          throw "Error";
+        } catch(error) {
+          Expect.equals("Error", error);
+          tracer.trace("c");
+          firstTime = false;
+          continue;
+        } finally {
+          tracer.trace("d");
+          break;
+        }
+      } else {
+        tracer.trace("e");
+        return;
+      }
+    }
+  } finally {
+    tracer.trace("f");
+  }
+  tracer.trace("g");
+}
+
+foo13(Tracer tracer) async {
+  try {
+    try {
+      tracer.trace("a");
+      return;
+    } catch (error) {
+      tracer.trace("b");
+    } finally {
+      tracer.trace("c");
+      try {
+        try {
+          await new Future.value(3);  /// forceAwait: continued
+          tracer.trace("d");
+          throw "Error";
+        } finally {
+          tracer.trace("e");
+        }
+      } finally {
+        tracer.trace("f");
+      }
+    }
+  } finally {
+    tracer.trace("g");
+  }
+  tracer.trace("h");
+}
+
+foo14(Tracer tracer) async {
+  try {
+    try {
+      tracer.trace("a");
+      throw "Error";
+    } catch (error) {
+      tracer.trace("b");
+      try {
+        await new Future.value(3);  /// forceAwait: continued
+        throw "Error2";
+      } catch(error) {
+        tracer.trace("c");
+      } finally {
+        tracer.trace("d");
+      }
+      tracer.trace("e");
+      throw "Error3";
+    } finally {
+      tracer.trace("f");
+    }
+  } finally {
+    tracer.trace("g");
+  }
+  tracer.trace("h");
+}
+
+foo15(Tracer tracer) async {
+  try {
+    try {
+      tracer.trace("a");
+      throw "Error";
+    } catch (error) {
+      tracer.trace("b");
+      try {
+        await new Future.value(3);  /// forceAwait: continued
+        throw "Error2";
+      } catch(error) {
+        tracer.trace("c");
+      } finally {
+        tracer.trace("d");
+      }
+      tracer.trace("e");
+      throw "Error3";
+    } finally {
+      tracer.trace("f");
+      return;
+    }
+  } finally {
+    tracer.trace("g");
+  }
+  tracer.trace("h");
+}
+
+foo16(Tracer tracer) async {
+  try {
+    try {
+      tracer.trace("a");
+      throw "Error";
+    } catch (error) {
+      tracer.trace("b");
+      try {
+        await new Future.value(3);  /// forceAwait: continued
+        throw "Error2";
+      } catch(error) {
+        tracer.trace("c");
+      } finally {
+        tracer.trace("d");
+        return;
+      }
+      tracer.trace("e");
+      throw "Error3";
+    } finally {
+      tracer.trace("f");
+    }
+  } finally {
+    tracer.trace("g");
+  }
+  tracer.trace("h");
+}
+
+foo17(Tracer tracer) async {
+  try {
+    tracer.trace("a");
+  } finally {
+    try {
+      tracer.trace("b");
+      throw "Error";
+    } catch (error) {
+      await new Future.value(3);  /// forceAwait: continued
+      Expect.equals("Error", error);
+      tracer.trace("c");
+    } finally {
+      tracer.trace("d");
+    }
+    tracer.trace("e");
+  }
+  tracer.trace("f");
+}
+
+foo18(Tracer tracer) async {
+  try {
+      tracer.trace("a");
+  } finally {
+    try {
+      tracer.trace("b");
+    } finally {
+      await new Future.value(3);  /// forceAwait: continued
+      tracer.trace("c");
+    }
+    tracer.trace("d");
+  }
+  tracer.trace("e");
+}
+
+runTest(expectedTrace, fun, [expectedError]) async {
+  Tracer tracer = new Tracer(expectedTrace, expectedTrace);
+  try {
+    await fun(tracer);
+  } catch (error) {
+    Expect.equals(expectedError, error);
+    tracer.trace("X");
+  }
+  tracer.done();
+}
+
+test() async {
+  await runTest("abceX", foo1, "Error2");
+  await runTest("abdeX", foo2, "Error2");
+  await runTest("abde", foo3);
+  await runTest("abcd", foo4);
+  await runTest("abcdX", foo5, "Error2");
+  await runTest("abcde", foo6);
+  await runTest("abcdX", foo7, "Error3");
+  await runTest("abcdX", foo8, "Error3");
+  await runTest("abcef", foo9);
+  await runTest("abcdefgabcdefghi", foo10);
+  await runTest("abcdaef", foo11);
+  await runTest("abcdfg", foo12);
+  await runTest("acdefgX", foo13, "Error");
+  await runTest("abcdefgX", foo14, "Error3");
+  await runTest("abcdefgX", foo14, "Error3");
+  await runTest("abcdefg", foo15);
+  await runTest("abcdfg", foo16);
+  await runTest("abcdef", foo17);
+  await runTest("abcde", foo18);
+}
+
+void main() {
+  asyncTest(test);
+}