Add MemberEntity.isAbstract and use MemberEntity in function_set.dart

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

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 976 matching lines @@
           }
         }
         visitingInitializers = false;
         // For a generative constructor like: `Foo();`, we synthesize
         // a call to the default super constructor (the one that takes
         // no argument). Resolution ensures that such a constructor
         // exists.
         if (!isConstructorRedirect &&
             !seenSuperConstructorCall &&
             !cls.isObject) {
-          FunctionElement target = cls.superclass.lookupDefaultConstructor();
+          ConstructorElement target = cls.superclass.lookupDefaultConstructor();
           ArgumentsTypes arguments = new ArgumentsTypes([], {});
           analyzeSuperConstructorCall(target, arguments);
           inferrer.registerCalledElement(node, null, null, outermostElement,
               target.implementation, arguments, sideEffects, inLoop);
         }
         visit(node.body);
         inferrer.recordExposesThis(analyzedElement, isThisExposed);
       }
       if (!isConstructorRedirect) {
         // Iterate over all instance fields, and give a null type to
@@ skipping 970 matching lines @@
     ArgumentsTypes arguments = new ArgumentsTypes([rhsType], null);
     if (Elements.isMalformed(element)) {
       // Code will always throw.
     } else if (Elements.isStaticOrTopLevelField(element)) {
       handleStaticSend(node, setterSelector, setterMask, element, arguments);
     } else if (Elements.isUnresolved(element) || element.isSetter) {
       if (analyzedElement.isGenerativeConstructor &&
           (node.asSendSet() != null) &&
           (node.asSendSet().receiver != null) &&
           node.asSendSet().receiver.isThis()) {
-        Iterable<Element> targets = closedWorld.allFunctions.filter(
+        Iterable<MemberEntity> targets = closedWorld.allFunctions.filter(
             setterSelector, types.newTypedSelector(thisType, setterMask));
         // We just recognized a field initialization of the form:
         // `this.foo = 42`. If there is only one target, we can update
         // its type.
         if (targets.length == 1) {
-          Element single = targets.first;
+          MemberElement single = targets.first;
           if (single.isField) {
             locals.updateField(single, rhsType);
           }
         }
       }
       handleDynamicSend(
           node, setterSelector, setterMask, receiverType, arguments);
     } else if (element.isField) {
       if (element.isFinal) {
         inferrer.recordTypeOfFinalField(
@@ skipping 804 matching lines @@
       }
     }
     return handleDynamicSend(node, selector, mask, receiverType, arguments);
   }
 
   void recordReturnType(TypeInformation type) {
     returnType = inferrer.addReturnTypeFor(analyzedElement, returnType, type);
   }
 
   TypeInformation synthesizeForwardingCall(
-      Spannable node, FunctionElement element) {
+      Spannable node, ConstructorElement element) {
     element = element.implementation;
     FunctionElement function = analyzedElement;
     FunctionSignature signature = function.functionSignature;
     FunctionSignature calleeSignature = element.functionSignature;
     if (!calleeSignature.isCompatibleWith(signature)) {
       return types.nonNullEmpty();
     }
 
     List<TypeInformation> unnamed = <TypeInformation>[];
     signature.forEachRequiredParameter((ParameterElement element) {
@@ skipping 12 matching lines @@
         unnamed.add(locals.use(element));
       });
     }
 
     ArgumentsTypes arguments = new ArgumentsTypes(unnamed, named);
     return inferrer.registerCalledElement(node, null, null, outermostElement,
         element, arguments, sideEffects, inLoop);
   }
 
   TypeInformation visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
-    Element element = elements.getRedirectingTargetConstructor(node);
+    ConstructorElement element = elements.getRedirectingTargetConstructor(node);
     if (Elements.isMalformed(element)) {
       recordReturnType(types.dynamicType);
     } else {
       // We don'TypeInformation create a selector for redirecting factories, and
       // the send is just a property access. Therefore we must
       // manually create the [ArgumentsTypes] of the call, and
       // manually register [analyzedElement] as a caller of [element].
       TypeInformation mask =
           synthesizeForwardingCall(node.constructorReference, element);
       recordReturnType(mask);
@@ skipping 76 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }