Add MemberEntity.isAbstract and use MemberEntity in function_set.dart

pkg/compiler/lib/src/inferrer/inferrer_engine.dart

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 73 matching lines @@
         this.closedWorld = closedWorld;
 
   CommonElements get commonElements => closedWorld.commonElements;
 
   /**
    * Applies [f] to all elements in the universe that match
    * [selector] and [mask]. If [f] returns false, aborts the iteration.
    */
   void forEachElementMatching(
       Selector selector, TypeMask mask, bool f(Element element)) {
-    Iterable<Element> elements =
+    Iterable<MemberEntity> elements =
         closedWorld.allFunctions.filter(selector, mask);
-    for (Element e in elements) {
+    for (MemberElement e in elements) {
       if (!f(e.implementation)) return;
     }
   }
 
   // TODO(johnniwinther): Make this private again.
   GlobalTypeInferenceElementData dataOf(AstElement element) => inTreeData
       .putIfAbsent(element, () => new GlobalTypeInferenceElementData());
 
   /**
    * Update [sideEffects] with the side effects of [callee] being
@@ skipping 328 matching lines @@
             'after ${info.refineCount}');
       });
       types.allocatedClosures.forEach((TypeInformation info) {
         if (info is ElementTypeInformation) {
           print('${types.getInferredSignatureOf(info.element)} for '
               '${info.element}');
         } else if (info is ClosureTypeInformation) {
           print('${types.getInferredSignatureOf(info.element)} for '
               '${info.element}');
         } else if (info is DynamicCallSiteTypeInformation) {
-          for (Element target in info.targets) {
-            if (target is FunctionElement) {
+          for (MemberElement target in info.targets) {
+            if (target is MethodElement) {
               print('${types.getInferredSignatureOf(target)} for ${target}');
             } else {
               print('${types.getInferredTypeOf(target).type} for ${target}');
             }
           }
         } else if (info is StaticCallSiteTypeInformation) {
           ClassElement cls = info.calledElement.enclosingClass;
           FunctionElement callMethod = cls.lookupMember(Identifiers.call);
           print('${types.getInferredSignatureOf(callMethod)} for ${cls}');
         } else {
@@ skipping 99 matching lines @@
   void processLoopInformation() {
     types.allocatedCalls.forEach((info) {
       if (!info.inLoop) return;
       if (info is StaticCallSiteTypeInformation) {
         closedWorldRefiner.addFunctionCalledInLoop(info.calledElement);
       } else if (info.mask != null && !info.mask.containsAll(closedWorld)) {
         // For instance methods, we only register a selector called in a
         // loop if it is a typed selector, to avoid marking too many
         // methods as being called from within a loop. This cuts down
         // on the code bloat.
-        info.targets.forEach(closedWorldRefiner.addFunctionCalledInLoop);
+        info.targets.forEach((MemberElement element) {
+          closedWorldRefiner.addFunctionCalledInLoop(element);
+        });
       }
     });
   }
 
   void refine() {
     while (!workQueue.isEmpty) {
       if (compiler.shouldPrintProgress) {
         reporter.log('Inferred $overallRefineCount types.');
         compiler.progress.reset();
       }
@@ skipping 299 matching lines @@
       TypeInformation receiverType,
       Element caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       bool inLoop) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
-    closedWorld.allFunctions.filter(selector, mask).forEach((callee) {
+    closedWorld.allFunctions
+        .filter(selector, mask)
+        .forEach((MemberElement callee) {
       updateSideEffects(sideEffects, selector, callee);
     });
 
     CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
         types.currentMember,
         node,
         caller,
         selector,
         mask,
         receiverType,
@@ skipping 160 matching lines @@
   /**
    * Records that the captured variable [local] is read.
    */
   void recordCapturedLocalRead(Local local) {}
 
   /**
    * Records that the variable [local] is being updated.
    */
   void recordLocalUpdate(Local local, TypeInformation type) {}
 }