Roll kernel to latest

tests/compiler/dart2js/kernel/impact_test.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 dart2js.kernel.impact_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/registry.dart';
 import 'package:compiler/src/ssa/kernel_impact.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
+import 'package:compiler/src/universe/call_structure.dart';
 import 'package:compiler/src/universe/feature.dart';
 import 'package:compiler/src/universe/use.dart';
 import 'package:expect/expect.dart';
 import '../memory_compiler.dart';
 import '../serialization/test_helper.dart';
 
 const Map<String, String> SOURCE = const <String, String>{
   'main.dart': r'''
 import 'helper.dart';
 
@@ skipping 27 matching lines @@
   testPreInc(null);
   testPreDec(null);
   testIs(null);
   testIsGeneric(null);
   testIsGenericRaw(null);
   testIsGenericDynamic(null);
   testIsNot(null);
   testIsNotGeneric(null);
   testIsNotGenericRaw(null);
   testIsNotGenericDynamic(null);
+  testIsTypedef(null);
+  testIsTypedefGeneric(null);
+  testIsTypedefGenericRaw(null);
+  testIsTypedefGenericDynamic(null);
   testAs(null);
   testAsGeneric(null);
   testAsGenericRaw(null);
   testAsGenericDynamic(null);
   testThrow();
   testSyncStar();
   testAsync();
   testAsyncStar();
   testIfThen();
   testIfThenElse();
   testForIn(null);
   testForInTyped(null);
   testAsyncForIn(null);
   testAsyncForInTyped(null);
   testTryCatch();
   testTryCatchOn();
   testTryCatchStackTrace();
   testTryFinally();
+  testSwitchWithoutFallthrough(null);
+  testSwitchWithFallthrough(null);
   testTopLevelInvoke();
   testTopLevelInvokeTyped();
   testTopLevelFunctionTyped();
   testTopLevelFunctionGet();
   testTopLevelGetterGet();
   testTopLevelGetterGetTyped();
   testTopLevelSetterSet();
   testTopLevelSetterSetTyped();
   testTopLevelField();
   testTopLevelFieldLazy();
@@ skipping 66 matching lines @@
 testPreDec(o) => --o;
 
 testIs(o) => o is Class;
 testIsGeneric(o) => o is GenericClass<int, String>;
 testIsGenericRaw(o) => o is GenericClass;
 testIsGenericDynamic(o) => o is GenericClass<dynamic, dynamic>;
 testIsNot(o) => o is! Class;
 testIsNotGeneric(o) => o is! GenericClass<int, String>;
 testIsNotGenericRaw(o) => o is! GenericClass;
 testIsNotGenericDynamic(o) => o is! GenericClass<dynamic, dynamic>;
+testIsTypedef(o) => o is Typedef;
+testIsTypedefGeneric(o) => o is GenericTypedef<int, String>;
+testIsTypedefGenericRaw(o) => o is GenericTypedef;
+testIsTypedefGenericDynamic(o) => o is GenericTypedef<dynamic, dynamic>;
 testAs(o) => o as Class;
 testAsGeneric(o) => o as GenericClass<int, String>;
 testAsGenericRaw(o) => o as GenericClass;
 testAsGenericDynamic(o) => o as GenericClass<dynamic, dynamic>;
 testThrow() => throw '';
 
 testSyncStar() sync* {}
 testAsync() async {}
 testAsyncStar() async* {}
 testIfThen() {
@@ skipping 24 matching lines @@
 }
 testTryCatchOn() {
   try {} on String catch (e) {}
 }
 testTryCatchStackTrace() {
   try {} catch (e, s) {}
 }
 testTryFinally() {
   try {} finally {}
 }
+testSwitchWithoutFallthrough(o) {
+  switch (o) {
+  case 0:
+  case 1:
+    o = 2;
+    break;
+  case 2:
+    o = 3;
+    return;
+  case 3:
+  default:
+  }
+}
+testSwitchWithFallthrough(o) {
+  switch (o) {
+  case 0:
+  case 1:
+    o = 2;
+  case 2:
+    o = 3;
+    return;
+  case 3:
+  default:
+  }
+}
 topLevelFunction1(a) {}
 topLevelFunction2(a, [b, c]) {}
 topLevelFunction3(a, {b, c}) {}
 testTopLevelInvoke() {
   topLevelFunction1(0);
   topLevelFunction2(1);
   topLevelFunction2(2, 3);
   topLevelFunction2(4, 5, 6);
   topLevelFunction3(7);
   topLevelFunction3(8, b: 9);
@@ skipping 146 matching lines @@
 class Class {
   Class.generative();
   factory Class.fact() => null;
   factory Class.redirect() = Class.generative;
 }
 class GenericClass<X, Y> {
   GenericClass.generative();
   factory GenericClass.fact() => null;
   factory GenericClass.redirect() = GenericClass.generative;
 }
+typedef Typedef();
+typedef X GenericTypedef<X, Y>(Y y);
 ''',
 };
 
 main(List<String> args) {
   asyncTest(() async {
     enableDebugMode();
     Uri entryPoint = Uri.parse('memory:main.dart');
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: SOURCE,
@@ skipping 15 matching lines @@
     } else if (element.isTypedef) {
       // Skip typedefs.
     } else {
       checkElement(compiler, element);
     }
   });
 }
 
 void checkElement(Compiler compiler, AstElement element) {
   ResolutionImpact astImpact = compiler.resolution.getResolutionImpact(element);
-  astImpact = laxImpact(element, astImpact);
+  astImpact = laxImpact(compiler, element, astImpact);
   ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
   Expect.isNotNull(kernelImpact, 'No impact computed for $element');
   testResolutionImpactEquivalence(
       astImpact, kernelImpact, const CheckStrategy());
 }
 
 /// Lax the precision of [impact] to meet expectancy of the corresponding impact
 /// generated from kernel.
