Add NativeClassData/NativeClassDataBuilder

pkg/compiler/lib/src/js_backend/backend.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 js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
@@ skipping 414 matching lines @@
 
   PatchResolverTask patchResolverTask;
 
   /// The strategy used for collecting and emitting source information.
   SourceInformationStrategy sourceInformationStrategy;
 
   /// Interface for serialization of backend specific data.
   JavaScriptBackendSerialization serialization;
 
   final NativeDataImpl _nativeData = new NativeDataImpl();
+  NativeClassData get nativeClassData => _nativeData;
   NativeData get nativeData => _nativeData;
+  NativeClassDataBuilder get nativeClassDataBuilder => _nativeData;
   NativeDataBuilder get nativeDataBuilder => _nativeData;
   InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   ResolutionEnqueuerListener _resolutionEnqueuerListener;
@@ skipping 50 matching lines @@
             generateSourceMap: generateSourceMap,
             useMultiSourceInfo: useMultiSourceInfo,
             useNewSourceInfo: useNewSourceInfo),
         frontend = new JSFrontendAccess(compiler),
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         this.compiler = compiler {
     _target = new JavaScriptBackendTarget(this);
     helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
     impacts = new BackendImpacts(compiler.options, commonElements, helpers);
     backendClasses = new JavaScriptBackendClasses(
-        compiler.elementEnvironment, helpers, nativeData);
+        compiler.elementEnvironment, helpers, nativeClassData);
     mirrorsData = new MirrorsData(
         compiler, compiler.options, commonElements, helpers, constants);
     _backendUsageBuilder = new BackendUsageBuilderImpl(
         compiler.elementEnvironment, commonElements, helpers);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
     emitter =
         new CodeEmitterTask(compiler, generateSourceMap, useStartupEmitter);
     _nativeResolutionEnqueuer = new native.NativeResolutionEnqueuer(compiler);
     _nativeCodegenEnqueuer = new native.NativeCodegenEnqueuer(
         compiler, emitter, _nativeResolutionEnqueuer);
 
     typeVariableAnalysis = new TypeVariableAnalysis(
         compiler.elementEnvironment, impacts, backendUsageBuilder);
     typeVariableHandler = new TypeVariableHandler(this, helpers, mirrorsData);
     customElementsResolutionAnalysis = new CustomElementsResolutionAnalysis(
         this,
         compiler.resolution,
         commonElements,
         backendClasses,
         helpers,
-        nativeData,
+        nativeClassData,
         backendUsageBuilder);
     customElementsCodegenAnalysis = new CustomElementsCodegenAnalysis(
         this,
         compiler.resolution,
         commonElements,
         backendClasses,
         helpers,
-        nativeData);
+        nativeClassData);
     jsInteropAnalysis = new JsInteropAnalysis(this);
     mirrorsAnalysis = new MirrorsAnalysis(this, compiler.resolution);
     lookupMapLibraryAccess =
         new LookupMapLibraryAccess(reporter, compiler.elementEnvironment);
     lookupMapAnalysis = new LookupMapAnalysis(this, compiler.options, reporter,
         compiler.elementEnvironment, commonElements, backendClasses);
 
     noSuchMethodRegistry = new NoSuchMethodRegistry(this);
     kernelTask = new KernelTask(compiler);
     impactTransformer = new JavaScriptImpactTransformer(this);
     patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(nativeData);
     _interceptorDataBuilder = new InterceptorDataBuilderImpl(
-        nativeData, helpers, commonElements, compiler.resolution);
+        nativeClassData, helpers, commonElements, compiler.resolution);
     _resolutionEnqueuerListener = new ResolutionEnqueuerListener(
         kernelTask,
         compiler.options,
         compiler.elementEnvironment,
         commonElements,
         helpers,
         impacts,
-        nativeData,
+        nativeClassData,
         _interceptorDataBuilder,
         _backendUsageBuilder,
         _rtiNeedBuilder,
         mirrorsData,
         noSuchMethodRegistry,
         customElementsResolutionAnalysis,
         lookupMapLibraryAccess,
         mirrorsAnalysis,
         typeVariableAnalysis,
         _nativeResolutionEnqueuer);
@@ skipping 109 matching lines @@
 
   bool isBackendLibrary(LibraryElement library) {
     return library == helpers.interceptorsLibrary ||
         library == helpers.jsHelperLibrary;
   }
 
   Namer determineNamer(
       ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
     return compiler.options.enableMinification
         ? compiler.options.useFrequencyNamer
-            ? new FrequencyBasedNamer(this, closedWorld, codegenWorldBuilder)
-            : new MinifyNamer(this, closedWorld, codegenWorldBuilder)
-        : new Namer(this, closedWorld, codegenWorldBuilder);
+            ? new FrequencyBasedNamer(
+                helpers, nativeData, closedWorld, codegenWorldBuilder)
+            : new MinifyNamer(
+                helpers, nativeData, closedWorld, codegenWorldBuilder)
+        : new Namer(helpers, nativeData, closedWorld, codegenWorldBuilder);
   }
 
   /// Returns true if global optimizations such as type inferencing can apply to
   /// the field [element].
   ///
   /// One category of elements that do not apply is runtime helpers that the
   /// backend calls, but the optimizations don't see those calls.
   bool canFieldBeUsedForGlobalOptimizations(FieldElement element) {
     return !backendUsage.isFieldUsedByBackend(element) &&
         !mirrorsData.invokedReflectively(element);
@@ skipping 36 matching lines @@
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
   void resolveNativeElement(MemberElement element, NativeRegistry registry) {
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
       _nativeResolutionEnqueuer.handleMethodAnnotations(element);
-      if (nativeData.isNativeMember(element)) {
+      if (nativeClassData.isNativeMember(element)) {
         native.NativeBehavior behavior =
             native.NativeBehavior.ofMethodElement(element, compiler);
         nativeDataBuilder.setNativeMethodBehavior(element, behavior);
         registry.registerNativeData(behavior);
       }
     } else if (element.isField) {
       _nativeResolutionEnqueuer.handleFieldAnnotations(element);
-      if (nativeData.isNativeMember(element)) {
+      if (nativeClassData.isNativeMember(element)) {
         native.NativeBehavior fieldLoadBehavior =
             native.NativeBehavior.ofFieldElementLoad(element, compiler);
         native.NativeBehavior fieldStoreBehavior =
             native.NativeBehavior.ofFieldElementStore(element, compiler);
         nativeDataBuilder.setNativeFieldLoadBehavior(
             element, fieldLoadBehavior);
         nativeDataBuilder.setNativeFieldStoreBehavior(
             element, fieldStoreBehavior);
 
         // TODO(sra): Process fields for storing separately.
@@ skipping 193 matching lines @@
       noSuchMethodRegistry.isComplex(element);
 
   /// Creates an [Enqueuer] for code generation specific to this backend.
   CodegenEnqueuer createCodegenEnqueuer(
       CompilerTask task, Compiler compiler, ClosedWorld closedWorld) {
     return new CodegenEnqueuer(
         task,
         compiler.options,
         const TreeShakingEnqueuerStrategy(),
         new CodegenWorldBuilderImpl(
-            this, closedWorld, const TypeMaskStrategy()),
+            nativeClassData, closedWorld, const TypeMaskStrategy()),
         new CodegenWorkItemBuilder(this, compiler.options),
         new CodegenEnqueuerListener(
             compiler.dumpInfoTask,
             compiler.elementEnvironment,
             commonElements,
             helpers,
             impacts,
             backendUsage,
             rtiNeed,
             mirrorsData,
@@ skipping 75 matching lines @@
     compiler.dumpInfoTask.registerImpact(element, worldImpact);
     return worldImpact;
   }
 
   native.NativeEnqueuer get nativeResolutionEnqueuer =>
       _nativeResolutionEnqueuer;
 
   native.NativeEnqueuer get nativeCodegenEnqueuer => _nativeCodegenEnqueuer;
 
   ClassElement defaultSuperclass(ClassElement element) {
-    if (nativeData.isJsInterop(element)) {
+    if (nativeClassData.isJsInteropClass(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
-    return nativeData.isNativeClass(element)
+    return nativeClassData.isNativeClass(element)
         ? helpers.jsInterceptorClass
         : commonElements.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String getGeneratedCode(Element element) {
@@ skipping 458 matching lines @@
       // TODO(johnniwinther): Allow emptying when serialization has been
       // performed.
       resolution.emptyCache();
     }
   }
 }
 
 class JavaScriptBackendClasses implements BackendClasses {
   final ElementEnvironment _env;
   final BackendHelpers helpers;
-  final NativeData _nativeData;
+  final NativeClassData _nativeData;
 
   JavaScriptBackendClasses(this._env, this.helpers, this._nativeData);
 
   ClassElement get intClass => helpers.jsIntClass;
   ClassElement get uint32Class => helpers.jsUInt32Class;
   ClassElement get uint31Class => helpers.jsUInt31Class;
   ClassElement get positiveIntClass => helpers.jsPositiveIntClass;
   ClassElement get doubleClass => helpers.jsDoubleClass;
   ClassElement get numClass => helpers.jsNumberClass;
   ClassElement get stringClass => helpers.jsStringClass;
@@ skipping 91 matching lines @@
     return _backend.isDefaultNoSuchMethod(element);
   }
 
   @override
   ClassElement defaultSuperclass(ClassElement element) {
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
-      _backend.nativeData.isNativeClass(element);
+      _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }