Implementation of async-await transformation on js ast.

pkg/compiler/lib/src/closure.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.
 
 library closureToClassMapper;
 
 import "elements/elements.dart";
 import "dart2jslib.dart";
 import "dart_types.dart";
 import "js_backend/js_backend.dart" show JavaScriptBackend;
@@ skipping 254 matching lines @@
 
 /// Call method of a closure class.
 class SynthesizedCallMethodElementX extends BaseFunctionElementX {
   final LocalFunctionElement expression;
 
   SynthesizedCallMethodElementX(String name,
                                 LocalFunctionElementX other,
                                 ClosureClassElement enclosing)
       : expression = other,
         super(name, other.kind, other.modifiers, enclosing, false) {
+    asyncMarker = other.asyncMarker;
     functionSignatureCache = other.functionSignature;
   }
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
 
   ClosureClassElement get closureClass => super.enclosingElement;
 
   MemberElement get memberContext {
@@ skipping 55 matching lines @@
   final Map<Local, CapturedVariable> freeVariableMap =
       new Map<Local, CapturedVariable>();
 
   // Maps [Loop] and [FunctionExpression] nodes to their
   // [ClosureScope] which contains their box and the
   // captured variables that are stored in the box.
   // This map will be empty if the method/closure of this [ClosureData] does not
   // contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes = new Map<Node, ClosureScope>();
 
-  final Set<Local> usedVariablesInTry = new Set<Local>();
+  final Set<Local> variablesUsedInTryOrGenerator = new Set<Local>();

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

Add comment.
Not every variable in a generator is in this set.

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

Done.

 
   ClosureClassMap(this.closureElement,
                   this.closureClassElement,
                   this.callElement,
                   this.thisLocal);
 
   void addFreeVariable(Local element) {
     assert(freeVariableMap[element] == null);
     freeVariableMap[element] = null;
   }
@@ skipping 59 matching lines @@
     });
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
   final TreeElements elements;
   int closureFieldCounter = 0;
   int boxedFieldCounter = 0;
   bool inTryStatement = false;
+
   final Map<Node, ClosureClassMap> closureMappingCache;
 
   // Map of captured variables. Initially they will map to `null`. If
   // a variable needs to be boxed then the scope declaring the variable
   // will update this to mapping to the capturing [BoxFieldElement].
   Map<Local, BoxFieldElement> _capturedVariableMapping =
       new Map<Local, BoxFieldElement>();
 
   // List of encountered closures.
   List<Expression> closures = <Expression>[];
@@ skipping 141 matching lines @@
     }
 
     if (insideClosure && !inCurrentContext(variable)) {
       closureData.addFreeVariable(variable);
     } else if (inTryStatement) {
       // Don't mark the this-element or a self-reference. This would complicate
       // things in the builder.
       // Note that nested (named) functions are immutable.
       if (variable != closureData.thisLocal &&
           variable != closureData.closureElement) {
         // TODO(ngeoffray): only do this if the variable is mutated.

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

We should have an "isEffectivelyFinal" getter on variables.
Johnni already talked about it some time ago.

Merge the TODOs (here and in line 600) and ask Johnni if we can put his ldap
into the TODO.

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

Done.

-        closureData.usedVariablesInTry.add(variable);
+        closureData.variablesUsedInTryOrGenerator.add(variable);
       }
+    } else if (variable is LocalParameterElement &&
+        variable.functionDeclaration.asyncMarker == AsyncMarker.SYNC_STAR) {
+      // Parameters in a sync* function are shared between each Iterator created
+      // by the Iterable returned by the function, therefore they must be boxed.
+      // TODO(sigurdm): only do this if the variable is mutated.
+      closureData.variablesUsedInTryOrGenerator.add(variable);
     }
   }
 
   void useTypeVariableAsLocal(TypeVariableType typeVariable) {
     useLocal(new TypeVariableLocal(typeVariable, outermostElement));
   }
 
   void declareLocal(LocalVariableElement element) {
     scopeVariables.add(element);
   }
@@ skipping 423 matching lines @@
 
   String get name => typeVariable.name;
 
   int get hashCode => typeVariable.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableLocal) return false;
     return typeVariable == other.typeVariable;
   }
 }