Add NativeDataResolver

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;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show FunctionElementX;
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/backend_usage.dart' show BackendUsageBuilder;
 import '../js_backend/js_backend.dart';
+import '../js_backend/native_data.dart' show NativeClassDataBuilder;
 import '../js_emitter/js_emitter.dart' show CodeEmitterTask, NativeEmitter;
 import 'package:front_end/src/fasta/scanner.dart' show BeginGroupToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
 import '../universe/use.dart' show StaticUse, TypeUse;
 import '../universe/world_impact.dart'
     show WorldImpact, WorldImpactBuilder, WorldImpactBuilderImpl;
 import 'behavior.dart';
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
   /// Called when a [type] has been instantiated natively.
   void onInstantiatedType(InterfaceType type) {}
 
   /// Initial entry point to native enqueuer.
   WorldImpact processNativeClasses(Iterable<LibraryElement> libraries) =>
       const WorldImpact();
 
   /// Registers the [nativeBehavior]. Adds the liveness of its instantiated
   /// types to the world.
   void registerNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {}
 
-  // TODO(johnniwinther): Move [handleFieldAnnotations] and
-  // [handleMethodAnnotations] to [JavaScriptBackend] or [NativeData].
-  // TODO(johnniwinther): Change the return type to 'bool' and rename them to
-  // something like `computeNativeField`.
-  /// Process the potentially native [field]. Adds information from metadata
-  /// attributes.
-  void handleFieldAnnotations(Element field) {}
-
-  /// Process the potentially native [method]. Adds information from metadata
-  /// attributes.
-  void handleMethodAnnotations(Element method) {}
-
   /// Returns whether native classes are being used.
   bool get hasInstantiatedNativeClasses => false;
 
   /// Emits a summary information using the [log] function.
   void logSummary(log(message)) {}
 }
 
 abstract class NativeEnqueuerBase implements NativeEnqueuer {
-  static final RegExp _identifier = new RegExp(r'^[a-zA-Z_$][a-zA-Z0-9_$]*$');
-
   /// The set of all native classes.  Each native class is in [nativeClasses]
   /// and exactly one of [unusedClasses] and [registeredClasses].
   final Set<ClassElement> _nativeClasses = new Set<ClassElement>();
 
   final Set<ClassElement> _registeredClasses = new Set<ClassElement>();
   final Set<ClassElement> _unusedClasses = new Set<ClassElement>();
 
   bool get hasInstantiatedNativeClasses => !_registeredClasses.isEmpty;
 
   final Set<ClassElement> nativeClassesAndSubclasses = new Set<ClassElement>();
@@ skipping 170 matching lines @@
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.value;
     }
 
     return reporter.withCurrentElement(classElement, () {
       return scanForExtendsName(classElement.position);
     });
   }
 
-  /// Returns the JSName annotation string or `null` if no JSName annotation is
-  /// present.
-  String findJsNameFromAnnotation(Element element) {
-    String name = null;
-    ClassElement annotationClass = backend.helpers.annotationJSNameClass;
-    for (MetadataAnnotation annotation in element.implementation.metadata) {
-      annotation.ensureResolved(resolution);
-      ConstantValue value =
-          compiler.constants.getConstantValue(annotation.constant);
-      if (!value.isConstructedObject) continue;
-      ConstructedConstantValue constructedObject = value;
-      if (constructedObject.type.element != annotationClass) continue;
-
-      Iterable<ConstantValue> fields = constructedObject.fields.values;
-      // TODO(sra): Better validation of the constant.
-      if (fields.length != 1 || fields.single is! StringConstantValue) {
-        reporter.internalError(
-            annotation, 'Annotations needs one string: ${annotation}');
-      }
-      StringConstantValue specStringConstant = fields.single;
-      String specString = specStringConstant.toDartString().slowToString();
-      if (name == null) {
-        name = specString;
-      } else {
-        reporter.internalError(
-            annotation, 'Too many JSName annotations: ${annotation}');
-      }
-    }
-    return name;
-  }
-
   /// Register [classes] as natively instantiated in [impactBuilder].
   void _registerTypeUses(
       WorldImpactBuilder impactBuilder, Set<ClassElement> classes, cause) {
     for (ClassElement cls in classes) {
       if (!_unusedClasses.contains(cls)) {
         // No need to add [classElement] to [impactBuilder]: it has already been
         // instantiated and we don't track origins of native instantiations
         // precisely.
         continue;
       }
       cls.ensureResolved(resolution);
       impactBuilder
           .registerTypeUse(new TypeUse.nativeInstantiation(cls.rawType));
     }
   }
 
-  void handleFieldAnnotations(Element element) {
-    if (compiler.serialization.isDeserialized(element)) {
-      return;
-    }
-    if (element.isInstanceMember &&
-        backend.nativeClassData.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.
-      _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.nativeClassDataBuilder.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.nativeClassDataBuilder
-          .getNativeTagsOfClassRaw(element.enclosingClass);
-      if (nativeNames.length != 1) {
-        reporter.internalError(
-            element,
-            'Unable to determine a native name for the enclosing class, '
-            'options: $nativeNames');
-      }
-      backend.nativeClassDataBuilder
-          .setNativeMemberName(element, '${nativeNames[0]}.$name');
-    } else {
-      backend.nativeClassDataBuilder.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);
-      if (node is! FunctionExpression) return false;
-      FunctionExpression functionExpression = node;
-      node = functionExpression.body;
-      Token token = node.getBeginToken();
-      if (identical(token.stringValue, 'native')) return true;
-      return false;
-    });
-  }
-
   void registerNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior nativeBehavior, cause) {
     _processNativeBehavior(impactBuilder, nativeBehavior, cause);
   }
 
   void _processNativeBehavior(
       WorldImpactBuilder impactBuilder, NativeBehavior behavior, cause) {
     void registerInstantiation(ResolutionInterfaceType type) {
       impactBuilder.registerTypeUse(new TypeUse.nativeInstantiation(type));
     }
@@ skipping 91 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.nativeData.isJsInterop(classElement)) return;
+    if (backend.nativeData.isJsInteropClass(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 117 matching lines @@
     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.');
   }
 }