Use entities in js_emitter/model.dart

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
@@ skipping 273 matching lines @@
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
 
   List<StaticField> _buildStaticLazilyInitializedFields(
       LibrariesMap librariesMap) {
     JavaScriptConstantCompiler handler = backend.constants;
     DeferredLoadTask loadTask = _compiler.deferredLoadTask;
-    Iterable<VariableElement> lazyFields = handler
+    Iterable<FieldElement> lazyFields = handler
         .getLazilyInitializedFieldsForEmission()
         .where((element) =>
             loadTask.outputUnitForElement(element) == librariesMap.outputUnit);
     return Elements
         .sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null) // Happens when the field was unused.
         .toList(growable: false);
   }
 
-  StaticField _buildLazyField(Element element) {
+  StaticField _buildLazyField(FieldElement element) {
     js.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     js.Name name = namer.globalPropertyName(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     // TODO(floitsch): we shouldn't update the registry in the middle of
@@ skipping 281 matching lines @@
     if (backend.isJsInterop(element)) {
       typeTests.properties.forEach((js.Name name, js.Node code) {
         _classes[helpers.jsInterceptorClass]
             .isChecks
             .add(_buildStubMethod(name, code));
       });
     } else {
       for (Field field in instanceFields) {
         if (field.needsCheckedSetter) {
           assert(!field.needsUncheckedSetter);
-          Element element = field.element;
+          FieldElement element = field.element;
           js.Expression code = backend.generatedCode[element];
           assert(code != null);
           js.Name name = namer.deriveSetterName(field.accessorName);
           checkedSetters.add(_buildStubMethod(name, code, element: element));
         }
       }
 
       typeTests.properties.forEach((js.Name name, js.Node code) {
         isChecks.add(_buildStubMethod(name, code));
       });
@@ skipping 89 matching lines @@
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
             backend.constants.getConstantValue(parameter.constant);
         optionalParameterDefaultValues.add(def);
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(MethodElement element) {
+    assert(element.isDeclaration);
     js.Name name = namer.methodPropertyName(element);
     js.Expression code = backend.generatedCode[element];
 
     // TODO(kasperl): Figure out under which conditions code is null.
     if (code == null) return null;
 
     bool canTearOff = false;
     js.Name tearOffName;
     bool isClosureCallMethod = false;
     bool isNotApplyTarget = !element.isFunction || element.isAccessor;
@@ skipping 91 matching lines @@
 
     ParameterStubGenerator generator =
         new ParameterStubGenerator(_compiler, namer, backend, closedWorld);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
-  Method _buildStubMethod(js.Name name, js.Expression code, {Element element}) {
+  Method _buildStubMethod(js.Name name, js.Expression code,
+      {MemberElement element}) {
     return new StubMethod(name, code, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Map<js.Name, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
@@ skipping 77 matching lines @@
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
     List<js.Name> names = backend.oneShotInterceptors.keys.toList()..sort();
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
-  StaticDartMethod _buildStaticMethod(FunctionElement element) {
+  StaticDartMethod _buildStaticMethod(MethodElement element) {
     js.Name name = namer.methodPropertyName(element);
     String holder = namer.globalObjectFor(element);
     js.Expression code = backend.generatedCode[element];
 
     bool isApplyTarget = !element.isConstructor && !element.isAccessor;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
@@ skipping 52 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }