Make backend.setAnnotations (mostly) handle LibraryEntities.

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;
@@ skipping 12 matching lines @@
         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 '../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
+          ? new _KernelAnnotationProcessor()
+          : new _ElementAnnotationProcessor(compiler);

[Johnni Winther, 2017/04/19 08:39:51]

Eventually we should use a strategy pattern for all these:

abstract class FrontendStrategy {
  factory FrontendStrategy(Compiler compiler) =>
     compiler.options.loadFromDill
         ? new _KernelStrategy()
         : new _ResolverStrategy(compiler);

  LibraryLoaderTask createLibraryLoaderTask(...);
  ElementEnvironment createElementEnvironment();
  AnnotationProcessor createAnnotationProcessor();
  ...
}

class ResolverStrategy implements FrontEndStrategy {
  final Compiler _compiler;

  ResolverStrategy(this._compiler);

  LibraryLoader createLibraryLoader(...) => 
      new _LibraryLoaderTask(...);
  ElementEnvironment createElementEnvironment() => 
      new _CompilerElementEnvironment(_compiler);
  AnnotationProcessor createAnnotationProcessor() => 
      new _ElementAnnotationProcessor(_compiler);
  ...
}

class KernelStrategy implements FrontStrategy {
  KernelWorldBuilder _worldBuilder;

  KernelStrategy();

  LibraryLoader createLibraryLoader(...) => 
      new _DillLibraryLoaderTask(_worldBuilder, ...);
  ElementEnvironment createElementEnvironment() => 
      _worldBuilder.elementEnvironment;
  AnnotationProcessor createAnnotationProcessor() => 
       new _KernelAnnotationProcessor(_worldBuilder);
  ...
}

[Siggi Cherem (dart-lang), 2017/04/19 15:36:29]

An alternative naming convention could be to rename Strategy as Module,
 Factory, or Injector (I'm borrowing names that are commonly used to refer to
this in dependency-injection frameworks).

[Emily Fortuna, 2017/04/19 22:35:46]

I started doing this, but ultimately I removed it because it felt like I was
grouping things together that were technically unrelated to each other together
just because they were "the kernel way of doing things" which resulted in
passing a "strategy object" around all the time (to the backend and elsewhere)
instead of just what was needed. It felt a bit like a re-inventing of the
compiler object. WDYT?

+
+  void extractNativeAnnotations(
+      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
+
+  void extractJsInteropAnnotations(
+      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder);
+}
+
+class _KernelAnnotationProcessor implements AnnotationProcessor {

[Emily Fortuna, 2017/04/19 00:59:55]

this class would use the KernelLookup class, but I didn't implement any further
until I got the go-ahead that some sort of lookup thing is what Johnni was
envisioning.

+  void extractNativeAnnotations(
+      LibraryEntity entity, NativeBasicDataBuilder nativeBasicDataBuilder) {
+    throw new UnimplementedError(
+        '_KernelAnnotationProcessor.extractNativeAnnotations');
+  }
+
+  void extractJsInteropAnnotations(
+      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder) {
+    throw new UnimplementedError(
+        '_KernelAnnotationProcessor.extractJsInteropAnnotations');
+  }
+}
+
+/// 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(
+      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder) {

[Johnni Winther, 2017/04/19 08:39:51]

Just use LibraryElement here. This is a model dependent class anyway.

[Emily Fortuna, 2017/04/19 22:35:46]

Done.

+    (library as LibraryElement).forEachLocalMember((Element element) {
+      if (element.isClass) {
+        EagerAnnotationHandler.checkAnnotation(_compiler, element,
+            new NativeAnnotationHandler(nativeBasicDataBuilder));
+      }
+    });
+  }
+
+  void extractJsInteropAnnotations(
+      LibraryEntity library, NativeBasicDataBuilder nativeBasicDataBuilder) {

[Johnni Winther, 2017/04/19 08:39:51]

Ditto

[Emily Fortuna, 2017/04/19 22:35:46]

Done.

+    bool checkJsInteropAnnotation(Element element) {
+      return EagerAnnotationHandler.checkAnnotation(
+          _compiler, element, const JsInteropAnnotationHandler());
+    }
+
+    if (checkJsInteropAnnotation(library as LibraryElement)) {
+      nativeBasicDataBuilder.markAsJsInteropLibrary(library);
+    }
+    (library as LibraryElement).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 277 matching lines @@
     ResolutionDartType annotationType =
         constant.getType(compiler.commonElements);
     if (annotationType.element !=
         compiler.commonElements.nativeAnnotationClass) {
       DiagnosticReporter reporter = compiler.reporter;
       reporter.internalError(annotation, 'Invalid @Native(...) annotation.');
     }
   }
 }
 
-void checkJsInteropClassAnnotations(Compiler compiler, 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);
-      }
-    }
-  });
-}
-
 bool checkJsInteropMemberAnnotations(Compiler compiler, MemberElement element,
     NativeDataBuilder nativeDataBuilder) {
   bool isJsInterop = EagerAnnotationHandler.checkAnnotation(
       compiler, element, const JsInteropAnnotationHandler());
   if (isJsInterop) {
     nativeDataBuilder.markAsJsInteropMember(element);
   }
   return isJsInterop;
 }
 
@@ skipping 201 matching lines @@
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.lexeme;
     }
 
     return _reporter.withCurrentElement(classElement, () {
       return scanForExtendsName(classElement.position);
     });
   }
 }