Use entities in Selector methods

pkg/compiler/lib/src/elements/common.dart

 // Copyright (c) 2015, 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.
 
 /// Mixins that implement convenience methods on [Element] subclasses.
 
 library elements.common;
 
 import '../common/names.dart' show Identifiers, Names, Uris;
 import '../common_elements.dart' show CommonElements;
@@ skipping 199 matching lines @@
   /**
    * Find the first member in the class chain with the given [memberName].
    *
    * This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
    * rules, where library scope comes before superclass scope.
    *
    * When called on the implementation element both members declared in the
    * origin and the patch class are returned.
    */
-  Element lookupByName(Name memberName, {ClassElement stopAt}) {
+  MemberElement lookupByName(Name memberName, {ClassElement stopAt}) {
     return internalLookupByName(memberName,
         isSuperLookup: false, stopAtSuperclass: stopAt);
   }
 
-  Element lookupSuperByName(Name memberName) {
+  MemberElement lookupSuperByName(Name memberName) {
     return internalLookupByName(memberName, isSuperLookup: true);
   }
 
-  Element internalLookupByName(Name memberName,
+  MemberElement internalLookupByName(Name memberName,
       {bool isSuperLookup, ClassElement stopAtSuperclass}) {
     String name = memberName.text;
     bool isPrivate = memberName.isPrivate;
     LibraryElement library = memberName.library;
     for (ClassElement current = isSuperLookup ? superclass : this;
         current != null && current != stopAtSuperclass;
         current = current.superclass) {
       Element member = current.lookupLocalMember(name);
       if (member == null && current.isPatched) {
         // Doing lookups on selectors is done after resolution, so it
         // is safe to look in the patch class.
         member = current.patch.lookupLocalMember(name);
       }
       if (member == null) continue;
       // Private members from a different library are not visible.
       if (isPrivate && !identical(library, member.library)) continue;
       // Static members are not inherited.
       if (member.isStatic && !identical(this, current)) continue;
       // If we find an abstract field we have to make sure that it has
       // the getter or setter part we're actually looking
       // for. Otherwise, we continue up the superclass chain.
       if (member.isAbstractField) {
         AbstractFieldElement field = member;
-        FunctionElement getter = field.getter;
-        FunctionElement setter = field.setter;
+        GetterElement getter = field.getter;
+        SetterElement setter = field.setter;
         if (memberName.isSetter) {
           // Abstract members can be defined in a super class.
           if (setter != null && !setter.isAbstract) {
             return setter;
           }
         } else {
           if (getter != null && !getter.isAbstract) {
             return getter;
           }
         }
         // Abstract members can be defined in a super class.
-      } else if (!member.isAbstract) {
+      } else if (!member.isAbstract && !member.isMalformed) {
         return member;
       }
     }
     return null;
   }
 
   /**
    * Find the first member in the class chain with the given
    * [memberName]. This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
@@ skipping 392 matching lines @@
   @override
   bool get isBoolFromEnvironmentConstructor {
     return fromEnvironmentState == _FromEnvironmentState.BOOL;
   }
 
   @override
   bool get isStringFromEnvironmentConstructor {
     return fromEnvironmentState == _FromEnvironmentState.STRING;
   }
 }