Rename KernelElementAdapter and element_adapter.dart to IrToElementMap and ir_map.dart

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 '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 13 matching lines @@
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/call_structure.dart';
 import '../universe/world_builder.dart';
 import '../util/util.dart' show Link, LinkBuilder;
-import 'element_adapter.dart';
+import 'element_map.dart';
 import 'elements.dart';
 
 part 'native_basic_data.dart';
 part 'no_such_method_resolver.dart';
 part 'types.dart';
 
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
-class KernelToElementMap extends KernelElementAdapterMixin {
+class KernelToElementMapImpl extends KernelToElementMapMixin {
   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 14 matching lines @@
 
   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>{};
 
-  KernelToElementMap(this.reporter, this._environment) {
+  KernelToElementMapImpl(this.reporter, this._environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder = new KernelBehaviorBuilder(_commonElements);
     _types = new _KernelDartTypes(this);
     _typeConverter = new DartTypeConverter(this);
   }
 
   /// Adds libraries in [program] to the set of libraries.
   ///
@@ skipping 722 matching lines @@
     _memberMap.values.forEach(f);
     for (ir.Member member in _setterMap.values) {
       if (member is ir.Procedure) {
         f(member);
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
-  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
+  Iterable<ConstantValue> getMetadata(KernelToElementMapImpl elementMap) {
     return _metadata ??= elementMap.getMetadata(cls.annotations);
   }
 }
 
 class _MemberData {
   final ir.Member node;
   Iterable<ConstantValue> _metadata;
 
   _MemberData(this.node);
 
-  ResolutionImpact getWorldImpact(KernelToElementMap elementMap) {
+  ResolutionImpact getWorldImpact(KernelToElementMapImpl elementMap) {
     return buildKernelImpact(node, elementMap);
   }
 
-  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap) {
+  Iterable<ConstantValue> getMetadata(KernelToElementMapImpl elementMap) {
     return _metadata ??= elementMap.getMetadata(node.annotations);
   }
 }
 
 class _FunctionData extends _MemberData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
   CallStructure _callStructure;
 
   _FunctionData(ir.Member node, this.functionNode) : super(node);
 
-  FunctionType getFunctionType(KernelToElementMap elementMap) {
+  FunctionType getFunctionType(KernelToElementMapImpl elementMap) {
     return _type ??= elementMap.getFunctionType(functionNode);
   }
 
   CallStructure get callStructure {
     return _callStructure ??= new CallStructure(
         functionNode.positionalParameters.length +
             functionNode.namedParameters.length,
         functionNode.namedParameters.map((d) => d.name).toList());
   }
 }
 
 class _ConstructorData extends _FunctionData {
   ConstantConstructor _constantConstructor;
 
   _ConstructorData(ir.Member node, ir.FunctionNode functionNode)
       : super(node, functionNode);
 
   ConstantConstructor getConstructorConstant(
-      KernelToElementMap elementMap, KConstructor constructor) {
+      KernelToElementMapImpl elementMap, KConstructor constructor) {
     if (_constantConstructor == null) {
       if (node is ir.Constructor && constructor.isConst) {
         _constantConstructor =
             new Constantifier(elementMap).computeConstantConstructor(node);
       } else {
         throw new SpannableAssertionFailure(
             constructor,
             "Unexpected constructor $constructor in "
             "KernelWorldBuilder._getConstructorConstant");
       }
     }
     return _constantConstructor;
   }
 }
 
 class _FieldData extends _MemberData {
   ConstantExpression _constant;
 
   _FieldData(ir.Field node) : super(node);
 
   ir.Field get node => super.node;
 
   ConstantExpression getFieldConstant(
-      KernelToElementMap elementMap, KField field) {
+      KernelToElementMapImpl elementMap, KField field) {
     if (_constant == null) {
       if (node.isConst) {
         _constant = new Constantifier(elementMap).visit(node.initializer);
       } else {
         throw new SpannableAssertionFailure(
             field,
             "Unexpected field $field in "
             "KernelWorldBuilder._getConstructorConstant");
       }
     }
     return _constant;
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
-  final KernelToElementMap elementMap;
+  final KernelToElementMapImpl elementMap;
 
   KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => elementMap._mainLibrary;
 
   @override
@@ skipping 153 matching lines @@
 
   @override
   Iterable<ConstantValue> getMemberMetadata(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 KernelToElementMap elementAdapter;
+  final KernelToElementMapImpl elementAdapter;
   bool topLevel = true;
 
   DartTypeConverter(this.elementAdapter);
 
   DartType convert(ir.DartType type) {
     topLevel = true;
     return type.accept(this);
   }
 
   /// Visit a inner type.
@@ skipping 78 matching lines @@
 
   @override
   NativeData get nativeData {
     throw new UnimplementedError("KernelNativeBehaviorComputer.nativeData");
   }
 }
 
 /// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
 /// [_EvaluationEnvironment] for the evaluation.
 class KernelConstantEnvironment implements ConstantEnvironment {
-  KernelToElementMap _worldBuilder;
+  KernelToElementMapImpl _worldBuilder;
   Map<ConstantExpression, ConstantValue> _valueMap =
       <ConstantExpression, ConstantValue>{};
 
   KernelConstantEnvironment(this._worldBuilder);
 
   @override
   ConstantSystem get constantSystem => const JavaScriptConstantSystem();
 
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
@@ skipping 11 matching lines @@
 
   @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 KernelToElementMap _elementMap;
+  final KernelToElementMapImpl _elementMap;
 
   _EvaluationEnvironment(this._elementMap);
 
   @override
   CommonElements get commonElements => _elementMap.commonElements;
 
   @override
   InterfaceType substByContext(InterfaceType base, InterfaceType target) {
     return _elementMap._substByContext(base, target);
   }
@@ skipping 13 matching lines @@
     throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
   }
 
   @override
   String readFromEnvironment(String name) {
     return _elementMap._environment.valueOf(name);
   }
 }
 
 class KernelResolutionWorldBuilder extends KernelResolutionWorldBuilderBase {
-  final KernelToElementMap elementMap;
+  final KernelToElementMapImpl elementMap;
 
   KernelResolutionWorldBuilder(this.elementMap, NativeBasicData nativeBasicData,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
       : super(elementMap.elementEnvironment, elementMap.commonElements,
             nativeBasicData, selectorConstraintsStrategy);
 
   @override
   Iterable<InterfaceType> getSupertypes(ClassEntity cls) {
     return elementMap._getOrderedTypeSet(cls).supertypes;
   }
@@ skipping 22 matching lines @@
 
   @override
   bool validateClass(ClassEntity cls) => true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
-  final KernelToElementMap elementMap;
+  final KernelToElementMapImpl elementMap;
 
   WorldDeconstructionForTesting(this.elementMap);
 
   KClass getSuperclassForClass(KClass cls) {
     _KClassEnv env = elementMap._classEnvs[cls.classIndex];
     ir.Supertype supertype = env.cls.supertype;
     if (supertype == null) return null;
     return elementMap.getClass(supertype.classNode);
   }
 
   bool isUnnamedMixinApplication(KClass cls) {
     return elementMap._isUnnamedMixinApplication(cls);
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     _KClassEnv env = elementMap._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return elementMap.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }