Remove BackendClasses and JavaScriptBackendClasses.

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 42 matching lines @@
 
   /// Sometimes for resolution the resolved AST element needs to change (for
   /// example, if we're inlining, or if we're in a constructor, but then also
   /// constructing the field values). We keep track of this with a stack.
   final List<ResolvedAst> _resolvedAstStack = <ResolvedAst>[];
 
   final native.BehaviorBuilder nativeBehaviorBuilder;
 
   KernelAstAdapter(this.kernel, this._backend, this._resolvedAst,
       this._nodeToAst, this._nodeToElement)
-      : nativeBehaviorBuilder =
-            new native.ResolverBehaviorBuilder(_backend.compiler) {
+      : nativeBehaviorBuilder = new native.ResolverBehaviorBuilder(
+            _backend.compiler, _backend.nativeData) {
     KernelJumpTarget.index = 0;
     // TODO(het): Maybe just use all of the kernel maps directly?
     for (FieldElement fieldElement in kernel.fields.keys) {
       _nodeToElement[kernel.fields[fieldElement]] = fieldElement;
     }
     for (FunctionElement functionElement in kernel.functions.keys) {
       _nodeToElement[kernel.functions[functionElement]] = functionElement;
     }
     for (ClassElement classElement in kernel.classes.keys) {
       _nodeToElement[kernel.classes[classElement]] = classElement;
@@ skipping 65 matching lines @@
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       _compiler.globalInference.results;
 
   GlobalTypeInferenceElementResult _resultOf(MemberElement e) =>
       _globalInferenceResults
           .resultOfMember(e is ConstructorBodyElementX ? e.constructor : e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     if (kernel.syntheticNodes.contains(node)) {
-      return _backend.constantSystem.createSymbol(
-          _compiler.commonElements, _backend.backendClasses, node.value);
+      return _backend.constantSystem
+          .createSymbol(_compiler.commonElements, node.value);
     }
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   // TODO(johnniwinther): Use the more precise functions below.
@@ skipping 123 matching lines @@
         // String is indexable but not iterable.
         !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) ||
+    if (mask.containsOnly(closedWorld.commonElements.jsFixedArrayClass) ||
+        mask.containsOnly(
+            closedWorld.commonElements.jsUnmodifiableArrayClass) ||
         mask.containsOnlyString(closedWorld) ||
         closedWorld.commonMasks.isTypedArray(mask)) {
       return true;
     }
     return false;
   }
 
   TypeMask inferredIndexType(ir.ForInStatement forInStatement) {
     return TypeMaskFactory.inferredTypeForSelector(new Selector.index(),
         typeOfIterator(forInStatement), _globalInferenceResults);
@@ skipping 34 matching lines @@
     //         defaultExpression.accept(new Constantifier(this));
     //     assert(constantExpression != null);
     ConstantExpression constantExpression =
         kernel.parameterInitializerNodeToConstant[defaultExpression];
     if (constantExpression == null) return null;
     return _backend.constants.getConstantValue(constantExpression);
   }
 
   ConstantValue getConstantForType(ir.DartType irType) {
     ResolutionDartType type = getDartType(irType);
-    return _backend.constantSystem.createType(
-        _compiler.commonElements, _backend.backendClasses, type.asRaw());
+    return _backend.constantSystem
+        .createType(_compiler.commonElements, type.asRaw());
   }
 
   bool isIntercepted(ir.Node node) {
     Selector selector = getSelector(node);
     return _backend.interceptorData.isInterceptedSelector(selector);
   }
 
   bool isInterceptedSelector(Selector selector) {
     return _backend.interceptorData.isInterceptedSelector(selector);
   }
@@ skipping 458 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++;
     }
   }
 }