Avoid using wrong 'adaptor' for native methods.

pkg/compiler/lib/src/cps_ir/inline.dart

 // Copyright (c) 2015, 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 cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 305 matching lines @@
           ++nameIndex;
         } else {
           Constant defaultValue = cps.makeConstant(
               backend.constants.getConstantValueForVariable(formal));
           defaultValue.type = typeSystem.getParameterType(formal);
           arguments.add(defaultValue);
         }
         outgoingNames.add(formal.name);
       });
       newCallStructure =
-      new CallStructure(signature.parameterCount, outgoingNames);
+          new CallStructure(signature.parameterCount, outgoingNames);
     } else {
       signature.forEachOptionalParameter((ParameterElement formal) {
         if (parameterIndex < parameters.length) {
           arguments.add(parameters[parameterIndex++]);
         } else {
           Constant defaultValue = cps.makeConstant(
               backend.constants.getConstantValueForVariable(formal));
           defaultValue.type = typeSystem.getParameterType(formal);
           arguments.add(defaultValue);
         }
@@ skipping 97 matching lines @@
     if (backend.annotations.noInline(target)) return doNotInline();
     if (isRecursive(target, callStructure)) return doNotInline();
 
     FunctionDefinition function;
     if (callStructure != null &&
         target.functionSignature.parameterCount !=
             callStructure.argumentCount) {
       // The argument count at the call site does not match the target's
       // formal parameter count.  Build the IR term for an adapter function
       // body.
-      function = buildAdapter(invoke, target);
+      if (backend.isNative(target)) {
+        // TODO(25548): Generate correct adaptor for native methods.
+        return doNotInline();
+      } else {
+        function = buildAdapter(invoke, target);
+      }
     } else {
       function = _inliner.functionCompiler.compileToCpsIr(target);
       void setValue(Variable variable, Reference<Primitive> value) {
         variable.type = value.definition.type;
       }
       if (invoke.callingConvention == CallingConvention.Intercepted) {
         setValue(function.thisParameter, invoke.receiver);
         function.parameters[0].type = abstractReceiverInMethod;
         for (int i = 1; i < invoke.arguments.length; ++i) {
           setValue(function.parameters[i], invoke.arguments[i]);
@@ skipping 79 matching lines @@
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
 }