Move implementation from KernelToElementMapImpl to *BaseImpl and *ForImpactImpl

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 44 matching lines @@
 
   /// 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 KernelToElementMapBase
-    with KernelToElementMapForBuildingMixin, KernelToElementMapForImpactMixin
-    implements KernelToWorldBuilder {
-  final Environment _environment;
+class KernelToElementMapBase extends KernelToElementMapBaseMixin {
+  final DiagnosticReporter reporter;
   CommonElements _commonElements;
-  native.BehaviorBuilder _nativeBehaviorBuilder;
-  final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
   KernelConstantEnvironment _constantEnvironment;
-  _KernelDartTypes _types;
 
   /// Library environment. Used for fast lookup.
   _KEnv _env = new _KEnv();
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
   List<_KLibraryEnv> _libraryEnvs = <_KLibraryEnv>[];
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<_KClassEnv> _classEnvs = <_KClassEnv>[];
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
 
   List<_MemberData> _memberList = <_MemberData>[];
 
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
-  KernelToElementMapImpl(this.reporter, this._environment) {
+  KernelToElementMapBase(this.reporter, Environment environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
-    _constantEnvironment = new KernelConstantEnvironment(this);
-    _nativeBehaviorBuilder = new KernelBehaviorBuilder(_commonElements);
-    _types = new _KernelDartTypes(this);
+    _constantEnvironment = new KernelConstantEnvironment(this, environment);
     _typeConverter = new DartTypeConverter(this);
   }
 
-  /// Adds libraries in [program] to the set of libraries.
-  ///
-  /// The main method of the first program is used as the main method for the
-  /// compilation.
-  void addProgram(ir.Program program) {
-    _env.addProgram(program);
-  }
+  @override
+  ElementEnvironment get elementEnvironment => _elementEnvironment;
+
+  @override
+  CommonElements get commonElements => _commonElements;
 
   KMethod get _mainFunction {
     return _env.mainMethod != null ? _getMethod(_env.mainMethod) : null;
   }
 
   KLibrary get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
   Iterable<LibraryEntity> get _libraries {
     if (_env.length != _libraryMap.length) {
       // Create a [KLibrary] for each library.
       _env.forEachLibrary((_KLibraryEnv env) {
         _getLibrary(env.library, env);
       });
     }
     return _libraryMap.values;
   }
 
-  @override
-  CommonElements get commonElements => _commonElements;
-
-  @override
-  ElementEnvironment get elementEnvironment => _elementEnvironment;
-
-  ConstantEnvironment get constantEnvironment => _constantEnvironment;
-
-  DartTypes get types => _types;
-
-  @override
-  native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
-
-  @override
-  ConstantValue computeConstantValue(ConstantExpression constant,
-      {bool requireConstant: true}) {
-    return _constantEnvironment.getConstantValue(constant);
-  }
-
-  @override
-  ConstantValue getFieldConstantValue(ir.Field field) {
-    // TODO(johnniwinther): Cache the result in [_FieldData].
-    return getConstantValue(field.initializer,
-        requireConstant: field.isConst, implicitNull: !field.isConst);
-  }
-
   LibraryEntity lookupLibrary(Uri uri) {
     _KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
-  KLibrary _getLibrary(ir.Library node, [_KLibraryEnv libraryEnv]) {
-    return _libraryMap.putIfAbsent(node, () {
-      Uri canonicalUri = node.importUri;
-      _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
-      String name = node.name;
-      if (name == null) {
-        // Use the file name as script name.
-        String path = canonicalUri.path;
-        name = path.substring(path.lastIndexOf('/') + 1);
-      }
-      return new KLibrary(_libraryMap.length, name, canonicalUri);
-    });
-  }
-
   String _getLibraryName(KLibrary library) {
     _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     return libraryEnv.library.name ?? '';
   }
 
   MemberEntity lookupLibraryMember(KLibrary library, String name,
       {bool setter: false}) {
     _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     ir.Member member = libraryEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
@@ skipping 30 matching lines @@
     ir.Member member = classEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   ConstructorEntity lookupConstructor(KClass cls, String name) {
     _KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupConstructor(name);
     return member != null ? getConstructor(member) : null;
   }
 
+  @override
+  InterfaceType createInterfaceType(
+      ir.Class cls, List<ir.DartType> typeArguments) {
+    return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
+  }
+
+  LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
+
+  KLibrary _getLibrary(ir.Library node, [_KLibraryEnv libraryEnv]) {
+    return _libraryMap.putIfAbsent(node, () {
+      Uri canonicalUri = node.importUri;
+      _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(canonicalUri));
+      String name = node.name;
+      if (name == null) {
+        // Use the file name as script name.
+        String path = canonicalUri.path;
+        name = path.substring(path.lastIndexOf('/') + 1);
+      }
+      return new KLibrary(_libraryMap.length, name, canonicalUri);
+    });
+  }
+
+  @override
+  ClassEntity getClass(ir.Class node) => _getClass(node);
+
   KClass _getClass(ir.Class node, [_KClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
       return new KClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
     });
   }
 
-  Iterable<ConstantValue> _getClassMetadata(KClass cls) {
-    return _classEnvs[cls.classIndex].getMetadata(this);
+  InterfaceType _getSuperType(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.supertype;
   }
 
+  void _ensureThisAndRawType(KClass cls, _KClassEnv env) {
+    if (env.thisType == null) {
+      ir.Class node = env.cls;
+      // TODO(johnniwinther): Add the type argument to the list literal when we
+      // no longer use resolution types.
+      if (node.typeParameters.isEmpty) {
+        env.thisType =
+            env.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+      } else {
+        env.thisType = new InterfaceType(
+            cls,
+            new List/*<DartType>*/ .generate(node.typeParameters.length,
+                (int index) {
+              return new TypeVariableType(
+                  _getTypeVariable(node.typeParameters[index]));
+            }));
+        env.rawType = new InterfaceType(
+            cls,
+            new List/*<DartType>*/ .filled(
+                node.typeParameters.length, const DynamicType()));
+      }
+    }
+  }
+
+  TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
+      _getTypeVariable(node);
+
   KTypeVariable _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         return new KTypeVariable(_getClass(cls), node.name, index);
       }
       if (node.parent is ir.FunctionNode) {
         ir.FunctionNode func = node.parent;
         int index = func.typeParameters.indexOf(node);
         if (func.parent is ir.Constructor) {
           ir.Constructor constructor = func.parent;
           ir.Class cls = constructor.enclosingClass;
           return _getTypeVariable(cls.typeParameters[index]);
         }
         if (func.parent is ir.Procedure) {
           ir.Procedure procedure = func.parent;
           if (procedure.kind == ir.ProcedureKind.Factory) {
             ir.Class cls = procedure.enclosingClass;
             return _getTypeVariable(cls.typeParameters[index]);
           } else {
             return new KTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
-  ParameterStructure _getParameterStructure(ir.FunctionNode node) {
-    // TODO(johnniwinther): Cache the computed function type.
-    int requiredParameters = node.requiredParameterCount;
-    int positionalParameters = node.positionalParameters.length;
-    List<String> namedParameters =
-        node.namedParameters.map((p) => p.name).toList()..sort();
-    return new ParameterStructure(
-        requiredParameters, positionalParameters, namedParameters);
+  void _ensureSupertypes(KClass cls, _KClassEnv env) {
+    if (env.orderedTypeSet == null) {
+      _ensureThisAndRawType(cls, env);
+
+      ir.Class node = env.cls;
+
+      if (node.supertype == null) {
+        env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
+        env.isMixinApplication = false;
+        env.interfaces = const <InterfaceType>[];
+      } else {
+        InterfaceType processSupertype(ir.Supertype node) {
+          InterfaceType type = _typeConverter.visitSupertype(node);
+          KClass superclass = type.element;
+          _KClassEnv env = _classEnvs[superclass.classIndex];
+          _ensureSupertypes(superclass, env);
+          return type;
+        }
+
+        env.supertype = processSupertype(node.supertype);
+        LinkBuilder<InterfaceType> linkBuilder =
+            new LinkBuilder<InterfaceType>();
+        if (node.mixedInType != null) {
+          env.isMixinApplication = true;
+          linkBuilder
+              .addLast(env.mixedInType = processSupertype(node.mixedInType));
+        } else {
+          env.isMixinApplication = false;
+        }
+        node.implementedTypes.forEach((ir.Supertype supertype) {
+          linkBuilder.addLast(processSupertype(supertype));
+        });
+        Link<InterfaceType> interfaces = linkBuilder.toLink();
+        OrderedTypeSetBuilder setBuilder =
+            new _KernelOrderedTypeSetBuilder(this, cls);
+        env.orderedTypeSet =
+            setBuilder.createOrderedTypeSet(env.supertype, interfaces);
+        env.interfaces = new List<InterfaceType>.from(interfaces.toList());
+      }
+    }
   }
 
+  @override
+  MemberEntity getMember(ir.Member node) {
+    if (node is ir.Field) {
+      return _getField(node);
+    } else if (node is ir.Constructor) {
+      return _getConstructor(node);
+    } else if (node is ir.Procedure) {
+      if (node.kind == ir.ProcedureKind.Factory) {
+        return _getConstructor(node);
+      } else {
+        return _getMethod(node);
+      }
+    }
+    throw new UnsupportedError("Unexpected member: $node");
+  }
+
+  MemberEntity getSuperMember(ir.Member context, ir.Name name, ir.Member target,
+      {bool setter: false}) {
+    if (target != null) {
+      return getMember(target);
+    }
+    KClass cls = getMember(context).enclosingClass;
+    KClass superclass = _getSuperType(cls)?.element;
+    while (superclass != null) {
+      _KClassEnv env = _classEnvs[superclass.classIndex];
+      ir.Member superMember = env.lookupMember(name.name, setter: setter);
+      if (superMember != null) {
+        return getMember(superMember);
+      }
+      superclass = _getSuperType(superclass)?.element;
+    }
+    throw new SpannableAssertionFailure(
+        cls, "No super method member found for ${name} in $cls.");
+  }
+
+  @override
+  ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
+
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
 
       ir.FunctionNode functionNode;
       if (node is ir.Constructor) {
@@ skipping 14 matching lines @@
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
       _memberList.add(new _ConstructorData(node, functionNode));
       return constructor;
     });
   }
 
+  ConstructorEntity getSuperConstructor(
+      ir.Constructor sourceNode, ir.Member targetNode) {
+    KConstructor source = getConstructor(sourceNode);
+    KClass sourceClass = source.enclosingClass;
+    KConstructor target = getConstructor(targetNode);
+    KClass targetClass = target.enclosingClass;
+    KClass superClass = _getSuperType(sourceClass)?.element;
+    if (superClass == targetClass) {
+      return target;
+    }
+    _KClassEnv env = _classEnvs[superClass.classIndex];
+    ir.Member member = env.lookupConstructor(target.name);
+    if (member != null) {
+      return getConstructor(member);
+    }
+    throw new SpannableAssertionFailure(
+        source, "Super constructor for $source not found.");
+  }
+
+  @override
+  FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
+
   KFunction _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KLibrary library;
       KClass enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
@@ skipping 46 matching lines @@
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
       }
       _memberList.add(new _FunctionData(node, node.function));
       return function;
     });
   }
 
-  MemberEntity getSuperMember(ir.Member context, ir.Name name, ir.Member target,
-      {bool setter: false}) {
-    if (target != null) {
-      return getMember(target);
-    }
-    KClass cls = getMember(context).enclosingClass;
-    KClass superclass = _getSuperType(cls)?.element;
-    while (superclass != null) {
-      _KClassEnv env = _classEnvs[superclass.classIndex];
-      ir.Member superMember = env.lookupMember(name.name, setter: setter);
-      if (superMember != null) {
-        return getMember(superMember);
-      }
-      superclass = _getSuperType(superclass)?.element;
-    }
-    throw new SpannableAssertionFailure(
-        cls, "No super method member found for ${name} in $cls.");
-  }
-
-  /// Returns the kernel [ir.Procedure] node for the [method].
-  ir.Procedure _lookupProcedure(KFunction method) {
-    return _memberList[method.memberIndex].node;
-  }
+  @override
+  FieldEntity getField(ir.Field node) => _getField(node);
 
   KField _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KLibrary library;
       KClass enclosingClass;
       if (node.enclosingClass != null) {
         enclosingClass = _getClass(node.enclosingClass);
         library = enclosingClass.library;
       } else {
         library = _getLibrary(node.enclosingLibrary);
       }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
       _memberList.add(new _FieldData(node));
       return new KField(memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
     });
   }
 
+  ParameterStructure _getParameterStructure(ir.FunctionNode node) {
+    // TODO(johnniwinther): Cache the computed function type.
+    int requiredParameters = node.requiredParameterCount;
+    int positionalParameters = node.positionalParameters.length;
+    List<String> namedParameters =
+        node.namedParameters.map((p) => p.name).toList()..sort();
+    return new ParameterStructure(
+        requiredParameters, positionalParameters, namedParameters);
+  }
+
+  @override
+  Local getLocalFunction(ir.TreeNode node) => _getLocal(node);
+
   KLocalFunction _getLocal(ir.TreeNode node) {
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
       Entity executableContext;
       ir.TreeNode parent = node.parent;
       while (parent != null) {
         if (parent is ir.Member) {
           executableContext = memberContext = getMember(parent);
           break;
         }
@@ skipping 15 matching lines @@
         functionType = getFunctionType(node.function);
       }
       return new KLocalFunction(
           name, memberContext, executableContext, functionType);
     });
   }
 
   @override
   DartType getDartType(ir.DartType type) => _typeConverter.convert(type);
 
-  @override
-  InterfaceType createInterfaceType(
-      ir.Class cls, List<ir.DartType> typeArguments) {
-    return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
-  }
-
-  @override
-  InterfaceType getInterfaceType(ir.InterfaceType type) =>
-      _typeConverter.convert(type);
-
-  @override
   List<DartType> getDartTypes(List<ir.DartType> types) {
     // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
     List<DartType> list = /*<DartType>*/ [];
     types.forEach((ir.DartType type) {
       list.add(getDartType(type));
     });
     return list;
   }
 
-  void _ensureThisAndRawType(KClass cls, _KClassEnv env) {
-    if (env.thisType == null) {
-      ir.Class node = env.cls;
-      // TODO(johnniwinther): Add the type argument to the list literal when we
-      // no longer use resolution types.
-      if (node.typeParameters.isEmpty) {
-        env.thisType =
-            env.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+  @override
+  InterfaceType getInterfaceType(ir.InterfaceType type) =>
+      _typeConverter.convert(type);
+
+  @override
+  FunctionType getFunctionType(ir.FunctionNode node) {
+    DartType returnType = getDartType(node.returnType);
+    List<DartType> parameterTypes = /*<DartType>*/ [];
+    List<DartType> optionalParameterTypes = /*<DartType>*/ [];
+    for (ir.VariableDeclaration variable in node.positionalParameters) {
+      if (parameterTypes.length == node.requiredParameterCount) {
+        optionalParameterTypes.add(getDartType(variable.type));
       } else {
-        env.thisType = new InterfaceType(
-            cls,
-            new List/*<DartType>*/ .generate(node.typeParameters.length,
-                (int index) {
-              return new TypeVariableType(
-                  _getTypeVariable(node.typeParameters[index]));
-            }));
-        env.rawType = new InterfaceType(
-            cls,
-            new List/*<DartType>*/ .filled(
-                node.typeParameters.length, const DynamicType()));
+        parameterTypes.add(getDartType(variable.type));
       }
     }
+    List<String> namedParameters = <String>[];
+    List<DartType> namedParameterTypes = /*<DartType>*/ [];
+    List<ir.VariableDeclaration> sortedNamedParameters =
+        node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
+    for (ir.VariableDeclaration variable in sortedNamedParameters) {
+      namedParameters.add(variable.name);
+      namedParameterTypes.add(getDartType(variable.type));
+    }
+    return new FunctionType(returnType, parameterTypes, optionalParameterTypes,
+        namedParameters, namedParameterTypes);
+  }
+
+  @override
+  ConstantValue computeConstantValue(ConstantExpression constant,
+      {bool requireConstant: true}) {
+    return _constantEnvironment.getConstantValue(constant);
+  }
+
+  DartType _substByContext(DartType type, InterfaceType context) {
+    return type.subst(
+        context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getThisType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.thisType;
   }
 
   InterfaceType _getRawType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.rawType;
   }
 
-  InterfaceType _asInstanceOf(InterfaceType type, KClass cls) {
-    OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
-    InterfaceType supertype =
-        orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
-    if (supertype != null) {
-      supertype = _substByContext(supertype, type);
-    }
-    return supertype;
-  }
-
-  void _ensureSupertypes(KClass cls, _KClassEnv env) {
-    if (env.orderedTypeSet == null) {
-      _ensureThisAndRawType(cls, env);
-
-      ir.Class node = env.cls;
-
-      if (node.supertype == null) {
-        env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
-        env.isMixinApplication = false;
-        env.interfaces = const <InterfaceType>[];
-      } else {
-        InterfaceType processSupertype(ir.Supertype node) {
-          InterfaceType type = _typeConverter.visitSupertype(node);
-          KClass superclass = type.element;
-          _KClassEnv env = _classEnvs[superclass.classIndex];
-          _ensureSupertypes(superclass, env);
-          return type;
-        }
-
-        env.supertype = processSupertype(node.supertype);
-        LinkBuilder<InterfaceType> linkBuilder =
-            new LinkBuilder<InterfaceType>();
-        if (node.mixedInType != null) {
-          env.isMixinApplication = true;
-          linkBuilder
-              .addLast(env.mixedInType = processSupertype(node.mixedInType));
-        } else {
-          env.isMixinApplication = false;
-        }
-        node.implementedTypes.forEach((ir.Supertype supertype) {
-          linkBuilder.addLast(processSupertype(supertype));
-        });
-        Link<InterfaceType> interfaces = linkBuilder.toLink();
-        OrderedTypeSetBuilder setBuilder =
-            new _KernelOrderedTypeSetBuilder(this, cls);
-        env.orderedTypeSet =
-            setBuilder.createOrderedTypeSet(env.supertype, interfaces);
-        env.interfaces = new List<InterfaceType>.from(interfaces.toList());
-      }
-    }
-  }
-
-  OrderedTypeSet _getOrderedTypeSet(KClass cls) {
-    _KClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.orderedTypeSet;
-  }
-
-  int _getHierarchyDepth(KClass cls) {
-    _KClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.orderedTypeSet.maxDepth;
+  FunctionType _getFunctionType(KFunction function) {
+    _FunctionData data = _memberList[function.memberIndex];
+    return data.getFunctionType(this);
   }
 
   ClassEntity _getAppliedMixin(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.mixedInType?.element;
   }
 
-  DartType _substByContext(DartType type, InterfaceType context) {
-    return type.subst(
-        context.typeArguments, _getThisType(context.element).typeArguments);
-  }
-
-  InterfaceType _getSuperType(KClass cls) {
-    _KClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.supertype;
-  }
-
   bool _isMixinApplication(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.isMixinApplication;
   }
 
   bool _isUnnamedMixinApplication(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.isUnnamedMixinApplication;
   }
 
-  Iterable<InterfaceType> _getInterfaces(KClass cls) {
-    _KClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.interfaces;
-  }
-
   void _forEachSupertype(KClass cls, void f(InterfaceType supertype)) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     env.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachMixin(KClass cls, void f(ClassEntity mixin)) {
     while (cls != null) {
       _KClassEnv env = _classEnvs[cls.classIndex];
       _ensureSupertypes(cls, env);
@@ skipping 16 matching lines @@
     _KClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     _ensureSupertypes(cls, env);
     if (env.supertype != null) {
       _forEachClassMember(env.supertype.element, f);
     }
   }
 
-  @override
-  FunctionType getFunctionType(ir.FunctionNode node) {
-    DartType returnType = getDartType(node.returnType);
-    List<DartType> parameterTypes = /*<DartType>*/ [];
-    List<DartType> optionalParameterTypes = /*<DartType>*/ [];
-    for (ir.VariableDeclaration variable in node.positionalParameters) {
-      if (parameterTypes.length == node.requiredParameterCount) {
-        optionalParameterTypes.add(getDartType(variable.type));
-      } else {
-        parameterTypes.add(getDartType(variable.type));
-      }
-    }
-    List<String> namedParameters = <String>[];
-    List<DartType> namedParameterTypes = /*<DartType>*/ [];
-    List<ir.VariableDeclaration> sortedNamedParameters =
-        node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
-    for (ir.VariableDeclaration variable in sortedNamedParameters) {
-      namedParameters.add(variable.name);
-      namedParameterTypes.add(getDartType(variable.type));
-    }
-    return new FunctionType(returnType, parameterTypes, optionalParameterTypes,
-        namedParameters, namedParameterTypes);
+  ConstantConstructor _getConstructorConstant(KConstructor constructor) {
+    _ConstructorData data = _memberList[constructor.memberIndex];
+    return data.getConstructorConstant(this, constructor);
   }
 
-  LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
+  ConstantExpression _getFieldConstant(KField field) {
+    _FieldData data = _memberList[field.memberIndex];
+    return data.getFieldConstant(this, field);
+  }
+}
+
+class KernelToElementMapForImpactImpl extends KernelToElementMapBase
+    with KernelToElementMapForImpactMixin {
+  native.BehaviorBuilder _nativeBehaviorBuilder;
+
+  KernelToElementMapForImpactImpl(
+      DiagnosticReporter reporter, Environment environment)
+      : super(reporter, environment) {
+    _nativeBehaviorBuilder = new KernelBehaviorBuilder(_commonElements);
+  }
+
+  @override
+  native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
+}
+
+/// Element builder used for creating elements and types corresponding to Kernel
+/// IR nodes.
+class KernelToElementMapImpl extends KernelToElementMapForImpactImpl
+    with KernelToElementMapForBuildingMixin
+    implements KernelToWorldBuilder {
+  _KernelDartTypes _types;
+
+  KernelToElementMapImpl(DiagnosticReporter reporter, Environment environment)
+      : super(reporter, environment) {
+    _types = new _KernelDartTypes(this);
+  }
+
+  /// Adds libraries in [program] to the set of libraries.
+  ///
+  /// The main method of the first program is used as the main method for the
+  /// compilation.
+  void addProgram(ir.Program program) {
+    _env.addProgram(program);
+  }
+
+  ConstantEnvironment get constantEnvironment => _constantEnvironment;
+
+  DartTypes get types => _types;
+
+  @override
+  ConstantValue getFieldConstantValue(ir.Field field) {
+    // TODO(johnniwinther): Cache the result in [_FieldData].
+    return getConstantValue(field.initializer,
+        requireConstant: field.isConst, implicitNull: !field.isConst);
+  }
+
+  Iterable<ConstantValue> _getClassMetadata(KClass cls) {
+    return _classEnvs[cls.classIndex].getMetadata(this);
+  }
+
+  /// Returns the kernel [ir.Procedure] node for the [method].
+  ir.Procedure _lookupProcedure(KFunction method) {
+    return _memberList[method.memberIndex].node;
+  }
+
+  InterfaceType _asInstanceOf(InterfaceType type, KClass cls) {
+    OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
+    InterfaceType supertype =
+        orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
+    if (supertype != null) {
+      supertype = _substByContext(supertype, type);
+    }
+    return supertype;
+  }
+
+  OrderedTypeSet _getOrderedTypeSet(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.orderedTypeSet;
+  }
+
+  int _getHierarchyDepth(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.orderedTypeSet.maxDepth;
+  }
+
+  Iterable<InterfaceType> _getInterfaces(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.interfaces;
+  }
 
   ir.Library getKernelLibrary(KLibrary entity) =>
       _libraryEnvs[entity.libraryIndex].library;
 
   ir.Class getKernelClass(KClass entity) => _classEnvs[entity.classIndex].cls;
 
-  @override
-  Local getLocalFunction(ir.TreeNode node) => _getLocal(node);
-
-  @override
-  ClassEntity getClass(ir.Class node) => _getClass(node);
-
-  @override
-  FieldEntity getField(ir.Field node) => _getField(node);
-
   bool hasConstantFieldInitializer(covariant KField field) {
     _FieldData data = _memberList[field.memberIndex];
     return getFieldConstantValue(data.node) != null;
   }
 
   ConstantValue getConstantFieldInitializer(covariant KField field) {
     _FieldData data = _memberList[field.memberIndex];
     ConstantValue value = getFieldConstantValue(data.node);
     assert(value != null,
         failedAt(field, "Field $field doesn't have a constant initial value."));
     return value;
   }
 
-  TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
-      _getTypeVariable(node);
-
-  @override
-  FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
-
   void forEachParameter(covariant KFunction function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     _FunctionData data = _memberList[function.memberIndex];
     data.forEachParameter(this, f);
   }
 
-  @override
-  MemberEntity getMember(ir.Member node) {
-    if (node is ir.Field) {
-      return _getField(node);
-    } else if (node is ir.Constructor) {
-      return _getConstructor(node);
-    } else if (node is ir.Procedure) {
-      if (node.kind == ir.ProcedureKind.Factory) {
-        return _getConstructor(node);
-      } else {
-        return _getMethod(node);
-      }
-    }
-    throw new UnsupportedError("Unexpected member: $node");
-  }
-
-  @override
-  ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
-
-  @override
-  ConstructorEntity getSuperConstructor(
-      ir.Constructor sourceNode, ir.Member targetNode) {
-    KConstructor source = getConstructor(sourceNode);
-    KClass sourceClass = source.enclosingClass;
-    KConstructor target = getConstructor(targetNode);
-    KClass targetClass = target.enclosingClass;
-    KClass superClass = _getSuperType(sourceClass)?.element;
-    if (superClass == targetClass) {
-      return target;
-    }
-    _KClassEnv env = _classEnvs[superClass.classIndex];
-    ir.Member member = env.lookupConstructor(target.name);
-    if (member != null) {
-      return getConstructor(member);
-    }
-    throw new SpannableAssertionFailure(
-        source, "Super constructor for $source not found.");
-  }
-
-  ConstantConstructor _getConstructorConstant(KConstructor constructor) {
-    _ConstructorData data = _memberList[constructor.memberIndex];
-    return data.getConstructorConstant(this, constructor);
-  }
-
-  ConstantExpression _getFieldConstant(KField field) {
-    _FieldData data = _memberList[field.memberIndex];
-    return data.getFieldConstant(this, field);
-  }
-
-  FunctionType _getFunctionType(KFunction function) {
-    _FunctionData data = _memberList[function.memberIndex];
-    return data.getFunctionType(this);
-  }
-
   ResolutionImpact computeWorldImpact(KMember member) {
     return _memberList[member.memberIndex].getWorldImpact(this);
   }
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
   @override
@@ skipping 388 matching lines @@
             field,
             "Unexpected field $field in "
             "KernelWorldBuilder._getConstructorConstant");
       }
     }
     return _constant;
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
-  final KernelToElementMapImpl elementMap;
+  final KernelToElementMapBase elementMap;
 
   KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => elementMap._mainLibrary;
 
   @override
@@ skipping 178 matching lines @@
 
   @override
   Iterable<ConstantValue> getMemberMetadata(covariant KMember member) {
     _MemberData memberData = elementMap._memberList[member.memberIndex];
     return memberData.getMetadata(elementMap);
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
-  final KernelToElementMapImpl elementAdapter;
+  final KernelToElementMapBase elementMap;
   bool topLevel = true;
 
-  DartTypeConverter(this.elementAdapter);
+  DartTypeConverter(this.elementMap);
 
   DartType convert(ir.DartType type) {
     topLevel = true;
     return type.accept(this);
   }
 
   /// Visit a inner type.
   DartType visitType(ir.DartType type) {
     topLevel = false;
     return type.accept(this);
   }
 
   InterfaceType visitSupertype(ir.Supertype node) {
-    ClassEntity cls = elementAdapter.getClass(node.classNode);
+    ClassEntity cls = elementMap.getClass(node.classNode);
     return new InterfaceType(cls, visitTypes(node.typeArguments));
   }
 
   List<DartType> visitTypes(List<ir.DartType> types) {
     topLevel = false;
     return new List.generate(
         types.length, (int index) => types[index].accept(this));
   }
 
   @override
   DartType visitTypeParameterType(ir.TypeParameterType node) {
-    return new TypeVariableType(elementAdapter.getTypeVariable(node.parameter));
+    return new TypeVariableType(elementMap.getTypeVariable(node.parameter));
   }
 
   @override
   DartType visitFunctionType(ir.FunctionType node) {
     return new FunctionType(
         visitType(node.returnType),
         visitTypes(node.positionalParameters
             .take(node.requiredParameterCount)
             .toList()),
         visitTypes(node.positionalParameters
             .skip(node.requiredParameterCount)
             .toList()),
         node.namedParameters.map((n) => n.name).toList(),
         node.namedParameters.map((n) => visitType(n.type)).toList());
   }
 
   @override
   DartType visitInterfaceType(ir.InterfaceType node) {
-    ClassEntity cls = elementAdapter.getClass(node.classNode);
+    ClassEntity cls = elementMap.getClass(node.classNode);
     return new InterfaceType(cls, visitTypes(node.typeArguments));
   }
 
   @override
   DartType visitVoidType(ir.VoidType node) {
     return const VoidType();
   }
 
   @override
   DartType visitDynamicType(ir.DynamicType node) {
@@ skipping 27 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 {
-  KernelToElementMapForBuilding _worldBuilder;
+  final KernelToElementMapBase _elementMap;
+  final Environment _environment;
+
   Map<ConstantExpression, ConstantValue> _valueMap =
       <ConstantExpression, ConstantValue>{};
 
-  KernelConstantEnvironment(this._worldBuilder);
+  KernelConstantEnvironment(this._elementMap, this._environment);
 
   @override
   ConstantSystem get constantSystem => const JavaScriptConstantSystem();
 
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
     throw new UnimplementedError(
         "KernelConstantEnvironment.getConstantValueForVariable");
   }
 
   @override
   ConstantValue getConstantValue(ConstantExpression expression) {
     return _valueMap.putIfAbsent(expression, () {
       return expression.evaluate(
-          new _EvaluationEnvironment(_worldBuilder), constantSystem);
+          new _EvaluationEnvironment(_elementMap, _environment),
+          constantSystem);
     });
   }
 
   @override
   bool hasConstantValue(ConstantExpression expression) {
     throw new UnimplementedError("KernelConstantEnvironment.hasConstantValue");
   }
 }
 
 /// Evaluation environment used for computing [ConstantValue]s for
 /// kernel based [ConstantExpression]s.
 class _EvaluationEnvironment implements EvaluationEnvironment {
-  final KernelToElementMapImpl _elementMap;
+  final KernelToElementMapBase _elementMap;
+  final Environment _environment;
 
-  _EvaluationEnvironment(this._elementMap);
+  _EvaluationEnvironment(this._elementMap, this._environment);
 
   @override
   CommonElements get commonElements => _elementMap.commonElements;
 
   @override
   InterfaceType substByContext(InterfaceType base, InterfaceType target) {
     return _elementMap._substByContext(base, target);
   }
 
   @override
   ConstantConstructor getConstructorConstant(ConstructorEntity constructor) {
     return _elementMap._getConstructorConstant(constructor);
   }
 
   @override
   ConstantExpression getFieldConstant(FieldEntity field) {
     return _elementMap._getFieldConstant(field);
   }
 
   @override
   ConstantExpression getLocalConstant(Local local) {
     throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
   }
 
   @override
   String readFromEnvironment(String name) {
-    return _elementMap._environment.valueOf(name);
+    return _environment.valueOf(name);
   }
 }
 
 class KernelResolutionWorldBuilder extends KernelResolutionWorldBuilderBase {
   final KernelToElementMapImpl elementMap;
 
   KernelResolutionWorldBuilder(
       this.elementMap,
       NativeBasicData nativeBasicData,
       NativeDataBuilder nativeDataBuilder,
@@ skipping 227 matching lines @@
 }
 
 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);
+  JsKernelToElementMap(
+      DiagnosticReporter reporter,
+      Environment environment,
+      this._map,
+      this._elementEnvironment,
+      this._commonElements,
+      this._elementMap)
+      : super(reporter, environment);
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return _elementMap.getSpannable(_map.toFrontendMember(member), node);
   }
 
   @override
   LibraryEntity getLibrary(ir.Library node) {
     return _map.toBackendLibrary(_elementMap.getLibrary(node));
   }
@@ skipping 104 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }