Add KernelWorldBuilder and KElement model.

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 '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/constants/expressions.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/elements.dart';
+import 'package:compiler/src/js_backend/backend.dart';
+import 'package:compiler/src/kernel/world_builder.dart';
+import 'package:compiler/src/kernel/element_adapter.dart';
 import 'package:compiler/src/resolution/registry.dart';
 import 'package:compiler/src/resolution/tree_elements.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 'package:kernel/ast.dart' as ir;
 import '../memory_compiler.dart';
 import '../serialization/test_helper.dart';
 
 const Map<String, String> SOURCE = const <String, String>{
   'main.dart': r'''
 import 'helper.dart';
 import 'dart:html';
 
 main() {
   testEmpty();
@@ skipping 587 matching lines @@
     Compiler compiler = compilerFor(
         entryPoint: entryPoint,
         memorySourceFiles: SOURCE,
         options: [
           fullTest ? Flags.analyzeAll : Flags.analyzeOnly,
           Flags.useKernel,
           Flags.enableAssertMessage
         ]);
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
-    checkLibrary(compiler, compiler.mainApp, fullTest: fullTest);
+    JavaScriptBackend backend = compiler.backend;
+    KernelElementAdapter kernelElementAdapter =
+        new KernelWorldBuilder(compiler.reporter, backend.kernelTask.program);
+
+    checkLibrary(compiler, kernelElementAdapter, compiler.mainApp,
+        fullTest: fullTest);
     if (fullTest) {
       // TODO(johnniwinther): Handle all libraries for `!fullTest`.
       compiler.libraryLoader.libraries.forEach((LibraryElement library) {
         if (library == compiler.mainApp) return;
-        checkLibrary(compiler, library, fullTest: fullTest);
+        checkLibrary(compiler, kernelElementAdapter, library,
+            fullTest: fullTest);
       });
     }
   });
 }
 
-void checkLibrary(Compiler compiler, LibraryElement library,
+void checkLibrary(Compiler compiler, KernelElementAdapter kernelElementAdapter,
+    LibraryElement library,
     {bool fullTest: false}) {
   library.forEachLocalMember((AstElement element) {
     if (element.isClass) {
       ClassElement cls = element;
       cls.forEachLocalMember((AstElement member) {
-        checkElement(compiler, member, fullTest: fullTest);
+        checkElement(compiler, kernelElementAdapter, member,
+            fullTest: fullTest);
       });
     } else if (element.isTypedef) {
       // Skip typedefs.
     } else {
-      checkElement(compiler, element, fullTest: fullTest);
+      checkElement(compiler, kernelElementAdapter, element, fullTest: fullTest);
     }
   });
 }
 
-void checkElement(Compiler compiler, AstElement element,
+void checkElement(Compiler compiler, KernelElementAdapter kernelElementAdapter,
+    AstElement element,
     {bool fullTest: false}) {
   if (!fullTest) {
     if (element.library.isPlatformLibrary) {
       // TODO(johnniwinther): Enqueue these elements for `!fullTest`.
       // Test only selected elements in web-related platform libraries since
       // this unittest otherwise takes too long to run.
       switch (element.library.canonicalUri.path) {
         case 'html':
           if ('$element' ==
               'function(_ValidatingTreeSanitizer#_sanitizeUntrustedElement)') {
@@ skipping 19 matching lines @@
   if (element.isConstructor) {
     ConstructorElement constructor = element;
     if (constructor.isRedirectingFactory) {
       // Skip redirecting constructors for now; they might not be supported.
       return;
     }
   }
   if (!fullTest && !compiler.resolution.hasResolutionImpact(element)) {
     return;
   }
-  ResolutionImpact astImpact = compiler.resolution.getResolutionImpact(element);
-  astImpact = laxImpact(compiler, element, astImpact);
-  ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
-  Expect.isNotNull(kernelImpact, 'No impact computed for $element');
-  testResolutionImpactEquivalence(
-      astImpact, kernelImpact, const CheckStrategy());
+  compiler.reporter.withCurrentElement(element.implementation, () {
+    ResolutionImpact astImpact =
+        compiler.resolution.getResolutionImpact(element);
+    astImpact = laxImpact(compiler, element, astImpact);
+    ResolutionImpact kernelImpact = build(compiler, element.resolvedAst);
+    ir.Member member = getIrMember(compiler, element.resolvedAst);
+    // TODO(johnniwinther): Check equivalence for the computed impact.
+    buildKernelImpact(member, kernelElementAdapter);
+    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(
     Compiler compiler, AstElement element, ResolutionImpact impact) {
   ResolutionWorldImpactBuilder builder =
       new ResolutionWorldImpactBuilder('Lax impact of ${element}');
   for (StaticUse staticUse in impact.staticUses) {
     switch (staticUse.kind) {
@@ skipping 119 matching lines @@
         visitList(type.optionalParameterTypes),
         type.namedParameters,
         visitList(type.namedParameterTypes));
   }
 }
 
 /// Perform unaliasing of all typedefs nested within a [ResolutionDartType].
 ResolutionDartType unalias(ResolutionDartType type) {
   return const Unaliaser().visit(type);
 }