Add NativeDataResolver

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 29 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 '../patch_parser.dart'
-    show checkNativeAnnotation, checkJsInteropAnnotation;
+import '../native/resolver.dart';
 import '../ssa/ssa.dart' show SsaFunctionCompiler;
 import '../tracer.dart';
 import '../tree/tree.dart';
 import '../types/types.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'
     show
@@ skipping 367 matching lines @@
   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;
+  final NativeDataResolver _nativeDataResolver;
   InterceptorDataBuilder _interceptorDataBuilder;
   InterceptorData _interceptorData;
   OneShotInterceptorData _oneShotInterceptorData;
   BackendUsage _backendUsage;
   BackendUsageBuilder _backendUsageBuilder;
   MirrorsData mirrorsData;
   CheckedModeHelpers _checkedModeHelpers;
 
   ResolutionEnqueuerListener _resolutionEnqueuerListener;
 
@@ skipping 30 matching lines @@
           const PositionSourceInformationStrategy()
         ]);
       }
     } else if (useNewSourceInfo) {
       return const PositionSourceInformationStrategy();
     } else {
       return const StartEndSourceInformationStrategy();
     }
   }
 
-  JavaScriptBackend(Compiler compiler,
+  JavaScriptBackend(this.compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useMultiSourceInfo: false,
       bool useNewSourceInfo: false,
       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 {
+        _nativeDataResolver = new NativeDataResolverImpl(compiler) {
     _target = new JavaScriptBackendTarget(this);
     helpers = new BackendHelpers(compiler.elementEnvironment, commonElements);
     impacts = new BackendImpacts(compiler.options, commonElements, helpers);
     backendClasses = new JavaScriptBackendClasses(
         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);
@@ skipping 143 matching lines @@
   }
 
   bool isDefaultNoSuchMethod(MethodElement element) {
     return noSuchMethodRegistry.isDefaultNoSuchMethodImplementation(element);
   }
 
   MethodElement resolveExternalFunction(MethodElement element) {
     if (isForeign(element)) {
       return element;
     }
-    if (nativeData.isJsInterop(element)) {
+    if (_nativeDataResolver.isJsInteropMember(element)) {

[Siggi Cherem (dart-lang), 2017/03/14 04:09:15]

was the jsinterop check within patchResolver.resolveExternalFunction unreachable
because of this check here?

[Johnni Winther, 2017/03/15 10:55:13]

Yes.

       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 58 matching lines @@
     return !selector.isGetter;
   }
 
   /**
    * Returns `true` if [member] is called from a subclass via `super`.
    */
   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 (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 (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.
-        // 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);
-      }
-    }
-  }
-
   /// Maps compile-time classes to their runtime class.  The runtime class is
   /// always a superclass or the class itself.
   ClassElement getRuntimeClass(ClassElement class_) {
     if (class_.isSubclassOf(helpers.jsIntClass)) return helpers.jsIntClass;
     if (class_.isSubclassOf(helpers.jsArrayClass)) return helpers.jsArrayClass;
     return class_;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(operatorEqfunction.enclosingClass);
@@ skipping 356 matching lines @@
         element == helpers.jsUnmodifiableArrayClass;
   }
 
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     if (!compiler.serialization.isDeserialized(library)) {
       if (canLibraryUseNative(library)) {
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
-            checkNativeAnnotation(compiler, element);
+            checkNativeAnnotation(compiler, element, nativeClassDataBuilder);
           }
         });
       }
-      checkJsInteropAnnotation(compiler, library);
-      library.forEachLocalMember((Element element) {
-        checkJsInteropAnnotation(compiler, element);
-        if (element.isClass && nativeData.isJsInterop(element)) {
-          ClassElement classElement = element;
-          classElement.forEachMember((_, memberElement) {
-            checkJsInteropAnnotation(compiler, memberElement);
-          });
-        }
-      });
+      checkJsInteropClassAnnotations(compiler, library, nativeClassDataBuilder);
     }
     if (library.isPlatformLibrary &&
         // Don't patch library currently disallowed.
         !library.isSynthesized &&
         !library.isPatched &&
         // Don't patch deserialized libraries.
         !compiler.serialization.isDeserialized(library)) {
       // Apply patch, if any.
       Uri patchUri = compiler.resolvePatchUri(library.canonicalUri.path);
       if (patchUri != null) {
@@ skipping 408 matching lines @@
     return classElement == helpers.commonElements.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
 
   @override
   bool isNativeClass(ClassEntity element) {
     return _nativeData.isNativeClass(element);
   }
 
-  @override
-  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);
@@ skipping 15 matching lines @@
   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);
+  void resolveNativeMember(MemberElement element, NativeRegistry registry) {
+    return _backend._nativeDataResolver.resolveNativeMember(element, registry);
   }
 
   @override
   MethodElement resolveExternalFunction(MethodElement element) {
     return _backend.resolveExternalFunction(element);
   }
 
   @override
   dynamic resolveForeignCall(Send node, Element element,
       CallStructure callStructure, ForeignResolver resolver) {
@@ skipping 10 matching lines @@
     return _backend.defaultSuperclass(element);
   }
 
   @override
   bool isNativeClass(ClassEntity element) =>
       _backend.nativeClassData.isNativeClass(element);
 
   @override
   bool isForeign(Element element) => _backend.isForeign(element);
 }