Add NativeDataResolver

pkg/compiler/lib/src/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 98 matching lines @@
  * - Builders shift between declaration and implementation depending on usages.
  * - Compile-time constants use constructor implementation exclusively.
  * - Work on function parameters is performed on the declaration of the function
  *   element.
  */
 
 library dart2js.patchparser;
 
 import 'dart:async';
 
+import 'package:front_end/src/fasta/parser.dart'
+    show Listener, Parser, ParserError;
+import 'package:front_end/src/fasta/scanner.dart' show Token;
+
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/values.dart' show ConstantValue;
 import 'elements/resolution_types.dart' show ResolutionDartType;
 import 'elements/elements.dart';
 import 'elements/modelx.dart'
     show
         BaseFunctionElementX,
         ClassElementX,
         GetterElementX,
         LibraryElementX,
         MetadataAnnotationX,
         SetterElementX;
 import 'id_generator.dart';
-import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'library_loader.dart' show LibraryLoader;
 import 'parser/element_listener.dart' show ElementListener;
-import 'package:front_end/src/fasta/parser.dart'
-    show Listener, Parser, ParserError;
 import 'parser/member_listener.dart' show MemberListener;
 import 'parser/partial_elements.dart'
     show ClassElementParser, PartialClassElement;
+import 'parser/diet_parser_task.dart' show PartialParser;
 import 'script.dart';
-import 'package:front_end/src/fasta/scanner.dart' show StringToken, Token;
-import 'parser/diet_parser_task.dart' show PartialParser;
 
 class PatchParserTask extends CompilerTask {
   final String name = "Patching Parser";
   final Compiler compiler;
   DiagnosticReporter get reporter => compiler.reporter;
 
   PatchParserTask(Compiler compiler)
       : compiler = compiler,
         super(compiler.measurer);
 
@@ skipping 171 matching lines @@
   }
   patchClass(compiler, reporter, origin, patch);
 }
 
 void patchClass(Compiler compiler, DiagnosticReporter reporter,
     ClassElementX origin, ClassElementX patch) {
   if (origin.isPatched) {
     reporter.internalError(origin, "Patching the same class more than once.");
   }
   origin.applyPatch(patch);
-  checkNativeAnnotation(compiler, patch);
-}
-
-/// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
-/// native name from the annotation.
-checkNativeAnnotation(Compiler compiler, ClassElement cls) {
-  EagerAnnotationHandler.checkAnnotation(
-      compiler, cls, const NativeAnnotationHandler());
-}
-
-checkJsInteropAnnotation(Compiler compiler, element) {
-  EagerAnnotationHandler.checkAnnotation(
-      compiler, element, const JsInteropAnnotationHandler());
 }
 
 /// Abstract interface for pre-resolution detection of metadata.
 ///
 /// The detection is handled in two steps:
 /// - match the annotation syntactically and assume that the annotation is valid
 ///   if it looks correct,
 /// - setup a deferred action to check that the annotation has a valid constant
 ///   value and report an internal error if not.
 abstract class EagerAnnotationHandler<T> {
+  const EagerAnnotationHandler();
+
   /// Checks that [annotation] looks like a matching annotation and optionally
   /// applies actions on [element]. Returns a non-null annotation marker if the
   /// annotation matched and should be validated.
   T apply(Compiler compiler, Element element, MetadataAnnotation annotation);
 
   /// Checks that the annotation value is valid.
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant);
 
   /// Checks [element] for metadata matching the [handler]. Return a non-null
   /// annotation marker matching metadata was found.
