Use entities in CommonElements interface.

pkg/compiler/lib/src/compiler.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 dart2js.compiler_base;
 
 import 'dart:async' show EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
@@ skipping 1152 matching lines @@
       _doubleClass ??= _findRequired(coreLibrary, 'double');
 
   ClassElement _stringClass;
   ClassElement get stringClass =>
       _stringClass ??= _findRequired(coreLibrary, 'String');
 
   ClassElement _functionClass;
   ClassElement get functionClass =>
       _functionClass ??= _findRequired(coreLibrary, 'Function');
 
-  Element _functionApplyMethod;
-  Element get functionApplyMethod {
+  MethodElement _functionApplyMethod;
+  MethodElement get functionApplyMethod {
     if (_functionApplyMethod == null) {
       functionClass.ensureResolved(resolution);
       _functionApplyMethod = functionClass.lookupLocalMember('apply');
       assert(invariant(functionClass, _functionApplyMethod != null,
           message: "Member `apply` not found in ${functionClass}."));
     }
     return _functionApplyMethod;
   }
 
-  bool isFunctionApplyMethod(Element element) =>
+  bool isFunctionApplyMethod(MemberElement element) =>
       element.name == 'apply' && element.enclosingClass == functionClass;
 
   ClassElement _nullClass;
   ClassElement get nullClass =>
       _nullClass ??= _findRequired(coreLibrary, 'Null');
 
   ClassElement _listClass;
   ClassElement get listClass =>
       _listClass ??= _findRequired(coreLibrary, 'List');
 
@@ skipping 27 matching lines @@
       _stackTraceClass ??= _findRequired(coreLibrary, 'StackTrace');
 
   ClassElement _iterableClass;
   ClassElement get iterableClass =>
       _iterableClass ??= _findRequired(coreLibrary, 'Iterable');
 
   ClassElement _resourceClass;
   ClassElement get resourceClass =>
       _resourceClass ??= _findRequired(coreLibrary, 'Resource');
 
-  Element _identicalFunction;
-  Element get identicalFunction =>
+  MethodElement _identicalFunction;
+  MethodElement get identicalFunction =>
       _identicalFunction ??= coreLibrary.find('identical');
 
   // From dart:async
 
   ClassElement _futureClass;
   ClassElement get futureClass =>
       _futureClass ??= _findRequired(asyncLibrary, 'Future');
 
   ClassElement _streamClass;
   ClassElement get streamClass =>
       _streamClass ??= _findRequired(asyncLibrary, 'Stream');
 
   ClassElement _deferredLibraryClass;
   ClassElement get deferredLibraryClass =>
       _deferredLibraryClass ??= _findRequired(asyncLibrary, "DeferredLibrary");
 
   // From dart:mirrors
 
   ClassElement _mirrorSystemClass;
   ClassElement get mirrorSystemClass =>
       _mirrorSystemClass ??= _findRequired(mirrorsLibrary, 'MirrorSystem');
 
   FunctionElement _mirrorSystemGetNameFunction;
-  bool isMirrorSystemGetNameFunction(Element element) {
+  bool isMirrorSystemGetNameFunction(MemberElement element) {
     if (_mirrorSystemGetNameFunction == null) {
       if (!element.isFunction || mirrorsLibrary == null) return false;
       ClassElement cls = mirrorSystemClass;
       if (element.enclosingClass != cls) return false;
       if (cls != null) {
         cls.ensureResolved(resolution);
         _mirrorSystemGetNameFunction = cls.lookupLocalMember('getName');
       }
     }
     return element == _mirrorSystemGetNameFunction;
@@ skipping 204 matching lines @@
   ConstructorElement _unnamedListConstructor;
   ConstructorElement get unnamedListConstructor =>
       _unnamedListConstructor ??= listClass.lookupDefaultConstructor();
 
   ConstructorElement _filledListConstructor;
   ConstructorElement get filledListConstructor =>
       _filledListConstructor ??= listClass.lookupConstructor("filled");
 
   // TODO(johnniwinther): Change types to `ClassElement` when these are not
   // called with unrelated elements.
-  bool isNumberOrStringSupertype(/*Class*/ Element element) {
+  bool isNumberOrStringSupertype(/*Class*/ Entity element) {
     return element == coreLibrary.find('Comparable');
   }
 
-  bool isStringOnlySupertype(/*Class*/ Element element) {
+  bool isStringOnlySupertype(/*Class*/ Entity element) {
     return element == coreLibrary.find('Pattern');
   }
 
-  bool isListSupertype(/*Class*/ Element element) => element == iterableClass;
+  bool isListSupertype(/*Class*/ Entity element) => element == iterableClass;
 }
 
 class CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
   Element _currentElement;
   bool hasCrashed = false;
 
   /// `true` if the last diagnostic was filtered, in which case the
@@ skipping 726 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }