Implement canonical name scheme in kernel.

pkg/kernel/lib/transformations/continuation.dart

 // Copyright (c) 2016, 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 kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../core_types.dart';
@@ skipping 99 matching lines @@
       [asyncJumpVariable, asyncContextVariable]
         ..addAll(createCapturedTryVariables())
         ..addAll(createCapturedCatchVariables());
 }
 
 class SyncStarFunctionRewriter extends ContinuationRewriterBase {
   final VariableDeclaration iteratorVariable;
 
   SyncStarFunctionRewriter(helper, enclosingFunction)
       : iteratorVariable = new VariableDeclaration(':iterator')
-            ..type = helper.iteratorClass.rawType,
+          ..type = helper.iteratorClass.rawType,
         super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     // :sync_body(:iterator) {
     //     modified <node.body>;
     // }
     final nestedClosureVariable = new VariableDeclaration(":sync_op");
     final function = new FunctionNode(buildClosureBody(),
         positionalParameters: [iteratorVariable],
         requiredParameterCount: 1,
@@ skipping 18 matching lines @@
     enclosingFunction.asyncMarker = AsyncMarker.Sync;
     return enclosingFunction;
   }
 
   Statement buildClosureBody() {
     // The body will insert calls to
     //    :iterator.current_=
     //    :iterator.isYieldEach=
     // and return `true` as long as it did something and `false` when it's done.
     return new Block(<Statement>[
-        enclosingFunction.body.accept(this),
-        new ReturnStatement(new BoolLiteral(false))
+      enclosingFunction.body.accept(this),
+      new ReturnStatement(new BoolLiteral(false))
     ]);
   }
 
   visitYieldStatement(YieldStatement node) {
     var transformedExpression = node.expression.accept(this);
 
     var statements = <Statement>[];
     if (node.isYieldStar) {
       var markYieldEach = new ExpressionStatement(new PropertySet(
           new VariableGet(iteratorVariable),
@@ skipping 608 matching lines @@
         if (future_type.typeArguments.length == 0) {
           returnType = const DynamicType();
         } else if (future_type.typeArguments.length == 1) {
           returnType = future_type.typeArguments[0];
         } else {
           returnType = const InvalidType();
         }
       }
     }
     var completerTypeArguments = <DartType>[returnType];
-    var completerType = new InterfaceType(
-        helper.completerClass, completerTypeArguments);
+    var completerType =
+        new InterfaceType(helper.completerClass, completerTypeArguments);
 
     // final Completer<T> :completer = new Completer<T>.sync();
     completerVariable = new VariableDeclaration(":completer",
         initializer: new StaticInvocation(helper.completerConstructor,
             new Arguments([], types: completerTypeArguments))
           ..fileOffset = enclosingFunction.body.fileOffset,
         isFinal: true,
         type: completerType);
     statements.add(completerVariable);
 
-    returnVariable = new VariableDeclaration(
-        ":return_value", type: returnType);
+    returnVariable = new VariableDeclaration(":return_value", type: returnType);
     statements.add(returnVariable);
 
     setupAsyncContinuations(statements);
 
     // new Future.microtask(:async_op);
     var newMicrotaskStatement = new ExpressionStatement(new StaticInvocation(
         helper.futureMicrotaskConstructor,
         new Arguments([new VariableGet(nestedClosureVariable)],
             types: [const DynamicType()]))
       ..fileOffset = enclosingFunction.fileOffset);
@@ skipping 157 matching lines @@
         findConstructor(syncIterableClass, ''),
         findConstructor(streamIteratorClass, ''),
         findFactoryConstructor(futureClass, 'microtask'),
         findConstructor(streamControllerClass, ''),
         findProcedure(asyncLibrary, '_asyncThenWrapperHelper'),
         findProcedure(asyncLibrary, '_asyncErrorWrapperHelper'),
         findProcedure(asyncLibrary, '_awaitHelper'),
         new CoreTypes(program));
   }
 }