Handle local invoke in inferrer

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 '../../compiler_new.dart';
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
@@ skipping 105 matching lines @@
   /// Sets the type of a parameter's default value to [type]. If the global
   /// mapping in [defaultTypeOfParameter] already contains a type, it must be
   /// a [PlaceholderTypeInformation], which will be replaced. All its uses are
   /// updated.
   void setDefaultTypeOfParameter(Local parameter, TypeInformation type,
       {bool isInstanceMember});
 
   Iterable<MemberEntity> getCallersOf(MemberEntity element);
 
   // TODO(johnniwinther): Make this private again.
-  GlobalTypeInferenceElementData dataOfMember(MemberEntity element);
+  GlobalTypeInferenceElementData<T> dataOfMember(MemberEntity element);
 
-  GlobalTypeInferenceElementData lookupDataOfMember(MemberEntity element);
+  GlobalTypeInferenceElementData<T> lookupDataOfMember(MemberEntity element);
 
   bool checkIfExposesThis(ConstructorEntity element);
 
   void recordExposesThis(ConstructorEntity element, bool exposesThis);
 
   /// Records that the return type [element] is of type [type].
   void recordReturnType(FunctionEntity element, TypeInformation type);
 
   /// Records that [element] is of type [type].
   void recordTypeOfField(FieldEntity element, TypeInformation type);
@@ skipping 48 matching lines @@
   /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledSelector(
       CallType callType,
       T node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
-      bool inLoop,
-      bool isConditional);
+      {bool inLoop,
+      bool isConditional});
 
   /// Update the assignments to parameters in the graph. [remove] tells whether
   /// assignments must be added or removed. If [init] is false, parameters are
   /// added to the work queue.
   void updateParameterAssignments(TypeInformation caller, MemberEntity callee,
       ArgumentsTypes arguments, Selector selector, TypeMask mask,
       {bool remove, bool addToQueue: true});
 
   void updateSelectorInMember(MemberEntity owner, CallType callType, T node,
       Selector selector, TypeMask mask);
@@ skipping 788 matching lines @@
 
   TypeInformation registerCalledSelector(
       CallType callType,
       T node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
-      bool inLoop,
-      bool isConditional) {
+      {bool inLoop,
+      bool isConditional}) {
     if (selector.isClosureCall) {
       return registerCalledClosure(node, selector, mask, receiverType, caller,
           arguments, sideEffects, inLoop);
     }
 
     closedWorld.locateMembers(selector, mask).forEach((callee) {
       updateSideEffects(sideEffects, selector, callee);
     });
 
     CallSiteTypeInformation info = new DynamicCallSiteTypeInformation(
@@ skipping 79 matching lines @@
     types.allocatedMaps.values.forEach(cleanup);
     types.allocatedLists.values.forEach(cleanup);
   }
 
   Iterable<MemberEntity> getCallersOf(MemberEntity element) {
     MemberTypeInformation info = types.getInferredTypeOfMember(element);
     return info.callers;
   }
 
   TypeInformation typeOfMemberWithSelector(
-      covariant MemberElement element, Selector selector) {
+      MemberEntity element, Selector selector) {
     if (element.name == Identifiers.noSuchMethod_ &&
         selector.name != element.name) {
       // An invocation can resolve to a [noSuchMethod], in which case
       // we get the return type of [noSuchMethod].
       return returnTypeOfMember(element);
     } else if (selector.isGetter) {
       if (element.isFunction) {
         // [functionType] is null if the inferrer did not run.
         return types.functionType == null
             ? types.dynamicType
             : types.functionType;
       } else if (element.isField) {
         return typeOfMember(element);
-      } else if (Elements.isUnresolved(element)) {
+      } else if (element.isGetter) {
+        return returnTypeOfMember(element);
+      } else {
+        assert(element is MemberElement && Elements.isUnresolved(element));
         return types.dynamicType;
-      } else {
-        assert(element.isGetter);
-        return returnTypeOfMember(element);
       }
     } else if (element.isGetter || element.isField) {
       assert(selector.isCall || selector.isSetter);
       return types.dynamicType;
     } else {
       return returnTypeOfMember(element);
     }
   }
 
   /// Returns true if global optimizations such as type inferencing can apply to
@@ skipping 46 matching lines @@
       // Put the other operators in buckets by size, later to be added in
       // size order.
       int size = computeSize(element);
       Set<MemberEntity> set =
           methodSizes.putIfAbsent(size, () => new Setlet<MemberEntity>());
       set.add(element);
     });
     return methodSizes;
   }
 }