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

lib/src/codegen/js_metalet.dart

 // 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.
 
 library dev_compiler.src.codegen.js_metalet;
 
 // TODO(jmesserly): import from its own package
 import 'package:dev_compiler/src/js/js_ast.dart';
 import 'package:dev_compiler/src/js/precedence.dart';
 
@@ skipping 46 matching lines @@
   /// Returns an expression that ignores the result. This is a cross between
   /// [toExpression] and [toStatement]. Used for C-style for-loop updaters,
   /// which is an expression syntactically, but functions more like a statement.
   Expression toVoidExpression() {
     var block = toStatement();
     var s = block.statements;
     if (s.length == 1 && s.first is ExpressionStatement) {
       ExpressionStatement es = s.first;
       return es.expression;
     }
-    return new Call(new ArrowFun([], block), []);
+
+    return _toInvokedFunction(block);
   }
 
   Expression toAssignExpression(Expression left) {
     if (left is Identifier) {
       var simple = _simplifyAssignment(left);
       if (simple != null) return simple;
 
       var exprs = body.toList();
       exprs.add(exprs.removeLast().toAssignExpression(left));
       return new MetaLet(variables, exprs);
     }
     return super.toAssignExpression(left);
   }
 
   Statement toVariableDeclaration(Identifier name) {
     var simple = _simplifyAssignment(name, isDeclaration: true);
     if (simple != null) return simple.toStatement();
     return super.toVariableDeclaration(name);
   }
 
   Expression toExpression() {
     if (_expression != null) return _expression;
     var block = toReturn();
     var s = block.statements;
     if (s.length == 1 && s.first is Return) {
       Return es = s.first;
       return _expression = es.value;
     }
     // Wrap it in an immediately called function to get in expression context.
-    // TODO(jmesserly):
-    return _expression = new Call(new ArrowFun([], block), []);
+    return _expression = _toInvokedFunction(block);
   }
 
   Block toStatement() {
     // Skip return value if not used.
     var statements = body.map((e) => e.toStatement()).toList();
     if (statelessResult) statements.removeLast();
     return _finishStatement(statements);
   }
 
   Block toReturn() {
@@ skipping 13 matching lines @@
 
   accept(NodeVisitor visitor) => toExpression().accept(visitor);
 
   void visitChildren(NodeVisitor visitor) {
     toExpression().visitChildren(visitor);
   }
 
   /// This generates as either a comma expression or a call.
   int get precedenceLevel => variables.isEmpty ? EXPRESSION : CALL;
 
+  Expression _toInvokedFunction(Statement block) {
+    var finder = new _YieldFinder();
+    block.accept(finder);
+    if (!finder.hasYield) {
+      return new Call(new ArrowFun([], block), []);
+    }
+    // If we have a yield, it's more tricky. We'll create a `function*`, which
+    // we `yield*` to immediately invoke. We also may need to bind this:
+    Expression fn = new Fun([], block, isGenerator: true);
+    if (finder.hasThis) fn = js.call('#.bind(this)', fn);
+    return new Yield(new Call(fn, []), star: true);
+  }
+
   Block _finishStatement(List<Statement> statements) {
     var params = <TemporaryId>[];
     var values = <Expression>[];
     var block = _build(params, values, new Block(statements));
     if (params.isEmpty) return block;
 
     var vars = [];
     for (int i = 0; i < params.length; i++) {
       vars.add(new VariableInitialization(params[i], values[i]));
     }
@@ skipping 81 matching lines @@
 
     var newBody = new Expression.binary([assign]..addAll(body), ',');
     Binary comma = new Template(null, newBody).safeCreate({name: left});
     return new MetaLet(vars, comma.commaToExpressionList(),
         statelessResult: statelessResult);
   }
 }
 
 class _VariableUseCounter extends BaseVisitor {
   final counts = <String, int>{};
-  visitInterpolatedExpression(InterpolatedExpression node) {
+  @override visitInterpolatedExpression(InterpolatedExpression node) {
     int n = counts[node.nameOrPosition];
     counts[node.nameOrPosition] = n == null ? 1 : n + 1;
   }
 }
 
 class _IdentFinder extends BaseVisitor {
   final String name;
   bool found = false;
   _IdentFinder(this.name);
 
-  visitIdentifier(Identifier node) {
+  @override visitIdentifier(Identifier node) {
     if (node.name == name) found = true;
   }
-  visitNode(Node node) {
+  @override visitNode(Node node) {
     if (!found) super.visitNode(node);
   }
 }
+
+class _YieldFinder extends BaseVisitor {
+  bool hasYield = false;
+  bool hasThis = false;
+  bool _nestedFunction = false;
+  @override visitThis(This node) {
+    hasThis = true;
+  }
+  @override visitFunctionExpression(FunctionExpression node) {
+    var savedNested = _nestedFunction;
+    _nestedFunction = true;
+    super.visitFunctionExpression(node);
+    _nestedFunction = savedNested;
+  }
+  @override visitYield(Yield node) {
+    if (!_nestedFunction) hasYield = true;
+  }
+  @override visitNode(Node node) {
+    if (!hasYield) super.visitNode(node);
+  }
+}