Remove Compiler and JavaScriptBackend from parameter_stub_generator

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

 // Copyright (c) 2015, 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.parameter_stub_generator;
 
 import '../closure.dart' show ClosureClassElement;
 import '../common.dart';
-import '../compiler.dart' show Compiler;
+import '../common_elements.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart'
     show
         ClassElement,
         FunctionElement,
         FunctionSignature,
         MethodElement,
         ParameterElement;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
-import '../js_backend/js_backend.dart'
-    show JavaScriptBackend, JavaScriptConstantCompiler, Namer;
+import '../js_backend/constant_handler_javascript.dart'
+    show JavaScriptConstantCompiler;
+import '../js_backend/namer.dart' show Namer;
+import '../js_backend/native_data.dart';
+import '../js_backend/interceptor_data.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
-import '../universe/world_builder.dart' show SelectorConstraints;
+import '../universe/world_builder.dart'
+    show CodegenWorldBuilder, SelectorConstraints;
 import '../world.dart' show ClosedWorld;
 
 import 'model.dart';
 
 import 'code_emitter_task.dart' show CodeEmitterTask, Emitter;
 
 class ParameterStubGenerator {
   static final Set<Selector> emptySelectorSet = new Set<Selector>();
 
-  final Namer namer;
-  final Compiler compiler;
-  final JavaScriptBackend backend;
-  final ClosedWorld closedWorld;
+  final CommonElements _commonElements;
+  final CodeEmitterTask _emitterTask;
+  final JavaScriptConstantCompiler _constants;
+  final Namer _namer;
+  final NativeData _nativeData;
+  final InterceptorData _interceptorData;
+  final CodegenWorldBuilder _codegenWorldBuilder;
+  final ClosedWorld _closedWorld;
 
   ParameterStubGenerator(
-      this.compiler, this.namer, this.backend, this.closedWorld);
+      this._commonElements,
+      this._emitterTask,
+      this._constants,
+      this._namer,
+      this._nativeData,
+      this._interceptorData,
+      this._codegenWorldBuilder,
+      this._closedWorld);
 
-  Emitter get emitter => backend.emitter.emitter;
-  CodeEmitterTask get emitterTask => backend.emitter;
-  DiagnosticReporter get reporter => compiler.reporter;
+  Emitter get _emitter => _emitterTask.emitter;
 
   bool needsSuperGetter(FunctionElement element) =>
-      compiler.codegenWorldBuilder.methodsNeedingSuperGetter.contains(element);
+      _codegenWorldBuilder.methodsNeedingSuperGetter.contains(element);
 
   /**
    * Generates stubs to handle invocation of methods with optional
    * arguments.
    *
    * A method like `foo([x])` may be invoked by the following
    * calls: `foo(), foo(1), foo(x: 1)`. This method generates the stub for the
    * given [selector] and returns the generated [ParameterStubMethod].
    *
    * Returns null if no stub is needed.
@@ skipping 13 matching lines @@
       assert(callStructure.isUnnamed);
       return null;
     }
     if (parameters.optionalParametersAreNamed &&
         callStructure.namedArgumentCount == parameters.optionalParameterCount) {
       // If the selector has the same number of named arguments as the element,
       // we don't need to add a stub. The call site will hit the method
       // directly.
       return null;
     }
-    JavaScriptConstantCompiler handler = backend.constants;
     List<String> names = callStructure.getOrderedNamedArguments();
 
-    bool isInterceptedMethod =
-        backend.interceptorData.isInterceptedMethod(member);
+    bool isInterceptedMethod = _interceptorData.isInterceptedMethod(member);
 
     // If the method is intercepted, we need to also pass the actual receiver.
     int extraArgumentCount = isInterceptedMethod ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because namer.safeVariableName used for getting
     // parameter names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
 
     // The parameters that this stub takes.
     List<jsAst.Parameter> parametersBuffer =
         new List<jsAst.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer = new List<jsAst.Expression>(
         parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
       argumentsBuffer[0] = js('#', receiverArgumentName);
     }
 
     int optionalParameterStart = positionalArgumentCount + extraArgumentCount;
     // Includes extra receiver argument when using interceptor convention
     int indexOfLastOptionalArgumentInParameters = optionalParameterStart - 1;
 
     parameters.orderedForEachParameter((ParameterElement element) {
-      String jsName = backend.namer.safeVariableName(element.name);
+      String jsName = _namer.safeVariableName(element.name);
       assert(jsName != receiverArgumentName);
       if (count < optionalParameterStart) {
         parametersBuffer[count] = new jsAst.Parameter(jsName);
         argumentsBuffer[count] = js('#', jsName);
       } else {
         int index = names.indexOf(element.name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
           argumentsBuffer[count] = js('#', jsName);
           parametersBuffer[optionalParameterStart + index] =
               new jsAst.Parameter(jsName);
         } else {
-          ConstantValue value = handler.getConstantValue(element.constant);
+          ConstantValue value = _constants.getConstantValue(element.constant);
           if (value == null) {
             argumentsBuffer[count] =
-                emitter.constantReference(new NullConstantValue());
+                _emitter.constantReference(new NullConstantValue());
           } else {
             if (!value.isNull) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
-            argumentsBuffer[count] = emitter.constantReference(value);
+            argumentsBuffer[count] = _emitter.constantReference(value);
           }
         }
       }
       count++;
     });
 
     var body; // List or jsAst.Statement.
-    if (backend.nativeData.hasFixedBackendName(member)) {
-      body = emitterTask.nativeEmitter.generateParameterStubStatements(
+    if (_nativeData.hasFixedBackendName(member)) {
+      body = _emitterTask.nativeEmitter.generateParameterStubStatements(
           member,
           isInterceptedMethod,
-          namer.invocationName(selector),
+          _namer.invocationName(selector),
           parametersBuffer,
           argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else if (member.isInstanceMember) {
       if (needsSuperGetter(member)) {
         ClassElement superClass = member.enclosingClass;
-        jsAst.Name methodName = namer.instanceMethodName(member);
+        jsAst.Name methodName = _namer.instanceMethodName(member);
         // When redirecting, we must ensure that we don't end up in a subclass.
         // We thus can't just invoke `this.foo$1.call(filledInArguments)`.
         // Instead we need to call the statically resolved target.
         //   `<class>.prototype.bar$1.call(this, argument0, ...)`.
         body = js.statement('return #.#.call(this, #);', [
-          backend.emitter
-              .prototypeAccess(superClass, hasBeenInstantiated: true),
+          _emitterTask.prototypeAccess(superClass, hasBeenInstantiated: true),
           methodName,
           argumentsBuffer
         ]);
       } else {
         body = js.statement('return this.#(#);',
-            [namer.instanceMethodName(member), argumentsBuffer]);
+            [_namer.instanceMethodName(member), argumentsBuffer]);
       }
     } else {
       body = js.statement('return #(#)',
-          [emitter.staticFunctionAccess(member), argumentsBuffer]);
+          [_emitter.staticFunctionAccess(member), argumentsBuffer]);
     }
 
     jsAst.Fun function = js('function(#) { #; }', [parametersBuffer, body]);
 
-    jsAst.Name name = member.isStatic ? null : namer.invocationName(selector);
+    jsAst.Name name = member.isStatic ? null : _namer.invocationName(selector);
     jsAst.Name callName =
-        (callSelector != null) ? namer.invocationName(callSelector) : null;
+        (callSelector != null) ? _namer.invocationName(callSelector) : null;
     return new ParameterStubMethod(name, callName, function);
   }
 
   // We fill the lists depending on possible/invoked selectors. For example,
   // take method foo:
   //    foo(a, b, {c, d});
   //
   // We may have multiple ways of calling foo:
   // (1) foo(1, 2);
   // (2) foo(1, 2, c: 3);
@@ skipping 18 matching lines @@
   // We need to pay attention if this stub is for a function that has been
   // invoked from a subclass. Then we cannot just redirect, since that
   // would invoke the methods of the subclass. We have to compile to:
   // (1) foo$2(a, b) => MyClass.foo$4$c$d.call(this, a, b, null, null)
   // (2) foo$3$c(a, b, c) => MyClass.foo$4$c$d(this, a, b, c, null);
   // (3) foo$3$d(a, b, d) => MyClass.foo$4$c$d(this, a, b, null, d);
   List<ParameterStubMethod> generateParameterStubs(MethodElement member,
       {bool canTearOff: true}) {
     if (member.enclosingElement.isClosure) {
       ClosureClassElement cls = member.enclosingElement;
-      if (cls.supertype.element == backend.commonElements.boundClosureClass) {
-        reporter.internalError(cls.methodElement, 'Bound closure1.');
+      if (cls.supertype.element == _commonElements.boundClosureClass) {
+        throw new SpannableAssertionFailure(
+            cls.methodElement, 'Bound closure1.');
       }
       if (cls.methodElement.isInstanceMember) {
-        reporter.internalError(cls.methodElement, 'Bound closure2.');
+        throw new SpannableAssertionFailure(
+            cls.methodElement, 'Bound closure2.');
       }
     }
 
     // The set of selectors that apply to `member`. For example, for
     // a member `foo(x, [y])` the following selectors may apply:
     // `foo(x)`, and `foo(x, y)`.
     Map<Selector, SelectorConstraints> selectors;
     // The set of selectors that apply to `member` if it's name was `call`.
     // This happens when a member is torn off. In that case calls to the
     // function use the name `call`, and we must be able to handle every
     // `call` invocation that matches the signature. For example, for
     // a member `foo(x, [y])` the following selectors would be possible
     // call-selectors: `call(x)`, and `call(x, y)`.
     Map<Selector, SelectorConstraints> callSelectors;
 
     // Only instance members (not static methods) need stubs.
     if (member.isInstanceMember) {
-      selectors = compiler.codegenWorldBuilder.invocationsByName(member.name);
+      selectors = _codegenWorldBuilder.invocationsByName(member.name);
     }
 
     if (canTearOff) {
-      String call = namer.closureInvocationSelectorName;
-      callSelectors = compiler.codegenWorldBuilder.invocationsByName(call);
+      String call = _namer.closureInvocationSelectorName;
+      callSelectors = _codegenWorldBuilder.invocationsByName(call);
     }
 
     assert(emptySelectorSet.isEmpty);
     if (selectors == null) selectors = const <Selector, SelectorConstraints>{};
     if (callSelectors == null)
       callSelectors = const <Selector, SelectorConstraints>{};
 
     List<ParameterStubMethod> stubs = <ParameterStubMethod>[];
 
     if (selectors.isEmpty && callSelectors.isEmpty) {
@@ skipping 29 matching lines @@
         }
       }
     }
 
     // Now run through the actual member selectors (eg. `foo$2(x, y)` and not
     // `call$2(x, y)`. Some of them have already been generated because of the
     // call-selectors (and they are in the renamedCallSelectors set.
     for (Selector selector in selectors.keys) {
       if (renamedCallSelectors.contains(selector)) continue;
       if (!selector.appliesUnnamed(member)) continue;
-      if (!selectors[selector].applies(member, selector, closedWorld)) {
+      if (!selectors[selector].applies(member, selector, _closedWorld)) {
         continue;
       }
 
       if (untypedSelectors.add(selector)) {
         ParameterStubMethod stub =
             generateParameterStub(member, selector, null);
         if (stub != null) {
           stubs.add(stub);
         }
       }
     }
 
     return stubs;
   }
 }