Merge CommonElements and BackendHelpers!

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/backend_helpers.dart';
 import '../js_backend/js_backend.dart';
 import '../js_backend/native_data.dart';
 import '../patch_parser.dart';
 import '../tree/tree.dart';
 import 'behavior.dart';
 
 /// 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.
@@ skipping 183 matching lines @@
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
   }
 
   /// 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;
+    ClassElement annotationClass =
+        _compiler.commonElements.annotationJSNameClass;
     for (MetadataAnnotation annotation in element.implementation.metadata) {
       annotation.ensureResolved(_compiler.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.
@@ skipping 71 matching lines @@
       }
     }
     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) {
+        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(
@@ skipping 33 matching lines @@
       annotation.beginToken.next.lexeme == 'JS';
 
   bool apply(
       Compiler compiler, Element element, MetadataAnnotation annotation) {
     return hasJsNameAnnotation(annotation);
   }
 
   @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) {
+    if (type.element != compiler.commonElements.jsAnnotationClass) {
       compiler.reporter
           .internalError(annotation, 'Invalid @JS(...) annotation.');
     }
   }
 
   bool get defaultResult => false;
 }
 
 /// Interface for computing all native classes in a set of libraries.
 abstract class NativeClassResolver {
   Iterable<ClassEntity> computeNativeClasses(Iterable<LibraryEntity> libraries);
 }
 
 class NativeClassResolverImpl implements NativeClassResolver {
   final DiagnosticReporter _reporter;
   final Resolution _resolution;
-  final BackendHelpers _helpers;
+  final CommonElements _commonElements;
   final NativeBasicData _nativeBasicData;
 
   Map<String, ClassElement> _tagOwner = new Map<String, ClassElement>();
 
-  NativeClassResolverImpl(
-      this._resolution, this._reporter, this._helpers, this._nativeBasicData);
+  NativeClassResolverImpl(this._resolution, this._reporter,
+      this._commonElements, this._nativeBasicData);
 
   Iterable<ClassElement> computeNativeClasses(
       Iterable<LibraryElement> libraries) {
     Set<ClassElement> nativeClasses = new Set<ClassElement>();
     libraries.forEach((l) => _processNativeClassesInLibrary(l, nativeClasses));
-    if (_helpers.isolateHelperLibrary != null) {
+    if (_commonElements.isolateHelperLibrary != null) {
       _processNativeClassesInLibrary(
-          _helpers.isolateHelperLibrary, nativeClasses);
+          _commonElements.isolateHelperLibrary, nativeClasses);
     }
     _processSubclassesOfNativeClasses(libraries, nativeClasses);
     return nativeClasses;
   }
 
   void _processNativeClassesInLibrary(
       LibraryElement library, Set<ClassElement> nativeClasses) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
       if (element.isClass) {
@@ skipping 141 matching lines @@
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.lexeme;
     }
 
     return _reporter.withCurrentElement(classElement, () {
       return scanForExtendsName(classElement.position);
     });
   }
 }