Split NativeData

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';
@@ skipping 450 matching lines @@
         closedWorld.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null &&
         element.isFunction
         // If we found out that the only target is an implicitly called
         // [:noSuchMethod:] we just ignore it.
         &&
         node.selector.applies(element)) {
       MethodElement method = element;
 
-      if (backend.isNative(method)) {
+      if (backend.nativeData.isNativeMember(method)) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
         ResolutionFunctionType type = method.type;
         int optionalParameterCount =
             type.optionalParameterTypes.length + type.namedParameters.length;
         if (optionalParameterCount == 0 ||
             type.parameterTypes.length + optionalParameterCount ==
                 node.selector.argumentCount) {
           node.element = method;
         }
       }
       return node;
     }
 
     // Replace method calls through fields with a closure call on the value of
     // the field. This usually removes the demand for the call-through stub and
     // makes the field load available to further optimization, e.g. LICM.
 
     if (element != null &&
         element.isField &&
         element.name == node.selector.name) {
       FieldEntity field = element;
-      if (!backend.isNative(field) && !node.isCallOnInterceptor(closedWorld)) {
+      if (!backend.nativeData.isNativeMember(field) &&
+          !node.isCallOnInterceptor(closedWorld)) {
         HInstruction receiver = node.getDartReceiver(closedWorld);
         TypeMask type = TypeMaskFactory.inferredTypeForElement(
             field as Entity, globalInferenceResults);
         HInstruction load = new HFieldGet(field, receiver, type);
         node.block.addBefore(node, load);
         Selector callSelector = new Selector.callClosureFrom(node.selector);
         List<HInstruction> inputs = <HInstruction>[load]
           ..addAll(node.inputs.skip(node.isInterceptedCall ? 2 : 1));
         HInstruction closureCall =
             new HInvokeClosure(callSelector, inputs, node.instructionType)
@@ skipping 54 matching lines @@
       type.parameterTypes.forEach(checkParameterType);
       type.optionalParameterTypes.forEach(checkParameterType);
       type.namedParameterTypes.forEach(checkParameterType);
     }
 
     if (!canInline) return null;
 
     // Strengthen instruction type from annotations to help optimize
     // dependent instructions.
     native.NativeBehavior nativeBehavior =
-        backend.getNativeMethodBehavior(method);
+        backend.nativeData.getNativeMethodBehavior(method);
     TypeMask returnType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     HInvokeDynamicMethod result =
         new HInvokeDynamicMethod(node.selector, node.mask, inputs, returnType);
     result.element = method;
     return result;
   }
 
   HInstruction visitBoundsCheck(HBoundsCheck node) {
     HInstruction index = node.index;
@@ skipping 368 matching lines @@
           node.sideEffects.clearAllDependencies();
           node.sideEffects.clearAllSideEffects();
           node.setUseGvn(); // We don't care about identity of tear-offs.
         }
       }
     }
     return node;
   }
 
   HInstruction directFieldGet(HInstruction receiver, FieldEntity field) {
-    bool isAssignable = !closedWorld.fieldNeverChanges(field as MemberEntity);
+    bool isAssignable = !closedWorld.fieldNeverChanges(field);
 
     TypeMask type;
-    if (backend.isNative(field.enclosingClass)) {
+    if (backend.nativeData.isNativeClass(field.enclosingClass)) {
       type = TypeMaskFactory.fromNativeBehavior(
-          backend.getNativeFieldLoadBehavior(field), closedWorld);
+          backend.nativeData.getNativeFieldLoadBehavior(field), closedWorld);
     } else {
       type = TypeMaskFactory.inferredTypeForElement(
           field as Entity, globalInferenceResults);
     }
 
     return new HFieldGet(field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
@@ skipping 1803 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }