Merge CommonElements and BackendHelpers!

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
@@ skipping 262 matching lines @@
   }
 
   TypeMask typeOfIteratorMoveNext(ir.ForInStatement forInStatement) {
     return _resultOf(_target).typeOfIteratorMoveNext(getNode(forInStatement));
   }
 
   bool isJsIndexableIterator(
       ir.ForInStatement forInStatement, ClosedWorld closedWorld) {
     TypeMask mask = typeOfIterator(forInStatement);
     return mask != null &&
-        mask.satisfies(_backend.helpers.jsIndexableClass, closedWorld) &&
+        mask.satisfies(
+            _compiler.commonElements.jsIndexableClass, closedWorld) &&
         // String is indexable but not iterable.
-        !mask.satisfies(_backend.helpers.jsStringClass, closedWorld);
+        !mask.satisfies(_compiler.commonElements.jsStringClass, closedWorld);
   }
 
   bool isFixedLength(TypeMask mask, ClosedWorld closedWorld) {
     if (mask.isContainer && (mask as ContainerTypeMask).length != null) {
       // A container on which we have inferred the length.
       return true;
     }
     // TODO(sra): Recognize any combination of fixed length indexables.
     if (mask.containsOnly(closedWorld.backendClasses.fixedListClass) ||
         mask.containsOnly(closedWorld.backendClasses.constListClass) ||
@@ skipping 66 matching lines @@
 
   // Is the member a lazy initialized static or top-level member?
   bool isLazyStatic(ir.Member member) {
     if (member is ir.Field) {
       FieldElement field = _nodeToElement[member];
       return field.constant == null;
     }
     return false;
   }
 
-  LibraryElement get jsHelperLibrary => _backend.helpers.jsHelperLibrary;
+  LibraryElement get jsHelperLibrary =>
+      _compiler.commonElements.jsHelperLibrary;
 
   KernelJumpTarget getJumpTarget(ir.TreeNode node,
       {bool isContinueTarget: false}) {
     return _jumpTargets.putIfAbsent(node, () {
       if (node is ir.LabeledStatement && _jumpTargets.containsKey(node.body)) {
         return _jumpTargets[node.body];
       }
       return new KernelJumpTarget(node, this,
           makeContinueLabel: isContinueTarget);
     });
   }
 
   ir.Procedure get checkDeferredIsLoaded =>
-      kernel.functions[_backend.helpers.checkDeferredIsLoaded];
+      kernel.functions[_compiler.commonElements.checkDeferredIsLoaded];
 
   TypeMask get checkDeferredIsLoadedType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.checkDeferredIsLoaded, _globalInferenceResults);
+          _compiler.commonElements.checkDeferredIsLoaded,
+          _globalInferenceResults);
 
   ir.Procedure get createInvocationMirror =>
-      kernel.functions[_backend.helpers.createInvocationMirror];
+      kernel.functions[_compiler.commonElements.createInvocationMirror];
 
   ir.Class get mapLiteralClass =>
-      kernel.classes[_backend.helpers.mapLiteralClass];
+      kernel.classes[_compiler.commonElements.mapLiteralClass];
 
   ir.Procedure get mapLiteralConstructor =>
-      kernel.functions[_backend.helpers.mapLiteralConstructor];
+      kernel.functions[_compiler.commonElements.mapLiteralConstructor];
 
   ir.Procedure get mapLiteralConstructorEmpty =>
-      kernel.functions[_backend.helpers.mapLiteralConstructorEmpty];
+      kernel.functions[_compiler.commonElements.mapLiteralConstructorEmpty];
 
   ir.Procedure get mapLiteralUntypedEmptyMaker =>
-      kernel.functions[_backend.helpers.mapLiteralUntypedEmptyMaker];
+      kernel.functions[_compiler.commonElements.mapLiteralUntypedEmptyMaker];
 
   ir.Procedure get exceptionUnwrapper =>
-      kernel.functions[_backend.helpers.exceptionUnwrapper];
+      kernel.functions[_compiler.commonElements.exceptionUnwrapper];
 
   TypeMask get exceptionUnwrapperType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.exceptionUnwrapper, _globalInferenceResults);
+          _compiler.commonElements.exceptionUnwrapper, _globalInferenceResults);
 
   ir.Procedure get traceFromException =>
-      kernel.functions[_backend.helpers.traceFromException];
+      kernel.functions[_compiler.commonElements.traceFromException];
 
   TypeMask get traceFromExceptionType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.traceFromException, _globalInferenceResults);
+          _compiler.commonElements.traceFromException, _globalInferenceResults);
 
   ir.Procedure get streamIteratorConstructor =>
-      kernel.functions[_backend.helpers.streamIteratorConstructor];
+      kernel.functions[_compiler.commonElements.streamIteratorConstructor];
 
   TypeMask get streamIteratorConstructorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           // ignore: UNNECESSARY_CAST
-          _backend.helpers.streamIteratorConstructor as FunctionEntity,
+          _compiler.commonElements.streamIteratorConstructor as FunctionEntity,
           _globalInferenceResults);
 
   ir.Procedure get fallThroughError =>
-      kernel.functions[_backend.helpers.fallThroughError];
+      kernel.functions[_compiler.commonElements.fallThroughError];
 
   TypeMask get fallThroughErrorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.fallThroughError, _globalInferenceResults);
+          _compiler.commonElements.fallThroughError, _globalInferenceResults);
 
   ir.Procedure get mapLiteralUntypedMaker =>