-  static checkAnnotation(
-      Compiler compiler, Element element, EagerAnnotationHandler handler) {
+  static T checkAnnotation<T>(
+      Compiler compiler, Element element, EagerAnnotationHandler<T> handler) {
     for (MetadataAnnotation annotation in element.implementation.metadata) {
-      var result = handler.apply(compiler, element, annotation);
-      if (result != null) {
+      T result = handler.apply(compiler, element, annotation);
+      if (result != handler.defaultResult) {
         // TODO(johnniwinther): Perform this check in
         // [Compiler.onLibrariesLoaded].
         compiler.enqueuer.resolution.addDeferredAction(element, () {
           annotation.ensureResolved(compiler.resolution);
           handler.validate(compiler, element, annotation,
               compiler.constants.getConstantValue(annotation.constant));
         });
         return result;
       }
     }
-    return null;
-  }
-}
-
-/// Annotation handler for pre-resolution detection of `@Native(...)`
-/// annotations.
-class NativeAnnotationHandler implements EagerAnnotationHandler<String> {
-  const NativeAnnotationHandler();
-
-  String getNativeAnnotation(MetadataAnnotationX annotation) {
-    if (annotation.beginToken != null &&
-        annotation.beginToken.next.value == 'Native') {
-      // Skipping '@', 'Native', and '('.
-      Token argument = annotation.beginToken.next.next.next;
-      if (argument is StringToken) {
-        return argument.value;
-      }
-    }
-    return null;
+    return handler.defaultResult;
   }
 
-  String apply(
-      Compiler compiler, Element element, MetadataAnnotation annotation) {
-    if (element.isClass) {
-      String native = getNativeAnnotation(annotation);
-      if (native != null) {
-        JavaScriptBackend backend = compiler.backend;
-        backend.nativeClassDataBuilder.setNativeClassTagInfo(element, native);
-        return native;
-      }
-    }
-    return null;
-  }
-
-  void validate(Compiler compiler, Element element,
-      MetadataAnnotation annotation, ConstantValue constant) {
-    ResolutionDartType annotationType =
-        constant.getType(compiler.commonElements);
-    if (annotationType.element !=
-        compiler.backend.helpers.nativeAnnotationClass) {
-      DiagnosticReporter reporter = compiler.reporter;
-      reporter.internalError(annotation, 'Invalid @Native(...) annotation.');
-    }
-  }
-}
-
-/// Annotation handler for pre-resolution detection of `@JS(...)`
-/// annotations.
-class JsInteropAnnotationHandler implements EagerAnnotationHandler<bool> {
-  const JsInteropAnnotationHandler();
-
-  bool hasJsNameAnnotation(MetadataAnnotationX annotation) =>
-      annotation.beginToken != null && annotation.beginToken.next.value == 'JS';
-
-  bool apply(
-      Compiler compiler, Element element, MetadataAnnotation annotation) {
-    bool hasJsInterop = hasJsNameAnnotation(annotation);
-    if (hasJsInterop) {
-      JavaScriptBackend backend = compiler.backend;
-      backend.nativeClassDataBuilder.markAsJsInterop(element);
-    }
-    // Due to semantics of apply in the baseclass we have to return null to
-    // indicate that no match was found.
-    return hasJsInterop ? true : null;
-  }
-
-  @override
-  void validate(Compiler compiler, Element element,
-      MetadataAnnotation annotation, ConstantValue constant) {
-    JavaScriptBackend backend = compiler.backend;
-    ResolutionDartType type = constant.getType(compiler.commonElements);
-    if (type.element != backend.helpers.jsAnnotationClass) {
-      compiler.reporter
-          .internalError(annotation, 'Invalid @JS(...) annotation.');
-    }
-  }
+  /// Result that signals the absence of annotations.
+  T get defaultResult => null;
 }
 
 /// Annotation handler for pre-resolution detection of `@patch` annotations.
-class PatchAnnotationHandler implements EagerAnnotationHandler<PatchVersion> {
+class PatchAnnotationHandler extends EagerAnnotationHandler<PatchVersion> {
   const PatchAnnotationHandler();
 
   PatchVersion getPatchVersion(MetadataAnnotationX annotation) {
     if (annotation.beginToken != null) {
       if (annotation.beginToken.next.value == 'patch') {
         return const PatchVersion(null);
       } else if (annotation.beginToken.next.value == 'patch_full') {
         return const PatchVersion('full');
       } else if (annotation.beginToken.next.value == 'patch_lazy') {
         return const PatchVersion('lazy');
@@ skipping 132 matching lines @@
 
 class PatchVersion {
   final String tag;
 
   const PatchVersion(this.tag);
 
   bool isActive(String patchTag) => tag == null || tag == patchTag;
 
   String toString() => 'PatchVersion($tag)';
 }