-ResolutionImpact laxImpact(AstElement element, ResolutionImpact impact) {
+ResolutionImpact laxImpact(
+    Compiler compiler, AstElement element, ResolutionImpact impact) {
   ResolutionWorldImpactBuilder builder =
       new ResolutionWorldImpactBuilder('Lax impact of ${element}');
   impact.staticUses.forEach(builder.registerStaticUse);
   impact.dynamicUses.forEach(builder.registerDynamicUse);
-  impact.typeUses.forEach(builder.registerTypeUse);
+  for (TypeUse typeUse in impact.typeUses) {
+    if (typeUse.type.isTypedef) {
+      typeUse = new TypeUse.internal(typeUse.type.unaliased, typeUse.kind);
+    }
+    builder.registerTypeUse(typeUse);
+  }
   impact.constantLiterals.forEach(builder.registerConstantLiteral);
   impact.constSymbolNames.forEach(builder.registerConstSymbolName);
   impact.listLiterals.forEach(builder.registerListLiteral);
   impact.mapLiterals.forEach(builder.registerMapLiteral);
   for (Feature feature in impact.features) {
-    builder.registerFeature(feature);
     switch (feature) {
       case Feature.STRING_INTERPOLATION:
       case Feature.STRING_JUXTAPOSITION:
         // These are both converted into a string concatenation in kernel so
         // we cannot tell the diferrence.
         builder.registerFeature(Feature.STRING_INTERPOLATION);
         builder.registerFeature(Feature.STRING_JUXTAPOSITION);
         break;
+      case Feature.FALL_THROUGH_ERROR:
+        LibraryElement library =
+            compiler.libraryLoader.lookupLibrary(Uris.dart_core);
+        ClassElement cls =
+            library.implementation.localLookup('FallThroughError');
+        ConstructorElement constructor = cls.lookupConstructor('');
+        builder.registerTypeUse(new TypeUse.instantiation(cls.thisType));
+        builder.registerStaticUse(new StaticUse.constructorInvoke(
+            constructor, CallStructure.NO_ARGS));
+        builder.registerFeature(Feature.THROW_EXPRESSION);
+        break;
       default:
+        builder.registerFeature(feature);
+        break;
     }
   }
   impact.nativeData.forEach(builder.registerNativeData);
   return builder;
 }