Split NativeData

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.
 
 library dart2js.js_emitter.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 574 matching lines @@
       Iterable<Method> staticFunctions, Fragment fragment) {
     if (staticFunctions == null) return;
 
     for (Method method in staticFunctions) {
       MethodElement element = method.element;
       // We need to filter out null-elements for the interceptors.
       // TODO(floitsch): use the precomputed interceptors here.
       if (element == null) continue;
       ClassBuilder builder = new ClassBuilder.forStatics(element, namer);
       containerBuilder.addMemberMethod(method, builder);
-      getElementDescriptor(element, fragment)
+      getStaticMethodDescriptor(element, fragment)
           .properties
           .addAll(builder.properties);
     }
   }
 
   jsAst.Statement buildStaticNonFinalFieldInitializations(
       OutputUnit outputUnit) {
     jsAst.Statement buildInitialization(
         Element element, jsAst.Expression initialValue) {
       return js.statement('${namer.staticStateHolder}.# = #',
@@ skipping 538 matching lines @@
           embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME, js.boolean(true));
 
       // We can be pretty sure that the objectClass is initialized, since
       // typedefs are only emitted with reflection, which requires lots of
       // classes.
       assert(commonElements.objectClass != null);
       builder.superName = namer.className(commonElements.objectClass);
       jsAst.Node declaration = builder.toObjectInitializer();
       jsAst.Name mangledName = namer.globalPropertyName(typedef);
       String reflectionName = getReflectionName(typedef, mangledName);
-      getElementDescriptor(library, mainFragment)
+      getLibraryDescriptor(library, mainFragment)
         ..addProperty(mangledName, declaration)
         ..addPropertyByName("+$reflectionName", js.string(''));
       // Also emit a trivial constructor for CSP mode.
       jsAst.Name constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<jsAst.Name> fieldNames = [];
       assemblePrecompiledConstructor(
           mainOutputUnit, constructorName, constructorAst, fieldNames);
     }
   }
@@ skipping 130 matching lines @@
           pendingStatics.first, 'Pending statics (see above).');
     }
   }
 
   void assembleLibrary(Library library, Fragment fragment) {
     LibraryElement libraryElement = library.element;
 
     assembleStaticFunctions(library.statics, fragment);
 
     ClassBuilder libraryBuilder =
-        getElementDescriptor(libraryElement, fragment);
+        getLibraryDescriptor(libraryElement, fragment);
     for (Class cls in library.classes) {
       assembleClass(cls, libraryBuilder, fragment);
     }
 
     classEmitter.emitFields(library, libraryBuilder, emitStatics: true);
   }
 
   void assembleProgram(Program program) {
     for (Fragment fragment in program.fragments) {
       for (Library library in fragment.libraries) {
@@ skipping 323 matching lines @@
     });
     emitMainOutputUnit(program.mainFragment.outputUnit, mainOutput);
 
     if (backend.backendUsage.requiresPreamble && !backend.htmlLibraryIsLoaded) {
       reporter.reportHintMessage(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
-  ClassBuilder getElementDescriptor(Element element, Fragment fragment) {
+  ClassBuilder getStaticMethodDescriptor(
+      MethodElement element, Fragment fragment) {
     Element owner = element.library;
-    if (!element.isLibrary &&
-        !element.isTopLevel &&
-        !backend.isNative(element)) {
+    if (!backend.nativeData.isNativeMember(element)) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
-      ClassElement cls = element.enclosingClassOrCompilationUnit.declaration;
+      ClassElement cls = element.enclosingClass;
       if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
               .contains(cls) &&
-          !backend.isNative(cls) &&
+          !backend.nativeData.isNativeClass(cls) &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
         owner = cls;
       }
     }
+    return _getElementDescriptor(element, owner, fragment);
+  }
+
+  ClassBuilder getLibraryDescriptor(LibraryElement element, Fragment fragment) {
+    return _getElementDescriptor(element, element, fragment);
+  }
+
+  ClassBuilder _getElementDescriptor(
+      Element element, Element owner, Fragment fragment) {
     if (owner == null) {
       reporter.internalError(element, 'Owner is null.');
     }
     return elementDescriptors
         .putIfAbsent(fragment, () => new Map<Element, ClassBuilder>())
         .putIfAbsent(owner, () {
       return new ClassBuilder(owner, namer, owner.isClass);
     });
   }
 
@@ skipping 244 matching lines @@
     // data.
     mapping["_comment"] = "This mapping shows which compiled `.js` files are "
         "needed for a given deferred library import.";
     mapping.addAll(compiler.deferredLoadTask.computeDeferredMap());
     compiler.outputProvider(
         compiler.options.deferredMapUri.path, '', OutputType.info)
       ..add(const JsonEncoder.withIndent("  ").convert(mapping))
       ..close();
   }
 }