Remove Compiler and JavaScriptBackend from interceptor_stub_generator.

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 24 matching lines @@
 import '../../js/js.dart' as js;
 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/custom_elements_analysis.dart';
 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;
@@ skipping 11 matching lines @@
 import '../model.dart';
 
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final Compiler _compiler;
-  final Namer namer;
+  final Namer _namer;
   final CodeEmitterTask _task;
-  final ClosedWorld closedWorld;
+  final ClosedWorld _closedWorld;
 
   /// Contains the collected information the program builder used to build
   /// the model.
   // The collector will be filled on the first call to `buildProgram`.
   // It is stored and publicly exposed for backwards compatibility. New code
   // (and in particular new emitters) should not use it.
   final Collector collector;
 
   final Registry _registry;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
-  ProgramBuilder(Compiler compiler, Namer namer, this._task, Emitter emitter,
+  ProgramBuilder(Compiler compiler, Namer _namer, this._task, Emitter emitter,
       ClosedWorld closedWorld, Set<ClassElement> rtiNeededClasses)
       : this._compiler = compiler,
-        this.namer = namer,
-        this.closedWorld = closedWorld,
+        this._namer = _namer,
+        this._closedWorld = closedWorld,
         this.collector = new Collector(
-            compiler, namer, closedWorld, rtiNeededClasses, emitter),
+            compiler, _namer, closedWorld, rtiNeededClasses, emitter),
         this._registry = new Registry(compiler);
 
   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;
+  CustomElementsCodegenAnalysis get _customElementsCodegenAnalysis =>
+      _backend.customElementsCodegenAnalysis;
 
   /// 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
@@ skipping 102 matching lines @@
     _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);
+    InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
+        _options,
+        _commonElements,
+        _emitter,
+        _nativeCodegenEnqueuer,
+        _constantHandler,
+        _namer,
+        _nativeData,
+        _interceptorData,
+        _oneShotInterceptorData,
+        _customElementsCodegenAnalysis,
+        _worldBuilder,
+        _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),
@@ skipping 40 matching lines @@
     if (staticNonFinalFields == null) return const <StaticField>[];
 
     return staticNonFinalFields.map(_buildStaticField).toList(growable: false);
   }
 
   StaticField _buildStaticField(FieldElement element) {
     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),
+    _registry.registerHolder(_namer.globalObjectForConstant(initialValue),
         isConstantsHolder: true);
     js.Expression code = _task.emitter.constantReference(initialValue);
-    js.Name name = namer.globalPropertyName(element);
+    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);
   }
@@ skipping 12 matching lines @@
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(FieldElement 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);
+    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(_commonElements.objectClass)) {
-      var toStringInvocation = namer.invocationName(Selectors.toString_);
+      var toStringInvocation = _namer.invocationName(Selectors.toString_);
       // TODO(jacobr): register toString as used so that it is always accessible
       // from JavaScript.
       _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[_commonElements.jsJavaScriptObjectClass];
     var stubNames = new Set<String>();
     librariesMap.forEach((LibraryElement library, List<Element> elements) {
       for (Element e in elements) {
         if (e is ClassElement && _nativeData.isJsInteropClass(e)) {
           e.declaration.forEachMember((_, Element member) {
             var jsName = _nativeData.computeUnescapedJSInteropName(member.name);
             if (!member.isInstanceMember) return;
             if (member.isGetter || member.isField || member.isFunction) {
               var selectors =
                   _worldBuilder.getterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
-                  var stubName = namer.invocationName(selector);
+                  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);
               if (selectors != null && !selectors.isEmpty) {
-                var stubName = namer.setterForElement(member);
+                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.
@@ skipping 44 matching lines @@
               // 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;
                   if (argumentCount > maxArgs) continue;
-                  var stubName = namer.invocationName(selector);
+                  var stubName = _namer.invocationName(selector);
                   if (!stubNames.add(stubName.key)) continue;
                   var parameters =
                       new List<String>.generate(argumentCount, (i) => 'p$i');
 
                   // We intentionally generate the same stub method for direct
                   // calls and call-throughs of getters so that calling a
                   // getter that returns a function behaves the same as calling
                   // a method. This is helpful as many typed JavaScript APIs
                   // specify member functions with getters that return
                   // functions. The behavior of this solution matches JavaScript
@@ skipping 49 matching lines @@
     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,
+        _namer, _backend, _worldBuilder, _closedWorld,
         enableMinification: _options.enableMinification);
     RuntimeTypeGenerator runtimeTypeGenerator =
-        new RuntimeTypeGenerator(_compiler, _task, namer);
+        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);
       }
@@ skipping 23 matching lines @@
           _symbolsMap[name] = selectorName;
         }
         noSuchMethodStubs.add(
             classStubGenerator.generateStubForNoSuchMethod(name, selector));
       });
     }
 
     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.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);
@@ skipping 19 matching lines @@
             .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];
           assert(code != null);
-          js.Name name = namer.deriveSetterName(field.accessorName);
+          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);
+    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 = !_nativeData.isJsInteropClass(element) &&
         _worldBuilder.directlyInstantiatedClasses.contains(element);
 
     Class result;
     if (element.isMixinApplication && !onlyForRti) {
       assert(!_nativeData.isNativeClass(element));
       assert(methods.isEmpty);
@@ skipping 36 matching lines @@
   bool _methodNeedsStubs(FunctionElement method) {
     return !method.functionSignature.optionalParameters.isEmpty;
   }
 
   bool _methodCanBeReflected(MethodElement method) {
     return _mirrorsData.isMemberAccessibleByReflection(method);
   }
 
   bool _methodCanBeApplied(FunctionElement method) {
     return _backendUsage.isFunctionApplyUsed &&
-        closedWorld.getMightBePassedToApply(method);
+        _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 =
             _constantHandler.getConstantValue(parameter.constant);
         optionalParameterDefaultValues[parameter.name] = def;
       });
     } else {
       optionalParameterDefaultValues = <ConstantValue>[];
       signature.forEachOptionalParameter((ParameterElement parameter) {
         ConstantValue def =
             _constantHandler.getConstantValue(parameter.constant);
         optionalParameterDefaultValues.add(def);
       });
     }
     return optionalParameterDefaultValues;
   }
 
   DartMethod _buildMethod(MethodElement element) {
     assert(element.isDeclaration);
-    js.Name name = namer.methodPropertyName(element);
+    js.Name name = _namer.methodPropertyName(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 = _superMemberData.isAliasedSuperMember(element)
-        ? namer.aliasedSuperMemberPropertyName(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));
-        tearOffName = namer.getterForElement(element);
+        tearOffName = _namer.getterForElement(element);
       }
     }
 
     if (canTearOff) {
       assert(invariant(element, !element.isGenerativeConstructor));
       assert(invariant(element, !element.isGenerativeConstructorBody));
       assert(invariant(element, !element.isConstructor));
     }
 
     js.Name callName = null;
     if (canTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
-      callName = namer.invocationName(callSelector);
+      callName = _namer.invocationName(callSelector);
     }
 
     ResolutionDartType memberType;
     if (element.isGenerativeConstructorBody) {
       // TODO(herhut): Why does this need to be normalized away? We never need
       //               this information anyway as they cannot be torn off or
       //               reflected.
       var body = element;
       memberType = body.constructor.type;
     } else {
@@ skipping 38 matching lines @@
       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 =
         _oneShotInterceptorData.specializedGetInterceptorNames;
     for (js.Name name in names) {
       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);
+    InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
+        _options,
+        _commonElements,
+        _emitter,
+        _nativeCodegenEnqueuer,
+        _constantHandler,
+        _namer,
+        _nativeData,
+        _interceptorData,
+        _oneShotInterceptorData,
+        _customElementsCodegenAnalysis,
+        _worldBuilder,
+        _closedWorld);
 
     String holderName =
-        namer.globalObjectForLibrary(_commonElements.interceptorsLibrary);
+        _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 =
         _oneShotInterceptorData.specializedGetInterceptorNames;
     return names.map((js.Name name) {
       Set<ClassEntity> classes =
           _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)
+    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) {
@@ skipping 25 matching lines @@
       }
 
       fields.add(new Field(field, name, accessorName, getterFlags, setterFlags,
           needsCheckedSetter));
     });
 
     return fields;
   }
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
-    InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, _backend, closedWorld);
+    InterceptorStubGenerator stubGenerator = new InterceptorStubGenerator(
+        _options,
+        _commonElements,
+        _emitter,
+        _nativeCodegenEnqueuer,
+        _constantHandler,
+        _namer,
+        _nativeData,
+        _interceptorData,
+        _oneShotInterceptorData,
+        _customElementsCodegenAnalysis,
+        _worldBuilder,
+        _closedWorld);
 
     String holderName =
-        namer.globalObjectForLibrary(_commonElements.interceptorsLibrary);
+        _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 = _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.Name name = _namer.methodPropertyName(element);
+    String holder = _namer.globalObjectFor(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));
 
     js.Name tearOffName =
-        needsTearOff ? namer.staticClosureName(element) : null;
+        needsTearOff ? _namer.staticClosureName(element) : null;
 
     js.Name callName = null;
     if (needsTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
-      callName = namer.invocationName(callSelector);
+      callName = _namer.invocationName(callSelector);
     }
     js.Expression functionType;
     ResolutionDartType type = element.type;
     if (needsTearOff || canBeReflected) {
       OutputUnit outputUnit = _deferredLoadTask.outputUnitForElement(element);
       functionType = _generateFunctionType(type, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
@@ skipping 17 matching lines @@
         functionType: functionType);
   }
 
   void _registerConstants(
       OutputUnit outputUnit, Iterable<ConstantValue> constantValues) {
     // `constantValues` is null if an outputUnit doesn't contain any constants.
     if (constantValues == null) return;
     for (ConstantValue constantValue in constantValues) {
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
-      js.Name name = namer.constantName(constantValue);
-      String constantObject = namer.globalObjectForConstant(constantValue);
+      js.Name name = _namer.constantName(constantValue);
+      String constantObject = _namer.globalObjectForConstant(constantValue);
       Holder holder =
           _registry.registerHolder(constantObject, isConstantsHolder: true);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
-    return _registry.registerHolder(namer.staticStateHolder,
+    return _registry.registerHolder(_namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }