Merge CommonElements and BackendHelpers!

pkg/compiler/lib/src/kernel/world_builder.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.
 
 library dart2js.kernel.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/backend_api.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
-import '../js_backend/backend_helpers.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../universe/call_structure.dart';
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
@@ skipping 37 matching lines @@
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<KField, ConstantExpression> _fieldConstantMap =
       <KField, ConstantExpression>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter, ir.Program program)
       : _env = new KEnv(program) {
     _elementEnvironment = new KernelElementEnvironment(this);
-    _commonElements = new CommonElementsImpl(_elementEnvironment);
+    _commonElements = new CommonElements(_elementEnvironment);
     ConstantEnvironment constants = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
-        new KernelBehaviorBuilder(_commonElements, helpers, constants);
+        new KernelBehaviorBuilder(_commonElements, constants);
     _typeConverter = new DartTypeConverter(this);
   }
 
   KMethod get _mainFunction {
     return _env.program.mainMethod != null
         ? _getMethod(_env.program.mainMethod)
         : null;
   }
 
   KLibrary get _mainLibrary {
@@ skipping 650 matching lines @@
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const DynamicType();
   }
 }
 
 /// [native.BehaviorBuilder] for kernel based elements.
 class KernelBehaviorBuilder extends native.BehaviorBuilder {
   final CommonElements commonElements;
-  final BackendHelpers helpers;
   final ConstantEnvironment constants;
 
-  KernelBehaviorBuilder(this.commonElements, this.helpers, this.constants);
+  KernelBehaviorBuilder(this.commonElements, this.constants);
 
   @override
   bool get trustJSInteropTypeAnnotations {
     throw new UnimplementedError(
         "KernelNativeBehaviorComputer.trustJSInteropTypeAnnotations");
   }
 
   @override
   DiagnosticReporter get reporter {
     throw new UnimplementedError("KernelNativeBehaviorComputer.reporter");
@@ skipping 125 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }