Add ClassEntity.library, MemberEntity.library and FunctionEntity.isExternal

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 StringToken, Token;
 
 import '../common.dart';
 import '../common/backend_api.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
+        FieldElement,
         LibraryElement,
         MemberElement,
         MetadataAnnotation,
         MethodElement;
 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';
@@ skipping 38 matching lines @@
     }
     return isJsInterop;
   }
 
   void resolveNativeMember(MemberElement element, NativeRegistry registry) {
     bool isJsInterop = isJsInteropMember(element);
     if (element.isFunction ||
         element.isConstructor ||
         element.isGetter ||
         element.isSetter) {
-      bool isNative = _processMethodAnnotations(element);
+      MethodElement method = element;
+      bool isNative = _processMethodAnnotations(method);
       if (isNative || isJsInterop) {
         NativeBehavior behavior = NativeBehavior
-            .ofMethodElement(element, _compiler, isJsInterop: isJsInterop);
-        _nativeDataBuilder.setNativeMethodBehavior(element, behavior);
+            .ofMethodElement(method, _compiler, isJsInterop: isJsInterop);
+        _nativeDataBuilder.setNativeMethodBehavior(method, behavior);
         registry.registerNativeData(behavior);
       }
     } else if (element.isField) {
-      bool isNative = _processFieldAnnotations(element);
+      FieldElement field = element;
+      bool isNative = _processFieldAnnotations(field);
       if (isNative || isJsInterop) {
         NativeBehavior fieldLoadBehavior = NativeBehavior
-            .ofFieldElementLoad(element, _compiler, isJsInterop: isJsInterop);
+            .ofFieldElementLoad(field, _compiler, isJsInterop: isJsInterop);
         NativeBehavior fieldStoreBehavior =
-            NativeBehavior.ofFieldElementStore(element, _compiler);
-        _nativeDataBuilder.setNativeFieldLoadBehavior(
-            element, fieldLoadBehavior);
+            NativeBehavior.ofFieldElementStore(field, _compiler);
+        _nativeDataBuilder.setNativeFieldLoadBehavior(field, fieldLoadBehavior);
         _nativeDataBuilder.setNativeFieldStoreBehavior(
-            element, fieldStoreBehavior);
+            field, 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);
       }
     }
   }
@@ skipping 139 matching lines @@
       if (argument is StringToken) {
         return argument.value;
       }
     }
     return null;
   }
 
   String apply(
       Compiler compiler, Element element, MetadataAnnotation annotation) {
     if (element.isClass) {
+      ClassElement cls = element;
       String native = getNativeAnnotation(annotation);
       if (native != null) {
-        _nativeClassDataBuilder.setNativeClassTagInfo(element, native);
+        _nativeClassDataBuilder.setNativeClassTagInfo(cls, native);
         return native;
       }
     }
     return null;
   }
 
   void validate(Compiler compiler, Element element,
       MetadataAnnotation annotation, ConstantValue constant) {
     ResolutionDartType annotationType =
         constant.getType(compiler.commonElements);
@@ skipping 10 matching lines @@
   bool checkJsInteropAnnotation(Element element) {
     return EagerAnnotationHandler.checkAnnotation(
         compiler, element, const JsInteropAnnotationHandler());
   }
 
   if (checkJsInteropAnnotation(library)) {
     nativeClassDataBuilder.markAsJsInteropLibrary(library);
   }
   library.forEachLocalMember((Element element) {
     if (element.isClass) {
+      ClassElement cls = element;
       if (checkJsInteropAnnotation(element)) {
-        nativeClassDataBuilder.markAsJsInteropClass(element);
+        nativeClassDataBuilder.markAsJsInteropClass(cls);
       }
     }
   });
 }
 
 bool checkJsInteropMemberAnnotations(Compiler compiler, MemberElement element,
     NativeDataBuilder nativeDataBuilder) {
   bool isJsInterop = EagerAnnotationHandler.checkAnnotation(
       compiler, element, const JsInteropAnnotationHandler());
   if (isJsInterop) {
@@ skipping 21 matching lines @@
     JavaScriptBackend backend = compiler.backend;
     ResolutionDartType type = constant.getType(compiler.commonElements);
     if (type.element != backend.helpers.jsAnnotationClass) {
       compiler.reporter
           .internalError(annotation, 'Invalid @JS(...) annotation.');
     }
   }
 
   bool get defaultResult => false;
 }