Use entity WorldImpl where possible

tests/compiler/dart2js/kernel/closed_world2_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.
 
 // Partial test that the closed world computed from [WorldImpact]s derived from
 // kernel is equivalent to the original computed from resolution.
 library dart2js.kernel.closed_world2_test;
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/closure.dart';
@@ skipping 57 matching lines @@
           Flags.useKernel,
           Flags.enableAssertMessage
         ]);
     ElementResolutionWorldBuilder.useInstantiationMap = true;
     compiler.resolution.retainCachesForTesting = true;
     await compiler.run(entryPoint);
     compiler.resolutionWorldBuilder.closeWorld(compiler.reporter);
 
     KernelWorldBuilder worldBuilder = new KernelWorldBuilder(
         compiler.reporter, compiler.backend.kernelTask.program);
-    List list = createKernelResolutionEnqueuerListener(
-        compiler.options, compiler.deferredLoadTask, worldBuilder);
+    List list = createKernelResolutionEnqueuerListener(compiler.options,
+        compiler.reporter, compiler.deferredLoadTask, worldBuilder);
     ResolutionEnqueuerListener resolutionEnqueuerListener = list[0];
     ImpactTransformer impactTransformer = list[1];
     ResolutionEnqueuer enqueuer = new ResolutionEnqueuer(
         compiler.enqueuer,
         compiler.options,
         compiler.reporter,
         const TreeShakingEnqueuerStrategy(),
         resolutionEnqueuerListener,
         new KernelResolutionWorldBuilder(
             worldBuilder.elementEnvironment,
             worldBuilder.commonElements,
             new NativeBasicDataImpl(),
             const OpenWorldStrategy()),
         new KernelWorkItemBuilder(worldBuilder, impactTransformer),
         'enqueuer from kelements');
 
     computeClosedWorld(
         compiler.reporter, enqueuer, worldBuilder.elementEnvironment);
   });
 }
 
-List createKernelResolutionEnqueuerListener(CompilerOptions options,
-    DeferredLoadTask deferredLoadTask, KernelWorldBuilder worldBuilder) {
+List createKernelResolutionEnqueuerListener(
+    CompilerOptions options,
+    DiagnosticReporter reporter,
+    DeferredLoadTask deferredLoadTask,
+    KernelWorldBuilder worldBuilder) {
   ElementEnvironment elementEnvironment = worldBuilder.elementEnvironment;
   CommonElements commonElements = worldBuilder.commonElements;
   BackendHelpers helpers =
       new BackendHelpers(elementEnvironment, commonElements);
   BackendImpacts impacts = new BackendImpacts(options, commonElements, helpers);
 
   // TODO(johnniwinther): Create Kernel based implementations for these:
   NativeBasicData nativeBasicData = new NativeBasicDataImpl();
   RuntimeTypesNeedBuilder rtiNeedBuilder = new RuntimeTypesNeedBuilderImpl();
   MirrorsDataBuilder mirrorsDataBuilder = new MirrorsDataBuilderImpl();
   CustomElementsResolutionAnalysis customElementsResolutionAnalysis =
       new CustomElementsResolutionAnalysisImpl();
-  LookupMapResolutionAnalysis lookupMapResolutionAnalysis =
-      new LookupMapResolutionAnalysisImpl();
   MirrorsResolutionAnalysis mirrorsResolutionAnalysis =
       new MirrorsResolutionAnalysisImpl();
 
+  LookupMapResolutionAnalysis lookupMapResolutionAnalysis =
+      new LookupMapResolutionAnalysis(reporter, elementEnvironment);
   BackendClasses backendClasses = new JavaScriptBackendClasses(
       elementEnvironment, helpers, nativeBasicData);
   InterceptorDataBuilder interceptorDataBuilder =
       new InterceptorDataBuilderImpl(
           nativeBasicData, helpers, elementEnvironment, commonElements);
   BackendUsageBuilder backendUsageBuilder =
       new BackendUsageBuilderImpl(commonElements, helpers);
   NoSuchMethodRegistry noSuchMethodRegistry = new NoSuchMethodRegistry(
       helpers, new KernelNoSuchMethodResolver(worldBuilder));
   NativeResolutionEnqueuer nativeResolutionEnqueuer =
@@ skipping 135 matching lines @@
   @override
   void registerStaticUse(MemberEntity element) {}
 
   @override
   void registerInstantiatedClass(ClassEntity classElement) {}
 
   @override
   void registerTypeLiteral(DartType type) {}
 }
 
-class LookupMapResolutionAnalysisImpl implements LookupMapResolutionAnalysis {
-  @override
-  FieldEntity lookupMapVersionVariable;
-  @override
-  LibraryEntity lookupMapLibrary;
-
-  @override
-  WorldImpact flush() {
-    // TODO(johnniwinther): Implement this.
-    return const WorldImpact();
-  }
-
-  @override
-  void init(LibraryEntity library) {}
-}
-
 class MirrorsResolutionAnalysisImpl implements MirrorsResolutionAnalysis {
   @override
   void onQueueEmpty(Enqueuer enqueuer, Iterable<ClassEntity> recentClasses) {}
 
   @override
   MirrorsCodegenAnalysis close() {
     throw new UnimplementedError('MirrorsResolutionAnalysisImpl.close');
   }
 
   @override
@@ skipping 18 matching lines @@
   final MemberEntity element;
 
   KernelWorkItem(this._worldBuilder, this._impactTransformer, this.element);
 
   @override
   WorldImpact run() {
     ResolutionImpact impact = _worldBuilder.computeWorldImpact(element);
     return _impactTransformer.transformResolutionImpact(impact);
   }
 }