Further reduce use of Element in codegen.

pkg/compiler/lib/src/js_backend/backend.dart

 // Copyright (c) 2012, 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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 391 matching lines @@
       new Set<ClassElement>();
 
   /**
    * Set of classes whose `operator ==` methods handle `null` themselves.
    */
   final Set<ClassElement> specialOperatorEqClasses = new Set<ClassElement>();
 
   /**
    * A set of members that are called from subclasses via `super`.
    */
-  final Set<FunctionElement> aliasedSuperMembers =
-      new Setlet<FunctionElement>();
+  final Set<MethodElement> aliasedSuperMembers = new Setlet<MethodElement>();
 
   List<CompilerTask> get tasks {
     List<CompilerTask> result = functionCompiler.tasks;
     result.add(emitter);
     result.add(patchResolverTask);
     result.add(kernelTask);
     return result;
   }
 
   final RuntimeTypes rti;
@@ skipping 326 matching lines @@
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
       oneShotInterceptors[name] = selector;
     }
     return name;
   }
 
   /**
    * Record that [method] is called from a subclass via `super`.
    */
-  bool maybeRegisterAliasedSuperMember(Element member, Selector selector) {
+  bool maybeRegisterAliasedSuperMember(
+      MemberElement member, Selector selector) {
     if (!canUseAliasedSuperMember(member, selector)) {
       // Invoking a super getter isn't supported, this would require changes to
       // compact field descriptors in the emitter.
       // We also turn off this optimization in incremental compilation, to
       // avoid having to regenerate a method just because someone started
       // calling it through super.
       return false;
     }
     aliasedSuperMembers.add(member);
     return true;
@@ skipping 12 matching lines @@
 
   /// Returns `true` if [element] is part of JsInterop.
   @override
   bool isJsInterop(Element element) => nativeData.isJsInterop(element);
 
   /// Whether [element] corresponds to a native JavaScript construct either
   /// through the native mechanism (`@Native(...)` or the `native` pseudo
   /// keyword) which is only allowed for internal libraries or via the typed
   /// JavaScriptInterop mechanism which is allowed for user libraries.
   @override
-  bool isNative(Element element) => nativeData.isNative(element);
+  bool isNative(Entity element) => nativeData.isNative(element);
 
   /// Returns the [NativeBehavior] for calling the native [method].
   native.NativeBehavior getNativeMethodBehavior(FunctionElement method) {
     return nativeData.getNativeMethodBehavior(method);
   }
 
   /// Returns the [NativeBehavior] for reading from the native [field].
   native.NativeBehavior getNativeFieldLoadBehavior(FieldElement field) {
     return nativeData.getNativeFieldLoadBehavior(field);
   }
@@ skipping 854 matching lines @@
         element == commonElements.boolClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'boolTypeCast' : 'boolTypeCheck';
     } else if (element == helpers.jsIntClass ||
         element == commonElements.intClass ||
         element == helpers.jsUInt32Class ||
         element == helpers.jsUInt31Class ||
         element == helpers.jsPositiveIntClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'intTypeCast' : 'intTypeCheck';
-    } else if (Elements.isNumberOrStringSupertype(element, commonElements)) {
+    } else if (commonElements.isNumberOrStringSupertype(element)) {
       if (nativeCheck) {
         return typeCast
             ? 'numberOrStringSuperNativeTypeCast'
             : 'numberOrStringSuperNativeTypeCheck';
       } else {
         return typeCast
             ? 'numberOrStringSuperTypeCast'
             : 'numberOrStringSuperTypeCheck';
       }
-    } else if (Elements.isStringOnlySupertype(element, commonElements)) {
+    } else if (commonElements.isStringOnlySupertype(element)) {
       if (nativeCheck) {
         return typeCast
             ? 'stringSuperNativeTypeCast'
             : 'stringSuperNativeTypeCheck';
       } else {
         return typeCast ? 'stringSuperTypeCast' : 'stringSuperTypeCheck';
       }
     } else if ((element == commonElements.listClass ||
             element == helpers.jsArrayClass) &&
         type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'listTypeCast' : 'listTypeCheck';
     } else {
-      if (Elements.isListSupertype(element, commonElements)) {
+      if (commonElements.isListSupertype(element)) {
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
           return typeCast ? 'listSuperTypeCast' : 'listSuperTypeCheck';
         }
       } else {
         if (type.isInterfaceType && !type.treatAsRaw) {
           return typeCast ? 'subtypeCast' : 'assertSubtype';
@@ skipping 1565 matching lines @@
   @override
   bool isInterceptorClass(ClassElement cls) {
     return helpers.backend.isInterceptorClass(cls);
   }
 
   @override
   bool isNative(Element element) {
     return helpers.backend.isNative(element);
   }
 }