More features handled 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/common.dart';
 import 'package:compiler/src/commandline_options.dart';
@@ skipping 21 matching lines @@
   testEmptyListLiteralTyped();
   testEmptyListLiteralConstant();
   testNonEmptyListLiteral();
   testEmptyMapLiteral();
   testEmptyMapLiteralDynamic();
   testEmptyMapLiteralTyped();
   testEmptyMapLiteralConstant();
   testNonEmptyMapLiteral();
   testNot();
   testUnaryMinus();
+  testConditional();
+  testPostInc(null);
+  testPostDec(null);
+  testPreInc(null);
+  testPreDec(null);
   testIfThen();
   testIfThenElse();
   testTopLevelInvoke();
   testTopLevelInvokeTyped();
   testTopLevelField();
   testTopLevelFieldTyped();
+  testDynamicInvoke(null);
+  testDynamicGet(null);
+  testDynamicSet(null);
+  testLocalWithInitializer();
+  testInvokeIndex(null);
+  testInvokeIndexSet(null);
+  testAssert();
+  testAssertWithMessage();
 }
 
 testEmpty() {}
 testNull() => null;
 testTrue() => true;
 testFalse() => false;
 testInt() => 42;
 testDouble() => 37.5;
 testString() => 'foo';
 testSymbol() => #main;
 testEmptyListLiteral() => [];
 testEmptyListLiteralDynamic() => <dynamic>[];
 testEmptyListLiteralTyped() => <String>[];
 testEmptyListLiteralConstant() => const [];
 testNonEmptyListLiteral() => [0];
 testEmptyMapLiteral() => {};
 testEmptyMapLiteralDynamic() => <dynamic, dynamic>{};
 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;
 testIfThen() {
   if (false) return 42;
   return 1;
 }
 testIfThenElse() {
   if (true) {
     return 42;
   } else {
     return 1;
   }
@@ skipping 25 matching lines @@
   topLevelFunction3Typed(true);
   topLevelFunction3Typed(false, b: []);
   topLevelFunction3Typed(null, c: {});
   topLevelFunction3Typed(true, b: [13], c: {'14': true});
   topLevelFunction3Typed(false, c: {'16': false}, b: [17]);
 }
 var topLevelField;
 testTopLevelField() => topLevelField;
 int topLevelFieldTyped;
 testTopLevelFieldTyped() => topLevelFieldTyped;
+testDynamicInvoke(o) {
+  o.f1(0);
+  o.f2(1);
+  o.f3(2, 3);
+  o.f4(4, 5, 6);
+  o.f5(7);
+  o.f6(8, b: 9);
+  o.f7(10, c: 11);
+  o.f8(12, b: 13, c: 14);
+  o.f9(15, c: 16, b: 17);
+}
+testDynamicGet(o) => o.foo;
+testDynamicSet(o) => o.foo = 42;
+testLocalWithInitializer() {
+  var l = 42;
+}
+testInvokeIndex(o) => o[42];
+testInvokeIndexSet(o) => o[42] = null;
+testAssert() {
+  assert(true);
+}
+testAssertWithMessage() {
+  assert(true, 'ok');
+}
 '''
 };
 
 main(List<String> args) {
   asyncTest(() async {
     enableDebugMode();
     Uri entryPoint = Uri.parse('memory:main.dart');
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: SOURCE,
-        options: [Flags.analyzeOnly, Flags.useKernel]);
+        options:
+            [Flags.analyzeAll, Flags.useKernel, Flags.enableAssertMessage]);
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
-    compiler.mainApp
-        .forEachLocalMember((element) => checkElement(compiler, element));
+    checkLibrary(compiler, compiler.mainApp);
   });
 }
 
+void checkLibrary(Compiler compiler, LibraryElement library) {
+  library.forEachLocalMember((AstElement element) {
+    if (element.isClass) {
+      // TODO(johnniwinther): Handle class members.
+    } else {
+      checkElement(compiler, element);
+    }
+  });
+}
+
 void checkElement(Compiler compiler, AstElement element) {
   ResolutionImpact astImpact = compiler.resolution.getResolutionImpact(element);
   ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
   testResolutionImpactEquivalence(
       astImpact, kernelImpact, const CheckStrategy());
 }