Merge CommonElements and BackendHelpers!

pkg/compiler/lib/src/js_backend/checked_mode_helpers.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.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart' show ErroneousElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart' show MalformedType;
 import '../elements/types.dart';
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../ssa/codegen.dart' show SsaCodeGenerator;
 import '../ssa/nodes.dart' show HTypeConversion;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/use.dart' show StaticUse;
-import 'backend_helpers.dart';
 import 'namer.dart' show Namer;
 
 class CheckedModeHelper {
   final String name;
 
   const CheckedModeHelper(String this.name);
 
-  StaticUse getStaticUse(BackendHelpers helpers) {
+  StaticUse getStaticUse(CommonElements commonElements) {
     // TODO(johnniwinther): Refactor this to avoid looking up directly in the
-    // js helper library but instead access helpers directly on backend helpers.
+    // js helper library but instead access commonElements.
     return new StaticUse.staticInvoke(
-        helpers.findHelperFunction(name), callStructure);
+        commonElements.findHelperFunction(name), callStructure);
   }
 
   CallStructure get callStructure => CallStructure.ONE_ARG;
 
   void generateAdditionalArguments(SsaCodeGenerator codegen, Namer namer,
       HTypeConversion node, List<jsAst.Expression> arguments) {
     // No additional arguments needed.
   }
 }
 
@@ skipping 65 matching lines @@
     arguments.add(js.quoteName(isField));
     codegen.use(node.typeRepresentation);
     arguments.add(codegen.pop());
     jsAst.Name asField = namer.substitutionName(element);
     arguments.add(js.quoteName(asField));
   }
 }
 
 class CheckedModeHelpers {
   final CommonElements _commonElements;
-  final BackendHelpers _helpers;
 
-  CheckedModeHelpers(this._commonElements, this._helpers);
+  CheckedModeHelpers(this._commonElements);
 
   /// All the checked mode helpers.
   static const List<CheckedModeHelper> helpers = const <CheckedModeHelper>[
     const MalformedCheckedModeHelper('checkMalformedType'),
     const CheckedModeHelper('voidTypeCheck'),
     const CheckedModeHelper('stringTypeCast'),
     const CheckedModeHelper('stringTypeCheck'),
     const CheckedModeHelper('doubleTypeCast'),
     const CheckedModeHelper('doubleTypeCheck'),
     const CheckedModeHelper('numTypeCast'),
@@ skipping 97 matching lines @@
         message: "Unexpected type: $type"));
     InterfaceType interfaceType = type;
     ClassEntity element = interfaceType.element;
     bool nativeCheck = true;
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     //  nativeCheckOnly || emitter.nativeEmitter.requiresNativeIsCheck(element);
 
     var suffix = typeCast ? 'TypeCast' : 'TypeCheck';
-    if (element == _helpers.jsStringClass ||
+    if (element == _commonElements.jsStringClass ||
         element == _commonElements.stringClass) {
       if (nativeCheckOnly) return null;
       return 'string$suffix';
     }
 
-    if (element == _helpers.jsDoubleClass ||
+    if (element == _commonElements.jsDoubleClass ||
         element == _commonElements.doubleClass) {
       if (nativeCheckOnly) return null;
       return 'double$suffix';
     }
 
-    if (element == _helpers.jsNumberClass ||
+    if (element == _commonElements.jsNumberClass ||
         element == _commonElements.numClass) {
       if (nativeCheckOnly) return null;
       return 'num$suffix';
     }
 
-    if (element == _helpers.jsBoolClass ||
+    if (element == _commonElements.jsBoolClass ||
         element == _commonElements.boolClass) {
       if (nativeCheckOnly) return null;
       return 'bool$suffix';
     }
 
-    if (element == _helpers.jsIntClass ||
+    if (element == _commonElements.jsIntClass ||
         element == _commonElements.intClass ||
-        element == _helpers.jsUInt32Class ||
-        element == _helpers.jsUInt31Class ||
-        element == _helpers.jsPositiveIntClass) {
+        element == _commonElements.jsUInt32Class ||
+        element == _commonElements.jsUInt31Class ||
+        element == _commonElements.jsPositiveIntClass) {
       if (nativeCheckOnly) return null;
       return 'int$suffix';
     }
 
     if (_commonElements.isNumberOrStringSupertype(element)) {
       return nativeCheck
           ? 'numberOrStringSuperNative$suffix'
           : 'numberOrStringSuper$suffix';
     }
 
     if (_commonElements.isStringOnlySupertype(element)) {
       return nativeCheck ? 'stringSuperNative$suffix' : 'stringSuper$suffix';
     }
 
     if ((element == _commonElements.listClass ||
-            element == _helpers.jsArrayClass) &&
+            element == _commonElements.jsArrayClass) &&
         type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return 'list$suffix';
     }
 
     if (_commonElements.isListSupertype(element)) {
       return nativeCheck ? 'listSuperNative$suffix' : 'listSuper$suffix';
     }
 
     if (type.isInterfaceType && !type.treatAsRaw) {
       return typeCast ? 'subtypeCast' : 'assertSubtype';
     }
 
     if (nativeCheck) {
       // TODO(karlklose): can we get rid of this branch when we use
       // interceptors?
       return 'intercepted$suffix';
     } else {
       return 'property$suffix';
     }
   }
 }