Make codegen and optimizations depend more directly on data objects.

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart'
     show ClassElement, FieldElement, MethodElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
+import '../js_backend/interceptor_data.dart' show InterceptorData;
+import '../js_backend/native_data.dart' show NativeData;
 import '../native/native.dart' as native;
+import '../options.dart';
 import '../tree/dartstring.dart' as ast;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 import 'interceptor_simplifier.dart';
 import 'nodes.dart';
 import 'types.dart';
 import 'types_propagation.dart';
 import 'value_range_analyzer.dart';
 import 'value_set.dart';
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
-  final JavaScriptBackend backend;
+  final JavaScriptBackend _backend;
 
   Map<HInstruction, Range> ranges = <HInstruction, Range>{};
 
-  SsaOptimizerTask(JavaScriptBackend backend)
-      : this.backend = backend,
-        super(backend.compiler.measurer);
+  SsaOptimizerTask(this._backend) : super(_backend.compiler.measurer);
 
   String get name => 'SSA optimizer';
 
-  Compiler get compiler => backend.compiler;
+  Compiler get _compiler => _backend.compiler;
+
+  GlobalTypeInferenceResults get _results => _compiler.globalInference.results;
+
+  BackendHelpers get _helpers => _backend.helpers;
+
+  CompilerOptions get _options => _compiler.options;
+
+  RuntimeTypesSubstitutions get _rtiSubstitutions => _backend.rtiSubstitutions;
+
+  InterceptorData get _interceptorData => _backend.interceptorData;
 
   void optimize(CodegenWorkItem work, HGraph graph, ClosedWorld closedWorld) {
     void runPhase(OptimizationPhase phase) {
       measureSubtask(phase.name, () => phase.visitGraph(graph));
-      backend.tracer.traceGraph(phase.name, graph);
+      _backend.tracer.traceGraph(phase.name, graph);
       assert(graph.isValid());
     }
 
-    bool trustPrimitives = compiler.options.trustPrimitives;
+    bool trustPrimitives = _options.trustPrimitives;
     CodegenRegistry registry = work.registry;
     Set<HInstruction> boundsChecked = new Set<HInstruction>();
     SsaCodeMotion codeMotion;
     SsaLoadElimination loadElimination;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
         // Run trivial instruction simplification first to optimize
         // some patterns useful for type conversion.
-        new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+        new SsaInstructionSimplifier(_results, _options, _helpers,
+            _rtiSubstitutions, closedWorld, registry),
         new SsaTypeConversionInserter(closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
-        new SsaTypePropagator(compiler, closedWorld),
+        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
         // After type propagation, more instructions can be
         // simplified.
-        new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+        new SsaInstructionSimplifier(_results, _options, _helpers,
+            _rtiSubstitutions, closedWorld, registry),
         new SsaCheckInserter(
-            trustPrimitives, backend, closedWorld, boundsChecked),
-        new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+            trustPrimitives, _helpers, closedWorld, boundsChecked),
+        new SsaInstructionSimplifier(_results, _options, _helpers,
+            _rtiSubstitutions, closedWorld, registry),
         new SsaCheckInserter(
-            trustPrimitives, backend, closedWorld, boundsChecked),
-        new SsaTypePropagator(compiler, closedWorld),
+            trustPrimitives, _helpers, closedWorld, boundsChecked),
+        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
         // Run a dead code eliminator before LICM because dead
         // interceptors are often in the way of LICM'able instructions.
         new SsaDeadCodeEliminator(closedWorld, this),
         new SsaGlobalValueNumberer(),
         // After GVN, some instructions might need their type to be
         // updated because they now have different inputs.
-        new SsaTypePropagator(compiler, closedWorld),
+        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
         codeMotion = new SsaCodeMotion(),
         loadElimination =
-            new SsaLoadElimination(backend, compiler, closedWorld),
+            new SsaLoadElimination(_helpers, _compiler, closedWorld),
         new SsaRedundantPhiEliminator(),
         new SsaDeadPhiEliminator(),
         // After GVN and load elimination the same value may be used in code
         // controlled by a test on the value, so redo 'conversion insertion' to
         // learn from the refined type.
         new SsaTypeConversionInserter(closedWorld),
-        new SsaTypePropagator(compiler, closedWorld),
-        new SsaValueRangeAnalyzer(backend.helpers, closedWorld, this),
+        new SsaTypePropagator(_results, _options, _helpers, closedWorld),
+        new SsaValueRangeAnalyzer(_helpers, closedWorld, this),
         // Previous optimizations may have generated new
         // opportunities for instruction simplification.
-        new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+        new SsaInstructionSimplifier(_results, _options, _helpers,
+            _rtiSubstitutions, closedWorld, registry),
         new SsaCheckInserter(
-            trustPrimitives, backend, closedWorld, boundsChecked),
+            trustPrimitives, _helpers, closedWorld, boundsChecked),
       ];
       phases.forEach(runPhase);
 
       // Simplifying interceptors is not strictly just an optimization, it is
       // required for implementation correctness because the code generator
       // assumes it is always performed.
-      runPhase(new SsaSimplifyInterceptors(
-          compiler, closedWorld, work.element.enclosingClass));
+      runPhase(new SsaSimplifyInterceptors(closedWorld, _helpers,
+          _interceptorData, work.element.enclosingClass));
 
       SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(closedWorld, this);
       runPhase(dce);
       if (codeMotion.movedCode ||
           dce.eliminatedSideEffects ||
           loadElimination.newGvnCandidates) {
         phases = <OptimizationPhase>[
-          new SsaTypePropagator(compiler, closedWorld),
+          new SsaTypePropagator(_results, _options, _helpers, closedWorld),
           new SsaGlobalValueNumberer(),
           new SsaCodeMotion(),
-          new SsaValueRangeAnalyzer(backend.helpers, closedWorld, this),
-          new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+          new SsaValueRangeAnalyzer(_helpers, closedWorld, this),
+          new SsaInstructionSimplifier(_results, _options, _helpers,
+              _rtiSubstitutions, closedWorld, registry),
           new SsaCheckInserter(
-              trustPrimitives, backend, closedWorld, boundsChecked),
-          new SsaSimplifyInterceptors(
-              compiler, closedWorld, work.element.enclosingClass),
+              trustPrimitives, _helpers, closedWorld, boundsChecked),
+          new SsaSimplifyInterceptors(closedWorld, _helpers, _interceptorData,
+              work.element.enclosingClass),
           new SsaDeadCodeEliminator(closedWorld, this),
         ];
       } else {
         phases = <OptimizationPhase>[
-          new SsaTypePropagator(compiler, closedWorld),
+          new SsaTypePropagator(_results, _options, _helpers, closedWorld),
           // Run the simplifier to remove unneeded type checks inserted by
           // type propagation.
-          new SsaInstructionSimplifier(backend, closedWorld, this, registry),
+          new SsaInstructionSimplifier(_results, _options, _helpers,
+              _rtiSubstitutions, closedWorld, registry),
         ];
       }
       phases.forEach(runPhase);
     });
   }
 }
 
 /// Returns `true` if [mask] represents only types that have a length that
 /// cannot change.  The current implementation is conservative for the purpose
 /// of identifying gvn-able lengths and mis-identifies some unions of fixed
@@ skipping 18 matching lines @@
  * compile-time.
  */
 class SsaInstructionSimplifier extends HBaseVisitor
     implements OptimizationPhase {
   // We don't produce constant-folded strings longer than this unless they have
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
-  final JavaScriptBackend backend;
-  final ClosedWorld closedWorld;
-  final CodegenRegistry registry;
-  HGraph graph;
-  Compiler get compiler => backend.compiler;
-  final SsaOptimizerTask optimizer;
+  final GlobalTypeInferenceResults _globalInferenceResults;
+  final CompilerOptions _options;
+  final BackendHelpers _helpers;
+  final RuntimeTypesSubstitutions _rtiSubstitutions;
+  final ClosedWorld _closedWorld;
+  final CodegenRegistry _registry;
+  HGraph _graph;
 
-  SsaInstructionSimplifier(
-      this.backend, this.closedWorld, this.optimizer, this.registry);
+  SsaInstructionSimplifier(this._globalInferenceResults, this._options,
+      this._helpers, this._rtiSubstitutions, this._closedWorld, this._registry);
 
-  CommonElements get commonElements => closedWorld.commonElements;
+  CommonElements get commonElements => _closedWorld.commonElements;
 
-  BackendHelpers get helpers => backend.helpers;
+  ConstantSystem get constantSystem => _closedWorld.constantSystem;
 
-  ConstantSystem get constantSystem => closedWorld.constantSystem;
-
-  GlobalTypeInferenceResults get globalInferenceResults =>
-      compiler.globalInference.results;
+  NativeData get _nativeData => _closedWorld.nativeData;
 
   void visitGraph(HGraph visitee) {
-    graph = visitee;
+    _graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       HInstruction replacement = instruction.accept(this);
       if (replacement != instruction) {
         block.rewrite(instruction, replacement);
 
         // The intersection of double and int return conflicting, and
         // because of our number implementation for JavaScript, it
         // might be that an operation thought to return double, can be
         // simplified to an int. For example:
         // `2.5 * 10`.
-        if (!(replacement.isNumberOrNull(closedWorld) &&
-            instruction.isNumberOrNull(closedWorld))) {
+        if (!(replacement.isNumberOrNull(_closedWorld) &&
+            instruction.isNumberOrNull(_closedWorld))) {
           // If we can replace [instruction] with [replacement], then
           // [replacement]'s type can be narrowed.
           TypeMask newType = replacement.instructionType
-              .intersection(instruction.instructionType, closedWorld);
+              .intersection(instruction.instructionType, _closedWorld);
           replacement.instructionType = newType;
         }
 
         // If the replacement instruction does not know its
         // source element, use the source element of the
         // instruction.
         if (replacement.sourceElement == null) {
           replacement.sourceElement = instruction.sourceElement;
         }
         if (replacement.sourceInformation == null) {
@@ skipping 26 matching lines @@
       }
       // TODO(het): consider supporting other values (short strings?)
     }
     return null;
   }
 
   void propagateConstantValueToUses(HInstruction node) {
     if (node.usedBy.isEmpty) return;
     ConstantValue value = getConstantFromType(node);
     if (value != null) {
-      HConstant constant = graph.addConstant(value, closedWorld);
+      HConstant constant = _graph.addConstant(value, _closedWorld);
       for (HInstruction user in node.usedBy.toList()) {
         user.changeUse(node, constant);
       }
     }
   }
 
   HInstruction visitParameterValue(HParameterValue node) {
     // [HParameterValue]s are either the value of the parameter (in fully SSA
     // converted code), or the mutable variable containing the value (in
     // incompletely SSA converted code, e.g. methods containing exceptions).
@@ skipping 15 matching lines @@
     }
 
     propagateConstantValueToUses(node);
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
-    if (input.isBoolean(closedWorld)) return input;
+    if (input.isBoolean(_closedWorld)) return input;
 
     // If the code is unreachable, remove the HBoolify.  This can happen when
     // there is a throw expression in a short-circuit conditional.  Removing the
     // unreachable HBoolify makes it easier to reconstruct the short-circuit
     // operation.
     if (input.instructionType.isEmpty) return input;
 
     // All values that cannot be 'true' are boolified to false.
     TypeMask mask = input.instructionType;
-    if (!mask.contains(helpers.jsBoolClass, closedWorld)) {
-      return graph.addConstantBool(false, closedWorld);
+    if (!mask.contains(_helpers.jsBoolClass, _closedWorld)) {
+      return _graph.addConstantBool(false, _closedWorld);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
       HConstant constant = input;
       bool isTrue = constant.constant.isTrue;
-      return graph.addConstantBool(!isTrue, closedWorld);
+      return _graph.addConstantBool(!isTrue, _closedWorld);
     } else if (input is HNot) {
       return input.inputs[0];
     }
     return node;
   }
 
   HInstruction visitInvokeUnary(HInvokeUnary node) {
     HInstruction folded =
         foldUnary(node.operation(constantSystem), node.operand);
     return folded != null ? folded : node;
   }
 
   HInstruction foldUnary(UnaryOperation operation, HInstruction operand) {
     if (operand is HConstant) {
       HConstant receiver = operand;
       ConstantValue folded = operation.fold(receiver.constant);
-      if (folded != null) return graph.addConstant(folded, closedWorld);
+      if (folded != null) return _graph.addConstant(folded, _closedWorld);
     }
     return null;
   }
 
   HInstruction tryOptimizeLengthInterceptedGetter(HInvokeDynamic node) {
     HInstruction actualReceiver = node.inputs[1];
-    if (actualReceiver.isIndexablePrimitive(closedWorld)) {
+    if (actualReceiver.isIndexablePrimitive(_closedWorld)) {
       if (actualReceiver.isConstantString()) {
         HConstant constantInput = actualReceiver;
         StringConstantValue constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, closedWorld);
+        return _graph.addConstantInt(constant.length, _closedWorld);
       } else if (actualReceiver.isConstantList()) {
         HConstant constantInput = actualReceiver;
         ListConstantValue constant = constantInput.constant;
-        return graph.addConstantInt(constant.length, closedWorld);
+        return _graph.addConstantInt(constant.length, _closedWorld);
       }
-      bool isFixed = isFixedLength(actualReceiver.instructionType, closedWorld);
+      bool isFixed =
+          isFixedLength(actualReceiver.instructionType, _closedWorld);
       TypeMask actualType = node.instructionType;
-      TypeMask resultType = closedWorld.commonMasks.positiveIntType;
+      TypeMask resultType = _closedWorld.commonMasks.positiveIntType;
       // If we already have computed a more specific type, keep that type.
       if (HInstruction.isInstanceOf(
-          actualType, helpers.jsUInt31Class, closedWorld)) {
-        resultType = closedWorld.commonMasks.uint31Type;
+          actualType, _helpers.jsUInt31Class, _closedWorld)) {
+        resultType = _closedWorld.commonMasks.uint31Type;
       } else if (HInstruction.isInstanceOf(
-          actualType, helpers.jsUInt32Class, closedWorld)) {
-        resultType = closedWorld.commonMasks.uint32Type;
+          actualType, _helpers.jsUInt32Class, _closedWorld)) {
+        resultType = _closedWorld.commonMasks.uint32Type;
       }
       HGetLength result =
           new HGetLength(actualReceiver, resultType, isAssignable: !isFixed);
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstantValue constant = constantInput.constant;
-      return graph.addConstantInt(constant.length, closedWorld);
+      return _graph.addConstantInt(constant.length, _closedWorld);
     }
     return null;
   }
 
   HInstruction handleInterceptedCall(HInvokeDynamic node) {
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
           ? foldUnary(operation, node.inputs[1])
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // Try converting the instruction to a builtin instruction.
-    HInstruction instruction =
-        node.specializer.tryConvertToBuiltin(node, compiler, closedWorld);
+    HInstruction instruction = node.specializer.tryConvertToBuiltin(
+        node, _globalInferenceResults, _options, _helpers, _closedWorld);
     if (instruction != null) return instruction;
 
     Selector selector = node.selector;
     TypeMask mask = node.mask;
     HInstruction input = node.inputs[1];
 
     bool applies(MemberEntity element) {
       return selector.applies(element) &&
-          (mask == null || mask.canHit(element, selector, closedWorld));
+          (mask == null || mask.canHit(element, selector, _closedWorld));
     }
 
     if (selector.isCall || selector.isOperator) {
       FunctionEntity target;
-      if (input.isExtendableArray(closedWorld)) {
-        if (applies(helpers.jsArrayRemoveLast)) {
-          target = helpers.jsArrayRemoveLast;
-        } else if (applies(helpers.jsArrayAdd)) {
+      if (input.isExtendableArray(_closedWorld)) {
+        if (applies(_helpers.jsArrayRemoveLast)) {
+          target = _helpers.jsArrayRemoveLast;
+        } else if (applies(_helpers.jsArrayAdd)) {
           // The codegen special cases array calls, but does not
           // inline argument type checks.
-          if (!compiler.options.enableTypeAssertions) {
-            target = helpers.jsArrayAdd;
+          if (!_options.enableTypeAssertions) {
+            target = _helpers.jsArrayAdd;
           }
         }
-      } else if (input.isStringOrNull(closedWorld)) {
-        if (applies(helpers.jsStringSplit)) {
+      } else if (input.isStringOrNull(_closedWorld)) {
+        if (applies(_helpers.jsStringSplit)) {
           HInstruction argument = node.inputs[2];
-          if (argument.isString(closedWorld)) {
-            target = helpers.jsStringSplit;
+          if (argument.isString(_closedWorld)) {
+            target = _helpers.jsStringSplit;
           }
-        } else if (applies(helpers.jsStringOperatorAdd)) {
+        } else if (applies(_helpers.jsStringOperatorAdd)) {
           // `operator+` is turned into a JavaScript '+' so we need to
           // make sure the receiver and the argument are not null.
           // TODO(sra): Do this via [node.specializer].
           HInstruction argument = node.inputs[2];
-          if (argument.isString(closedWorld) && !input.canBeNull()) {
+          if (argument.isString(_closedWorld) && !input.canBeNull()) {
             return new HStringConcat(input, argument, node.instructionType);
           }
-        } else if (applies(helpers.jsStringToString) && !input.canBeNull()) {
+        } else if (applies(_helpers.jsStringToString) && !input.canBeNull()) {
           return input;
         }
       }
       if (target != null) {
         // TODO(ngeoffray): There is a strong dependency between codegen
         // and this optimization that the dynamic invoke does not need an
         // interceptor. We currently need to keep a
         // HInvokeDynamicMethod and not create a HForeign because
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(node.selector,
             node.mask, node.inputs.sublist(1), node.instructionType);
         result.element = target;
         return result;
       }
     } else if (selector.isGetter) {
-      if (selector.applies(helpers.jsIndexableLength)) {
+      if (selector.applies(_helpers.jsIndexableLength)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
-    TypeMask receiverType = node.getDartReceiver(closedWorld).instructionType;
+    TypeMask receiverType = node.getDartReceiver(_closedWorld).instructionType;
     MemberEntity element =
-        closedWorld.locateSingleElement(node.selector, receiverType);
+        _closedWorld.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null &&
         element.isFunction
         // If we found out that the only target is an implicitly called
         // [:noSuchMethod:] we just ignore it.
         &&
         node.selector.applies(element)) {
       MethodElement method = element;
 
-      if (backend.nativeData.isNativeMember(method)) {
+      if (_nativeData.isNativeMember(method)) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
         ResolutionFunctionType type = method.type;
         int optionalParameterCount =
             type.optionalParameterTypes.length + type.namedParameters.length;
         if (optionalParameterCount == 0 ||
             type.parameterTypes.length + optionalParameterCount ==
                 node.selector.argumentCount) {
           node.element = method;
         }
       }
       return node;
     }
 
     // Replace method calls through fields with a closure call on the value of
     // the field. This usually removes the demand for the call-through stub and
     // makes the field load available to further optimization, e.g. LICM.
 
     if (element != null &&
         element.isField &&
         element.name == node.selector.name) {
       FieldEntity field = element;
-      if (!backend.nativeData.isNativeMember(field) &&
-          !node.isCallOnInterceptor(closedWorld)) {
-        HInstruction receiver = node.getDartReceiver(closedWorld);
+      if (!_nativeData.isNativeMember(field) &&
+          !node.isCallOnInterceptor(_closedWorld)) {
+        HInstruction receiver = node.getDartReceiver(_closedWorld);
         TypeMask type = TypeMaskFactory.inferredTypeForElement(
-            field as Entity, globalInferenceResults);
+            field as Entity, _globalInferenceResults);
         HInstruction load = new HFieldGet(field, receiver, type);
         node.block.addBefore(node, load);
         Selector callSelector = new Selector.callClosureFrom(node.selector);
         List<HInstruction> inputs = <HInstruction>[load]
           ..addAll(node.inputs.skip(node.isInterceptedCall ? 2 : 1));
         HInstruction closureCall =
             new HInvokeClosure(callSelector, inputs, node.instructionType)
               ..sourceInformation = node.sourceInformation;
         node.block.addAfter(load, closureCall);
         return closureCall;
@@ skipping 25 matching lines @@
     if (type.namedParameters.isNotEmpty) return null;
 
     // Return types on native methods don't need to be checked, since the
     // declaration has to be truthful.
 
     // The call site might omit optional arguments. The inlined code must
     // preserve the number of arguments, so check only the actual arguments.
 
     List<HInstruction> inputs = node.inputs.sublist(1);
     bool canInline = true;
-    if (compiler.options.enableTypeAssertions && inputs.length > 1) {
+    if (_options.enableTypeAssertions && inputs.length > 1) {
       // TODO(sra): Check if [input] is guaranteed to pass the parameter
       // type check.  Consider using a strengthened type check to avoid
       // passing `null` to primitive types since the native methods usually
       // have non-nullable primitive parameter types.
       canInline = false;
     } else {
       int inputPosition = 1; // Skip receiver.
       void checkParameterType(ResolutionDartType type) {
         if (inputPosition++ < inputs.length && canInline) {
           if (type.unaliased.isFunctionType) {
             canInline = false;
           }
         }
       }
 
       type.parameterTypes.forEach(checkParameterType);
       type.optionalParameterTypes.forEach(checkParameterType);
       type.namedParameterTypes.forEach(checkParameterType);
     }
 
     if (!canInline) return null;
 
     // Strengthen instruction type from annotations to help optimize
     // dependent instructions.
     native.NativeBehavior nativeBehavior =
-        backend.nativeData.getNativeMethodBehavior(method);
+        _nativeData.getNativeMethodBehavior(method);
     TypeMask returnType =
-        TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
+        TypeMaskFactory.fromNativeBehavior(nativeBehavior, _closedWorld);
     HInvokeDynamicMethod result =
         new HInvokeDynamicMethod(node.selector, node.mask, inputs, returnType);
     result.element = method;
     return result;
   }
 
   HInstruction visitBoundsCheck(HBoundsCheck node) {
     HInstruction index = node.index;
-    if (index.isInteger(closedWorld)) return node;
+    if (index.isInteger(_closedWorld)) return node;
     if (index.isConstant()) {
       HConstant constantInstruction = index;
       assert(!constantInstruction.constant.isInt);
       if (!constantSystem.isInt(constantInstruction.constant)) {
         // -0.0 is a double but will pass the runtime integer check.
         node.staticChecks = HBoundsCheck.ALWAYS_FALSE;
       }
     }
     return node;
   }
 
   HInstruction foldBinary(
       BinaryOperation operation, HInstruction left, HInstruction right) {
     if (left is HConstant && right is HConstant) {
       HConstant op1 = left;
       HConstant op2 = right;
       ConstantValue folded = operation.fold(op1.constant, op2.constant);
-      if (folded != null) return graph.addConstant(folded, closedWorld);
+      if (folded != null) return _graph.addConstant(folded, _closedWorld);
     }
     return null;
   }
 
   HInstruction visitAdd(HAdd node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     // We can only perform this rewriting on Integer, as it is not
     // valid for -0.0.
-    if (left.isInteger(closedWorld) && right.isInteger(closedWorld)) {
+    if (left.isInteger(_closedWorld) && right.isInteger(_closedWorld)) {
       if (left is HConstant && left.constant.isZero) return right;
       if (right is HConstant && right.constant.isZero) return left;
     }
     return super.visitAdd(node);
   }
 
   HInstruction visitMultiply(HMultiply node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
-    if (left.isNumber(closedWorld) && right.isNumber(closedWorld)) {
+    if (left.isNumber(_closedWorld) && right.isNumber(_closedWorld)) {
       if (left is HConstant && left.constant.isOne) return right;
       if (right is HConstant && right.constant.isOne) return left;
     }
     return super.visitMultiply(node);
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     BinaryOperation operation = node.operation(constantSystem);
@@ skipping 20 matching lines @@
     // in the remaining optimizations.
     return super.visitRelational(node);
   }
 
   HInstruction handleIdentityCheck(HRelational node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     TypeMask leftType = left.instructionType;
     TypeMask rightType = right.instructionType;
 
-    HInstruction makeTrue() => graph.addConstantBool(true, closedWorld);
-    HInstruction makeFalse() => graph.addConstantBool(false, closedWorld);
+    HInstruction makeTrue() => _graph.addConstantBool(true, _closedWorld);
+    HInstruction makeFalse() => _graph.addConstantBool(false, _closedWorld);
 
     // Intersection of int and double return conflicting, so
     // we don't optimize on numbers to preserve the runtime semantics.
-    if (!(left.isNumberOrNull(closedWorld) &&
-        right.isNumberOrNull(closedWorld))) {
-      if (leftType.isDisjoint(rightType, closedWorld)) {
+    if (!(left.isNumberOrNull(_closedWorld) &&
+        right.isNumberOrNull(_closedWorld))) {
+      if (leftType.isDisjoint(rightType, _closedWorld)) {
         return makeFalse();
       }
     }
 
     if (left.isNull() && right.isNull()) {
       return makeTrue();
     }
 
     HInstruction compareConstant(HConstant constant, HInstruction input) {
       if (constant.constant.isTrue) {
         return input;
       } else {
-        return new HNot(input, closedWorld.commonMasks.boolType);
+        return new HNot(input, _closedWorld.commonMasks.boolType);
       }
     }
 
-    if (left.isConstantBoolean() && right.isBoolean(closedWorld)) {
+    if (left.isConstantBoolean() && right.isBoolean(_closedWorld)) {
       return compareConstant(left, right);
     }
 
-    if (right.isConstantBoolean() && left.isBoolean(closedWorld)) {
+    if (right.isConstantBoolean() && left.isBoolean(_closedWorld)) {
       return compareConstant(right, left);
     }
 
     if (identical(left.nonCheck(), right.nonCheck())) {
       // Avoid constant-folding `identical(x, x)` when `x` might be double.  The
       // dart2js runtime has not always been consistent with the Dart
       // specification (section 16.0.1), which makes distinctions on NaNs and
       // -0.0 that are hard to implement efficiently.
-      if (left.isIntegerOrNull(closedWorld)) return makeTrue();
-      if (!left.canBePrimitiveNumber(closedWorld)) return makeTrue();
+      if (left.isIntegerOrNull(_closedWorld)) return makeTrue();
+      if (!left.canBePrimitiveNumber(_closedWorld)) return makeTrue();
     }
 
     return null;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction == null ? super.visitIdentity(node) : newInstruction;
   }
 
   void simplifyCondition(
       HBasicBlock block, HInstruction condition, bool value) {
     condition.dominatedUsers(block.first).forEach((user) {
-      HInstruction newCondition = graph.addConstantBool(value, closedWorld);
+      HInstruction newCondition = _graph.addConstantBool(value, _closedWorld);
       user.changeUse(condition, newCondition);
     });
   }
 
   HInstruction visitIf(HIf node) {
     HInstruction condition = node.condition;
     if (condition.isConstant()) return node;
     bool isNegated = condition is HNot;
 
     if (isNegated) {
@@ skipping 21 matching lines @@
 
     if (!node.isRawCheck) {
       return node;
     } else if (type.isTypedef) {
       return node;
     } else if (type.isFunctionType) {
       return node;
     }
 
     if (type.isObject || type.treatAsDynamic) {
-      return graph.addConstantBool(true, closedWorld);
+      return _graph.addConstantBool(true, _closedWorld);
     }
     ResolutionInterfaceType interfaceType = type;
     ClassEntity element = interfaceType.element;
     HInstruction expression = node.expression;
-    if (expression.isInteger(closedWorld)) {
+    if (expression.isInteger(_closedWorld)) {
       if (element == commonElements.intClass ||
           element == commonElements.numClass ||
           commonElements.isNumberOrStringSupertype(element)) {
-        return graph.addConstantBool(true, closedWorld);
+        return _graph.addConstantBool(true, _closedWorld);
       } else if (element == commonElements.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
       } else {
-        return graph.addConstantBool(false, closedWorld);
+        return _graph.addConstantBool(false, _closedWorld);
       }
-    } else if (expression.isDouble(closedWorld)) {
+    } else if (expression.isDouble(_closedWorld)) {
       if (element == commonElements.doubleClass ||
           element == commonElements.numClass ||
           commonElements.isNumberOrStringSupertype(element)) {
-        return graph.addConstantBool(true, closedWorld);
+        return _graph.addConstantBool(true, _closedWorld);
       } else if (element == commonElements.intClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will return true for a double that can be
         // represented as a 31-bit integer and for -0.0.
         return node;
       } else {
-        return graph.addConstantBool(false, closedWorld);
+        return _graph.addConstantBool(false, _closedWorld);
       }
-    } else if (expression.isNumber(closedWorld)) {
+    } else if (expression.isNumber(_closedWorld)) {
       if (element == commonElements.numClass) {
-        return graph.addConstantBool(true, closedWorld);
+        return _graph.addConstantBool(true, _closedWorld);
       } else {
         // We cannot just return false, because the expression may be of
         // type int or double.
       }
-    } else if (expression.canBePrimitiveNumber(closedWorld) &&
+    } else if (expression.canBePrimitiveNumber(_closedWorld) &&
         element == commonElements.intClass) {
       // We let the JS semantics decide for that check.
       return node;
       // We need the [:hasTypeArguments:] check because we don't have
       // the notion of generics in the backend. For example, [:this:] in
       // a class [:A<T>:], is currently always considered to have the
       // raw type.
     } else if (!RuntimeTypesSubstitutions.hasTypeArguments(type)) {
       TypeMask expressionMask = expression.instructionType;
-      assert(TypeMask.assertIsNormalized(expressionMask, closedWorld));
+      assert(TypeMask.assertIsNormalized(expressionMask, _closedWorld));
       TypeMask typeMask = (element == commonElements.nullClass)
-          ? new TypeMask.subtype(element, closedWorld)
-          : new TypeMask.nonNullSubtype(element, closedWorld);
-      if (expressionMask.union(typeMask, closedWorld) == typeMask) {
-        return graph.addConstantBool(true, closedWorld);
-      } else if (expressionMask.isDisjoint(typeMask, closedWorld)) {
-        return graph.addConstantBool(false, closedWorld);
+          ? new TypeMask.subtype(element, _closedWorld)
+          : new TypeMask.nonNullSubtype(element, _closedWorld);
+      if (expressionMask.union(typeMask, _closedWorld) == typeMask) {
+        return _graph.addConstantBool(true, _closedWorld);
+      } else if (expressionMask.isDisjoint(typeMask, _closedWorld)) {
+        return _graph.addConstantBool(false, _closedWorld);
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
     ResolutionDartType type = node.typeExpression;
     if (type != null) {
       if (type.isMalformed) {
         // Malformed types are treated as dynamic statically, but should
@@ skipping 23 matching lines @@
       }
     }
     return removeIfCheckAlwaysSucceeds(node, node.checkedType);
   }
 
   HInstruction visitTypeKnown(HTypeKnown node) {
     return removeIfCheckAlwaysSucceeds(node, node.knownType);
   }
 
   HInstruction removeIfCheckAlwaysSucceeds(HCheck node, TypeMask checkedType) {
-    if (checkedType.containsAll(closedWorld)) return node;
+    if (checkedType.containsAll(_closedWorld)) return node;
     HInstruction input = node.checkedInput;
     TypeMask inputType = input.instructionType;
-    return inputType.isInMask(checkedType, closedWorld) ? input : node;
+    return inputType.isInMask(checkedType, _closedWorld) ? input : node;
   }
 
   HInstruction removeCheck(HCheck node) => node.checkedInput;
 
   FieldEntity findConcreteFieldForDynamicAccess(
       HInstruction receiver, Selector selector) {
     TypeMask receiverType = receiver.instructionType;
-    return closedWorld.locateSingleField(selector, receiverType);
+    return _closedWorld.locateSingleField(selector, receiverType);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) return node;
     var receiver = node.receiver;
 
     // HFieldGet of a constructed constant can be replaced with the constant's
     // field.
     if (receiver is HConstant) {
       ConstantValue constant = receiver.constant;
       if (constant.isConstructedObject) {
         ConstructedConstantValue constructedConstant = constant;
         Map<FieldEntity, ConstantValue> fields = constructedConstant.fields;
         ConstantValue value = fields[node.element];
         if (value != null) {
-          return graph.addConstant(value, closedWorld);
+          return _graph.addConstant(value, _closedWorld);
         }
       }
     }
 
     return node;
   }
 
   HInstruction visitGetLength(HGetLength node) {
     var receiver = node.receiver;
-    if (graph.allocatedFixedLists.contains(receiver)) {
+    if (_graph.allocatedFixedLists.contains(receiver)) {
       // TODO(ngeoffray): checking if the second input is an integer
       // should not be necessary but it currently makes it easier for
       // other optimizations to reason about a fixed length constructor
       // that we know takes an int.
-      if (receiver.inputs[0].isInteger(closedWorld)) {
+      if (receiver.inputs[0].isInteger(_closedWorld)) {
         return receiver.inputs[0];
       }
     } else if (receiver.isConstantList() || receiver.isConstantString()) {
-      return graph.addConstantInt(receiver.constant.length, closedWorld);
+      return _graph.addConstantInt(receiver.constant.length, _closedWorld);
     } else {
       var type = receiver.instructionType;
       if (type.isContainer && type.length != null) {
-        HInstruction constant = graph.addConstantInt(type.length, closedWorld);
+        HInstruction constant =
+            _graph.addConstantInt(type.length, _closedWorld);
         if (type.isNullable) {
           // If the container can be null, we update all uses of the length
           // access to use the constant instead, but keep the length access in
           // the graph, to ensure we still have a null check.
           node.block.rewrite(node, constant);
           return node;
         } else {
           return constant;
         }
       }
     }
 
     if (node.isAssignable &&
-        isFixedLength(receiver.instructionType, closedWorld)) {
+        isFixedLength(receiver.instructionType, _closedWorld)) {
       // The input type has changed to fixed-length so change to an unassignable
       // HGetLength to allow more GVN optimizations.
       return new HGetLength(receiver, node.instructionType,
           isAssignable: false);
     }
     return node;
   }
 
   HInstruction visitIndex(HIndex node) {
     if (node.receiver.isConstantList() && node.index.isConstantInteger()) {
       var instruction = node.receiver;
       List<ConstantValue> entries = instruction.constant.entries;
       instruction = node.index;
       int index = instruction.constant.primitiveValue;
       if (index >= 0 && index < entries.length) {
-        return graph.addConstant(entries[index], closedWorld);
+        return _graph.addConstant(entries[index], _closedWorld);
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
-    HInstruction receiver = node.getDartReceiver(closedWorld);
+    HInstruction receiver = node.getDartReceiver(_closedWorld);
     FieldEntity field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field != null) return directFieldGet(receiver, field);
 
     if (node.element == null) {
-      MemberEntity element = closedWorld.locateSingleElement(
+      MemberEntity element = _closedWorld.locateSingleElement(
           node.selector, receiver.instructionType);
       if (element != null && element.name == node.selector.name) {
         node.element = element;
         if (element.isFunction) {
           // A property extraction getter, aka a tear-off.
           node.sideEffects.clearAllDependencies();
           node.sideEffects.clearAllSideEffects();
           node.setUseGvn(); // We don't care about identity of tear-offs.
         }
       }
     }
     return node;
   }
 
   HInstruction directFieldGet(HInstruction receiver, FieldEntity field) {
-    bool isAssignable = !closedWorld.fieldNeverChanges(field);
+    bool isAssignable = !_closedWorld.fieldNeverChanges(field);
 
     TypeMask type;
-    if (backend.nativeData.isNativeClass(field.enclosingClass)) {
+    if (_nativeData.isNativeClass(field.enclosingClass)) {
       type = TypeMaskFactory.fromNativeBehavior(
-          backend.nativeData.getNativeFieldLoadBehavior(field), closedWorld);
+          _nativeData.getNativeFieldLoadBehavior(field), _closedWorld);
     } else {
       type = TypeMaskFactory.inferredTypeForElement(
-          field as Entity, globalInferenceResults);
+          field as Entity, _globalInferenceResults);
     }
 
     return new HFieldGet(field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
-    HInstruction receiver = node.getDartReceiver(closedWorld);
+    HInstruction receiver = node.getDartReceiver(_closedWorld);
     FieldElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null || !field.isAssignable) return node;
     // Use `node.inputs.last` in case the call follows the interceptor calling
     // convention, but is not a call on an interceptor.
     HInstruction value = node.inputs.last;
-    if (compiler.options.enableTypeAssertions) {
+    if (_options.enableTypeAssertions) {
       ResolutionDartType type = field.type;
       if (!type.treatAsRaw ||
           type.isTypeVariable ||
           type.unaliased.isFunctionType) {
         // We cannot generate the correct type representation here, so don't
         // inline this access.
         // TODO(sra): If the input is such that we don't need a type check, we
         // can skip the test an generate the HFieldSet.
         return node;
       }
       HInstruction other = value.convertType(
-          closedWorld, type, HTypeConversion.CHECKED_MODE_CHECK);
+          _closedWorld, type, HTypeConversion.CHECKED_MODE_CHECK);
       if (other != value) {
         node.block.addBefore(node, other);
         value = other;
       }
     }
     return new HFieldSet(field, receiver, value);
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     propagateConstantValueToUses(node);
     MemberEntity element = node.element;
 
-    if (element == compiler.commonElements.identicalFunction) {
+    if (element == commonElements.identicalFunction) {
       if (node.inputs.length == 2) {
         return new HIdentity(node.inputs[0], node.inputs[1], null,
-            closedWorld.commonMasks.boolType)
+            _closedWorld.commonMasks.boolType)
           ..sourceInformation = node.sourceInformation;
       }
-    } else if (element == backend.helpers.checkConcurrentModificationError) {
+    } else if (element == _helpers.checkConcurrentModificationError) {
       if (node.inputs.length == 2) {
         HInstruction firstArgument = node.inputs[0];
         if (firstArgument is HConstant) {
           HConstant constant = firstArgument;
           if (constant.constant.isTrue) return constant;
         }
       }
-    } else if (element == backend.helpers.checkInt) {
+    } else if (element == _helpers.checkInt) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
-        if (argument.isInteger(closedWorld)) return argument;
+        if (argument.isInteger(_closedWorld)) return argument;
       }
-    } else if (element == backend.helpers.checkNum) {
+    } else if (element == _helpers.checkNum) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
-        if (argument.isNumber(closedWorld)) return argument;
+        if (argument.isNumber(_closedWorld)) return argument;
       }
-    } else if (element == backend.helpers.checkString) {
+    } else if (element == _helpers.checkString) {
       if (node.inputs.length == 1) {
         HInstruction argument = node.inputs[0];
-        if (argument.isString(closedWorld)) return argument;
+        if (argument.isString(_closedWorld)) return argument;
       }
     }
     return node;
   }
 
   HInstruction visitStringConcat(HStringConcat node) {
     // Simplify string concat:
     //
     //     "" + R                ->  R
     //     L + ""                ->  L
@@ skipping 24 matching lines @@
       prefix = leftConcat.left;
       leftString = getString(leftConcat.right);
       if (leftString == null) return node;
     }
 
     if (leftString.primitiveValue.length + rightString.primitiveValue.length >
         MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH) {
       if (node.usedBy.length > 1) return node;
     }
 
-    HInstruction folded = graph.addConstant(
+    HInstruction folded = _graph.addConstant(
         constantSystem.createString(new ast.DartString.concat(
             leftString.primitiveValue, rightString.primitiveValue)),
-        closedWorld);
+        _closedWorld);
     if (prefix == null) return folded;
     return new HStringConcat(
-        prefix, folded, closedWorld.commonMasks.stringType);
+        prefix, folded, _closedWorld.commonMasks.stringType);
   }
 
   HInstruction visitStringify(HStringify node) {
     HInstruction input = node.inputs[0];
-    if (input.isString(closedWorld)) return input;
+    if (input.isString(_closedWorld)) return input;
 
     HInstruction tryConstant() {
       if (!input.isConstant()) return null;
       HConstant constant = input;
       if (!constant.constant.isPrimitive) return null;
       if (constant.constant.isInt) {
         // Only constant-fold int.toString() when Dart and JS results the same.
         // TODO(18103): We should be able to remove this work-around when issue
         // 18103 is resolved by providing the correct string.
         IntConstantValue intConstant = constant.constant;
         // Very conservative range.
         if (!intConstant.isUInt32()) return null;
       }
       PrimitiveConstantValue primitive = constant.constant;
-      return graph.addConstant(
-          constantSystem.createString(primitive.toDartString()), closedWorld);
+      return _graph.addConstant(
+          constantSystem.createString(primitive.toDartString()), _closedWorld);
     }
 
     HInstruction tryToString() {
       // If the `toString` method is guaranteed to return a string we can call
       // it directly. Keep the stringifier for primitives (since they have fast
       // path code in the stringifier) and for classes requiring interceptors
       // (since SsaInstructionSimplifier runs after SsaSimplifyInterceptors).
-      if (input.canBePrimitive(closedWorld)) return null;
+      if (input.canBePrimitive(_closedWorld)) return null;
       if (input.canBeNull()) return null;
       Selector selector = Selectors.toString_;
       TypeMask toStringType = TypeMaskFactory.inferredTypeForSelector(
-          selector, input.instructionType, globalInferenceResults);
-      if (!toStringType.containsOnlyString(closedWorld)) return null;
+          selector, input.instructionType, _globalInferenceResults);
+      if (!toStringType.containsOnlyString(_closedWorld)) return null;
       // All intercepted classes extend `Interceptor`, so if the receiver can't
       // be a class extending `Interceptor` then it can be called directly.
-      if (new TypeMask.nonNullSubclass(helpers.jsInterceptorClass, closedWorld)
-          .isDisjoint(input.instructionType, closedWorld)) {
+      if (new TypeMask.nonNullSubclass(
+              _helpers.jsInterceptorClass, _closedWorld)
+          .isDisjoint(input.instructionType, _closedWorld)) {
         var inputs = <HInstruction>[input, input]; // [interceptor, receiver].
         HInstruction result = new HInvokeDynamicMethod(
             selector,
             input.instructionType, // receiver mask.
             inputs,
             toStringType)..sourceInformation = node.sourceInformation;
         return result;
       }
       return null;
     }
 
     return tryConstant() ?? tryToString() ?? node;
   }
 
   HInstruction visitOneShotInterceptor(HOneShotInterceptor node) {
     return handleInterceptedCall(node);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassEntity cls) {
-    if (closedWorld.isUsedAsMixin(cls)) return true;
+    if (_closedWorld.isUsedAsMixin(cls)) return true;
 
-    return closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
-      return !backend.rtiSubstitutions.isTrivialSubstitution(subclass, cls);
+    return _closedWorld.anyStrictSubclassOf(cls, (ClassEntity subclass) {
+      return !_rtiSubstitutions.isTrivialSubstitution(subclass, cls);
     });
   }
 
   HInstruction visitTypeInfoExpression(HTypeInfoExpression node) {
     // Identify the case where the type info expression would be of the form:
     //
     //  [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)]
     //
     // and k is the number of type arguments of 'this'.  We can simply copy the
     // list from 'this'.
@@ skipping 28 matching lines @@
             // substitution, even though the general case does, e.g. inlining a
             // method on an exact class.
             return null;
           }
         } else {
           return null;
         }
       }
 
       if (source == null) return null;
-      return new HTypeInfoReadRaw(source, closedWorld.commonMasks.dynamicType);
+      return new HTypeInfoReadRaw(source, _closedWorld.commonMasks.dynamicType);
     }
 
     // TODO(sra): Consider fusing type expression trees with no type variables,
     // as these could be represented like constants.
 
     return tryCopyInfo() ?? node;
   }
 
   HInstruction visitTypeInfoReadVariable(HTypeInfoReadVariable node) {
     ResolutionTypeVariableType variable = node.variable;
     HInstruction object = node.object;
 
     HInstruction finishGroundType(ResolutionInterfaceType groundType) {
       ResolutionInterfaceType typeAtVariable =
           groundType.asInstanceOf(variable.element.enclosingClass);
       if (typeAtVariable != null) {
         int index = variable.element.index;
         ResolutionDartType typeArgument = typeAtVariable.typeArguments[index];
         HInstruction replacement = new HTypeInfoExpression(
             TypeInfoExpressionKind.COMPLETE,
             typeArgument,
             const <HInstruction>[],
-            closedWorld.commonMasks.dynamicType);
+            _closedWorld.commonMasks.dynamicType);
         return replacement;
       }
       return node;
     }
 
     /// Read the type variable from an allocation of type [createdClass], where
     /// [selectTypeArgumentFromObjectCreation] extracts the type argument from
     /// the allocation for factory constructor call.
     HInstruction finishSubstituted(ClassElement createdClass,
         HInstruction selectTypeArgumentFromObjectCreation(int index)) {
       HInstruction instructionForTypeVariable(ResolutionTypeVariableType tv) {
         return selectTypeArgumentFromObjectCreation(
             createdClass.thisType.typeArguments.indexOf(tv));
       }
 
       ResolutionDartType type = createdClass.thisType
           .asInstanceOf(variable.element.enclosingClass)
           .typeArguments[variable.element.index];
       if (type is ResolutionTypeVariableType) {
         return instructionForTypeVariable(type);
       }
       List<HInstruction> arguments = <HInstruction>[];
       type.forEachTypeVariable((v) {
         arguments.add(instructionForTypeVariable(v));
       });
       HInstruction replacement = new HTypeInfoExpression(
           TypeInfoExpressionKind.COMPLETE,
           type,
           arguments,
-          closedWorld.commonMasks.dynamicType);
+          _closedWorld.commonMasks.dynamicType);
       return replacement;
     }
 
     // Type variable evaluated in the context of a constant can be replaced with
     // a ground term type.
     if (object is HConstant) {
       ConstantValue value = object.constant;
       if (value is ConstructedConstantValue) {
         return finishGroundType(value.type);
       }
@@ skipping 12 matching lines @@
     //        HTypeInfoExpression(t_0, t_1, t_2, ...)]);
     //
     // The `t_i` are the values of the type parameters of ClassElement.
 
     if (object is HCreate) {
       void registerInstantiations() {
         // Forwarding the type variable references might cause the HCreate to
         // become dead. This breaks the algorithm for generating the per-type
         // runtime type information, so we instantiate them here in case the
         // HCreate becomes dead.
-        object.instantiatedTypes?.forEach(registry.registerInstantiation);
+        object.instantiatedTypes?.forEach(_registry.registerInstantiation);
       }
 
       if (object.hasRtiInput) {
         HInstruction typeInfo = object.rtiInput;
         if (typeInfo is HTypeInfoExpression) {
           registerInstantiations();
           return finishSubstituted(
               object.element, (int index) => typeInfo.inputs[index]);
         }
       } else {
         // Non-generic type (which extends or mixes in a generic type, for
         // example CodeUnits extends UnmodifiableListBase<int>).  Also used for
         // raw-type when the type parameters are elided.
         registerInstantiations();
         return finishSubstituted(
             object.element,
             // If there are type arguments, all type arguments are 'dynamic'.
-            (int i) => graph.addConstantNull(closedWorld));
+            (int i) => _graph.addConstantNull(_closedWorld));
       }
     }
 
     // TODO(sra): Factory constructors pass type arguments after the value
     // arguments. The [selectTypeArgumentFromObjectCreation] argument of
     // [finishSubstituted] indexes into these type arguments.
 
     return node;
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final Set<HInstruction> boundsChecked;
   final bool trustPrimitives;
-  final JavaScriptBackend backend;
+  final BackendHelpers _helpers;
   final ClosedWorld closedWorld;
   final String name = "SsaCheckInserter";
   HGraph graph;
 
-  SsaCheckInserter(
-      this.trustPrimitives, this.backend, this.closedWorld, this.boundsChecked);
-
-  BackendHelpers get helpers => backend.helpers;
+  SsaCheckInserter(this.trustPrimitives, this._helpers, this.closedWorld,
+      this.boundsChecked);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
 
     // In --trust-primitives mode we don't add bounds checks.  This is better
     // than trying to remove them later as the limit expression would become
     // dead and require DCE.
     if (trustPrimitives) return;
 
     visitDominatorTree(graph);
@@ skipping 42 matching lines @@
 
   void visitIndexAssign(HIndexAssign node) {
     if (boundsChecked.contains(node)) return;
     HInstruction index = node.index;
     index = insertBoundsCheck(node, node.receiver, index);
   }
 
   void visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     MemberEntity element = node.element;
     if (node.isInterceptedCall) return;
-    if (element != helpers.jsArrayRemoveLast) return;
+    if (element != _helpers.jsArrayRemoveLast) return;
     if (boundsChecked.contains(node)) return;
     // `0` is the index we want to check, but we want to report `-1`, as if we
     // executed `a[a.length-1]`
     HBoundsCheck check = insertBoundsCheck(
         node, node.receiver, graph.addConstantInt(0, closedWorld));
     HInstruction minusOne = graph.addConstantInt(-1, closedWorld);
     check.inputs.add(minusOne);
     minusOne.usedBy.add(check);
   }
 }
@@ skipping 837 matching lines @@
     }
   }
 }
 
 /**
  * Optimization phase that tries to eliminate memory loads (for
  * example [HFieldGet]), when it knows the value stored in that memory
  * location.
  */
 class SsaLoadElimination extends HBaseVisitor implements OptimizationPhase {
-  final JavaScriptBackend backend;
+  final BackendHelpers _helpers;
   final Compiler compiler;
   final ClosedWorld closedWorld;
   final String name = "SsaLoadElimination";
   MemorySet memorySet;
   List<MemorySet> memories;
   bool newGvnCandidates = false;
 
-  SsaLoadElimination(this.backend, this.compiler, this.closedWorld);
+  SsaLoadElimination(this._helpers, this.compiler, this.closedWorld);
 
   void visitGraph(HGraph graph) {
     memories = new List<MemorySet>(graph.blocks.length);
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = 0; i < blocks.length; i++) {
       HBasicBlock block = blocks[i];
       visitBasicBlock(block);
       if (block.successors.isNotEmpty && block.successors[0].isLoopHeader()) {
         // We've reached the ending block of a loop. Iterate over the
         // blocks of the loop again to take values that flow from that
@@ skipping 48 matching lines @@
   }
 
   void visitFieldGet(HFieldGet instruction) {
     if (instruction.isNullCheck) return;
     FieldEntity element = instruction.element;
     HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     _visitFieldGet(element, receiver, instruction);
   }
 
   void visitGetLength(HGetLength instruction) {
-    _visitFieldGet(backend.helpers.jsIndexableLength,
-        instruction.receiver.nonCheck(), instruction);
+    _visitFieldGet(_helpers.jsIndexableLength, instruction.receiver.nonCheck(),
+        instruction);
   }
 
   void _visitFieldGet(
       MemberEntity element, HInstruction receiver, HInstruction instruction) {
     HInstruction existing = memorySet.lookupFieldValue(element, receiver);
     if (existing != null) {
       checkNewGvnCandidates(instruction, existing);
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
@@ skipping 454 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }