Implementation of async-await transformation on js ast.

pkg/compiler/lib/src/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
+  R visitAwait(HAwait node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitBreak(HBreak node);
   R visitConstant(HConstant node);
   R visitContinue(HContinue node);
   R visitDivide(HDivide node);
@@ skipping 45 matching lines @@
   R visitStringify(HStringify node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
   R visitThrowExpression(HThrowExpression node);
   R visitTruncatingDivide(HTruncatingDivide node);
   R visitTry(HTry node);
   R visitTypeConversion(HTypeConversion node);
   R visitTypeKnown(HTypeKnown node);
+  R visitYield(HYield node);
   R visitReadTypeVariable(HReadTypeVariable node);
   R visitFunctionType(HFunctionType node);
   R visitVoidType(HVoidType node);
   R visitInterfaceType(HInterfaceType node);
   R visitDynamicType(HDynamicType node);
 }
 
 abstract class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
     void visitBasicBlockAndSuccessors(HBasicBlock block) {
@@ skipping 263 matching lines @@
   visitTry(HTry node) => visitControlFlow(node);
   visitIs(HIs node) => visitInstruction(node);
   visitIsViaInterceptor(HIsViaInterceptor node) => visitInstruction(node);
   visitTypeConversion(HTypeConversion node) => visitCheck(node);
   visitTypeKnown(HTypeKnown node) => visitCheck(node);
   visitReadTypeVariable(HReadTypeVariable node) => visitInstruction(node);
   visitFunctionType(HFunctionType node) => visitInstruction(node);
   visitVoidType(HVoidType node) => visitInstruction(node);
   visitInterfaceType(HInterfaceType node) => visitInstruction(node);
   visitDynamicType(HDynamicType node) => visitInstruction(node);
+  visitAwait(HAwait node) => visitInstruction(node);
+  visitYield(HYield node) => visitInstruction(node);
 }
 
 class SubGraph {
   // The first and last block of the sub-graph.
   final HBasicBlock start;
   final HBasicBlock end;
 
   const SubGraph(this.start, this.end);
 
   bool contains(HBasicBlock block) {
@@ skipping 1860 matching lines @@
 }
 
 class HThrowExpression extends HInstruction {
   HThrowExpression(value)
       : super(<HInstruction>[value], const TypeMask.nonNullEmpty());
   toString() => 'throw expression';
   accept(HVisitor visitor) => visitor.visitThrowExpression(this);
   bool canThrow() => true;
 }
 
+class HAwait extends HInstruction {
+  HAwait(HInstruction value, TypeMask type)
+      : super(<HInstruction>[value], type);
+  toString() => 'await';
+  accept(HVisitor visitor) => visitor.visitAwait(this);
+  bool canThrow() => inputs[0].canThrow(); // TODO is this true?

[floitsch, 2015/02/02 22:00:11]

I don't think that's correct.

I believe an await can throw, if the future is not "correct".

var myFakeFuture = new BadFuture();  // (throwing for `then`);
await myFakeFuture; // BOOM.

[sigurdm, 2015/02/03 16:59:32]

Thanks

+  SideEffects sideEffects = new SideEffects();
+}
+
+class HYield extends HInstruction {
+  HYield(HInstruction value, this.hasStar)
+      : super(<HInstruction>[value], const TypeMask.nonNullEmpty());
+  bool hasStar;
+  toString() => 'yield';
+  accept(HVisitor visitor) => visitor.visitYield(this);
+  bool canThrow() => inputs[0].canThrow(); // TODO is this true?

[floitsch, 2015/02/02 22:00:11]

ditto. I don't think this is correct.
This should only be true, if yield(x) can throw for any evaluated x. That is, if
the following can throw: var t = x; yield(t);

[sigurdm, 2015/02/03 16:59:32]

Done.

+  SideEffects sideEffects = new SideEffects();
+}
+
 class HThrow extends HControlFlow {
   final bool isRethrow;
   HThrow(value, {this.isRethrow: false}) : super(<HInstruction>[value]);
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element, type) : super(<HInstruction>[], type) {
@@ skipping 853 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }