Use entities in js_emitter/model.dart

pkg/compiler/lib/src/js_emitter/model.dart

 // Copyright (c) 2014, 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.new_js_emitter.model;
 
 import '../constants/values.dart' show ConstantValue;
 import '../deferred_load.dart' show OutputUnit;
-import '../elements/elements.dart' show Element, FieldElement;
+import '../elements/entities.dart';
 import '../js/js.dart' as js show Expression, Name, Statement, TokenFinalizer;
 import 'js_emitter.dart' show MetadataCollector;
 
 class Program {
   final List<Fragment> fragments;
   final List<Holder> holders;
   final bool outputContainsConstantList;
   final bool needsNativeSupport;
   final bool hasIsolateSupport;
 
@@ skipping 151 matching lines @@
   Constant(this.name, this.holder, this.value);
 }
 
 abstract class FieldContainer {
   List<Field> get staticFieldsForReflection;
 }
 
 class Library implements FieldContainer {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
-  final Element element;
+  final LibraryEntity element;
 
   final String uri;
   final List<StaticMethod> statics;
   final List<Class> classes;
 
   final List<Field> staticFieldsForReflection;
 
   Library(this.element, this.uri, this.statics, this.classes,
       this.staticFieldsForReflection);
 }
 
 class StaticField {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
-  final Element element;
+  final FieldEntity element;
 
   js.Name name;
   // TODO(floitsch): the holder for static fields is the isolate object. We
   // could remove this field and use the isolate object directly.
   final Holder holder;
   final js.Expression code;
   final bool isFinal;
   final bool isLazy;
 
   StaticField(this.element, this.name, this.holder, this.code, this.isFinal,
       this.isLazy);
 }
 
 class Class implements FieldContainer {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
-  final Element element;
+  final ClassEntity element;
 
   final js.Name name;
   final Holder holder;
   Class _superclass;
   final List<Method> methods;
   final List<Field> fields;
   final List<StubMethod> isChecks;
   final List<StubMethod> checkedSetters;
 
   /// Stub methods for this class that are call stubs for getters.
@@ skipping 58 matching lines @@
   js.Name get superclassName => superclass == null ? null : superclass.name;
 
   int get superclassHolderIndex =>
       (superclass == null) ? 0 : superclass.holder.index;
 }
 
 class MixinApplication extends Class {
   Class _mixinClass;
 
   MixinApplication(
-      Element element,
+      ClassEntity element,
       js.Name name,
       Holder holder,
       List<Field> instanceFields,
       List<Field> staticFieldsForReflection,
       List<StubMethod> callStubs,
       List<StubMethod> typeVariableReaderStubs,
       List<StubMethod> checkedSetters,
       List<StubMethod> isChecks,
       js.Expression functionTypeIndex,
       {bool hasRtiField,
@@ skipping 25 matching lines @@
   }
 }
 
 /// A field.
 ///
 /// In general represents an instance field, but for reflection may also
 /// represent static fields.
 class Field {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
-  final FieldElement element;
+  final FieldEntity element;
 
   final js.Name name;
   final js.Name accessorName;
 
   /// 00: Does not need any getter.
   /// 01:  function() { return this.field; }
   /// 10:  function(receiver) { return receiver.field; }
   /// 11:  function(receiver) { return this.field; }
   final int getterFlags;
 
@@ skipping 18 matching lines @@
   bool get needsInterceptedGetterOnReceiver => getterFlags == 2;
   bool get needsInterceptedSetterOnReceiver => setterFlags == 2;
 
   bool get needsInterceptedGetterOnThis => getterFlags == 3;
   bool get needsInterceptedSetterOnThis => setterFlags == 3;
 }
 
 abstract class Method {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
-  final Element element;
+  final MemberEntity element;
 
   /// The name of the method. If the method is a [ParameterStubMethod] for a
   /// static function, then the name can be `null`. In that case, only the
   /// [ParameterStubMethod.callName] should be used.
   final js.Name name;
   final js.Expression code;
 
   Method(this.element, this.name, this.code);
 }
 
@@ skipping 15 matching lines @@
   // Signature information for this method. This is only required and stored
   // here if the method [canBeApplied] or [canBeReflected]
   final int requiredParameterCount;
   final /* Map | List */ optionalParameterDefaultValues;
 
   // If this method can be torn off, contains the name of the corresponding
   // call method. For example, for the member `foo$1$name` it would be
   // `call$1$name` (in unminified mode).
   final js.Name callName;
 
-  DartMethod(Element element, js.Name name, js.Expression code,
+  DartMethod(FunctionEntity element, js.Name name, js.Expression code,
       this.parameterStubs, this.callName,
       {this.needsTearOff,
       this.tearOffName,
       this.canBeApplied,
       this.canBeReflected,
       this.requiredParameterCount,
       this.optionalParameterDefaultValues,
       this.functionType})
       : super(element, name, code) {
     assert(needsTearOff != null);
@@ skipping 13 matching lines @@
   /// a method via `super`. If [aliasName] is non-null, the emitter has to
   /// ensure that this method is registered on the prototype under both [name]
   /// and [aliasName].
   final js.Name aliasName;
 
   /// True if this is the implicit `call` instance method of an anonymous
   /// closure. This predicate is false for explicit `call` methods and for
   /// functions that can be torn off.
   final bool isClosureCallMethod;
 
-  InstanceMethod(Element element, js.Name name, js.Expression code,
+  InstanceMethod(FunctionEntity element, js.Name name, js.Expression code,
       List<ParameterStubMethod> parameterStubs, js.Name callName,
       {bool needsTearOff,
       js.Name tearOffName,
       this.aliasName,
       bool canBeApplied,
       bool canBeReflected,
       int requiredParameterCount,
       /* List | Map */ optionalParameterDefaultValues,
       this.isClosureCallMethod,
       js.Expression functionType})
       : super(element, name, code, parameterStubs, callName,
             needsTearOff: needsTearOff,
             tearOffName: tearOffName,
             canBeApplied: canBeApplied,
             canBeReflected: canBeReflected,
             requiredParameterCount: requiredParameterCount,
             optionalParameterDefaultValues: optionalParameterDefaultValues,
             functionType: functionType) {
     assert(isClosureCallMethod != null);
   }
 
   bool get isStatic => false;
 }
 
 /// A method that is generated by the backend and has not direct correspondence
 /// to a method in the original Dart program. Examples are getter and setter
 /// stubs and stubs to dispatch calls to methods with optional parameters.
 class StubMethod extends Method {
-  StubMethod(js.Name name, js.Expression code, {Element element})
+  StubMethod(js.Name name, js.Expression code, {MemberEntity element})
       : super(element, name, code);
 }
 
 /// A stub that adapts and redirects to the main method (the one containing)
 /// the actual code.
 ///
 /// For example, given a method `foo$2(x, [y: 499])` a possible parameter
 /// stub-method could be `foo$1(x) => foo$2(x, 499)`.
 ///
 /// ParameterStubMethods are always attached to (static or instance) methods.
@@ skipping 12 matching lines @@
 }
 
 abstract class StaticMethod implements Method {
   Holder get holder;
 }
 
 class StaticDartMethod extends DartMethod implements StaticMethod {
   final Holder holder;
 
   StaticDartMethod(
-      Element element,
+      FunctionEntity element,
       js.Name name,
       this.holder,
       js.Expression code,
       List<ParameterStubMethod> parameterStubs,
       js.Name callName,
       {bool needsTearOff,
       js.Name tearOffName,
       bool canBeApplied,
       bool canBeReflected,
       int requiredParameterCount,
       /* List | Map */ optionalParameterDefaultValues,
       js.Expression functionType})
       : super(element, name, code, parameterStubs, callName,
             needsTearOff: needsTearOff,
             tearOffName: tearOffName,
             canBeApplied: canBeApplied,
             canBeReflected: canBeReflected,
             requiredParameterCount: requiredParameterCount,
             optionalParameterDefaultValues: optionalParameterDefaultValues,
             functionType: functionType);
 
   bool get isStatic => true;
 }
 
 class StaticStubMethod extends StubMethod implements StaticMethod {
   Holder holder;
   StaticStubMethod(js.Name name, this.holder, js.Expression code)
       : super(name, code);
 }