Less direct use of JavaScriptBackend in ProgramBuilder

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
@@ skipping 12 matching lines @@
         FunctionElement,
         FunctionSignature,
         GetterElement,
         LibraryElement,
         MemberElement,
         MethodElement,
         ParameterElement,
         TypedefElement,
         VariableElement;
 import '../../elements/entities.dart';
+import '../../elements/resolution_types.dart' show Types;
 import '../../elements/types.dart' show DartType;
 import '../../js/js.dart' as js;
-import '../../js_backend/js_backend.dart'
-    show Namer, JavaScriptBackend, JavaScriptConstantCompiler, StringBackedName;
+import '../../js_backend/backend.dart'
+    show
+        JavaScriptBackend,
+        RuntimeTypesEncoder,
+        RuntimeTypesNeed,
+        SuperMemberData;
+import '../../js_backend/backend_usage.dart';
+import '../../js_backend/constant_handler_javascript.dart'
+    show JavaScriptConstantCompiler;
+import '../../js_backend/namer.dart' show Namer, StringBackedName;
+import '../../js_backend/native_data.dart';
+import '../../js_backend/interceptor_data.dart';
+import '../../js_backend/mirrors_data.dart';
+import '../../native/enqueue.dart' show NativeCodegenEnqueuer;
+import '../../options.dart';
 import '../../universe/selector.dart' show Selector;
 import '../../universe/world_builder.dart'
     show CodegenWorldBuilder, SelectorConstraints;
 import '../../world.dart' show ClosedWorld;
 import '../js_emitter.dart'
     show
         ClassStubGenerator,
         CodeEmitterTask,
         computeMixinClass,
         Emitter,
@@ skipping 30 matching lines @@
 
   ProgramBuilder(Compiler compiler, Namer namer, this._task, Emitter emitter,
       ClosedWorld closedWorld, Set<ClassElement> rtiNeededClasses)
       : this._compiler = compiler,
         this.namer = namer,
         this.closedWorld = closedWorld,
         this.collector = new Collector(
             compiler, namer, closedWorld, rtiNeededClasses, emitter),
         this._registry = new Registry(compiler);
 
-  JavaScriptBackend get backend => _compiler.backend;
-  CodegenWorldBuilder get worldBuilder => _compiler.codegenWorldBuilder;
+  JavaScriptBackend get _backend => _compiler.backend;
+  CodegenWorldBuilder get _worldBuilder => _compiler.codegenWorldBuilder;
+  DeferredLoadTask get _deferredLoadTask => _compiler.deferredLoadTask;
+  Types get _types => _compiler.types;
+  CommonElements get _commonElements => _compiler.commonElements;
+  CompilerOptions get _options => _compiler.options;
+  NativeCodegenEnqueuer get _nativeCodegenEnqueuer =>
+      _backend.nativeCodegenEnqueuer;
+  Namer get _namer => _backend.namer;
+  BackendUsage get _backendUsage => _backend.backendUsage;
+  CodeEmitterTask get _emitter => _backend.emitter;
+  JavaScriptConstantCompiler get _constantHandler => _backend.constants;
+  NativeData get _nativeData => _backend.nativeData;
+  RuntimeTypesNeed get _rtiNeed => _backend.rtiNeed;
+  MirrorsData get _mirrorsData => _backend.mirrorsData;
+  InterceptorData get _interceptorData => _backend.interceptorData;
+  SuperMemberData get _superMemberData => _backend.superMemberData;
+  RuntimeTypesEncoder get _rtiEncoder => _backend.rtiEncoder;
+  OneShotInterceptorData get _oneShotInterceptorData =>
+      _backend.oneShotInterceptorData;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
   /// Mapping from names to strings.
   ///
   /// This mapping is used to support `const Symbol` expressions.
   ///
   /// This map is filled when building classes.
   final Map<js.Name, String> _symbolsMap = <js.Name, String>{};
 
   Set<Class> _unneededNativeClasses;
 
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     collector.collect();
 
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
-    _compiler.deferredLoadTask.allOutputUnits
-        .forEach(_registry.registerOutputUnit);
+    _deferredLoadTask.allOutputUnits.forEach(_registry.registerOutputUnit);
     collector.outputClassLists.forEach(_registry.registerElements);
     collector.outputStaticLists.forEach(_registry.registerElements);
     collector.outputConstantLists.forEach(_registerConstants);
     collector.outputStaticNonFinalFieldLists
         .forEach(_registry.registerElements);
 
     // We always add the current isolate holder.
     _registerStaticStateHolder();
 
     // We need to run the native-preparation before we build the output. The
@@ skipping 38 matching lines @@
 
     List<Fragment> fragments = new List<Fragment>(_registry.librariesMapCount);
     fragments[0] = mainFragment;
     fragments.setAll(1, deferredFragments);
 
     _markEagerClasses();
 
     List<Holder> holders = _registry.holders.toList(growable: false);
 
     bool needsNativeSupport =
-        backend.nativeCodegenEnqueuer.hasInstantiatedNativeClasses;
+        _nativeCodegenEnqueuer.hasInstantiatedNativeClasses;
 
     assert(!needsNativeSupport || nativeClasses.isNotEmpty);
 
     List<js.TokenFinalizer> finalizers = [_task.metadataCollector];
-    if (backend.namer is js.TokenFinalizer) {
-      var namingFinalizer = backend.namer;
+    if (_namer is js.TokenFinalizer) {
+      var namingFinalizer = _namer;
       finalizers.add(namingFinalizer as js.TokenFinalizer);
     }
 
     return new Program(fragments, holders, _buildLoadMap(), _symbolsMap,
         _buildTypeToInterceptorMap(), _task.metadataCollector, finalizers,
         needsNativeSupport: needsNativeSupport,
         outputContainsConstantList: collector.outputContainsConstantList,
-        hasIsolateSupport: backend.backendUsage.isIsolateInUse);
+        hasIsolateSupport: _backendUsage.isIsolateInUse);
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
 
   /// Builds a map from loadId to outputs-to-load.
   Map<String, List<Fragment>> _buildLoadMap() {
     Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
-    _compiler.deferredLoadTask.hunksToLoad
+    _deferredLoadTask.hunksToLoad
         .forEach((String loadId, List<OutputUnit> outputUnits) {
       loadMap[loadId] = outputUnits
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
   }
 
   js.Expression _buildTypeToInterceptorMap() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
+        new InterceptorStubGenerator(_compiler, namer, _backend, closedWorld);
     return stubGenerator.generateTypeToInterceptorMap();
   }
 
   MainFragment _buildMainFragment(LibrariesMap librariesMap) {
     // Construct the main output from the libraries and the registered holders.
     MainFragment result = new MainFragment(
         librariesMap.outputUnit,
         "", // The empty string is the name for the main output file.
         _buildInvokeMain(),
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
         _buildStaticLazilyInitializedFields(librariesMap),
         _buildConstants(librariesMap));
     _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
   js.Statement _buildInvokeMain() {
     if (_compiler.isMockCompilation) return js.js.comment("Mock compilation");
 
     MainCallStubGenerator generator =
-        new MainCallStubGenerator(backend, backend.emitter);
+        new MainCallStubGenerator(_backend, _emitter);
     return generator.generateInvokeMain(_compiler.mainFunction);
   }
 
   DeferredFragment _buildDeferredFragment(LibrariesMap librariesMap) {
     DeferredFragment result = new DeferredFragment(
         librariesMap.outputUnit,
-        backend.deferredPartFileName(librariesMap.name, addExtension: false),
+        _backend.deferredPartFileName(librariesMap.name, addExtension: false),
         librariesMap.name,
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
         _buildStaticLazilyInitializedFields(librariesMap),
         _buildConstants(librariesMap));
     _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
   List<Constant> _buildConstants(LibrariesMap librariesMap) {
     List<ConstantValue> constantValues =
         collector.outputConstantLists[librariesMap.outputUnit];
     if (constantValues == null) return const <Constant>[];
     return constantValues
         .map((ConstantValue value) => _constants[value])
         .toList(growable: false);
   }
 
   List<StaticField> _buildStaticNonFinalFields(LibrariesMap librariesMap) {
     List<VariableElement> staticNonFinalFields =
         collector.outputStaticNonFinalFieldLists[librariesMap.outputUnit];
     if (staticNonFinalFields == null) return const <StaticField>[];
 
     return staticNonFinalFields.map(_buildStaticField).toList(growable: false);
   }
 
   StaticField _buildStaticField(FieldElement element) {
-    JavaScriptConstantCompiler handler = backend.constants;
-    ConstantValue initialValue = handler.getConstantValue(element.constant);
+    ConstantValue initialValue =
+        _constantHandler.getConstantValue(element.constant);
     // TODO(zarah): The holder should not be registered during building of
     // a static field.
     _registry.registerHolder(namer.globalObjectForConstant(initialValue),
         isConstantsHolder: true);
     js.Expression code = _task.emitter.constantReference(initialValue);
     js.Name name = namer.globalPropertyName(element);
     bool isFinal = false;
     bool isLazy = false;
 
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the static-state holder was
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
 
   List<StaticField> _buildStaticLazilyInitializedFields(
       LibrariesMap librariesMap) {
-    JavaScriptConstantCompiler handler = backend.constants;
-    DeferredLoadTask loadTask = _compiler.deferredLoadTask;
-    Iterable<FieldElement> lazyFields = handler
+    Iterable<FieldElement> lazyFields = _constantHandler
         .getLazilyInitializedFieldsForEmission()
         .where((element) =>
-            loadTask.outputUnitForElement(element) == librariesMap.outputUnit);
+            _deferredLoadTask.outputUnitForElement(element) ==
+            librariesMap.outputUnit);
     return Elements
         .sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null) // Happens when the field was unused.
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(FieldElement element) {
-    js.Expression code = backend.generatedCode[element];
+    js.Expression code = _backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     js.Name name = namer.globalPropertyName(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a static field. (Note that the static-state holder was
     // already registered earlier, and that we just call the register to get
     // the holder-instance.
     return new StaticField(
         element, name, _registerStaticStateHolder(), code, isFinal, isLazy);
   }
 
   List<Library> _buildLibraries(LibrariesMap librariesMap) {
     List<Library> libraries = new List<Library>(librariesMap.length);
     int count = 0;
     librariesMap.forEach((LibraryElement library, List<Element> elements) {
       libraries[count++] = _buildLibrary(library, elements);
     });
     return libraries;
   }
 
   void _addJsInteropStubs(LibrariesMap librariesMap) {
-    if (_classes.containsKey(_compiler.commonElements.objectClass)) {
+    if (_classes.containsKey(_commonElements.objectClass)) {
       var toStringInvocation = namer.invocationName(Selectors.toString_);
       // TODO(jacobr): register toString as used so that it is always accessible
       // from JavaScript.
-      _classes[_compiler.commonElements.objectClass].callStubs.add(
-          _buildStubMethod(new StringBackedName("toString"),
-              js.js('function() { return this.#(this) }', toStringInvocation)));
+      _classes[_commonElements.objectClass].callStubs.add(_buildStubMethod(
+          new StringBackedName("toString"),
+          js.js('function() { return this.#(this) }', toStringInvocation)));
     }
 
     // We add all members from classes marked with isJsInterop to the base
     // Interceptor class with implementations that directly call the
     // corresponding JavaScript member. We do not attempt to bind this when
     // tearing off JavaScript methods as we cannot distinguish between calling
     // a regular getter that returns a JavaScript function and tearing off
     // a method in the case where there exist multiple JavaScript classes
     // that conflict on whether the member is a getter or a method.
-    var interceptorClass =
-        _classes[_compiler.commonElements.jsJavaScriptObjectClass];
+    var interceptorClass = _classes[_commonElements.jsJavaScriptObjectClass];
     var stubNames = new Set<String>();
     librariesMap.forEach((LibraryElement library, List<Element> elements) {
       for (Element e in elements) {
-        if (e is ClassElement && backend.nativeData.isJsInteropClass(e)) {
+        if (e is ClassElement && _nativeData.isJsInteropClass(e)) {
           e.declaration.forEachMember((_, Element member) {
-            var jsName =
-                backend.nativeData.computeUnescapedJSInteropName(member.name);
+            var jsName = _nativeData.computeUnescapedJSInteropName(member.name);
             if (!member.isInstanceMember) return;
             if (member.isGetter || member.isField || member.isFunction) {
-              var selectors = worldBuilder.getterInvocationsByName(member.name);
+              var selectors =
+                  _worldBuilder.getterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   var stubName = namer.invocationName(selector);
                   if (stubNames.add(stubName.key)) {
                     interceptorClass.callStubs.add(_buildStubMethod(stubName,
                         js.js('function(obj) { return obj.# }', [jsName]),
                         element: member));
                   }
                 }
               }
             }
 
             if (member.isSetter || (member.isField && !member.isConst)) {
-              var selectors = worldBuilder.setterInvocationsByName(member.name);
+              var selectors =
+                  _worldBuilder.setterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 var stubName = namer.setterForElement(member);
                 if (stubNames.add(stubName.key)) {
                   interceptorClass.callStubs.add(_buildStubMethod(stubName,
                       js.js('function(obj, v) { return obj.# = v }', [jsName]),
                       element: member));
                 }
               }
             }
 
             // Generating stubs for direct calls and stubs for call-through
             // of getters that happen to be functions.
             bool isFunctionLike = false;
             ResolutionFunctionType functionType = null;
 
             if (member.isFunction) {
               FunctionElement fn = member;
               functionType = fn.type;
             } else if (member.isGetter) {
-              if (_compiler.options.trustTypeAnnotations) {
+              if (_options.trustTypeAnnotations) {
                 GetterElement getter = member;
                 ResolutionDartType returnType = getter.type.returnType;
                 if (returnType.isFunctionType) {
                   functionType = returnType;
                 } else if (returnType.treatAsDynamic ||
-                    _compiler.types.isSubtype(
+                    _types.isSubtype(
                         returnType,
                         // ignore: UNNECESSARY_CAST
-                        backend.commonElements.functionType as DartType)) {
+                        _commonElements.functionType as DartType)) {
                   if (returnType.isTypedef) {
                     ResolutionTypedefType typedef = returnType;
                     // TODO(jacobr): can we just use typdef.unaliased instead?
                     functionType = typedef.element.functionSignature.type;
                   } else {
                     // Other misc function type such as commonElements.Function.
                     // Allow any number of arguments.
                     isFunctionLike = true;
                   }
                 }
               } else {
                 isFunctionLike = true;
               }
             } // TODO(jacobr): handle field elements.
 
             if (isFunctionLike || functionType != null) {
               int minArgs;
               int maxArgs;
               if (functionType != null) {
                 minArgs = functionType.parameterTypes.length;
                 maxArgs = minArgs + functionType.optionalParameterTypes.length;
               } else {
                 minArgs = 0;
                 maxArgs = 32767;
               }
-              var selectors = worldBuilder.invocationsByName(member.name);
+              var selectors = _worldBuilder.invocationsByName(member.name);
               // Named arguments are not yet supported. In the future we
               // may want to map named arguments to an object literal containing
               // all named arguments.
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   // Check whether the arity matches this member.
                   var argumentCount = selector.argumentCount;
                   // JS interop does not support named arguments.
                   if (selector.namedArgumentCount > 0) continue;
                   if (argumentCount < minArgs) continue;
@@ skipping 28 matching lines @@
   // Note that a library-element may have multiple [Library]s, if it is split
   // into multiple output units.
   Library _buildLibrary(LibraryElement library, List<Element> elements) {
     String uri = library.canonicalUri.toString();
 
     List<StaticMethod> statics = elements
         .where((e) => e is FunctionElement)
         .map(_buildStaticMethod)
         .toList();
 
-    if (library == _compiler.commonElements.interceptorsLibrary) {
+    if (library == _commonElements.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
     List<Class> classes = elements
         .where((e) => e is ClassElement)
         .map((ClassElement classElement) => _classes[classElement])
         .where((Class cls) =>
             !cls.isNative || !_unneededNativeClasses.contains(cls))
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection =
         _buildFields(library, visitStatics: visitStatics);
 
     return new Library(
         library, uri, statics, classes, staticFieldsForReflection);
   }
 
   Class _buildClass(ClassElement element) {
     bool onlyForRti = collector.classesOnlyNeededForRti.contains(element);
-    bool hasRtiField = backend.rtiNeed.classNeedsRtiField(element);
-    if (backend.nativeData.isJsInteropClass(element)) {
+    bool hasRtiField = _rtiNeed.classNeedsRtiField(element);
+    if (_nativeData.isJsInteropClass(element)) {
       // TODO(jacobr): check whether the class has any active static fields
       // if it does not we can suppress it completely.
       onlyForRti = true;
     }
 
     List<Method> methods = [];
     List<StubMethod> callStubs = <StubMethod>[];
 
     ClassStubGenerator classStubGenerator = new ClassStubGenerator(
-        namer, backend, worldBuilder, closedWorld,
-        enableMinification: _compiler.options.enableMinification);
+        namer, _backend, _worldBuilder, closedWorld,
+        enableMinification: _options.enableMinification);
     RuntimeTypeGenerator runtimeTypeGenerator =
         new RuntimeTypeGenerator(_compiler, _task, namer);
 
     void visitMember(ClassElement enclosing, MemberElement member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
       if (Elements.isNonAbstractInstanceMember(member)) {
         // TODO(herhut): Remove once _buildMethod can no longer return null.
         Method method = _buildMethod(member);
         if (method != null) methods.add(method);
       }
       if (member.isGetter || member.isField) {
         Map<Selector, SelectorConstraints> selectors =
-            worldBuilder.invocationsByName(member.name);
+            _worldBuilder.invocationsByName(member.name);
         if (selectors != null && !selectors.isEmpty) {
           Map<js.Name, js.Expression> callStubsForMember =
               classStubGenerator.generateCallStubsForGetter(member, selectors);
           callStubsForMember.forEach((js.Name name, js.Expression code) {
             callStubs.add(_buildStubMethod(name, code, element: member));
           });
         }
       }
     }
 
     List<StubMethod> noSuchMethodStubs = <StubMethod>[];
 
-    if (backend.backendUsage.isNoSuchMethodUsed && element.isObject) {
+    if (_backendUsage.isNoSuchMethodUsed && element.isObject) {
       Map<js.Name, Selector> selectors =
           classStubGenerator.computeSelectorsForNsmHandlers();
       selectors.forEach((js.Name name, Selector selector) {
         // If the program contains `const Symbol` names we have to retain them.
         String selectorName = selector.name;
         if (selector.isSetter) selectorName = "$selectorName=";
-        if (backend.mirrorsData.symbolsUsed.contains(selectorName)) {
+        if (_mirrorsData.symbolsUsed.contains(selectorName)) {
           _symbolsMap[name] = selectorName;
         }
         noSuchMethodStubs.add(
             classStubGenerator.generateStubForNoSuchMethod(name, selector));
       });
     }
 
-    if (element == _compiler.commonElements.closureClass) {
+    if (element == _commonElements.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
       js.Name name = namer.getterForMember(Names.call);
       js.Fun function = js.js('function() { return this; }');
       callStubs.add(_buildStubMethod(name, function));
     }
 
     ClassElement implementation = element.implementation;
 
     // MixinApplications run through the members of their mixin. Here, we are
     // only interested in direct members.
     if (!onlyForRti && !element.isMixinApplication) {
       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
-    bool isInterceptedClass =
-        backend.interceptorData.isInterceptedClass(element);
+    bool isInterceptedClass = _interceptorData.isInterceptedClass(element);
     List<Field> instanceFields = onlyForRti
         ? const <Field>[]
         : _buildFields(element,
             visitStatics: false, isHolderInterceptedClass: isInterceptedClass);
     List<Field> staticFieldsForReflection = onlyForRti
         ? const <Field>[]
         : _buildFields(element,
             visitStatics: true, isHolderInterceptedClass: isInterceptedClass);
 
     TypeTestProperties typeTests = runtimeTypeGenerator.generateIsTests(element,
         storeFunctionTypeInMetadata: _storeFunctionTypesInMetadata);
 
     List<StubMethod> checkedSetters = <StubMethod>[];
     List<StubMethod> isChecks = <StubMethod>[];
-    if (backend.nativeData.isJsInteropClass(element)) {
+    if (_nativeData.isJsInteropClass(element)) {
       typeTests.properties.forEach((js.Name name, js.Node code) {
-        _classes[_compiler.commonElements.jsInterceptorClass]
+        _classes[_commonElements.jsInterceptorClass]
             .isChecks
             .add(_buildStubMethod(name, code));
       });
     } else {
       for (Field field in instanceFields) {
         if (field.needsCheckedSetter) {
           assert(!field.needsUncheckedSetter);
           FieldElement element = field.element;
-          js.Expression code = backend.generatedCode[element];
+          js.Expression code = _backend.generatedCode[element];
           assert(code != null);
           js.Name name = namer.deriveSetterName(field.accessorName);
           checkedSetters.add(_buildStubMethod(name, code, element: element));
         }
       }
 
       typeTests.properties.forEach((js.Name name, js.Node code) {
         isChecks.add(_buildStubMethod(name, code));
       });
     }
 
     js.Name name = namer.className(element);
     String holderName = namer.globalObjectFor(element);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // building a class.
     Holder holder = _registry.registerHolder(holderName);
-    bool isInstantiated = !backend.nativeData.isJsInteropClass(element) &&
-        worldBuilder.directlyInstantiatedClasses.contains(element);
+    bool isInstantiated = !_nativeData.isJsInteropClass(element) &&
+        _worldBuilder.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
-      assert(!backend.nativeData.isNativeClass(element));
+      assert(!_nativeData.isNativeClass(element));
       assert(methods.isEmpty);
 
       result = new MixinApplication(
           element,
           name,
           holder,
           instanceFields,
           staticFieldsForReflection,
           callStubs,
           checkedSetters,
@@ skipping 11 matching lines @@
           instanceFields,
           staticFieldsForReflection,
           callStubs,
           noSuchMethodStubs,
           checkedSetters,
           isChecks,
           typeTests.functionTypeIndex,
           isDirectlyInstantiated: isInstantiated,
           hasRtiField: hasRtiField,
           onlyForRti: onlyForRti,
-          isNative: backend.nativeData.isNativeClass(element));
+          isNative: _nativeData.isNativeClass(element));
     }
     _classes[element] = result;
     return result;
   }
 
   bool _methodNeedsStubs(FunctionElement method) {
     return !method.functionSignature.optionalParameters.isEmpty;
   }
 
   bool _methodCanBeReflected(MethodElement method) {
-    return backend.mirrorsData.isMemberAccessibleByReflection(method);
+    return _mirrorsData.isMemberAccessibleByReflection(method);
   }
 
   bool _methodCanBeApplied(FunctionElement method) {
-    return backend.backendUsage.isFunctionApplyUsed &&
+    return _backendUsage.isFunctionApplyUsed &&
         closedWorld.getMightBePassedToApply(method);
   }
 
   /* Map | List */ _computeParameterDefaultValues(FunctionSignature signature) {
     var /* Map | List */ optionalParameterDefaultValues;
     if (signature.optionalParametersAreNamed) {
       optionalParameterDefaultValues = new Map<String, ConstantValue>();
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
-            backend.constants.getConstantValue(parameter.constant);
+            _constantHandler.getConstantValue(parameter.constant);
         optionalParameterDefaultValues[parameter.name] = def;
       });
     } else {
       optionalParameterDefaultValues = <ConstantValue>[];
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
-            backend.constants.getConstantValue(parameter.constant);
+            _constantHandler.getConstantValue(parameter.constant);
         optionalParameterDefaultValues.add(def);
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(MethodElement element) {
     assert(element.isDeclaration);
     js.Name name = namer.methodPropertyName(element);
-    js.Expression code = backend.generatedCode[element];
+    js.Expression code = _backend.generatedCode[element];
 
     // TODO(kasperl): Figure out under which conditions code is null.
     if (code == null) return null;
 
     bool canTearOff = false;
     js.Name tearOffName;
     bool isClosureCallMethod = false;
     bool isNotApplyTarget = !element.isFunction || element.isAccessor;
 
     bool canBeReflected = _methodCanBeReflected(element);
     bool canBeApplied = _methodCanBeApplied(element);
 
-    js.Name aliasName = backend.superMemberData.isAliasedSuperMember(element)
+    js.Name aliasName = _superMemberData.isAliasedSuperMember(element)
         ? namer.aliasedSuperMemberPropertyName(element)
         : null;
 
     if (isNotApplyTarget) {
       canTearOff = false;
     } else {
       if (element.enclosingClass.isClosure) {
         canTearOff = false;
         isClosureCallMethod = true;
       } else {
         // Careful with operators.
-        canTearOff = worldBuilder.hasInvokedGetter(element, closedWorld) ||
+        canTearOff = _worldBuilder.hasInvokedGetter(element, closedWorld) ||
             (canBeReflected && !element.isOperator);
         assert(canTearOff ||
-            !worldBuilder.methodsNeedingSuperGetter.contains(element));
+            !_worldBuilder.methodsNeedingSuperGetter.contains(element));
         tearOffName = namer.getterForElement(element);
       }
     }
 
     if (canTearOff) {
       assert(invariant(element, !element.isGenerativeConstructor));
       assert(invariant(element, !element.isGenerativeConstructorBody));
       assert(invariant(element, !element.isConstructor));
     }
 
@@ skipping 10 matching lines @@
       //               this information anyway as they cannot be torn off or
       //               reflected.
       var body = element;
       memberType = body.constructor.type;
     } else {
       memberType = element.type;
     }
 
     js.Expression functionType;
     if (canTearOff || canBeReflected) {
-      OutputUnit outputUnit =
-          _compiler.deferredLoadTask.outputUnitForElement(element);
+      OutputUnit outputUnit = _deferredLoadTask.outputUnitForElement(element);
       functionType = _generateFunctionType(memberType, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
       FunctionSignature signature = element.functionSignature;
       requiredParameterCount = signature.requiredParameterCount;
       optionalParameterDefaultValues =
           _computeParameterDefaultValues(signature);
     }
 
     return new InstanceMethod(element, name, code,
         _generateParameterStubs(element, canTearOff), callName,
         needsTearOff: canTearOff,
         tearOffName: tearOffName,
         isClosureCallMethod: isClosureCallMethod,
         aliasName: aliasName,
         canBeApplied: canBeApplied,
         canBeReflected: canBeReflected,
         requiredParameterCount: requiredParameterCount,
         optionalParameterDefaultValues: optionalParameterDefaultValues,
         functionType: functionType);
   }
 
   js.Expression _generateFunctionType(
       ResolutionDartType type, OutputUnit outputUnit) {
     if (type.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
-      return backend.rtiEncoder
-          .getSignatureEncoding(backend.emitter.emitter, type, thisAccess);
+      return _rtiEncoder.getSignatureEncoding(
+          _emitter.emitter, type, thisAccess);
     } else {
-      return backend.emitter.metadataCollector
+      return _emitter.metadataCollector
           .reifyTypeForOutputUnit(type, outputUnit);
     }
   }
 
   List<ParameterStubMethod> _generateParameterStubs(
       MethodElement element, bool canTearOff) {
     if (!_methodNeedsStubs(element)) return const <ParameterStubMethod>[];
 
     ParameterStubGenerator generator =
-        new ParameterStubGenerator(_compiler, namer, backend, closedWorld);
+        new ParameterStubGenerator(_compiler, namer, _backend, closedWorld);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
   Method _buildStubMethod(js.Name name, js.Expression code,
       {MemberElement element}) {
     return new StubMethod(name, code, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Iterable<js.Name> names =
-        backend.oneShotInterceptorData.specializedGetInterceptorNames;
+        _oneShotInterceptorData.specializedGetInterceptorNames;
     for (js.Name name in names) {
-      for (ClassElement element in backend.oneShotInterceptorData
-          .getSpecializedGetInterceptorsFor(name)) {
+      for (ClassElement element
+          in _oneShotInterceptorData.getSpecializedGetInterceptorsFor(name)) {
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticStubMethod> _generateGetInterceptorMethods() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
+        new InterceptorStubGenerator(_compiler, namer, _backend, closedWorld);
 
-    String holderName = namer
-        .globalObjectForLibrary(_compiler.commonElements.interceptorsLibrary);
+    String holderName =
+        namer.globalObjectForLibrary(_commonElements.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
     Iterable<js.Name> names =
-        backend.oneShotInterceptorData.specializedGetInterceptorNames;
+        _oneShotInterceptorData.specializedGetInterceptorNames;
     return names.map((js.Name name) {
       Set<ClassEntity> classes =
-          backend.oneShotInterceptorData.getSpecializedGetInterceptorsFor(name);
+          _oneShotInterceptorData.getSpecializedGetInterceptorsFor(name);
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   List<Field> _buildFields(Element holder,
       {bool visitStatics, bool isHolderInterceptedClass: false}) {
     List<Field> fields = <Field>[];
     new FieldVisitor(_compiler, namer, closedWorld)
         .visitFields(holder, visitStatics, (FieldElement field,
             js.Name name,
             js.Name accessorName,
             bool needsGetter,
             bool needsSetter,
             bool needsCheckedSetter) {
       assert(invariant(field, field.isDeclaration));
 
       int getterFlags = 0;
       if (needsGetter) {
         if (visitStatics ||
-            !backend.interceptorData.fieldHasInterceptedGetter(field)) {
+            !_interceptorData.fieldHasInterceptedGetter(field)) {
           getterFlags = 1;
         } else {
           getterFlags += 2;
           // TODO(sra): 'isInterceptedClass' might not be the correct test
           // for methods forced to use the interceptor convention because
           // the method's class was elsewhere mixed-in to an interceptor.
           if (!isHolderInterceptedClass) {
             getterFlags += 1;
           }
         }
       }
 
       int setterFlags = 0;
       if (needsSetter) {
         if (visitStatics ||
-            !backend.interceptorData.fieldHasInterceptedSetter(field)) {
+            !_interceptorData.fieldHasInterceptedSetter(field)) {
           setterFlags = 1;
         } else {
           setterFlags += 2;
           if (!isHolderInterceptedClass) {
             setterFlags += 1;
           }
         }
       }
 
       fields.add(new Field(field, name, accessorName, getterFlags, setterFlags,
           needsCheckedSetter));
     });
 
     return fields;
   }
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
+        new InterceptorStubGenerator(_compiler, namer, _backend, closedWorld);
 
-    String holderName = namer
-        .globalObjectForLibrary(_compiler.commonElements.interceptorsLibrary);
+    String holderName =
+        namer.globalObjectForLibrary(_commonElements.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
-    List<js.Name> names =
-        backend.oneShotInterceptorData.oneShotInterceptorNames;
+    List<js.Name> names = _oneShotInterceptorData.oneShotInterceptorNames;
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   StaticDartMethod _buildStaticMethod(MethodElement element) {
     js.Name name = namer.methodPropertyName(element);
     String holder = namer.globalObjectFor(element);
-    js.Expression code = backend.generatedCode[element];
+    js.Expression code = _backend.generatedCode[element];
 
     bool isApplyTarget = !element.isConstructor && !element.isAccessor;
     bool canBeApplied = _methodCanBeApplied(element);
     bool canBeReflected = _methodCanBeReflected(element);
 
     bool needsTearOff = isApplyTarget &&
         (canBeReflected ||
-            worldBuilder.staticFunctionsNeedingGetter.contains(element));
+            _worldBuilder.staticFunctionsNeedingGetter.contains(element));
 
     js.Name tearOffName =
         needsTearOff ? namer.staticClosureName(element) : null;
 
     js.Name callName = null;
     if (needsTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = namer.invocationName(callSelector);
     }
     js.Expression functionType;
     ResolutionDartType type = element.type;
     if (needsTearOff || canBeReflected) {
-      OutputUnit outputUnit =
-          _compiler.deferredLoadTask.outputUnitForElement(element);
+      OutputUnit outputUnit = _deferredLoadTask.outputUnitForElement(element);
       functionType = _generateFunctionType(type, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
       FunctionSignature signature = element.functionSignature;
       requiredParameterCount = signature.requiredParameterCount;
       optionalParameterDefaultValues =
           _computeParameterDefaultValues(signature);
@@ skipping 26 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }