dart2js kernel: update tryInlineNativeMethod to Entities

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, 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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
-import '../elements/elements.dart' show ClassElement, MethodElement;
+import '../elements/elements.dart' show ClassElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart';
 import '../js_backend/native_data.dart' show NativeData;
 import '../js_backend/runtime_types.dart';
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../types/types.dart';
@@ skipping 501 matching lines @@
               ..sourceInformation = node.sourceInformation;
         node.block.addAfter(load, closureCall);
         return closureCall;
       }
     }
 
     return node;
   }
 
   HInstruction tryInlineNativeMethod(
-      HInvokeDynamicMethod node, MethodElement method) {
+      HInvokeDynamicMethod node, FunctionEntity method) {
     // Enable direct calls to a native method only if we don't run in checked
     // mode, where the Dart version may have type annotations on parameters and
     // return type that it should check.
     // Also check that the parameters are not functions: it's the callee that
     // will translate them to JS functions.
     //
     // TODO(ngeoffray): There are some cases where we could still inline in
     // checked mode if we know the arguments have the right type. And we could
     // do the closure conversion as well as the return type annotation check.
 
     if (!node.isInterceptedCall) return null;
 
-    // TODO(sra): Check for legacy methods with bodies in the native strings.
-    //   foo() native 'return something';
-    // They should not be used.
-
-    ResolutionFunctionType type = method.type;
+    FunctionType type = _closedWorld.elementEnvironment.getFunctionType(method);
     if (type.namedParameters.isNotEmpty) return null;
 
     // Return types on native methods don't need to be checked, since the
     // declaration has to be truthful.
 
     // The call site might omit optional arguments. The inlined code must
     // preserve the number of arguments, so check only the actual arguments.
 
     List<HInstruction> inputs = node.inputs.sublist(1);
     bool canInline = true;
     if (_options.enableTypeAssertions && inputs.length > 1) {
       // TODO(sra): Check if [input] is guaranteed to pass the parameter
       // type check.  Consider using a strengthened type check to avoid
       // passing `null` to primitive types since the native methods usually
       // have non-nullable primitive parameter types.
       canInline = false;
     } else {
       int inputPosition = 1; // Skip receiver.
-      void checkParameterType(ResolutionDartType type) {
+      void checkParameterType(DartType type) {
         if (inputPosition++ < inputs.length && canInline) {
           if (type.unaliased.isFunctionType) {
             canInline = false;
           }
         }
       }
 
       type.parameterTypes.forEach(checkParameterType);
       type.optionalParameterTypes.forEach(checkParameterType);
       type.namedParameterTypes.forEach(checkParameterType);
@@ skipping 2408 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }