Remove most direct uses of 'backend' and 'compiler' in GraphBuilder.

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

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Identifiers, Selectors;
 import '../common/tasks.dart' show CompilerTask;
-import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/resolution_types.dart';
 import '../diagnostics/messages.dart' show Message, MessageTemplate;
 import '../dump_info.dart' show InfoReporter;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart' show ConstructorBodyElementX;
 import '../io/source_information.dart';
@@ skipping 21 matching lines @@
 import 'nodes.dart';
 import 'optimize.dart';
 import 'ssa_branch_builder.dart';
 import 'type_builder.dart';
 import 'types.dart';
 
 class SsaBuilderTask extends CompilerTask {
   final CodeEmitterTask emitter;
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
-  final Compiler compiler;
 
   String get name => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : emitter = backend.emitter,
         backend = backend,
-        compiler = backend.compiler,
         super(backend.compiler.measurer);
 
-  DiagnosticReporter get reporter => compiler.reporter;
+  DiagnosticReporter get reporter => backend.reporter;
 
   HGraph build(CodegenWorkItem work, ClosedWorld closedWorld) {
     return measure(() {
       MemberElement element = work.element.implementation;
       return reporter.withCurrentElement(element, () {
         SsaBuilder builder = new SsaBuilder(
             work.element.implementation,
             work.resolvedAst,
             work.registry,
             backend,
@@ skipping 135 matching lines @@
     sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     localsHandler = new LocalsHandler(
         this, target, null, backend.nativeData, backend.interceptorData);
     loopHandler = new SsaLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
   }
 
-  BackendHelpers get helpers => backend.helpers;
-
-  RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
-
   Element get targetElement => target;
 
   /// Reference to resolved elements in [target]'s AST.
   TreeElements get elements => resolvedAst.elements;
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   @override
   void visitNode(ast.Node node) {
@@ skipping 154 matching lines @@
 
   /**
    * Try to inline [element] within the correct context of the builder. The
    * insertion point is the state of the builder.
    */
   bool tryInlineMethod(MethodElement element, Selector selector, TypeMask mask,
       List<HInstruction> providedArguments, ast.Node currentNode,
       {ResolutionInterfaceType instanceType}) {
     registry.registerStaticUse(new StaticUse.inlining(element));
 
-    if (backend.nativeData.isJsInteropMember(element) &&
+    if (nativeData.isJsInteropMember(element) &&
         !element.isFactoryConstructor) {
       // We only inline factory JavaScript interop constructors.
       return false;
     }
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
 
     if (compiler.elementHasCompileTimeError(element)) return false;
 
     MethodElement function = element;
     ResolvedAst functionResolvedAst = function.resolvedAst;
     bool insideLoop = loopDepth > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
-        backend.inlineCache.canInline(function, insideLoop: insideLoop);
+        inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : function,
           selector != null ||
               Elements.isStaticOrTopLevel(function) ||
               function.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $function."));
       if (selector != null) {
         if (!selector.applies(function)) return false;
         if (mask != null && !mask.canHit(function, selector, closedWorld)) {
           return false;
         }
       }
 
-      if (backend.nativeData.isJsInteropMember(function)) return false;
+      if (nativeData.isJsInteropMember(function)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (function.name == '==') {
         if (function.enclosingClass != commonElements.objectClass &&
             providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
       if (function.isGenerativeConstructor &&
-          backend.nativeData.isNativeOrExtendsNative(function.enclosingClass)) {
+          nativeData.isNativeOrExtendsNative(function.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
       if (!function.isGenerativeConstructorBody) {
         if (globalInferenceResults.resultOfMember(function).throwsAlways) {
           isReachable = false;
           return false;
         }
@@ skipping 69 matching lines @@
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
       if (isCalledOnce(function)) {
         maxInliningNodes = null;
       }
       bool canInline = InlineWeeder.canBeInlined(
           functionResolvedAst, maxInliningNodes,
           enableUserAssertions: options.enableUserAssertions);
       if (canInline) {
-        backend.inlineCache.markAsInlinable(function, insideLoop: insideLoop);
+        inlineCache.markAsInlinable(function, insideLoop: insideLoop);
       } else {
-        backend.inlineCache
-            .markAsNonInlinable(function, insideLoop: insideLoop);
+        inlineCache.markAsNonInlinable(function, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
       if (function.isInstanceMember &&
           !function.isGenerativeConstructorBody &&
@@ skipping 60 matching lines @@
 
   /**
    * Return null so it is simple to remove the optional parameters completely
    * from interop methods to match JavaScript semantics for omitted arguments.
    */
   HInstruction handleConstantForOptionalParameterJsInterop(Element parameter) =>
       null;
 
   HInstruction handleConstantForOptionalParameter(ParameterElement parameter) {
     ConstantValue constantValue =
-        backend.constants.getConstantValue(parameter.constant);
+        constants.getConstantValue(parameter.constant);
     assert(invariant(parameter, constantValue != null,
         message: 'No constant computed for $parameter'));
     return graph.addConstant(constantValue, closedWorld);
   }
 
   ClassElement get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       dynamic closureClass = cls;
       // ignore: UNDEFINED_GETTER
@@ skipping 12 matching lines @@
   final List<ResolutionDartType> currentInlinedInstantiations =
       <ResolutionDartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   ResolutionDartType returnType;
 
   ConstantValue getConstantForNode(ast.Node node) {
     ConstantValue constantValue =
-        backend.constants.getConstantValueForNode(node, elements);
+        constants.getConstantValueForNode(node, elements);
     assert(invariant(node, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), closedWorld);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(MethodElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = closedWorld.isCalledInLoop(functionElement);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
-    if (backend.nativeData.isJsInteropMember(functionElement)) {
+    if (nativeData.isJsInteropMember(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
       return closeFunction();
     }
     assert(invariant(functionElement, !function.modifiers.isExternal));
 
     // If [functionElement] is `operator==` we explicitly add a null check at
@@ skipping 97 matching lines @@
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       FunctionElement function, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
-    localsHandler = new LocalsHandler(this, function, instanceType,
-        backend.nativeData, backend.interceptorData);
+    localsHandler = new LocalsHandler(
+        this, function, instanceType, nativeData, interceptorData);
     localsHandler.closureData =
         closureToClassMapper.getClosureToClassMapping(resolvedAst);
     returnLocal = new SyntheticLocal("result", function);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
     ClassElement enclosing = function.enclosingClass;
     if ((function.isConstructor || function.isGenerativeConstructorBody) &&
-        backend.rtiNeed.classNeedsRti(enclosing)) {
+        rtiNeed.classNeedsRti(enclosing)) {
       enclosing.typeVariables
           .forEach((ResolutionTypeVariableType typeVariable) {
         HInstruction argument = compiledArguments[argumentIndex++];
         localsHandler.updateLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable), argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
     returnType = signature.type.returnType;
@@ skipping 59 matching lines @@
   void inlineSuperOrRedirect(
       ResolvedAst constructorResolvedAst,
       List<HInstruction> compiledArguments,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues,
       FunctionElement caller) {
     ConstructorElement callee = constructorResolvedAst.element.implementation;
     reporter.withCurrentElement(callee, () {
       constructorResolvedAsts.add(constructorResolvedAst);
       ClassElement enclosingClass = callee.enclosingClass;
-      if (backend.rtiNeed.classNeedsRti(enclosingClass)) {
+      if (rtiNeed.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         ResolutionInterfaceType type =
             currentClass.thisType.asInstanceOf(enclosingClass);
         type = localsHandler.substInContext(type);
@@ skipping 210 matching lines @@
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       if (compiler.elementHasCompileTimeError(member)) return;
       reporter.withCurrentElement(member, () {
         ResolvedAst fieldResolvedAst = member.resolvedAst;
         ast.Expression initializer = fieldResolvedAst.body;
         if (initializer == null) {
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
-          if (!backend.nativeData.isNativeOrExtendsNative(classElement)) {
+          if (!nativeData.isNativeOrExtendsNative(classElement)) {
             fieldValues[member] = graph.addConstantNull(closedWorld);
           }
         } else {
           ast.Node right = initializer;
           ResolvedAst savedResolvedAst = resolvedAst;
           resolvedAst = fieldResolvedAst;
           final oldElementInferenceResults = elementInferenceResults;
           elementInferenceResults =
               globalInferenceResults.resultOfMember(member);
           // In case the field initializer uses closures, run the
@@ skipping 15 matching lines @@
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
    */
   HGraph buildFactory(ResolvedAst resolvedAst) {
     ConstructorElement functionElement = resolvedAst.element;
     functionElement = functionElement.implementation;
     ClassElement classElement = functionElement.enclosingClass.implementation;
     bool isNativeUpgradeFactory =
-        backend.nativeData.isNativeOrExtendsNative(classElement) &&
-            !backend.nativeData.isJsInteropClass(classElement);
+        nativeData.isNativeOrExtendsNative(classElement) &&
+            !nativeData.isJsInteropClass(classElement);
     ast.FunctionExpression function;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       function = resolvedAst.node;
     }
 
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
@@ skipping 54 matching lines @@
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes =
           new List<ResolutionDartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
       // Create the runtime type information, if needed.
       bool hasRtiInput = false;
-      if (backend.rtiNeed.classNeedsRtiField(classElement)) {
+      if (rtiNeed.classNeedsRtiField(classElement)) {
         // Read the values of the type arguments and create a
         // HTypeInfoExpression to set on the newly create object.
         hasRtiInput = true;
         List<HInstruction> typeArguments = <HInstruction>[];
         classElement.typeVariables
             .forEach((ResolutionTypeVariableType typeVariable) {
           HInstruction argument = localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
           typeArguments.add(argument);
         });
@@ skipping 66 matching lines @@
       // The box must be passed before any type variable.
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
       // Type variables arguments must come after the box (if there is one).
       ConstructorElement constructor =
           constructorResolvedAst.element.implementation;
       ClassElement currentClass = constructor.enclosingClass;
-      if (backend.rtiNeed.classNeedsRti(currentClass)) {
+      if (rtiNeed.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables
             .forEach((ResolutionTypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
           // `localsHandler.substInContext(argument)`.
           bodyCallInputs.add(localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(argument)));
         });
       }
@@ skipping 31 matching lines @@
     localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     var enclosing = element.enclosingElement;
     if ((element.isConstructor || element.isGenerativeConstructorBody) &&
-        backend.rtiNeed.classNeedsRti(enclosing)) {
+        rtiNeed.classNeedsRti(enclosing)) {
       enclosing.typeVariables
           .forEach((ResolutionTypeVariableType typeVariable) {
         HParameterValue param =
             addParameter(typeVariable.element, commonMasks.nonNullType);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
       });
     }
 
     if (element is MethodElement) {
@@ skipping 41 matching lines @@
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
     insertTraceCall(element);
     insertCoverageCall(element);
   }
 
   insertTraceCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'console') {
-      if (element == backend.helpers.traceHelper) return;
+      if (element == helpers.traceHelper) return;
       n(e) => e == null ? '' : e.name;
       String name = "${n(element.library)}:${n(element.enclosingClass)}."
           "${n(element)}";
       HConstant nameConstant = addConstantString(name);
-      add(new HInvokeStatic(backend.helpers.traceHelper,
-          <HInstruction>[nameConstant], commonMasks.dynamicType));
+      add(new HInvokeStatic(helpers.traceHelper, <HInstruction>[nameConstant],
+          commonMasks.dynamicType));
     }
   }
 
   insertCoverageCall(Element element) {
     if (JavaScriptBackend.TRACE_METHOD == 'post') {
-      if (element == backend.helpers.traceHelper) return;
+      if (element == helpers.traceHelper) return;
       // TODO(sigmund): create a better uuid for elements.
       HConstant idConstant =
           graph.addConstantInt(element.hashCode, closedWorld);
       HConstant nameConstant = addConstantString(element.name);
-      add(new HInvokeStatic(backend.helpers.traceHelper,
+      add(new HInvokeStatic(helpers.traceHelper,
           <HInstruction>[idConstant, nameConstant], commonMasks.dynamicType));
     }
   }
 
   void assertIsSubtype(ast.Node node, ResolutionDartType subtype,
       ResolutionDartType supertype, String message) {
     HInstruction subtypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(subtype), sourceElement);
     HInstruction supertypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(supertype), sourceElement);
@@ skipping 593 matching lines @@
       assert(invariant(node, element == null || element.isMalformed));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
       stack.add(graph.addConstantNull(closedWorld));
     }
   }
 
   /// Read a static or top level [field] of constant value.
   void generateStaticConstGet(ast.Send node, FieldElement field,
       ConstantExpression constant, SourceInformation sourceInformation) {
-    ConstantValue value = backend.constants.getConstantValue(constant);
+    ConstantValue value = constants.getConstantValue(constant);
     HConstant instruction;
     // Constants that are referred via a deferred prefix should be referred
     // by reference.
     PrefixElement prefix =
         compiler.deferredLoadTask.deferredPrefixElement(node, elements);
     if (prefix != null) {
       instruction = graph.addDeferredConstant(
           value, prefix, sourceInformation, compiler, closedWorld);
     } else {
       instruction = graph.addConstant(value, closedWorld,
@@ skipping 325 matching lines @@
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, commonMasks.boolType);
     } else if (RuntimeTypesSubstitutions.hasTypeArguments(type)) {
       ClassElement element = type.element;
       MethodElement helper = helpers.checkSubtype;
       HInstruction representations =
           typeBuilder.buildTypeArgumentRepresentations(type, sourceElement);
       add(representations);
-      js.Name operator = backend.namer.operatorIs(element);
+      js.Name operator = namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
-          ? addConstantStringFromName(backend.namer.substitutionName(element))
+          ? addConstantStringFromName(namer.substitutionName(element))
           : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       pushInvokeStatic(node, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, commonMasks.boolType);
@@ skipping 55 matching lines @@
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
     return Elements.makeArgumentsList<HInstruction>(
         callStructure,
         arguments,
         element.implementation,
         compileArgument,
-        backend.nativeData.isJsInteropMember(element)
+        nativeData.isJsInteropMember(element)
             ? handleConstantForOptionalParameterJsInterop
             : handleConstantForOptionalParameter);
   }
 
   void addGenericSendArgumentsToList(
       Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
@@ skipping 149 matching lines @@
     }
     push(new HStringConcat(inputs[0], inputs[1], commonMasks.stringType));
   }
 
   void handleForeignJsCurrentIsolateContext(ast.Send node) {
     if (!node.arguments.isEmpty) {
       reporter.internalError(
           node, 'Too many arguments to JS_CURRENT_ISOLATE_CONTEXT.');
     }
 
-    if (!backend.backendUsage.isIsolateInUse) {
+    if (!backendUsage.isIsolateInUse) {
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
-      String name = backend.namer.staticStateHolder;
+      String name = namer.staticStateHolder;
       push(new HForeignCode(
           js.js.parseForeignJS(name), commonMasks.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       MethodElement element = helpers.currentIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
@@ skipping 22 matching lines @@
     }
     ast.LiteralString string = argument.asLiteralString();
     if (string == null) {
       reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a literal string.'});
     }
     String name = string.dartString.slowToString();
     bool value = false;
     switch (name) {
       case 'MUST_RETAIN_METADATA':
-        value = backend.mirrorsData.mustRetainMetadata;
+        value = mirrorsData.mustRetainMetadata;
         break;
       case 'USE_CONTENT_SECURITY_POLICY':
         value = options.useContentSecurityPolicy;
         break;
       default:
         reporter.reportErrorMessage(node, MessageKind.GENERIC,
             {'text': 'Error: Unknown internal flag "$name".'});
     }
     stack.add(graph.addConstantBool(value, closedWorld));
   }
@@ skipping 19 matching lines @@
     Element element = elements[argument];
     if (element == null ||
         element is! EnumConstantElement ||
         element.enclosingClass != helpers.jsGetNameEnum) {
       reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsGetName enum value.'});
     }
     EnumConstantElement enumConstant = element;
     int index = enumConstant.index;
     stack.add(addConstantStringFromName(
-        backend.namer.getNameForJsGetName(argument, JsGetName.values[index])));
+        namer.getNameForJsGetName(argument, JsGetName.values[index])));
   }
 
   void handleForeignJsBuiltin(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
     if (arguments.length < 2) {
       reporter.reportErrorMessage(node, MessageKind.GENERIC,
           {'text': 'Error: Expected at least two arguments to JS_BUILTIN.'});
     }
 
     Element builtinElement = elements[arguments[1]];
     if (builtinElement == null ||
         (builtinElement is! EnumConstantElement) ||
         builtinElement.enclosingClass != helpers.jsBuiltinEnum) {
       reporter.reportErrorMessage(argument, MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
     }
     EnumConstantElement enumConstant = builtinElement;
     int index = enumConstant.index;
 
-    js.Template template =
-        backend.emitter.builtinTemplateFor(JsBuiltin.values[index]);
+    js.Template template = emitter.builtinTemplateFor(JsBuiltin.values[index]);
 
     List<HInstruction> compiledArguments = <HInstruction>[];
     for (int i = 2; i < arguments.length; i++) {
       visit(arguments[i]);
       compiledArguments.add(pop());
     }
 
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
     assert(invariant(node, nativeBehavior != null,
         message: "No NativeBehavior for $node"));
@@ skipping 32 matching lines @@
       reporter.reportErrorMessage(arguments[1], MessageKind.GENERIC, {
         'text': 'Error: Expected String as second argument '
             'to JS_EMBEDDED_GLOBAL.'
       });
       return;
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
-        backend.emitter.generateEmbeddedGlobalAccess(globalName));
+        emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
     assert(invariant(node, nativeBehavior != null,
         message: "No NativeBehavior for $node"));
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const [],
         nativeBehavior: nativeBehavior));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
@@ skipping 15 matching lines @@
         }
       }
     }
     reporter.reportErrorMessage(
         node, MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
-    if (!backend.backendUsage.isIsolateInUse) {
+    if (!backendUsage.isIsolateInUse) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[pop()], commonMasks.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       MethodElement element = helpers.callInIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
@@ skipping 21 matching lines @@
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
       reporter.internalError(
           closure, '"$name" does not handle closure with optional parameters.');
     }
 
     push(new HForeignCode(
-        js.js.expressionTemplateYielding(
-            backend.emitter.staticFunctionAccess(function)),
+        js.js
+            .expressionTemplateYielding(emitter.staticFunctionAccess(function)),
         commonMasks.dynamicType,
         <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE,
         foreignFunction: function));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignJsSetStaticState(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       reporter.internalError(
           node.argumentsNode, 'Exactly one argument required.');
     }
     visit(node.arguments.head);
-    String isolateName = backend.namer.staticStateHolder;
+    String isolateName = namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
     push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
         commonMasks.dynamicType, <HInstruction>[pop()],
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ast.Send node) {
     if (!node.arguments.isEmpty) {
       reporter.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeignCode(js.js.parseForeignJS(backend.namer.staticStateHolder),
+    push(new HForeignCode(js.js.parseForeignJS(namer.staticStateHolder),
         commonMasks.dynamicType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
   }
 
   void handleForeignSend(ast.Send node, FunctionElement element) {
     String name = element.name;
     if (name == BackendHelpers.JS) {
       handleForeignJs(node);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
       handleForeignJsCurrentIsolateContext(node);
@@ skipping 45 matching lines @@
   generateSuperNoSuchMethodSend(
       ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       ClassElement objectClass = commonElements.objectClass;
       element = objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
-    if (backend.backendUsage.isInvokeOnUsed &&
-        !element.enclosingClass.isObject) {
+    if (backendUsage.isInvokeOnUsed && !element.enclosingClass.isObject) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
     ConstantValue nameConstant =
         constantSystem.createString(new ast.DartString.literal(publicName));
 
-    js.Name internalName = backend.namer.invocationName(selector);
+    js.Name internalName = namer.invocationName(selector);
 
     MethodElement createInvocationMirror = helpers.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
@@ skipping 194 matching lines @@
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
     return closedWorld.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   HInstruction handleListConstructor(ResolutionInterfaceType type,
       ast.Node currentNode, HInstruction newObject) {
-    if (!backend.rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
+    if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
     type.typeArguments.forEach((ResolutionDartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, inputs, newObject);
@@ skipping 44 matching lines @@
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred = _inferredTypeOfNewList(send);
         return inferred.containsAll(closedWorld)
             ? commonMasks.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
           originalElement, closedWorld)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         ClassElement cls = element.enclosingClass;
-        assert(backend.nativeData.isNativeClass(cls));
+        assert(nativeData.isNativeClass(cls));
         return inferred.containsAll(closedWorld)
             ? new TypeMask.nonNullExact(cls, closedWorld)
             : inferred;
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
         if (cls.isAbstract) {
           // An error will be thrown.
           return new TypeMask.nonNullEmpty();
         } else {
           return new TypeMask.nonNullExact(cls, closedWorld);
@@ skipping 67 matching lines @@
     // calling [makeStaticArgumentList].
     constructorImplementation = constructor.implementation;
     if (constructorImplementation.isMalformed ||
         !callStructure.signatureApplies(constructorImplementation.type)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
-        backend.nativeData
-            .isNativeOrExtendsNative(constructor.enclosingClass) &&
-        !backend.nativeData.isJsInteropMember(constructor)) {
+        nativeData.isNativeOrExtendsNative(constructor.enclosingClass) &&
+        !nativeData.isJsInteropMember(constructor)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(closedWorld));
     }
     inputs.addAll(makeStaticArgumentList(
         callStructure, send.arguments, constructorImplementation.declaration));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(closedWorld)) {
         HTypeConversion conversion = new HTypeConversion(
@@ skipping 50 matching lines @@
       // Overwrite the element type, in case the allocation site has
       // been inlined.
       newInstance.instructionType = elementType;
       graph.allocatedFixedLists?.add(newInstance);
     }
 
     // The List constructor forwards to a Dart static method that does
     // not know about the type argument. Therefore we special case
     // this constructor to have the setRuntimeTypeInfo called where
     // the 'new' is done.
-    if (backend.rtiNeed.classNeedsRti(commonElements.listClass) &&
+    if (rtiNeed.classNeedsRti(commonElements.listClass) &&
         (isFixedListConstructorCall ||
             isGrowableListConstructorCall ||
             isJSArrayTypedConstructor)) {
       newInstance = handleListConstructor(type, send, pop());
       stack.add(newInstance);
     }
 
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
       HInstruction checked =
           typeBuilder.potentiallyCheckOrTrustType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
       ResolutionInterfaceType expectedType,
       {SourceInformation sourceInformation}) {
-    if (!backend.rtiNeed.classNeedsRti(cls)) return;
+    if (!rtiNeed.classNeedsRti(cls)) return;
     assert(cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((ResolutionDartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement,
           sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(
@@ skipping 444 matching lines @@
         return closedWorld.isSubtypeOf(
             element.enclosingClass, helpers.jsMutableIndexableClass);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.enclosingClass;
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
-      if (!backend.interceptorData.interceptedClasses.contains(cls))
-        return false;
+      if (!interceptorData.interceptedClasses.contains(cls)) return false;
       if (selector.isOperator) return true;
       if (selector.isSetter) return true;
       if (selector.isIndex) return true;
       if (selector.isIndexSet) return true;
       if (element == helpers.jsArrayAdd ||
           element == helpers.jsArrayRemoveLast ||
           element == helpers.jsStringSplit) {
         return true;
       }
       return false;
     }
 
     MemberElement element = closedWorld.locateSingleElement(selector, mask);
     if (element != null &&
         !element.isField &&
         !(element.isGetter && selector.isCall) &&
         !(element.isFunction && selector.isGetter) &&
         !isOptimizableOperation(selector, element)) {
       if (tryInlineMethod(element, selector, mask, arguments, node)) {
         return;
       }
     }
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
-    bool isIntercepted =
-        backend.interceptorData.isInterceptedSelector(selector);
+    bool isIntercepted = interceptorData.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(
         selector, mask, globalInferenceResults);
     if (selector.isGetter) {
       push(new HInvokeDynamicGetter(selector, mask, null, inputs, type)
         ..sourceInformation = sourceInformation);
     } else if (selector.isSetter) {
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type)
         ..sourceInformation = sourceInformation);
     } else {
       push(new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted)
         ..sourceInformation = sourceInformation);
     }
   }
 
   HForeignCode invokeJsInteropFunction(MethodElement element,
       List<HInstruction> arguments, SourceInformation sourceInformation) {
-    assert(backend.nativeData.isJsInteropMember(element));
+    assert(nativeData.isJsInteropMember(element));
     nativeEmitter.nativeMethods.add(element);
 
     if (element.isFactoryConstructor &&
-        backend.jsInteropAnalysis
-            .hasAnonymousAnnotation(element.contextClass)) {
+        jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass)) {
       // Factory constructor that is syntactic sugar for creating a JavaScript
       // object literal.
       ConstructorElement constructor = element;
       FunctionSignature params = constructor.functionSignature;
       int i = 0;
       int positions = 0;
       var filteredArguments = <HInstruction>[];
       var parameterNameMap = new Map<String, js.Expression>();
       params.orderedForEachParameter((ParameterElement parameter) {
         // TODO(jacobr): consider throwing if parameter names do not match
         // names of properties in the class.
         assert(parameter.isNamed);
         HInstruction argument = arguments[i];
         if (argument != null) {
           filteredArguments.add(argument);
-          var jsName =
-              backend.nativeData.computeUnescapedJSInteropName(parameter.name);
+          var jsName = nativeData.computeUnescapedJSInteropName(parameter.name);
           parameterNameMap[jsName] = new js.InterpolatedExpression(positions++);
         }
         i++;
       });
       var codeTemplate =
           new js.Template(null, js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
       if (options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
           codeTemplate, commonMasks.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
     var target = new HForeignCode(
-        js.js.parseForeignJS(
-            "${backend.nativeData.getFixedBackendMethodPath(element)}."
-            "${backend.nativeData.getFixedBackendName(element)}"),
+        js.js.parseForeignJS("${nativeData.getFixedBackendMethodPath(element)}."
+            "${nativeData.getFixedBackendName(element)}"),
         commonMasks.dynamicType,
         <HInstruction>[]);
     add(target);
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
     ResolutionDartType type = element.isConstructor
         ? element.enclosingClass.thisType
         : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
     nativeBehavior.typesReturned.add(options.trustJSInteropTypeAnnotations
         ? type
         : const ResolutionDynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type is ResolutionInterfaceType &&
-        backend.nativeData.isNativeClass(type.element)) {
+        nativeData.isNativeClass(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!options.trustJSInteropTypeAnnotations ||
         type.isObject ||
         type.isDynamic) {
-      ClassElement cls = backend.helpers.jsJavaScriptObjectClass;
+      ClassElement cls = helpers.jsJavaScriptObjectClass;
       nativeBehavior.typesInstantiated.add(cls.thisType);
     }
 
     String code;
     if (element.isGetter) {
       code = "#";
     } else if (element.isSetter) {
       code = "# = #";
     } else {
       var args = new List.filled(arguments.length, '#').join(',');
@@ skipping 19 matching lines @@
       return;
     }
 
     if (typeMask == null) {
       typeMask = TypeMaskFactory.inferredReturnTypeForElement(
           element, globalInferenceResults);
     }
     bool targetCanThrow = !closedWorld.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
-    if (backend.nativeData.isJsInteropMember(element)) {
+    if (nativeData.isJsInteropMember(element)) {
       instruction =
           invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
       instruction = new HInvokeStatic(element, arguments, typeMask,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (currentInlinedInstantiations.isNotEmpty) {
         instruction.instantiatedTypes =
             new List<ResolutionDartType>.from(currentInlinedInstantiations);
       }
       instruction.sideEffects = closedWorld.getSideEffectsOfElement(element);
     }
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
   HInstruction buildInvokeSuper(
       Selector selector, MemberElement element, List<HInstruction> arguments,
       [SourceInformation sourceInformation]) {
     HInstruction receiver = localsHandler.readThis();
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     List<HInstruction> inputs = <HInstruction>[];
-    if (backend.interceptorData.isInterceptedSelector(selector) &&
+    if (interceptorData.isInterceptedSelector(selector) &&
         // Fields don't need an interceptor; consider generating HFieldGet/Set
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForMember(
@@ skipping 912 matching lines @@
           }
         }
       } else {
         for (ParameterElement parameter in targetOptionals) {
           loadPosition(position++, parameter);
         }
       }
     }
 
     ClassElement targetClass = targetConstructor.enclosingClass;
-    if (backend.rtiNeed.classNeedsRti(targetClass)) {
+    if (rtiNeed.classNeedsRti(targetClass)) {
       ClassElement cls = redirectingConstructor.enclosingClass;
       ResolutionInterfaceType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
       targetType = localsHandler.substInContext(targetType);
       targetType.typeArguments.forEach((ResolutionDartType argument) {
         inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
     }
     pushInvokeStatic(node, targetConstructor.declaration, inputs);
     HInstruction value = pop();
@@ skipping 94 matching lines @@
         generateNonInstanceSetter(
             node, local, visitAndPop(node.arguments.first));
         pop(); // Discard value.
       }
     }
   }
 
   HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) {
     ResolutionInterfaceType type =
         localsHandler.substInContext(elements.getType(node));
-    if (!backend.rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
+    if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (ResolutionDartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
@@ skipping 427 matching lines @@
     listConstructor = constructorElement.effectiveTarget;
 
     ResolutionInterfaceType type = elements.getType(node);
     ResolutionInterfaceType expectedType =
         constructorElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     ClassElement cls = listConstructor.enclosingClass;
 
     MethodElement createFunction = listConstructor;
-    if (backend.rtiNeed.classNeedsRti(cls)) {
+    if (rtiNeed.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
       expectedType.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
@@ skipping 1098 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }