dart2js cps: Support sync* and yield.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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 dart2js.ir_nodes;
 
 import 'dart:collection';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 68 matching lines @@
 }
 
 /// An expression that passes a continuation to a call.
 abstract class CallExpression extends Expression {
   Reference<Continuation> get continuation;
   Expression get next => continuation.definition.body;
 }
 
 /// An expression without a continuation or a subexpression body.
 ///
-/// These break straight-line control flow and can be throught of as ending a
+/// These break straight-line control flow and can be thought of as ending a
 /// basic block.
 abstract class TailExpression extends Expression {
   Expression get next => null;
 }
 
 /// The base class of things that variables can refer to: primitives,
 /// continuations, function and continuation parameters, etc.
 abstract class Definition<T extends Definition<T>> extends Node {
   // The head of a linked-list of occurrences, in no particular order.
   Reference<T> firstRef;
@@ skipping 1154 matching lines @@
   Await(Primitive input, Continuation continuation)
     : this.input = new Reference<Primitive>(input),
       this.continuation = new Reference<Continuation>(continuation);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitAwait(this);
   }
 }
 
+class Yield extends CallExpression {
+  final Reference<Primitive> input;
+  final Reference<Continuation> continuation;
+  final bool hasStar;
+
+  Yield(Primitive input, this.hasStar, Continuation continuation)
+    : this.input = new Reference<Primitive>(input),
+      this.continuation = new Reference<Continuation>(continuation);
+
+  @override
+  accept(Visitor visitor) {
+    return visitor.visitYield(this);
+  }
+}
+
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node);
 
   // Concrete classes.
@@ skipping 12 matching lines @@
   T visitThrow(Throw node);
   T visitRethrow(Rethrow node);
   T visitBranch(Branch node);
   T visitTypeCast(TypeCast node);
   T visitSetMutable(SetMutable node);
   T visitSetStatic(SetStatic node);
   T visitGetLazyStatic(GetLazyStatic node);
   T visitSetField(SetField node);
   T visitUnreachable(Unreachable node);
   T visitAwait(Await node);
+  T visitYield(Yield node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutable(GetMutable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
@@ skipping 289 matching lines @@
     processUnreachable(node);
   }
 
   processAwait(Await node) {}
   visitAwait(Await node) {
     processAwait(node);
     processReference(node.input);
     processReference(node.continuation);
   }
 
+  processYield(Yield node) {}
+  visitYield(Yield node) {
+    processYield(node);
+    processReference(node.input);
+    processReference(node.continuation);
+  }
+
   processGetLength(GetLength node) {}
   visitGetLength(GetLength node) {
     processGetLength(node);
     processReference(node.object);
   }
 
   processGetIndex(GetIndex node) {}
   visitGetIndex(GetIndex node) {
     processGetIndex(node);
     processReference(node.object);
@@ skipping 137 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends RecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }