Use MemberEntity more in type_graph_nodes

pkg/compiler/lib/src/inferrer/type_graph_nodes.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 compiler.src.inferrer.type_graph_nodes;
 
 import 'dart:collection' show IterableBase;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 42 matching lines @@
   var /* List|ParameterAssignments */ _assignments;
 
   /// The type the inferrer has found for this [TypeInformation].
   /// Initially empty.
   TypeMask type = const TypeMask.nonNullEmpty();
 
   /// The graph node of the member this [TypeInformation] node belongs to.
   final MemberTypeInformation context;
 
   /// The element this [TypeInformation] node belongs to.
-  MemberElement get contextMember => context == null ? null : context.member;
+  MemberEntity get contextMember => context == null ? null : context.member;
 
   Iterable<TypeInformation> get assignments => _assignments;
 
   /// We abandon inference in certain cases (complex cyclic flow, native
   /// behaviours, etc.). In some case, we might resume inference in the
   /// closure tracer, which is handled by checking whether [assignments] has
   /// been set to [STOP_TRACKING_ASSIGNMENTS_MARKER].
   bool abandonInferencing = false;
   bool get mightResume =>
       !identical(assignments, STOP_TRACKING_ASSIGNMENTS_MARKER);
@@ skipping 122 matching lines @@
     type = const TypeMask.nonNullEmpty();
     refineCount = 0;
     return true;
   }
 
   accept(TypeInformationVisitor visitor);
 
   /// The [Element] where this [TypeInformation] was created. May be `null`
   /// for some [TypeInformation] nodes, where we do not need to store
   /// the information.
-  TypedElement get owner => (context != null) ? context.member : null;
+  MemberEntity get owner => (context != null) ? context.member : null;
 
   /// Returns whether the type cannot change after it has been
   /// inferred.
   bool hasStableType(InferrerEngine inferrer) {
     return !mightResume && assignments.every((e) => e.isStable);
   }
 
   void removeAndClearReferences(InferrerEngine inferrer) {
     assignments.forEach((info) {
       info.removeUser(this);
@@ skipping 165 matching lines @@
   /**
    * This map contains the callers of [element]. It stores all unique call sites
    * to enable counting the global number of call sites of [element].
    *
    * A call site is either an AST [ast.Node], an [Element] (see uses of
    * [synthesizeForwardingCall] in [SimpleTypeInferrerVisitor]).
    *
    * The global information is summarized in [cleanup], after which [_callers]
    * is set to `null`.
    */
-  Map<MemberElement, Setlet<Spannable>> _callers;
+  Map<MemberEntity, Setlet<Spannable>> _callers;
 
   MemberTypeInformation._internal(this._member) : super._internal(null);
 
   MemberElement get member => _member;
 
   String get debugName => '$member';
 
-  void addCall(MemberElement caller, Spannable node) {
+  void addCall(MemberEntity caller, Spannable node) {
     assert(node is ast.Node || node is Element);
-    _callers ??= <MemberElement, Setlet<Spannable>>{};
+    _callers ??= <MemberEntity, Setlet<Spannable>>{};
     _callers.putIfAbsent(caller, () => new Setlet()).add(node);
   }
 
-  void removeCall(MemberElement caller, node) {
+  void removeCall(MemberEntity caller, node) {
     if (_callers == null) return;
     Setlet calls = _callers[caller];
     if (calls == null) return;
     calls.remove(node);
     if (calls.isEmpty) {
       _callers.remove(caller);
     }
   }
 
-  Iterable<MemberElement> get callers {
+  Iterable<MemberEntity> get callers {
     // TODO(sra): This is called only from an unused API and a test. If it
     // becomes used, [cleanup] will need to copy `_caller.keys`.
 
     // `simple_inferrer_callers_test.dart` ensures that cleanup has not
     // happened.
     return _callers.keys;
   }
 
   bool isCalledOnce() {
     // If this assert fires it means that this MemberTypeInformation for the
@@ skipping 216 matching lines @@
   }
 
   bool hasStableType(InferrerEngine inferrer) {
     return super.hasStableType(inferrer);
   }
 }
 
 class GenerativeConstructorTypeInformation extends MemberTypeInformation {
   ConstructorEntity get _constructor => _member;
 
-  GenerativeConstructorTypeInformation(ConstructorElement element)
+  GenerativeConstructorTypeInformation(ConstructorEntity element)
       : super._internal(element);
 
   TypeMask handleSpecialCases(InferrerEngine inferrer) {
     return _handleFunctionCase(_constructor, inferrer);
   }
 
   TypeMask _potentiallyNarrowType(TypeMask mask, InferrerEngine inferrer) {
     return mask;
   }
 
@@ skipping 1225 matching lines @@
     // TODO(ngeoffray): Narrow to bound.
     return type;
   } else {
     ResolutionInterfaceType interfaceType = annotation;
     otherType = new TypeMask.nonNullSubtype(interfaceType.element, closedWorld);
   }
   if (isNullable) otherType = otherType.nullable();
   if (type == null) return otherType;
   return type.intersection(otherType, closedWorld);
 }