Handle constructor invocation, is, as, throw, for-in and (a)sync(*) in kernel_impact

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';
@@ skipping 36 matching lines @@
   testEmptyMapLiteralTyped();
   testEmptyMapLiteralConstant();
   testNonEmptyMapLiteral();
   testNot();
   testUnaryMinus();
   testConditional();
   testPostInc(null);
   testPostDec(null);
   testPreInc(null);
   testPreDec(null);
+  testIs(null);
+  testIsGeneric(null);
+  testIsGenericRaw(null);
+  testIsGenericDynamic(null);
+  testIsNot(null);
+  testIsNotGeneric(null);
+  testIsNotGenericRaw(null);
+  testIsNotGenericDynamic(null);
+  testAs(null);
+  testAsGeneric(null);
+  testAsGenericRaw(null);
+  testAsGenericDynamic(null);
+  testThrow();
+  testSyncStar();
+  testAsync();
+  testAsyncStar();
   testIfThen();
   testIfThenElse();
+  testForIn(null);
+  testForInTyped(null);
+  testAsyncForIn(null);
+  testAsyncForInTyped(null);
   testTopLevelInvoke();
   testTopLevelInvokeTyped();
   testTopLevelFunctionTyped();
   testTopLevelFunctionGet();
   testTopLevelField();
   testTopLevelFieldLazy();
   testTopLevelFieldConst();
   testTopLevelFieldFinal();
   testTopLevelFieldTyped();
   testTopLevelFieldGeneric1();
   testTopLevelFieldGeneric2();
   testTopLevelFieldGeneric3();
   testDynamicInvoke(null);
   testDynamicGet(null);
   testDynamicSet(null);
   testLocalWithoutInitializer();
   testLocalWithInitializer();
   testLocalWithInitializerTyped();
   testLocalFunction();
   testLocalFunctionTyped();
   testLocalFunctionInvoke();
   testLocalFunctionGet();
   testClosure();
   testClosureInvoke();
   testInvokeIndex(null);
   testInvokeIndexSet(null);
   testAssert();
   testAssertWithMessage();
+  testConstructorInvoke();
+  testConstructorInvokeGeneric();
+  testConstructorInvokeGenericRaw();
+  testConstructorInvokeGenericDynamic();
   testFactoryInvoke();
   testFactoryInvokeGeneric();
   testFactoryInvokeGenericRaw();
   testFactoryInvokeGenericDynamic();
   testRedirectingFactoryInvoke();
   testRedirectingFactoryInvokeGeneric();
   testRedirectingFactoryInvokeGenericRaw();
   testRedirectingFactoryInvokeGenericDynamic();
 }
 
@@ skipping 20 matching lines @@
 testEmptyMapLiteralTyped() => <String, int>{};
 testEmptyMapLiteralConstant() => const {};
 testNonEmptyMapLiteral() => {0: true};
 testNot() => !false;
 testUnaryMinus() => -1;
 testConditional() => true ? 1 : '';
 testPostInc(o) => o++;
 testPostDec(o) => o--;
 testPreInc(o) => ++o;
 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>;
+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() {
   if (false) return 42;
   return 1;
 }
 testIfThenElse() {
   if (true) {
     return 42;
   } else {
     return 1;
   }
 }
+testForIn(o) {
+  for (var e in o) {}
+}
+testForInTyped(o) {
+  for (int e in o) {}
+}
+testAsyncForIn(o) async {
+  await for (var e in o) {}
+}
+testAsyncForInTyped(o) async {
+  await for (int e in o) {}
+}
 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 90 matching lines @@
   () {} ();
 }
 testInvokeIndex(o) => o[42];
 testInvokeIndexSet(o) => o[42] = null;
 testAssert() {
   assert(true);
 }
 testAssertWithMessage() {
   assert(true, 'ok');
 }
+testConstructorInvoke() {
+  new Class.generative();
+}
+testConstructorInvokeGeneric() {
+  new GenericClass<int, String>.generative();
+}
+testConstructorInvokeGenericRaw() {
+  new GenericClass.generative();
+}
+testConstructorInvokeGenericDynamic() {
+  new GenericClass<dynamic, dynamic>.generative();
+}
 testFactoryInvoke() {
   new Class.fact();
 }
 testFactoryInvokeGeneric() {
   new GenericClass<int, String>.fact();
 }
 testFactoryInvokeGenericRaw() {
   new GenericClass.fact();
 }
 testFactoryInvokeGenericDynamic() {
@@ skipping 41 matching lines @@
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
     checkLibrary(compiler, compiler.mainApp);
   });
 }
 
 void checkLibrary(Compiler compiler, LibraryElement library) {
   library.forEachLocalMember((AstElement element) {
     if (element.isClass) {
       // TODO(johnniwinther): Handle class members.
+    } 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);
   ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
@@ skipping 23 matching lines @@
         // we cannot tell the diferrence.
         builder.registerFeature(Feature.STRING_INTERPOLATION);
         builder.registerFeature(Feature.STRING_JUXTAPOSITION);
         break;
       default:
     }
   }
   impact.nativeData.forEach(builder.registerNativeData);
   return builder;
 }