Add CallType to DynamicCallSiteTypeInformation

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 ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 1306 matching lines @@
 
       if (Elements.isMalformed(element)) return types.dynamicType;
 
       if (Elements.isStaticOrTopLevelField(element)) {
         Element getterElement = elements[node.selector];
         getterType = handleStaticSend(
             node, getterSelector, getterMask, getterElement, null);
       } else if (Elements.isUnresolved(element) ||
           element.isSetter ||
           element.isField) {
-        getterType = handleDynamicSend(
-            node, getterSelector, getterMask, receiverType, null);
+        getterType = handleDynamicSend(CallType.complex, node, getterSelector,
+            getterMask, receiverType, null);
       } else if (element.isLocal) {
         LocalElement local = element;
         getterType = locals.use(local);
       } else {
         // Bogus SendSet, for example [: myMethod += 42 :].
         getterType = types.dynamicType;
       }
 
       if (op == '??=') {
         newType = types.allocateDiamondPhi(getterType, rhsType);
       } else {
         Selector operatorSelector =
             elements.getOperatorSelectorInComplexSendSet(node);
-        newType = handleDynamicSend(node, operatorSelector, operatorMask,
-            getterType, new ArgumentsTypes([rhsType], null));
+        newType = handleDynamicSend(CallType.complex, node, operatorSelector,
+            operatorMask, getterType, new ArgumentsTypes([rhsType], null));
       }
 
       if (Elements.isStaticOrTopLevelField(element)) {
         handleStaticSend(node, setterSelector, setterMask, element,
             new ArgumentsTypes([newType], null));
       } else if (Elements.isUnresolved(element) ||
           element.isSetter ||
           element.isField) {
-        handleDynamicSend(node, setterSelector, setterMask, receiverType,
-            new ArgumentsTypes([newType], null));
+        handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
+            receiverType, new ArgumentsTypes([newType], null));
       } else if (element.isLocal) {
         locals.update(element, newType, node);
       }
 
       return node.isPostfix ? getterType : newType;
     }
   }
 
   /// Handle compound index set, like `foo[0] += 42` or `foo[0]++`.
   TypeInformation handleCompoundIndexSet(
       ast.SendSet node,
       TypeInformation receiverType,
       TypeInformation indexType,
       TypeInformation rhsType) {
     Selector getterSelector = elements.getGetterSelectorInComplexSendSet(node);
 
     TypeMask getterMask = memberData.typeOfGetter(node);
     Selector operatorSelector =
         elements.getOperatorSelectorInComplexSendSet(node);
     TypeMask operatorMask = memberData.typeOfOperator(node);
     Selector setterSelector = elements.getSelector(node);
     TypeMask setterMask = memberData.typeOfSend(node);
 
-    TypeInformation getterType = handleDynamicSend(node, getterSelector,
-        getterMask, receiverType, new ArgumentsTypes([indexType], null));
+    TypeInformation getterType = handleDynamicSend(
+        CallType.complex,
+        node,
+        getterSelector,
+        getterMask,
+        receiverType,
+        new ArgumentsTypes([indexType], null));
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
-      returnType = handleDynamicSend(node, operatorSelector, operatorMask,
-          getterType, new ArgumentsTypes([rhsType], null));
+      returnType = handleDynamicSend(CallType.complex, node, operatorSelector,
+          operatorMask, getterType, new ArgumentsTypes([rhsType], null));
     }
-    handleDynamicSend(node, setterSelector, setterMask, receiverType,
-        new ArgumentsTypes([indexType, returnType], null));
+    handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
+        receiverType, new ArgumentsTypes([indexType, returnType], null));
 
     if (node.isPostfix) {
       return getterType;
     } else {
       return returnType;
     }
   }
 
   /// Handle compound prefix/postfix operations, like `a[0]++`.
   TypeInformation handleCompoundPrefixPostfix(
@@ skipping 77 matching lines @@
     TypeInformation getterType = handleSuperSend(node, getterSelector,
         getterMask, getter, new ArgumentsTypes([indexType], null));
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
       TypeMask operatorMask = memberData.typeOfOperator(node);
-      returnType = handleDynamicSend(node, operatorSelector, operatorMask,
-          getterType, new ArgumentsTypes([rhsType], null));
+      returnType = handleDynamicSend(CallType.complex, node, operatorSelector,
+          operatorMask, getterType, new ArgumentsTypes([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes([indexType, returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   TypeInformation handleSuperSend(ast.Node node, Selector selector,
       TypeMask mask, Element element, ArgumentsTypes arguments) {
     if (element.isMalformed) {
@@ skipping 414 matching lines @@
     TypeInformation getterType =
         handleSuperSend(node, getterSelector, getterMask, getter, null);
 
     TypeInformation returnType;
     if (node.isIfNullAssignment) {
       returnType = types.allocateDiamondPhi(getterType, rhsType);
     } else {
       Selector operatorSelector =
           elements.getOperatorSelectorInComplexSendSet(node);
       TypeMask operatorMask = memberData.typeOfOperator(node);
-      returnType = handleDynamicSend(node, operatorSelector, operatorMask,
-          getterType, new ArgumentsTypes([rhsType], null));
+      returnType = handleDynamicSend(CallType.complex, node, operatorSelector,
+          operatorMask, getterType, new ArgumentsTypes([rhsType], null));
     }
     handleSuperSend(node, setterSelector, setterMask, setter,
         new ArgumentsTypes([returnType], null));
 
     return node.isPostfix ? getterType : returnType;
   }
 
   /// Handle index set, like `foo[0] = 42`.
   TypeInformation handleIndexSet(ast.SendSet node, TypeInformation receiverType,
       TypeInformation indexType, TypeInformation rhsType) {
     Selector setterSelector = elements.getSelector(node);
     TypeMask setterMask = memberData.typeOfSend(node);
-    handleDynamicSend(node, setterSelector, setterMask, receiverType,
-        new ArgumentsTypes([indexType, rhsType], null));
+    handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
+        receiverType, new ArgumentsTypes([indexType, rhsType], null));
     return rhsType;
   }
 
   @override
   TypeInformation visitIndexSet(
       ast.SendSet node, ast.Node receiver, ast.Node index, ast.Node rhs, _) {
     TypeInformation receiverType = visit(receiver);
     TypeInformation indexType = visit(index);
     TypeInformation rhsType = visit(rhs);
     return handleIndexSet(node, receiverType, indexType, rhsType);
@@ skipping 46 matching lines @@
         // 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) {
           MemberElement single = targets.first;
           if (single.isField) {
             locals.updateField(single, rhsType);
           }
         }
       }
-      handleDynamicSend(
-          node, setterSelector, setterMask, receiverType, arguments);
+      handleDynamicSend(CallType.access, node, setterSelector, setterMask,
+          receiverType, arguments);
     } else if (element.isField) {
       FieldElement field = element;
       if (field.isFinal) {
         inferrer.recordTypeOfField(field, rhsType);
       } else {
         if (analyzedElement.isGenerativeConstructor) {
           locals.updateField(field, rhsType);
         }
         if (visitingInitializers) {
           inferrer.recordTypeOfField(field, rhsType);
         } else {
-          handleDynamicSend(
-              node, setterSelector, setterMask, receiverType, arguments);
+          handleDynamicSend(CallType.complex, node, setterSelector, setterMask,
+              receiverType, arguments);
         }
       }
     } else if (element.isLocal) {
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
 
   /// Handle a super access or invocation that results in a `noSuchMethod` call.
   TypeInformation handleErroneousSuperSend(ast.Send node) {
@@ skipping 708 matching lines @@
         !(element as ConstructorElement).isRedirectingFactory);
     // Erroneous elements may be unresolved, for example missing getters.
     if (Elements.isUnresolved(element)) return types.dynamicType;
     // TODO(herhut): should we follow redirecting constructors here? We would
     // need to pay attention if the constructor is pointing to an erroneous
     // element.
     return inferrer.registerCalledMember(node, selector, mask, outermostElement,
         element, arguments, sideEffects, inLoop);
   }
 
-  TypeInformation handleDynamicSend(ast.Node node, Selector selector,
-      TypeMask mask, TypeInformation receiverType, ArgumentsTypes arguments) {
+  TypeInformation handleDynamicSend(
+      CallType callType,
+      ast.Node node,
+      Selector selector,
+      TypeMask mask,
+      TypeInformation receiverType,
+      ArgumentsTypes arguments) {
     assert(receiverType != null);
     if (types.selectorNeedsUpdate(receiverType, mask)) {
       mask = receiverType == types.dynamicType
           ? null
           : types.newTypedSelector(receiverType, mask);
-      inferrer.updateSelectorInMember(outermostElement, node, selector, mask);
+      inferrer.updateSelectorInMember(
+          outermostElement, callType, node, selector, mask);
     }
 
     // If the receiver of the call is a local, we may know more about
     // its type by refining it with the potential targets of the
     // calls.
     ast.Send send = node.asSend();
     bool isConditional = false;
     if (send != null) {
       isConditional = send.isConditional;
       ast.Node receiver = send.receiver;
       if (receiver != null) {
         Element element = elements[receiver];
         if (Elements.isLocal(element) && !capturedVariables.contains(element)) {
           TypeInformation refinedType = types.refineReceiver(
               selector, mask, receiverType, send.isConditional);
           locals.update(element, refinedType, node);
         }
       }
     }
 
-    return inferrer.registerCalledSelector(node, selector, mask, receiverType,
-        outermostElement, arguments, sideEffects, inLoop, isConditional);
+    return inferrer.registerCalledSelector(
+        callType,
+        node,
+        selector,
+        mask,
+        receiverType,
+        outermostElement,
+        arguments,
+        sideEffects,
+        inLoop,
+        isConditional);
   }
 
   TypeInformation handleDynamicInvoke(ast.Send node) {
     return _handleDynamicSend(node);
   }
 
   TypeInformation handleDynamicGet(ast.Send node) {
     return _handleDynamicSend(node);
   }
 
@@ skipping 22 matching lines @@
         node.isPropertyAccess ? null : analyzeArguments(node.arguments);
     if (selector.name == '==' || selector.name == '!=') {
       if (types.isNull(receiverType)) {
         potentiallyAddNullCheck(node, node.arguments.head);
         return types.boolType;
       } else if (types.isNull(arguments.positional[0])) {
         potentiallyAddNullCheck(node, node.receiver);
         return types.boolType;
       }
     }
-    return handleDynamicSend(node, selector, mask, receiverType, arguments);
+    return handleDynamicSend(
+        CallType.access, node, selector, mask, receiverType, arguments);
   }
 
   void recordReturnType(TypeInformation type) {
     MethodElement analyzedMethod = analyzedElement;
     returnType =
         inferrer.addReturnTypeForMethod(analyzedMethod, returnType, type);
   }
 
   TypeInformation synthesizeForwardingCall(
       Spannable node, ConstructorElement element) {
@@ skipping 57 matching lines @@
     return null;
   }
 
   TypeInformation handleForInLoop(
       ast.ForIn node,
       TypeInformation iteratorType,
       Selector currentSelector,
       TypeMask currentMask,
       Selector moveNextSelector,
       TypeMask moveNextMask) {
-    handleDynamicSend(node, moveNextSelector, moveNextMask, iteratorType,
-        new ArgumentsTypes.empty());
-    TypeInformation currentType = handleDynamicSend(node, currentSelector,
-        currentMask, iteratorType, new ArgumentsTypes.empty());
+    handleDynamicSend(CallType.forIn, node, moveNextSelector, moveNextMask,
+        iteratorType, new ArgumentsTypes.empty());
+    TypeInformation currentType = handleDynamicSend(CallType.forIn, node,
+        currentSelector, currentMask, iteratorType, new ArgumentsTypes.empty());
 
     if (node.expression.isThis()) {
       // Any reasonable implementation of an iterator would expose
       // this, so we play it safe and assume it will.
       isThisExposed = true;
     }
 
     ast.Node identifier = node.declaredIdentifier;
     Element element = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
@@ skipping 34 matching lines @@
 
   TypeInformation visitSyncForIn(ast.SyncForIn node) {
     TypeInformation expressionType = visit(node.expression);
     Selector iteratorSelector = Selectors.iterator;
     TypeMask iteratorMask = memberData.typeOfIterator(node);
     Selector currentSelector = Selectors.current;
     TypeMask currentMask = memberData.typeOfIteratorCurrent(node);
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
-    TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
-        iteratorMask, expressionType, new ArgumentsTypes.empty());
+    TypeInformation iteratorType = handleDynamicSend(
+        CallType.forIn,
+        node,
+        iteratorSelector,
+        iteratorMask,
+        expressionType,
+        new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }