Split KernelToElementMap into sub-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 30 matching lines @@
 import '../world.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_map.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 KernelToElementMap {
+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));
 }
 
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 class KernelToElementMapImpl extends KernelToElementMapMixin
-    implements KernelToWorldBuilder {
+    implements KernelToWorldBuilder, KernelToElementMapForImpact {
   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 1027 matching lines @@
 class _FunctionData extends _MemberData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
 
   _FunctionData(ir.Member node, this.functionNode) : super(node);
 
   FunctionType getFunctionType(KernelToElementMapImpl elementMap) {
     return _type ??= elementMap.getFunctionType(functionNode);
   }
 
-  void forEachParameter(KernelToElementMap elementMap,
+  void forEachParameter(KernelToElementMapForBuilding elementMap,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     void handleParameter(ir.VariableDeclaration node, {bool isOptional: true}) {
       DartType type = elementMap.getDartType(node.type);
       String name = node.name;
       ConstantValue defaultValue;
       if (isOptional) {
         if (node.initializer != null) {
           defaultValue = elementMap.getConstantValue(node.initializer);
         } else {
           defaultValue = new NullConstantValue();
@@ skipping 347 matching lines @@
 
   NativeBasicData get nativeBasicData {
     throw new UnimplementedError(
         "KernelNativeBehaviorComputer.nativeBasicData");
   }
 }
 
 /// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
 /// [_EvaluationEnvironment] for the evaluation.
 class KernelConstantEnvironment implements ConstantEnvironment {
-  KernelToElementMap _worldBuilder;
+  KernelToElementMapForBuilding _worldBuilder;
   Map<ConstantExpression, ConstantValue> _valueMap =
       <ConstantExpression, ConstantValue>{};
 
   KernelConstantEnvironment(this._worldBuilder);
 
   @override
   ConstantSystem get constantSystem => const JavaScriptConstantSystem();
 
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
@@ skipping 338 matching lines @@
   ir.Member getMemberNode(MemberEntity member) {
     return _elementMap.getMemberNode(_map.toFrontendMember(member));
   }
 
   @override
   MemberEntity getMember(ir.Member node) {
     return _map.toBackendMember(_elementMap.getMember(node));
   }
 
   @override
-  ConstructorEntity getSuperConstructor(

[Siggi Cherem (dart-lang), 2017/06/26 18:05:41]

this means that jstoelement-map doesn't need this?

[Johnni Winther, 2017/06/27 08:26:31]

I think it might. We haven't handled explicit super-constructor calls yet. We
re-insert it if necessary.

-      ir.Constructor constructor, ir.Member target) {
-    return _map
-        .toBackendMember(_elementMap.getSuperConstructor(constructor, target));
-  }
-
-  @override
   ConstructorEntity getConstructor(ir.Member node) {
     return _map.toBackendMember(_elementMap.getConstructor(node));
   }
 
   @override
   InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return _map
         .toBackendType(_elementMap.createInterfaceType(cls, typeArguments));
   }
@@ skipping 60 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }