Remove use of Compiler in inferrer engines.

pkg/compiler/lib/src/inferrer/kernel_inferrer_engine.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
+import '../../compiler_new.dart';
 import '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
+import '../js_backend/annotations.dart';
+import '../js_backend/mirrors_data.dart';
+import '../js_backend/no_such_method_registry.dart';
 import '../js_model/locals.dart';
 import '../kernel/element_map.dart';
 import '../options.dart';
 import '../types/types.dart';
 import '../world.dart';
 import 'builder_kernel.dart';
 import 'inferrer_engine.dart';
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
@@ skipping 10 matching lines @@
       this._globalLocalsMap,
       this._closureDataLookup,
       ClosedWorld closedWorld,
       ClosedWorldRefiner closedWorldRefiner,
       {bool disableTypeInference: false})
       : super(closedWorld, closedWorldRefiner,
             disableTypeInference: disableTypeInference);
 
   @override
   InferrerEngine<ir.Node> createInferrerEngineFor(FunctionEntity main) {
-    return new KernelInferrerEngine(_compiler, _elementMap, _globalLocalsMap,
-        _closureDataLookup, closedWorld, closedWorldRefiner, main);
+    return new KernelInferrerEngine(
+        _compiler.options,
+        _compiler.progress,
+        _compiler.reporter,
+        _compiler.outputProvider,
+        _compiler.backend.optimizerHints,
+        _elementMap,
+        _globalLocalsMap,
+        _closureDataLookup,
+        closedWorld,
+        closedWorldRefiner,
+        _compiler.backend.mirrorsData,
+        _compiler.backend.noSuchMethodRegistry,
+        main);
   }
 
   @override
   GlobalTypeInferenceResults createResults() {
     return new KernelGlobalTypeInferenceResults(this, closedWorld);
   }
 }
 
 class KernelGlobalTypeInferenceResults
     extends GlobalTypeInferenceResults<ir.Node> {
@@ skipping 15 matching lines @@
   }
 
   GlobalTypeInferenceParameterResult<ir.Node> createParameterResult(
       TypeGraphInferrer<ir.Node> inferrer, Local parameter) {
     return new GlobalTypeInferenceParameterResultImpl<ir.Node>(
         parameter, inferrer, dynamicType);
   }
 }
 
 class KernelInferrerEngine extends InferrerEngineImpl<ir.Node> {
-  final CompilerOptions _options;
   final KernelToElementMapForBuilding _elementMap;
   final GlobalLocalsMap _globalLocalsMap;
   final ClosureDataLookup<ir.Node> _closureDataLookup;
 
   KernelInferrerEngine(
-      Compiler compiler,
+      CompilerOptions options,
+      Progress progress,
+      DiagnosticReporter reporter,
+      CompilerOutput compilerOutput,
+      OptimizerHintsForTests optimizerHints,
       this._elementMap,
       this._globalLocalsMap,
       this._closureDataLookup,
       ClosedWorld closedWorld,
       ClosedWorldRefiner closedWorldRefiner,
+      MirrorsData mirrorsData,
+      NoSuchMethodRegistry noSuchMethodRegistry,
       FunctionEntity mainElement)
-      : this._options = compiler.options,
-        super(
-            compiler,
+      : super(
+            options,
+            progress,
+            reporter,
+            compilerOutput,
+            optimizerHints,
             closedWorld,
             closedWorldRefiner,
+            mirrorsData,
+            noSuchMethodRegistry,
             mainElement,
             new KernelTypeSystemStrategy(
                 _elementMap, _globalLocalsMap, _closureDataLookup));
 
   ElementEnvironment get _elementEnvironment => _elementMap.elementEnvironment;
 
   @override
   ConstantValue getFieldConstant(FieldEntity field) {
     return _elementMap.getFieldConstantValue(field);
   }
 
   @override
   bool isFieldInitializerPotentiallyNull(
       FieldEntity field, ir.Node initializer) {
     // TODO(johnniwinther): Implement the ad-hoc check in ast inferrer?
     return true;
   }
 
   @override
   TypeInformation computeMemberTypeInformation(
       MemberEntity member, ir.Node body) {
     KernelTypeGraphBuilder visitor = new KernelTypeGraphBuilder(
-        _options, closedWorld, _closureDataLookup, this, member, body);
+        options, closedWorld, _closureDataLookup, this, member, body);
     return visitor.run();
   }
 
   @override
   FunctionEntity lookupCallMethod(ClassEntity cls) {
     throw new UnimplementedError('KernelInferrerEngine.lookupCallMethod');
   }
 
   @override
   ir.Node computeMemberBody(MemberEntity member) {
@@ skipping 171 matching lines @@
       ConstructorEntity constructor = member;
       if (constructor.isFactoryConstructor) {
         DartType type = _elementEnvironment.getFunctionType(constructor);
         return new FactoryConstructorTypeInformation(constructor, type);
       } else {
         return new GenerativeConstructorTypeInformation(constructor);
       }
     }
   }
 }