Add FrontEndStrategy, ResolutionFrontEndStrategy and KernelFrontEndStrategy

pkg/compiler/lib/src/native/resolver.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 'package:front_end/src/fasta/scanner.dart'
     show BeginGroupToken, StringToken, Token;
 import 'package:front_end/src/fasta/scanner.dart' as Tokens show EOF_TOKEN;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements;
 import '../common/backend_api.dart';
 import '../common/resolution.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         FieldElement,
         LibraryElement,
         MemberElement,
         MetadataAnnotation,
         MethodElement;
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show FunctionElementX, MetadataAnnotationX;
 import '../elements/resolution_types.dart' show ResolutionDartType;
 import '../js_backend/js_backend.dart';
 import '../js_backend/native_data.dart';
-import '../kernel/world_builder.dart' show KernelAnnotationProcessor;
 import '../patch_parser.dart';
 import '../tree/tree.dart';
 import 'behavior.dart';
 
-/// Class that performs the mechanics to investigate annotations in the code.
-abstract class AnnotationProcessor {
-  factory AnnotationProcessor(Compiler compiler) =>
-      compiler.options.loadFromDill
-          // TODO(johnniwinther): Pass the [KernelWorldBuilder] to
-          // [KernelAnnotationProcessor].
-          ? new KernelAnnotationProcessor(null)
-          : new _ElementAnnotationProcessor(compiler);
-
-  void extractNativeAnnotations(
-      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
-
-  void extractJsInteropAnnotations(
-      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
-}
-
-/// Original logic for annotation processing, which involves in some cases
-/// triggering pre-parsing and validation of the annotations.
-class _ElementAnnotationProcessor implements AnnotationProcessor {
-  Compiler _compiler;
-
-  _ElementAnnotationProcessor(this._compiler);
-
-  /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
-  /// native name from the annotation.
-  void extractNativeAnnotations(
-      LibraryElement library, NativeBasicDataBuilder nativeBasicDataBuilder) {
-    library.forEachLocalMember((Element element) {
-      if (element.isClass) {
-        EagerAnnotationHandler.checkAnnotation(_compiler, element,
-            new NativeAnnotationHandler(nativeBasicDataBuilder));
-      }
-    });
-  }
-
-  void extractJsInteropAnnotations(
-      LibraryElement library, NativeBasicDataBuilder nativeBasicDataBuilder) {
-    bool checkJsInteropAnnotation(Element element) {
-      return EagerAnnotationHandler.checkAnnotation(
-          _compiler, element, const JsInteropAnnotationHandler());
-    }
-
-    if (checkJsInteropAnnotation(library)) {
-      nativeBasicDataBuilder.markAsJsInteropLibrary(library);
-    }
-    library.forEachLocalMember((Element element) {
-      if (element.isClass) {
-        ClassElement cls = element;
-        if (checkJsInteropAnnotation(element)) {
-          nativeBasicDataBuilder.markAsJsInteropClass(cls);
-        }
-      }
-    });
-  }
-}
-
 /// Interface for computing native members and [NativeBehavior]s in member code
 /// based on the AST.
 abstract class NativeDataResolver {
   /// Returns `true` if [element] is a JsInterop member.
   bool isJsInteropMember(MemberElement element);
 
   /// Computes whether [element] is native or JsInterop and, if so, registers
   /// its [NativeBehavior]s to [registry].
   void resolveNativeMember(MemberElement element, NativeRegistry registry);
 
@@ skipping 213 matching lines @@
         node, _reporter, _compiler.commonElements, resolver);
   }
 
   @override
   NativeBehavior resolveJsBuiltinCall(Send node, ForeignResolver resolver) {
     return NativeBehavior.ofJsBuiltinCallSend(
         node, _reporter, _compiler.commonElements, resolver);
   }
 }
 
-/// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
-/// native name from the annotation.
-checkNativeAnnotation(Compiler compiler, ClassElement cls,
-    NativeBasicDataBuilder nativeBasicDataBuilder) {
-  EagerAnnotationHandler.checkAnnotation(
-      compiler, cls, new NativeAnnotationHandler(nativeBasicDataBuilder));
-}
-
 /// Annotation handler for pre-resolution detection of `@Native(...)`
 /// annotations.
 class NativeAnnotationHandler extends EagerAnnotationHandler<String> {
   final NativeBasicDataBuilder _nativeBasicDataBuilder;
 
   NativeAnnotationHandler(this._nativeBasicDataBuilder);
 
   String getNativeAnnotation(MetadataAnnotationX annotation) {
     if (annotation.beginToken != null &&
         annotation.beginToken.next.lexeme == 'Native') {
@@ skipping 264 matching lines @@
 
   Iterable<ConstantValue> fields = constructedObject.fields.values;
   // TODO(sra): Better validation of the constant.
   if (fields.length != 1 || fields.single is! StringConstantValue) {
     throw new SpannableAssertionFailure(
         spannable, 'Annotations needs one string: ${value.toStructuredText()}');
   }
   StringConstantValue specStringConstant = fields.single;
   return specStringConstant.toDartString().slowToString();
 }