Add CallType to DynamicCallSiteTypeInformation

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 165 matching lines @@
       bool inLoop);
 
   /// Registers that [caller] calls [selector] with [receiverType] as receiver,
   /// and [arguments].
   ///
   /// [sideEffects] will be updated to incorporate the potential callees' side
   /// effects.
   ///
   /// [inLoop] tells whether the call happens in a loop.
   TypeInformation registerCalledSelector(
+      CallType callType,
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       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, ast.Node node, Selector selector, TypeMask mask);
+  void updateSelectorInMember(MemberEntity owner, CallType callType,
+      ast.Node node, Selector selector, TypeMask mask);
 
   /// Returns the return type of [element].
   TypeInformation returnTypeOfMember(MemberEntity element);
 
   /// Returns the type of [element] when being called with [selector].
   TypeInformation typeOfMemberWithSelector(
       MemberEntity element, Selector selector);
 
   /// Returns the type of [element].
   TypeInformation typeOfMember(MemberEntity element);
@@ skipping 135 matching lines @@
         mappedType = types.nonNullSubtype(type.element);
       }
       returnType = types.computeLUB(returnType, mappedType);
       if (returnType == types.dynamicType) {
         break;
       }
     }
     return returnType;
   }
 
-  void updateSelectorInMember(
-      MemberEntity owner, ast.Node node, Selector selector, TypeMask mask) {
+  void updateSelectorInMember(MemberEntity owner, CallType callType,
+      ast.Node node, Selector selector, TypeMask mask) {
     GlobalTypeInferenceElementData data = dataOfMember(owner);
-    if (node.asSendSet() != null) {
+    switch (callType) {
+      case CallType.complex:
+        assert(node.asSendSet() != null);
+        if (selector.isSetter || selector.isIndexSet) {
+          data.setTypeMask(node, mask);
+        } else if (selector.isGetter || selector.isIndex) {
+          data.setGetterTypeMaskInComplexSendSet(node, mask);
+        } else {
+          assert(selector.isOperator);
+          data.setOperatorTypeMaskInComplexSendSet(node, mask);
+        }
+        break;
+      case CallType.access:
+        assert(node.asSend() != null);
+        data.setTypeMask(node, mask);
+        break;
+      case CallType.forIn:
+        assert(node.asForIn() != null);
+        if (selector == Selectors.iterator) {
+          data.setIteratorTypeMask(node, mask);
+        } else if (selector == Selectors.current) {
+          data.setCurrentTypeMask(node, mask);
+        } else {
+          assert(selector == Selectors.moveNext);
+          data.setMoveNextTypeMask(node, mask);
+        }
+        break;
+    }
+    /*if (node.asSendSet() != null) {

[Siggi Cherem (dart-lang), 2017/07/31 19:30:29]

delete old code

[Johnni Winther, 2017/08/01 13:09:20]

Done.

       if (selector.isSetter || selector.isIndexSet) {
         data.setTypeMask(node, mask);
       } else if (selector.isGetter || selector.isIndex) {
         data.setGetterTypeMaskInComplexSendSet(node, mask);
       } else {
         assert(selector.isOperator);
         data.setOperatorTypeMaskInComplexSendSet(node, mask);
       }
     } else if (node.asSend() != null) {
       data.setTypeMask(node, mask);
     } else {
       assert(node.asForIn() != null);
       if (selector == Selectors.iterator) {
         data.setIteratorTypeMask(node, mask);
       } else if (selector == Selectors.current) {
         data.setCurrentTypeMask(node, mask);
       } else {
         assert(selector == Selectors.moveNext);
         data.setMoveNextTypeMask(node, mask);
       }
-    }
+    }*/
   }
 
   bool checkIfExposesThis(ConstructorEntity element) {
     assert(!(element is ConstructorElement && !element.isDeclaration));
     return generativeConstructorsExposingThis.contains(element);
   }
 
   void recordExposesThis(ConstructorEntity element, bool exposesThis) {
     assert(!(element is ConstructorElement && !element.isDeclaration));
     if (exposesThis) {
@@ skipping 574 matching lines @@
         types.allocatedClosures.add(info);
       }
     }
     info.addToGraph(this);
     types.allocatedCalls.add(info);
     updateSideEffects(sideEffects, selector, callee);
     return info;
   }
 
   TypeInformation registerCalledSelector(
+      CallType callType,
       ast.Node node,
       Selector selector,
       TypeMask mask,
       TypeInformation receiverType,
       MemberEntity caller,
       ArgumentsTypes arguments,
       SideEffects sideEffects,
       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(
         types.currentMember,
+        callType,
         node,
         caller,
         selector,
         mask,
         receiverType,
         arguments,
         inLoop,
         isConditional);
 
     info.addToGraph(this);
@@ skipping 240 matching lines @@
   @override
   bool checkPhiNode(ast.Node node) {
     return true;
   }
 
   @override
   bool checkClassEntity(covariant ClassElement cls) {
     return cls.isDeclaration;
   }
 }