[kernel] vm: Fix a few issues in the kernel flow graph builder, update status file for checked-mode

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 776 matching lines @@
       if (future_type.classNode == helper.futureClass) {
         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();
         }
       }
     }
+    // In an "Future<FooBar> foo() async {}" function the body can either return
+    // a "FooBar" or a "Future<FooBar>" => a "FutureOr<FooBar>".
+    returnType =
+        new InterfaceType(helper.futureOrClass, <DartType>[returnType]);
     var completerTypeArguments = <DartType>[returnType];
     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,
@@ skipping 57 matching lines @@
     statements.add(new BreakStatement(labeledBody));
     return null;
   }
 }
 
 class HelperNodes {
   final Library asyncLibrary;
   final Library coreLibrary;
   final Class iteratorClass;
   final Class futureClass;
+  final Class futureOrClass;
   final Class completerClass;
   final Procedure printProcedure;
   final Procedure completerConstructor;
   final Procedure futureMicrotaskConstructor;
   final Constructor streamControllerConstructor;
   final Constructor syncIterableConstructor;
   final Constructor streamIteratorConstructor;
   final Procedure asyncThenWrapper;
   final Procedure asyncErrorWrapper;
   final Procedure awaitHelper;
   final CoreTypes coreTypes;
 
   HelperNodes(
       this.asyncLibrary,
       this.coreLibrary,
       this.iteratorClass,
       this.futureClass,
+      this.futureOrClass,
       this.completerClass,
       this.printProcedure,
       this.completerConstructor,
       this.syncIterableConstructor,
       this.streamIteratorConstructor,
       this.futureMicrotaskConstructor,
       this.streamControllerConstructor,
       this.asyncThenWrapper,
       this.asyncErrorWrapper,
       this.awaitHelper,
       this.coreTypes);
 
   factory HelperNodes.fromProgram(Program program) {
     var coreTypes = new CoreTypes(program);
     return new HelperNodes(
         coreTypes.getLibrary('dart:async'),
         coreTypes.getLibrary('dart:core'),
         coreTypes.getClass('dart:core', 'Iterator'),
         coreTypes.getClass('dart:async', 'Future'),
+        coreTypes.getClass('dart:async', 'FutureOr'),
         coreTypes.getClass('dart:async', 'Completer'),
         coreTypes.getTopLevelMember('dart:core', 'print'),
         coreTypes.getMember('dart:async', 'Completer', 'sync'),
         coreTypes.getMember('dart:core', '_SyncIterable', ''),
         coreTypes.getMember('dart:async', '_StreamIterator', ''),
         coreTypes.getMember('dart:async', 'Future', 'microtask'),
         coreTypes.getMember('dart:async', '_AsyncStarStreamController', ''),
         coreTypes.getTopLevelMember('dart:async', '_asyncThenWrapperHelper'),
         coreTypes.getTopLevelMember('dart:async', '_asyncErrorWrapperHelper'),
         coreTypes.getTopLevelMember('dart:async', '_awaitHelper'),
         coreTypes);
   }
 }