Split KernelToElementMap mixins to match interfaces

pkg/compiler/lib/src/kernel/element_map_impl.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.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 23 matching lines @@
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/class_set.dart';
 import '../universe/function_set.dart';
 import '../universe/selector.dart';
 import '../universe/world_builder.dart';
 import '../world.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_map.dart';
+import 'element_map_mixins.dart';
 import 'elements.dart';
 
 part 'native_basic_data.dart';
 part 'no_such_method_resolver.dart';
 part 'types.dart';
 
 /// Interface for kernel queries needed to implement the [CodegenWorldBuilder].
 abstract class KernelToWorldBuilder implements KernelToElementMapForBuilding {
   /// Returns `true` if [field] has a constant initializer.
   bool hasConstantFieldInitializer(FieldEntity field);
 
   /// Returns the constant initializer for [field].
   ConstantValue getConstantFieldInitializer(FieldEntity field);
 
   /// Calls [f] for each parameter of [function] providing the type and name of
   /// the parameter and the [defaultValue] if the parameter is optional.
   void forEachParameter(FunctionEntity function,
       void f(DartType type, String name, ConstantValue defaultValue));
 }
 
+abstract class KernelToElementMapBase extends KernelToElementMapBaseMixin {}
+
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
-class KernelToElementMapImpl extends KernelToElementMapMixin
-    implements KernelToWorldBuilder, KernelToElementMapForImpact {
+class KernelToElementMapImpl extends KernelToElementMapBase
+    with KernelToElementMapForBuildingMixin, KernelToElementMapForImpactMixin
+    implements KernelToWorldBuilder {
   final Environment _environment;
   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
   KernelConstantEnvironment _constantEnvironment;
   _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
@@ skipping 1696 matching lines @@
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(redemption): Compute this.
     return false;
   }
 }
 
-class JsKernelToElementMap extends KernelToElementMapMixin
+class JsKernelToElementMap extends KernelToElementMapBase
+    with KernelToElementMapForBuildingMixin
     implements KernelToWorldBuilder {
   final JsToFrontendMap _map;
   final ElementEnvironment _elementEnvironment;
   final CommonElements _commonElements;
   final KernelToElementMapImpl _elementMap;
 
   JsKernelToElementMap(this._map, this._elementEnvironment,
       this._commonElements, this._elementMap);
 
   @override
@@ skipping 85 matching lines @@
     return _commonElements;
   }
 
   @override
   ConstantValue computeConstantValue(ConstantExpression constant,
       {bool requireConstant: true}) {
     throw new UnsupportedError("JsKernelToElementMap.computeConstantValue");
   }
 
   @override
-  native.BehaviorBuilder get nativeBehaviorBuilder {
-    throw new UnsupportedError("JsKernelToElementMap.nativeBehaviorBuilder");
-  }
-
-  @override
   DiagnosticReporter get reporter {
     return _elementMap.reporter;
   }
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     throw new UnsupportedError("JsKernelToElementMap.getFieldConstantValue");
   }
 
   @override
   void forEachParameter(FunctionEntity function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     throw new UnsupportedError("JsKernelToElementMap.forEachParameter");
   }
 
   @override
   ConstantValue getConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }