Handle local invoke in inferrer

pkg/compiler/lib/src/inferrer/builder_kernel.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 '../closure.dart';
 import '../common.dart';
 import '../constants/constant_system.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../kernel/element_map.dart';
 import '../options.dart';
 import '../types/constants.dart';
+import '../types/types.dart';
+import '../universe/selector.dart';
+import '../universe/side_effects.dart';
 import '../world.dart';
 import 'inferrer_engine.dart';
 import 'locals_handler.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 /// [KernelTypeGraphBuilder] constructs a type-inference graph for a particular
 /// element.
 ///
 /// Calling [run] will start the work of visiting the body of the code to
 /// construct a set of inference-nodes that abstractly represent what the code
 /// is doing.
 class KernelTypeGraphBuilder extends ir.Visitor<TypeInformation> {
   final CompilerOptions _options;
   final ClosedWorld _closedWorld;
   final ClosureDataLookup<ir.Node> _closureDataLookup;
   final InferrerEngine<ir.Node> _inferrer;
   final TypeSystem<ir.Node> _types;
   final MemberEntity _analyzedMember;
   final ir.Node _analyzedNode;
   final KernelToElementMapForBuilding _elementMap;
   final KernelToLocalsMap _localsMap;
   LocalsHandler _locals;
+  final GlobalTypeInferenceElementData<ir.Node> _memberData;
+  SideEffects _sideEffects = new SideEffects.empty();
 
   TypeInformation _returnType;
 
   KernelTypeGraphBuilder(
       this._options,
       this._closedWorld,
       this._closureDataLookup,
       this._inferrer,
       this._analyzedMember,
       this._analyzedNode,
       this._elementMap,
       this._localsMap,
       [this._locals])
-      : this._types = _inferrer.types {
+      : this._types = _inferrer.types,
+        this._memberData = _inferrer.dataOfMember(_analyzedMember) {
     if (_locals != null) return;
 
     FieldInitializationScope<ir.Node> fieldScope =
         _analyzedNode is ir.Constructor
             ? new FieldInitializationScope(_types)
             : null;
     _locals = new LocalsHandler(
         _inferrer, _types, _options, _analyzedNode, fieldScope);
   }
 
+  int _loopLevel = 0;
+
+  bool get inLoop => _loopLevel > 0;
+
   TypeInformation run() {
     if (_analyzedMember.isField) {
       if (_analyzedNode == null || _analyzedNode is ir.NullLiteral) {
         // Eagerly bailout, because computing the closure data only
         // works for functions and field assignments.
         return _types.nullType;
       }
     }
 
     // Update the locals that are boxed in [locals]. These locals will
@@ skipping 175 matching lines @@
   }
 
   @override
   TypeInformation visitVariableSet(ir.VariableSet node) {
     Local local = _localsMap.getLocalVariable(node.variable);
     DartType type = _localsMap.getLocalType(_elementMap, local);
     TypeInformation rhsType = visit(node.value);
     _locals.update(local, rhsType, node, type);
     return rhsType;
   }
+
+  ArgumentsTypes analyzeArguments(ir.Arguments arguments) {
+    List<TypeInformation> positional = <TypeInformation>[];
+    Map<String, TypeInformation> named;
+    for (ir.Expression argument in arguments.positional) {
+      positional.add(argument.accept(this));
+    }
+    for (ir.NamedExpression argument in arguments.named) {
+      named ??= <String, TypeInformation>{};
+      named[argument.name] = argument.value.accept(this);
+    }
+
+    /// TODO(johnniwinther): Track `isThisExposed`.
+    return new ArgumentsTypes(positional, named);
+  }
+
+  @override
+  TypeInformation visitMethodInvocation(ir.MethodInvocation node) {
+    TypeInformation receiverType = visit(node.receiver);
+    Selector selector = _elementMap.getSelector(node);
+    TypeMask mask = _memberData.typeOfSend(node);
+
+    ArgumentsTypes arguments = analyzeArguments(node.arguments);
+    if (selector.name == '==' || selector.name == '!=') {
+      if (_types.isNull(receiverType)) {
+        // TODO(johnniwinther): Add null check.
+        return _types.boolType;
+      } else if (_types.isNull(arguments.positional[0])) {
+        // TODO(johnniwinther): Add null check.
+        return _types.boolType;
+      }
+    }
+    return handleDynamicInvoke(
+        CallType.access, node, selector, mask, receiverType, arguments);
+  }
+
+  TypeInformation handleDynamicInvoke(
+      CallType callType,
+      ir.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(
+          _analyzedMember, callType, node, selector, mask);
+    }
+
+    // TODO(johnniwinther): Refine receiver on non-captured locals.
+
+    return _inferrer.registerCalledSelector(callType, node, selector, mask,
+        receiverType, _analyzedMember, arguments, _sideEffects,
+        inLoop: inLoop, isConditional: false);
+  }
 }