Merge CommonElements and BackendHelpers!

pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart

 // Copyright (c) 2013, 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 '../common/backend_api.dart';
 import '../common/resolution.dart';
 import '../common_elements.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../universe/call_structure.dart';
 import '../universe/use.dart' show ConstantUse, StaticUse;
 import '../universe/world_impact.dart'
     show WorldImpact, StagedWorldImpactBuilder;
 import 'backend_usage.dart' show BackendUsageBuilder;
-import 'backend_helpers.dart';
 import 'native_data.dart';
 
 /**
  * Support for Custom Elements.
  *
  * The support for custom elements the compiler builds a table that maps the
  * custom element class's [Type] to the interceptor for the class and the
  * constructor(s) for the class.
  *
  * We want the table to contain only the custom element classes used, and we
@@ skipping 21 matching lines @@
  *       final tag;
  *       Component(this.tag);
  *       void register() => document.register(T, tag);
  *     }
  *     const Component<FancyButton>('x-fancy-button').register();
  *
  * In these cases we conservatively generate all viable entries in the table.
  */
 abstract class CustomElementsAnalysisBase {
   final NativeBasicData _nativeData;
-  final BackendHelpers _helpers;
   final Resolution _resolution;
+  final CommonElements _commonElements;
 
-  CustomElementsAnalysisBase(this._resolution, this._helpers, this._nativeData);
+  CustomElementsAnalysisBase(
+      this._resolution, this._commonElements, this._nativeData);
 
   CustomElementsAnalysisJoin get join;
 
   void registerInstantiatedClass(ClassElement classElement) {
     classElement.ensureResolved(_resolution);
     if (!_nativeData.isNativeOrExtendsNative(classElement)) return;
     if (classElement.isMixinApplication) return;
     if (classElement.isAbstract) return;
     // JsInterop classes are opaque interfaces without a concrete
     // implementation.
     if (_nativeData.isJsInteropClass(classElement)) return;
     join.instantiatedClasses.add(classElement);
   }
 
   void registerStaticUse(MemberEntity element) {
     assert(element != null);
-    if (element == _helpers.findIndexForNativeSubclassType) {
+    if (element == _commonElements.findIndexForNativeSubclassType) {
       join.demanded = true;
     }
   }
 
   /// Computes the [WorldImpact] of the classes registered since last flush.
   WorldImpact flush() => join.flush();
 }
 
 class CustomElementsResolutionAnalysis extends CustomElementsAnalysisBase {
   final CustomElementsAnalysisJoin join;
 
   CustomElementsResolutionAnalysis(
       Resolution resolution,
       ConstantSystem constantSystem,
       CommonElements commonElements,
       BackendClasses backendClasses,
-      BackendHelpers helpers,
       NativeBasicData nativeData,
       BackendUsageBuilder backendUsageBuilder)
       : join = new CustomElementsAnalysisJoin(resolution, constantSystem,
             commonElements, backendClasses, nativeData,
             backendUsageBuilder: backendUsageBuilder),
-        super(resolution, helpers, nativeData) {
+        super(resolution, commonElements, nativeData) {
     // TODO(sra): Remove this work-around.  We should mark allClassesSelected in
     // both joins only when we see a construct generating an unknown [Type] but
     // we can't currently recognize all cases.  In particular, the work-around
     // for the unimplemented `ClassMirror.reflectedType` is not recognizable.
     // TODO(12607): Match on [ClassMirror.reflectedType]
     join.allClassesSelected = true;
   }
 
   void registerTypeLiteral(ResolutionDartType type) {
     if (type.isInterfaceType) {
@@ skipping 11 matching lines @@
 }
 
 class CustomElementsCodegenAnalysis extends CustomElementsAnalysisBase {
   final CustomElementsAnalysisJoin join;
 
   CustomElementsCodegenAnalysis(
       Resolution resolution,
       ConstantSystem constantSystem,
       CommonElements commonElements,
       BackendClasses backendClasses,
-      BackendHelpers helpers,
       NativeBasicData nativeData)
       : join = new CustomElementsAnalysisJoin(resolution, constantSystem,
             commonElements, backendClasses, nativeData),
-        super(resolution, helpers, nativeData) {
+        super(resolution, commonElements, nativeData) {
     // TODO(sra): Remove this work-around.  We should mark allClassesSelected in
     // both joins only when we see a construct generating an unknown [Type] but
     // we can't currently recognize all cases.  In particular, the work-around
     // for the unimplemented `ClassMirror.reflectedType` is not recognizable.
     // TODO(12607): Match on [ClassMirror.reflectedType]
     join.allClassesSelected = true;
   }
 
   void registerTypeConstant(ClassElement element) {
     assert(element.isClass);
@@ skipping 102 matching lines @@
           result.add(member);
         }
       }
     }
 
     classElement.forEachMember(selectGenerativeConstructors,
         includeBackendMembers: false, includeSuperAndInjectedMembers: false);
     return result;
   }
 }