Split NativeData

pkg/compiler/lib/src/universe/world_builder.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.
 
 library universe;
 
 import 'dart:collection';
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 542 matching lines @@
   void registerTypeInstantiation(
       ResolutionInterfaceType type, ClassUsedCallback classUsed,
       {ConstructorElement constructor,
       bool byMirrors: false,
       bool isRedirection: false}) {
     ClassElement cls = type.element;
     cls.ensureResolved(_resolution);
     InstantiationInfo info =
         _instantiationInfo.putIfAbsent(cls, () => new InstantiationInfo());
     Instantiation kind = Instantiation.UNINSTANTIATED;
-    bool isNative = _backend.isNative(cls);
+    bool isNative = _backend.nativeData.isNativeClass(cls);
     if (!cls.isAbstract ||
         // We can't use the closed-world assumption with native abstract
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
         isNative ||
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
         // TODO(herhut): Track classes required by mirrors seperately.
         byMirrors) {
@@ skipping 290 matching lines @@
     String memberName = member.name;
     member.computeType(_resolution);
     // The obvious thing to test here would be "member.isNative",
     // however, that only works after metadata has been parsed/analyzed,
     // and that may not have happened yet.
     // So instead we use the enclosing class, which we know have had
     // its metadata parsed and analyzed.
     // Note: this assumes that there are no non-native fields on native
     // classes, which may not be the case when a native class is subclassed.
     _instanceMemberUsage.putIfAbsent(member, () {
-      bool isNative = _backend.isNative(cls);
+      bool isNative = _backend.nativeData.isNativeClass(cls);
       _MemberUsage usage = new _MemberUsage(member, isNative: isNative);
       EnumSet<MemberUse> useSet = new EnumSet<MemberUse>();
       useSet.addAll(usage.appliedUse);
       if (member.isField && isNative) {
         registerUsedElement(member);
       }
       if (member.isFunction &&
           member.name == Identifiers.call &&
           !cls.typeVariables.isEmpty) {
         callMethodsWithFreeTypeVariables.add(member);
@@ skipping 368 matching lines @@
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(
       ResolutionInterfaceType type, ClassUsedCallback classUsed,
       {bool byMirrors: false}) {
     ClassElement cls = type.element;
-    bool isNative = _backend.isNative(cls);
+    bool isNative = _backend.nativeData.isNativeClass(cls);
     _instantiatedTypes.add(type);
     if (!cls.isAbstract
         // We can't use the closed-world assumption with native abstract
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
         ||
         isNative
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
@@ skipping 221 matching lines @@
       _getMemberUsage(member, memberUsed);
     });
   }
 
   _MemberUsage _getMemberUsage(
       MemberElement member, MemberUsedCallback memberUsed) {
     assert(invariant(member, member.isDeclaration));
     return _instanceMemberUsage.putIfAbsent(member, () {
       String memberName = member.name;
       ClassElement cls = member.enclosingClass;
-      bool isNative = _backend.isNative(cls);
+      bool isNative = _backend.nativeData.isNativeClass(cls);
       _MemberUsage usage = new _MemberUsage(member, isNative: isNative);
       EnumSet<MemberUse> useSet = new EnumSet<MemberUse>();
       useSet.addAll(usage.appliedUse);
       if (hasInvokedGetter(member, _world)) {
         useSet.addAll(usage.read());
       }
       if (hasInvokedSetter(member, _world)) {
         useSet.addAll(usage.write());
       }
       if (hasInvocation(member, _world)) {
@@ skipping 427 matching lines @@
     if (hasClosurization) {
       return MemberUses.NONE;
     }
     hasNormalUse = hasClosurization = true;
     return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }