initial sync*, part of #221

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';
 
 import 'js_names.dart' show TemporaryId;
 
 /// A synthetic `let*` node, similar to that found in Scheme.
 ///
 /// For example, postfix increment can be desugared as:
 ///
 ///     // psuedocode mix of Scheme and JS:
 ///     (let* (x1=expr1, x2=expr2, t=x1[x2]) { x1[x2] = t + 1; t })
 ///
 /// [MetaLet] will simplify itself automatically when [toExpression],
-/// [toStatement], or [toReturn] is called.
+/// [toStatement], [toReturn], or [toYieldStatement] is called.
 ///
 /// * variables used once will be inlined.
 /// * if used in a statement context they can emit as blocks.
 /// * if return value is not used it can be eliminated, see [statelessResult].
 /// * if there are no variables, the codegen will be simplified.
 ///
 /// Because this deals with JS AST nodes, it is not aware of any Dart semantics
 /// around statelessness (such as `final` variables). [variables] should not
 /// be created for these Dart expressions.
 ///
@@ skipping 73 matching lines @@
     return _finishStatement(statements);
   }
 
   Block toReturn() {
     var statements = body
         .map((e) => e == body.last ? e.toReturn() : e.toStatement())
         .toList();
     return _finishStatement(statements);
   }
 
+  Block toYieldStatement({bool star: false}) {
+    var statements = body
+        .map((e) =>
+            e == body.last ? e.toYieldStatement(star: star) : e.toStatement())
+        .toList();
+    return _finishStatement(statements);
+  }
+
   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;
 
   Block _finishStatement(List<Statement> statements) {
@@ skipping 108 matching lines @@
   bool found = false;
   _IdentFinder(this.name);
 
   visitIdentifier(Identifier node) {
     if (node.name == name) found = true;
   }
   visitNode(Node node) {
     if (!found) super.visitNode(node);
   }
 }