Split NativeData

pkg/compiler/lib/src/native/enqueue.dart

 // Copyright (c) 2014, 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.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
@@ skipping 96 matching lines @@
     }
     processSubclassesOfNativeClasses(libraries);
     if (!enableLiveTypeAnalysis) {
       _registerTypeUses(impactBuilder, _nativeClasses, 'forced');
     }
   }
 
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
-      if (element.isClass && backend.isNative(element)) {
-        processNativeClass(element);
+      if (element.isClass) {
+        ClassElement cls = element;
+        if (backend.nativeData.isNativeClass(cls)) {
+          processNativeClass(element);
+        }
       }
     });
   }
 
   void processNativeClass(ClassElement classElement) {
     _nativeClasses.add(classElement);
     _unusedClasses.add(classElement);
     // Resolve class to ensure the class has valid inheritance info.
     classElement.ensureResolved(resolution);
   }
@@ skipping 18 matching lines @@
           }
         }
       });
     });
 
     // Resolve all the native classes and any classes that might extend them in
     // [potentialExtends], and then check that the properly resolved class is in
     // fact a subclass of a native class.
 
     ClassElement nativeSuperclassOf(ClassElement classElement) {
-      if (backend.isNative(classElement)) return classElement;
+      if (backend.nativeData.isNativeClass(classElement)) return classElement;
       if (classElement.superclass == null) return null;
       return nativeSuperclassOf(classElement.superclass);
     }
 
     void walkPotentialSubclasses(ClassElement element) {
       if (nativeClassesAndSubclasses.contains(element)) return;
       element.ensureResolved(resolution);
       ClassElement nativeSuperclass = nativeSuperclassOf(element);
       if (nativeSuperclass != null) {
         nativeClassesAndSubclasses.add(element);
@@ skipping 124 matching lines @@
       cls.ensureResolved(resolution);
       impactBuilder
           .registerTypeUse(new TypeUse.nativeInstantiation(cls.rawType));
     }
   }
 
   void handleFieldAnnotations(Element element) {
     if (compiler.serialization.isDeserialized(element)) {
       return;
     }
-    if (backend.isNative(element.enclosingElement)) {
-      // Exclude non-instance (static) fields - they not really native and are
-      // compiled as isolate globals.  Access of a property of a constructor
+    if (element.isInstanceMember &&
+        backend.nativeData.isNativeClass(element.enclosingClass)) {
+      // Exclude non-instance (static) fields - they are not really native and
+      // are compiled as isolate globals.  Access of a property of a constructor
       // function or a non-method property in the prototype chain, must be coded
       // using a JS-call.
-      if (element.isInstanceMember) {
-        _setNativeName(element);
-      }
+      _setNativeName(element);
     }
   }
 
   void handleMethodAnnotations(Element method) {
     if (compiler.serialization.isDeserialized(method)) {
       return;
     }
     if (isNativeMethod(method)) {
       if (method.isStatic) {
         _setNativeNameForStaticMethod(method);
       } else {
         _setNativeName(method);
       }
     }
   }
 
   /// Sets the native name of [element], either from an annotation, or
   /// defaulting to the Dart name.
   void _setNativeName(MemberElement element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
-    backend.nativeData.setNativeMemberName(element, name);
+    backend.nativeDataBuilder.setNativeMemberName(element, name);
   }
 
   /// Sets the native name of the static native method [element], using the
   /// following rules:
   /// 1. If [element] has a @JSName annotation that is an identifier, qualify
   ///    that identifier to the @Native name of the enclosing class
   /// 2. If [element] has a @JSName annotation that is not an identifier,
   ///    use the declared @JSName as the expression
   /// 3. If [element] does not have a @JSName annotation, qualify the name of
   ///    the method with the @Native name of the enclosing class.
   void _setNativeNameForStaticMethod(MethodElement element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     if (isIdentifier(name)) {
-      List<String> nativeNames =
-          backend.nativeData.getNativeTagsOfClassRaw(element.enclosingClass);
+      List<String> nativeNames = backend.nativeDataBuilder
+          .getNativeTagsOfClassRaw(element.enclosingClass);
       if (nativeNames.length != 1) {
         reporter.internalError(
             element,
             'Unable to determine a native name for the enclosing class, '
             'options: $nativeNames');
       }
-      backend.nativeData
+      backend.nativeDataBuilder
           .setNativeMemberName(element, '${nativeNames[0]}.$name');
     } else {
-      backend.nativeData.setNativeMemberName(element, name);
+      backend.nativeDataBuilder.setNativeMemberName(element, name);
     }
   }
 
   bool isIdentifier(String s) => _identifier.hasMatch(s);
 
   bool isNativeMethod(FunctionElementX element) {
     if (!backend.canLibraryUseNative(element.library)) return false;
     // Native method?
     return reporter.withCurrentElement(element, () {
       Node node = element.parseNode(resolution.parsingContext);
@@ skipping 110 matching lines @@
 
   void registerBackendUse(MethodElement element) {
     _backendUsageBuilder.registerBackendFunctionUse(element);
     _backendUsageBuilder.registerGlobalFunctionDependency(element);
   }
 
   void processNativeClass(ClassElement classElement) {
     super.processNativeClass(classElement);
 
     // Js Interop interfaces do not have tags.
-    if (backend.isJsInterop(classElement)) return;
+    if (backend.nativeData.isJsInterop(classElement)) return;
     // Since we map from dispatch tags to classes, a dispatch tag must be used
     // on only one native class.
     for (String tag in backend.nativeData.getNativeTagsOfClass(classElement)) {
       ClassElement owner = tagOwner[tag];
       if (owner != null) {
         if (owner != classElement) {
           reporter.internalError(
               classElement, "Tag '$tag' already in use by '${owner.name}'");
         }
       } else {
@@ skipping 82 matching lines @@
     super._registerTypeUses(impactBuilder, classes, cause);
 
     for (ClassElement classElement in classes) {
       // Add the information that this class is a subtype of its supertypes. The
       // code emitter and the ssa builder use that information.
       _addSubtypes(classElement, emitter.nativeEmitter);
     }
   }
 
   void _addSubtypes(ClassElement cls, NativeEmitter emitter) {
-    if (!backend.isNative(cls)) return;
+    if (!backend.nativeData.isNativeClass(cls)) return;
     if (doneAddSubtypes.contains(cls)) return;
     doneAddSubtypes.add(cls);
 
     // Walk the superclass chain since classes on the superclass chain might not
     // be instantiated (abstract or simply unused).
     _addSubtypes(cls.superclass, emitter);
 
     for (ResolutionInterfaceType type in cls.allSupertypes) {
       List<ClassEntity> subtypes =
           emitter.subtypes.putIfAbsent(type.element, () => <ClassEntity>[]);
       subtypes.add(cls);
     }
 
     // Skip through all the mixin applications in the super class
     // chain. That way, the direct subtypes set only contain the
     // natives classes.
     ClassElement superclass = cls.superclass;
     while (superclass != null && superclass.isMixinApplication) {
-      assert(!backend.isNative(superclass));
+      assert(!backend.nativeData.isNativeClass(superclass));
       superclass = superclass.superclass;
     }
 
     List<ClassEntity> directSubtypes =
         emitter.directSubtypes.putIfAbsent(superclass, () => <ClassEntity>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${_registeredClasses.length} native classes, '
         '${_unusedClasses.length} native classes omitted.');
   }
 }