Split NativeData

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;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show BackendClasses, ForeignResolver, NativeRegistry;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
-import '../common/names.dart' show Identifiers, Uris;
+import '../common/names.dart' show Uris;
 import '../common/resolution.dart'
     show Frontend, Resolution, ResolutionImpact, Target;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
@@ skipping 14 matching lines @@
 import '../io/start_end_information.dart'
     show StartEndSourceInformationStrategy;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js/js_source_mapping.dart' show JavaScriptSourceInformationStrategy;
 import '../js/rewrite_async.dart';
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask;
 import '../kernel/task.dart';
 import '../library_loader.dart' show LibraryLoader, LoadedLibraries;
 import '../native/native.dart' as native;
-import '../options.dart' show CompilerOptions;
 import '../patch_parser.dart'
     show checkNativeAnnotation, checkJsInteropAnnotation;
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
 import '../tracer.dart';
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart';
 import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/world_impact.dart'
@@ skipping 16 matching lines @@
 import 'custom_elements_analysis.dart';
 import 'enqueuer.dart';
 import 'impact_transformer.dart';
 import 'interceptor_data.dart';
 import 'js_interop_analysis.dart' show JsInteropAnalysis;
 import 'lookup_map_analysis.dart'
     show LookupMapLibraryAccess, LookupMapAnalysis;
 import 'mirrors_analysis.dart';
 import 'mirrors_data.dart';
 import 'namer.dart';
-import 'native_data.dart' show NativeData;
+import 'native_data.dart';
 import 'no_such_method_registry.dart';
 import 'patch_resolver.dart';
 import 'resolution_listener.dart';
 import 'type_variable_handler.dart';
 
 part 'runtime_types.dart';
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 abstract class FunctionCompiler {
@@ skipping 205 matching lines @@
   }
 }
 
 enum SyntheticConstantKind {
   DUMMY_INTERCEPTOR,
   EMPTY_VALUE,
   TYPEVARIABLE_REFERENCE, // Reference to a type in reflection data.
   NAME
 }
 
-class JavaScriptBackend extends Target {
+class JavaScriptBackend {
   final Compiler compiler;
 
   String get patchVersion => emitter.patchVersion;
 
   /// Returns true if the backend supports reflection.
   bool get supportsReflection => emitter.supportsReflection;
 
   final Annotations annotations;
 
   /// Set of classes that need to be considered for reflection although not
@@ skipping 100 matching lines @@
   JavaScriptImpactTransformer impactTransformer;
 
   PatchResolverTask patchResolverTask;
 
   /// The strategy used for collecting and emitting source information.
   SourceInformationStrategy sourceInformationStrategy;
 
   /// Interface for serialization of backend specific data.
   JavaScriptBackendSerialization serialization;
 
-  final NativeData nativeData = new NativeData();
+  final NativeDataImpl _nativeData = new NativeDataImpl();
+  NativeData get nativeData => _nativeData;
+  NativeDataBuilder get nativeDataBuilder => _nativeData;
   InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   ResolutionEnqueuerListener _resolutionEnqueuerListener;
   CodegenEnqueuerListener _codegenEnqueuerListener;
 
   BackendHelpers helpers;
   BackendImpacts impacts;
 
   /// Common classes used by the backend.
   BackendClasses backendClasses;
 
   /// Backend access to the front-end.
   final JSFrontendAccess frontend;
 
+  Target _target;
+
   Tracer tracer;
 
   static SourceInformationStrategy createSourceInformationStrategy(
       {bool generateSourceMap: false,
       bool useMultiSourceInfo: false,
       bool useNewSourceInfo: false}) {
     if (!generateSourceMap) return const JavaScriptSourceInformationStrategy();
     if (useMultiSourceInfo) {
       if (useNewSourceInfo) {
         return const MultiSourceInformationStrategy(const [
@@ skipping 21 matching lines @@
       bool useKernel: false})
       : _rti = new _RuntimeTypes(compiler),
         annotations = new Annotations(compiler),
         this.sourceInformationStrategy = createSourceInformationStrategy(
             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);
     mirrorsData = new MirrorsData(
         compiler, compiler.options, commonElements, helpers, constants);
     _backendUsageBuilder = new BackendUsageBuilderImpl(
         compiler.elementEnvironment, commonElements, helpers);
     _checkedModeHelpers = new CheckedModeHelpers(commonElements, helpers);
     emitter =
@@ skipping 64 matching lines @@
   /// The [ConstantSystem] used to interpret compile-time constants for this
   /// backend.
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   CommonElements get commonElements => compiler.commonElements;
 
   Resolution get resolution => compiler.resolution;
 
+  Target get target => _target;
+
   InterceptorData get interceptorData {
     assert(invariant(NO_LOCATION_SPANNABLE, _interceptorData != null,
         message: "InterceptorData has not been computed yet."));
     return _interceptorData;
   }
 
   OneShotInterceptorData get oneShotInterceptorData {
     assert(invariant(NO_LOCATION_SPANNABLE, _oneShotInterceptorData != null,
         message: "OneShotInterceptorData has not been prepared yet."));
     return _oneShotInterceptorData;
@@ skipping 49 matching lines @@
       _resolutionEnqueuerListener;
 
   EnqueuerListener get codegenEnqueuerListener => _codegenEnqueuerListener;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
-  @override
   bool isDefaultNoSuchMethod(MethodElement element) {
     return noSuchMethodRegistry.isDefaultNoSuchMethodImplementation(element);
   }
 
   MethodElement resolveExternalFunction(MethodElement element) {
     if (isForeign(element)) {
       return element;
     }
-    if (isJsInterop(element)) {
+    if (nativeData.isJsInterop(element)) {
       if (element.memberName == const PublicName('[]') ||
           element.memberName == const PublicName('[]=')) {
         reporter.reportErrorMessage(
             element, MessageKind.JS_INTEROP_INDEX_NOT_SUPPORTED);
       }
       return element;
     }
     return patchResolverTask.measure(() {
       return patchResolverTask.resolveExternalFunction(element);
     });
@@ skipping 53 matching lines @@
     return !selector.isGetter;
   }
 
   /**
    * Returns `true` if [member] is called from a subclass via `super`.
    */
   bool isAliasedSuperMember(FunctionElement member) {
     return aliasedSuperMembers.contains(member);
   }
 
-  /// Returns `true` if [element] is implemented via typed JavaScript interop.
-  @override
-  bool isJsInterop(Element element) => nativeData.isJsInterop(element);
-
-  /// Returns `true` if [element] is a JsInterop class.
-  bool isJsInteropClass(ClassElement element) => isJsInterop(element);
-
-  /// Returns `true` if [element] is a JsInterop method.
-  bool isJsInteropMethod(MethodElement element) => isJsInterop(element);
-
-  /// Whether [element] corresponds to a native JavaScript construct either
-  /// through the native mechanism (`@Native(...)` or the `native` pseudo
-  /// keyword) which is only allowed for internal libraries or via the typed
-  /// JavaScriptInterop mechanism which is allowed for user libraries.
-  @override
-  bool isNative(Entity element) => nativeData.isNative(element);
-
-  /// Returns the [NativeBehavior] for calling the native [method].
-  native.NativeBehavior getNativeMethodBehavior(MethodElement method) {
-    return nativeData.getNativeMethodBehavior(method);
-  }
-
-  /// Returns the [NativeBehavior] for reading from the native [field].
-  native.NativeBehavior getNativeFieldLoadBehavior(FieldElement field) {
-    return nativeData.getNativeFieldLoadBehavior(field);
-  }
-
-  /// Returns the [NativeBehavior] for writing to the native [field].
-  native.NativeBehavior getNativeFieldStoreBehavior(FieldElement field) {
-    return nativeData.getNativeFieldStoreBehavior(field);
-  }
-
-  @override
-  void resolveNativeElement(Element element, NativeRegistry registry) {
+  void resolveNativeElement(MemberElement element, NativeRegistry registry) {
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
       compiler.enqueuer.resolution.nativeEnqueuer
           .handleMethodAnnotations(element);
-      if (isNative(element)) {
+      if (nativeData.isNativeMember(element)) {
         native.NativeBehavior behavior =
             native.NativeBehavior.ofMethodElement(element, compiler);
-        nativeData.setNativeMethodBehavior(element, behavior);
+        nativeDataBuilder.setNativeMethodBehavior(element, behavior);
         registry.registerNativeData(behavior);
       }
     } else if (element.isField) {
       compiler.enqueuer.resolution.nativeEnqueuer
           .handleFieldAnnotations(element);
-      if (isNative(element)) {
+      if (nativeData.isNativeMember(element)) {
         native.NativeBehavior fieldLoadBehavior =
             native.NativeBehavior.ofFieldElementLoad(element, compiler);
         native.NativeBehavior fieldStoreBehavior =
             native.NativeBehavior.ofFieldElementStore(element, compiler);
-        nativeData.setNativeFieldLoadBehavior(element, fieldLoadBehavior);
-        nativeData.setNativeFieldStoreBehavior(element, fieldStoreBehavior);
+        nativeDataBuilder.setNativeFieldLoadBehavior(
+            element, fieldLoadBehavior);
+        nativeDataBuilder.setNativeFieldStoreBehavior(
+            element, fieldStoreBehavior);
 
         // TODO(sra): Process fields for storing separately.
         // We have to handle both loading and storing to the field because we
         // only get one look at each member and there might be a load or store
         // we have not seen yet.
         registry.registerNativeData(fieldLoadBehavior);
         registry.registerNativeData(fieldStoreBehavior);
       }
     }
   }
@@ skipping 271 matching lines @@
 
   native.NativeEnqueuer nativeResolutionEnqueuer() {
     return new native.NativeResolutionEnqueuer(compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer() {
     return new native.NativeCodegenEnqueuer(compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
-    if (isJsInterop(element)) {
+    if (nativeData.isJsInterop(element)) {
       return helpers.jsJavaScriptObjectClass;
     }
     // Native classes inherit from Interceptor.
-    return isNative(element)
+    return nativeData.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 78 matching lines @@
       if (canLibraryUseNative(library)) {
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
             checkNativeAnnotation(compiler, element);
           }
         });
       }
       checkJsInteropAnnotation(compiler, library);
       library.forEachLocalMember((Element element) {
         checkJsInteropAnnotation(compiler, element);
-        if (element.isClass && isJsInterop(element)) {
+        if (element.isClass && nativeData.isJsInterop(element)) {
           ClassElement classElement = element;
           classElement.forEachMember((_, memberElement) {
             checkJsInteropAnnotation(compiler, memberElement);
           });
         }
       });
     }
     if (library.isPlatformLibrary &&
         // Don't patch library currently disallowed.
         !library.isSynthesized &&
@@ skipping 101 matching lines @@
   }
 
   // Does this element belong in the output
   bool shouldOutput(Element element) => true;
 
   /// Returns `true` if the `native` pseudo keyword is supported for [library].
   bool canLibraryUseNative(LibraryElement library) {
     return native.maybeEnableNative(compiler, library);
   }
 
-  @override
   bool isTargetSpecificLibrary(LibraryElement library) {
     Uri canonicalUri = library.canonicalUri;
     if (canonicalUri == BackendHelpers.DART_JS_HELPER ||
         canonicalUri == BackendHelpers.DART_INTERCEPTORS) {
       return true;
     }
     return false;
   }
 
   /// Process backend specific annotations.
@@ skipping 288 matching lines @@
 
   bool isDefaultEqualityImplementation(MemberElement element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == helpers.commonElements.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   @override
-  bool isNativeClass(ClassElement element) {
-    return _nativeData.isNative(element);
+  bool isNativeClass(ClassEntity element) {
+    return _nativeData.isNativeClass(element);
   }
 
   @override
-  bool isNativeMember(MemberElement element) {
-    return _nativeData.isNative(element);
+  bool isNativeMember(MemberEntity element) {
+    return _nativeData.isNativeMember(element);
   }
 
   InterfaceType getConstantMapTypeFor(InterfaceType sourceType,
       {bool hasProtoKey: false, bool onlyStringKeys: false}) {
     ClassElement classElement = onlyStringKeys
         ? (hasProtoKey
             ? helpers.constantProtoMapClass
             : helpers.constantStringMapClass)
         : helpers.generalConstantMapClass;
     List<DartType> typeArgument = sourceType.typeArguments;
     if (sourceType.treatAsRaw) {
       return _env.getRawType(classElement);
     } else {
       return _env.createInterfaceType(classElement, typeArgument);
     }
   }
 
   @override
   FieldEntity get symbolField => helpers.symbolImplementationField;
 
   @override
   InterfaceType get symbolType {
     return _env.getRawType(helpers.symbolImplementationClass);
   }
 }
+
+class JavaScriptBackendTarget extends Target {
+  final JavaScriptBackend _backend;
+
+  JavaScriptBackendTarget(this._backend);
+
+  @override
+  bool isTargetSpecificLibrary(LibraryElement element) {
+    return _backend.isTargetSpecificLibrary(element);
+  }
+
+  @override
+  void resolveNativeElement(MemberElement element, NativeRegistry registry) {
+    return _backend.resolveNativeElement(element, registry);
+  }
+
+  @override
+  MethodElement resolveExternalFunction(MethodElement element) {
+    return _backend.resolveExternalFunction(element);
+  }
+
+  @override
+  dynamic resolveForeignCall(Send node, Element element,
+      CallStructure callStructure, ForeignResolver resolver) {
+    return _backend.resolveForeignCall(node, element, callStructure, resolver);
+  }
+
+  @override
+  bool isDefaultNoSuchMethod(MethodElement element) {
+    return _backend.isDefaultNoSuchMethod(element);
+  }
+
+  @override
+  ClassElement defaultSuperclass(ClassElement element) {
+    return _backend.defaultSuperclass(element);
+  }
+
+  @override
+  bool isNativeClass(ClassEntity element) =>
+      _backend.nativeData.isNativeClass(element);
+
+  @override
+  bool isForeign(Element element) => _backend.isForeign(element);
+}