-      kernel.functions[_backend.helpers.mapLiteralUntypedMaker];
+      kernel.functions[_compiler.commonElements.mapLiteralUntypedMaker];
 
-  ir.Procedure get checkConcurrentModificationError =>
-      kernel.functions[_backend.helpers.checkConcurrentModificationError];
+  ir.Procedure get checkConcurrentModificationError => kernel
+      .functions[_compiler.commonElements.checkConcurrentModificationError];
 
   TypeMask get checkConcurrentModificationErrorReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.checkConcurrentModificationError,
+          _compiler.commonElements.checkConcurrentModificationError,
           _globalInferenceResults);
 
   ir.Procedure get checkSubtype =>
-      kernel.functions[_backend.helpers.checkSubtype];
+      kernel.functions[_compiler.commonElements.checkSubtype];
 
   ir.Procedure get checkSubtypeOfRuntimeType =>
-      kernel.functions[_backend.helpers.checkSubtypeOfRuntimeType];
+      kernel.functions[_compiler.commonElements.checkSubtypeOfRuntimeType];
 
   ir.Procedure get functionTypeTest =>
-      kernel.functions[_backend.helpers.functionTypeTest];
+      kernel.functions[_compiler.commonElements.functionTypeTest];
 
   ir.Procedure get throwTypeError =>
-      kernel.functions[_backend.helpers.throwTypeError];
+      kernel.functions[_compiler.commonElements.throwTypeError];
 
   TypeMask get throwTypeErrorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.throwTypeError, _globalInferenceResults);
+          _compiler.commonElements.throwTypeError, _globalInferenceResults);
 
   ir.Procedure get assertHelper =>
-      kernel.functions[_backend.helpers.assertHelper];
+      kernel.functions[_compiler.commonElements.assertHelper];
 
   TypeMask get assertHelperReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.assertHelper, _globalInferenceResults);
+          _compiler.commonElements.assertHelper, _globalInferenceResults);
 
-  ir.Procedure get assertTest => kernel.functions[_backend.helpers.assertTest];
+  ir.Procedure get assertTest =>
+      kernel.functions[_compiler.commonElements.assertTest];
 
   TypeMask get assertTestReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.assertTest, _globalInferenceResults);
+          _compiler.commonElements.assertTest, _globalInferenceResults);
 
   ir.Procedure get assertThrow =>
-      kernel.functions[_backend.helpers.assertThrow];
+      kernel.functions[_compiler.commonElements.assertThrow];
 
   ir.Procedure get setRuntimeTypeInfo =>
-      kernel.functions[_backend.helpers.setRuntimeTypeInfo];
+      kernel.functions[_compiler.commonElements.setRuntimeTypeInfo];
 
   TypeMask get assertThrowReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.assertThrow, _globalInferenceResults);
+          _compiler.commonElements.assertThrow, _globalInferenceResults);
 
   ir.Procedure get runtimeTypeToString =>
-      kernel.functions[_backend.helpers.runtimeTypeToString];
+      kernel.functions[_compiler.commonElements.runtimeTypeToString];
 
   ir.Procedure get createRuntimeType =>
-      kernel.functions[_backend.helpers.createRuntimeType];
+      kernel.functions[_compiler.commonElements.createRuntimeType];
 
   TypeMask get createRuntimeTypeReturnType =>
       TypeMaskFactory.inferredReturnTypeForElement(
-          _backend.helpers.createRuntimeType, _globalInferenceResults);
+          _compiler.commonElements.createRuntimeType, _globalInferenceResults);
 
   ir.Class get objectClass =>
       kernel.classes[_compiler.commonElements.objectClass];
 
   ir.Class get futureClass =>
       kernel.classes[_compiler.commonElements.futureClass];
 
   TypeMask makeSubtypeOfObject(ClosedWorld closedWorld) =>
       new TypeMask.subclass(_compiler.commonElements.objectClass, closedWorld);
 
   ir.Procedure get currentIsolate =>
-      kernel.functions[_backend.helpers.currentIsolate];
+      kernel.functions[_compiler.commonElements.currentIsolate];
 
   ir.Procedure get callInIsolate =>
-      kernel.functions[_backend.helpers.callInIsolate];
+      kernel.functions[_compiler.commonElements.callInIsolate];
 
   bool isInForeignLibrary(ir.Member member) =>
       _backend.isForeign(getElement(member));
 
   native.NativeBehavior getNativeBehavior(ir.Node node) {
     return elements.getNativeData(getNode(node));
   }
 
   js.Name getNameForJsGetName(ir.Node argument, ConstantValue constant) {
     int index = _extractEnumIndexFromConstantValue(
-        constant, _backend.helpers.jsGetNameEnum);
+        constant, _compiler.commonElements.jsGetNameEnum);
     if (index == null) return null;
     return _backend.namer
         .getNameForJsGetName(getNode(argument), JsGetName.values[index]);
   }
 
   js.Template getJsBuiltinTemplate(ConstantValue constant) {
     int index = _extractEnumIndexFromConstantValue(
-        constant, _backend.helpers.jsBuiltinEnum);
+        constant, _compiler.commonElements.jsBuiltinEnum);
     if (index == null) return null;
     return _backend.emitter.builtinTemplateFor(JsBuiltin.values[index]);
   }
 
   int _extractEnumIndexFromConstantValue(
       ConstantValue constant, ClassEntity classElement) {
     if (constant is ConstructedConstantValue) {
       if (constant.type.element == classElement) {
         assert(constant.fields.length == 1 || constant.fields.length == 2);
         ConstantValue indexConstant = constant.fields.values.first;
@@ skipping 277 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }