Handle local invoke in inferrer

pkg/compiler/lib/src/inferrer/kernel_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 '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
@@ skipping 187 matching lines @@
 
   @override
   int computeMemberSize(MemberEntity member) {
     // TODO(johnniwinther): Find an ordering that can be shared between the
     // front ends.
     return 0;
   }
 
   @override
   GlobalTypeInferenceElementData<ir.Node> createElementData() {
-    throw new UnimplementedError('KernelInferrerEngine.createElementData');
+    return new KernelGlobalTypeInferenceElementData();
   }
 }
 
 class KernelTypeSystemStrategy implements TypeSystemStrategy<ir.Node> {
   KernelToElementMapForBuilding _elementMap;
   GlobalLocalsMap _globalLocalsMap;
   ClosureDataLookup<ir.Node> _closureDataLookup;
 
   KernelTypeSystemStrategy(
       this._elementMap, this._globalLocalsMap, this._closureDataLookup);
@@ skipping 117 matching lines @@
       ConstructorEntity constructor = member;
       if (constructor.isFactoryConstructor) {
         DartType type = _elementEnvironment.getFunctionType(constructor);
         return new FactoryConstructorTypeInformation(constructor, type);
       } else {
         return new GenerativeConstructorTypeInformation(constructor);
       }
     }
   }
 }
+
+class KernelGlobalTypeInferenceElementData
+    extends GlobalTypeInferenceElementData<ir.Node> {
+  // TODO(johnniwinther): Rename this together with [typeOfSend].
+  Map<ir.Node, TypeMask> _sendMap;
+
+  @override
+  TypeMask typeOfSend(ir.Node node) {
+    if (_sendMap == null) return null;
+    return _sendMap[node];
+  }
+
+  @override
+  void setCurrentTypeMask(ir.Node node, TypeMask mask) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.setCurrentTypeMask');
+  }
+
+  @override
+  void setMoveNextTypeMask(ir.Node node, TypeMask mask) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.setMoveNextTypeMask');
+  }
+
+  @override
+  void setIteratorTypeMask(ir.Node node, TypeMask mask) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.setIteratorTypeMask');
+  }
+
+  @override
+  TypeMask typeOfIteratorCurrent(ir.Node node) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.typeOfIteratorCurrent');
+  }
+
+  @override
+  TypeMask typeOfIteratorMoveNext(ir.Node node) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.typeOfIteratorMoveNext');
+  }
+
+  @override
+  TypeMask typeOfIterator(ir.Node node) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.typeOfIterator');
+  }
+
+  @override
+  void setOperatorTypeMaskInComplexSendSet(ir.Node node, TypeMask mask) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.setOperatorTypeMaskInComplexSendSet');
+  }
+
+  @override
+  void setGetterTypeMaskInComplexSendSet(ir.Node node, TypeMask mask) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.setGetterTypeMaskInComplexSendSet');
+  }
+
+  @override
+  void setTypeMask(ir.Node node, TypeMask mask) {
+    _sendMap ??= <ir.Node, TypeMask>{};
+    _sendMap[node] = mask;
+  }
+
+  @override
+  TypeMask typeOfOperator(ir.Node node) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.typeOfOperator');
+  }
+
+  @override
+  TypeMask typeOfGetter(ir.Node node) {
+    throw new UnsupportedError(
+        'KernelGlobalTypeInferenceElementData.typeOfGetter');
+  }
+}