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

pkg/compiler/lib/src/ssa/graph_builder.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 '../closure.dart';
+import '../constants/constant_system.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart' show Entity, Local;
 import '../elements/resolution_types.dart';
+import '../js_backend/backend_helpers.dart';
+import '../js_backend/backend_usage.dart';
+import '../js_backend/constant_handler_javascript.dart';
 import '../js_backend/js_backend.dart';
+import '../js_backend/native_data.dart';
+import '../js_backend/js_interop_analysis.dart';
+import '../js_backend/interceptor_data.dart';
+import '../js_backend/mirrors_data.dart';
+import '../js_emitter/code_emitter_task.dart';
 import '../options.dart';
 import '../resolution/tree_elements.dart';
 import '../types/types.dart';
 import '../world.dart' show ClosedWorld;
 import 'jump_handler.dart';
 import 'locals_handler.dart';
 import 'nodes.dart';
 import 'type_builder.dart';
 
 /// Base class for objects that build up an SSA graph.
@@ skipping 24 matching lines @@
   ClosedWorld get closedWorld;
 
   CommonMasks get commonMasks => closedWorld.commonMasks;
 
   DiagnosticReporter get reporter => backend.reporter;
 
   CompilerOptions get options => compiler.options;
 
   CommonElements get commonElements => closedWorld.commonElements;
 
+  CodeEmitterTask get emitter => backend.emitter;
+
   GlobalTypeInferenceResults get globalInferenceResults =>
       compiler.globalInference.results;
 
   ClosureTask get closureToClassMapper => compiler.closureToClassMapper;
 
+  NativeData get nativeData => backend.nativeData;
+
+  InterceptorData get interceptorData => backend.interceptorData;
+
+  BackendUsage get backendUsage => backend.backendUsage;
+
+  Namer get namer => backend.namer;
+
+  RuntimeTypesNeed get rtiNeed => backend.rtiNeed;
+
+  JavaScriptConstantCompiler get constants => backend.constants;
+
+  ConstantSystem get constantSystem => constants.constantSystem;
+
+  BackendHelpers get helpers => backend.helpers;
+
+  RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
+
+  FunctionInlineCache get inlineCache => backend.inlineCache;
+
+  MirrorsData get mirrorsData => backend.mirrorsData;
+
+  JsInteropAnalysis get jsInteropAnalysis => backend.jsInteropAnalysis;
+
   /// Used to track the locals while building the graph.
   LocalsHandler localsHandler;
 
   /// A stack of instructions.
   ///
   /// We build the SSA graph by simulating a stack machine.
   List<HInstruction> stack = <HInstruction>[];
 
   /// The count of nested loops we are currently building.
   ///
@@ skipping 135 matching lines @@
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
   bool hasDirectLocal(Local local) {
     return !localsHandler.isAccessedDirectly(local) ||
         localsHandler.directLocals[local] != null;
   }
 
   HInstruction callSetRuntimeTypeInfoWithTypeArguments(ResolutionDartType type,
       List<HInstruction> rtiInputs, HInstruction newObject) {
-    if (!backend.rtiNeed.classNeedsRti(type.element)) {
+    if (!rtiNeed.classNeedsRti(type.element)) {
       return newObject;
     }
 
     HInstruction typeInfo = new HTypeInfoExpression(
         TypeInfoExpressionKind.INSTANCE,
         (type.element as ClassElement).thisType,
         rtiInputs,
         closedWorld.commonMasks.dynamicType);
     add(typeInfo);
     return callSetRuntimeTypeInfo(typeInfo, newObject);
   }
 
   /// Called when control flow is about to change, in which case we need to
   /// specify special successors if we are already in a try/catch/finally block.
   void handleInTryStatement() {
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject);
 
   /// The element for which this SSA builder is being used.
   Element get targetElement;
   TypeBuilder get typeBuilder;
 }