dartfmt pkg/compiler

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.
 
 part of dart2js.js_emitter;
 
 class ParameterStubGenerator {
   static final Set<Selector> emptySelectorSet = new Set<Selector>();
 
   final Namer namer;
   final Compiler compiler;
   final JavaScriptBackend backend;
 
   ParameterStubGenerator(this.compiler, this.namer, this.backend);
 
   Emitter get emitter => backend.emitter.emitter;
   CodeEmitterTask get emitterTask => backend.emitter;
   DiagnosticReporter get reporter => compiler.reporter;
 
   bool needsSuperGetter(FunctionElement element) =>
-    compiler.codegenWorld.methodsNeedingSuperGetter.contains(element);
+      compiler.codegenWorld.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.
    *
    * Members may be invoked in two ways: directly, or through a closure. In the
    * latter case the caller invokes the closure's `call` method. This method
    * accepts two selectors. The returned stub method has the corresponding
    * name [ParameterStubMethod.name] and [ParameterStubMethod.callName] set if
    * the input selector is non-null (and the member needs a stub).
    */
-  ParameterStubMethod generateParameterStub(FunctionElement member,
-                                            Selector selector,
-                                            Selector callSelector) {
+  ParameterStubMethod generateParameterStub(
+      FunctionElement member, Selector selector, Selector callSelector) {
     CallStructure callStructure = selector.callStructure;
     FunctionSignature parameters = member.functionSignature;
     int positionalArgumentCount = callStructure.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       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,
@@ skipping 10 matching lines @@
     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);
+    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
@@ skipping 25 matching lines @@
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] = emitter.constantReference(value);
           }
         }
       }
       count++;
     });
 
-    var body;  // List or jsAst.Statement.
+    var body; // List or jsAst.Statement.
     if (backend.nativeData.hasFixedBackendName(member)) {
       body = emitterTask.nativeEmitter.generateParameterStubStatements(
-          member, isInterceptedMethod, namer.invocationName(selector),
-          parametersBuffer, argumentsBuffer,
+          member,
+          isInterceptedMethod,
+          namer.invocationName(selector),
+          parametersBuffer,
+          argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else if (member.isInstanceMember) {
       if (needsSuperGetter(member)) {
         ClassElement superClass = member.enclosingClass;
         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),
-             methodName,
-             argumentsBuffer]);
+        body = js.statement('return #.#.call(this, #);', [
+          backend.emitter
+              .prototypeAccess(superClass, hasBeenInstantiated: true),
+          methodName,
+          argumentsBuffer
+        ]);
       } else {
-        body = js.statement(
-            'return this.#(#);',
+        body = js.statement('return this.#(#);',
             [namer.instanceMethodName(member), argumentsBuffer]);
       }
     } else {
       body = js.statement('return #(#)',
           [emitter.staticFunctionAccess(member), argumentsBuffer]);
     }
 
     jsAst.Fun function = js('function(#) { #; }', [parametersBuffer, body]);
 
     jsAst.Name name = member.isStatic ? null : namer.invocationName(selector);
@@ skipping 27 matching lines @@
   // (4) No stub generated, call is direct.
   // (5) No stub generated, call is direct.
   //
   // 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}) {
+      {bool canTearOff: true}) {
     if (member.enclosingElement.isClosure) {
       ClosureClassElement cls = member.enclosingElement;
       if (cls.supertype.element == backend.helpers.boundClosureClass) {
         reporter.internalError(cls.methodElement, 'Bound closure1.');
       }
       if (cls.methodElement.isInstanceMember) {
         reporter.internalError(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.codegenWorld.invocationsByName(member.name);
+      selectors = compiler.codegenWorld.invocationsByName(member.name);
     }
 
     if (canTearOff) {
       String call = namer.closureInvocationSelectorName;
       callSelectors = compiler.codegenWorld.invocationsByName(call);
     }
 
     assert(emptySelectorSet.isEmpty);
     if (selectors == null) selectors = const <Selector, SelectorConstraints>{};
-    if (callSelectors == null) callSelectors =
-        const <Selector, SelectorConstraints>{};
+    if (callSelectors == null)
+      callSelectors = const <Selector, SelectorConstraints>{};
 
     List<ParameterStubMethod> stubs = <ParameterStubMethod>[];
 
     if (selectors.isEmpty && callSelectors.isEmpty) {
       return stubs;
     }
 
     // For every call-selector the corresponding selector with the name of the
     // member.
     //
     // For example, for the call-selector `call(x, y)` the renamed selector
     // for member `foo` would be `foo(x, y)`.
     Set<Selector> renamedCallSelectors =
         callSelectors.isEmpty ? emptySelectorSet : new Set<Selector>();
 
     Set<Selector> untypedSelectors = new Set<Selector>();
 
     // Start with the callSelectors since they imply the generation of the
     // non-call version.
     for (Selector selector in callSelectors.keys) {
-      Selector renamedSelector = new Selector.call(
-          member.memberName,
-          selector.callStructure);
+      Selector renamedSelector =
+          new Selector.call(member.memberName, selector.callStructure);
       renamedCallSelectors.add(renamedSelector);
 
       if (!renamedSelector.appliesUnnamed(member, compiler.world)) continue;
 
       if (untypedSelectors.add(renamedSelector)) {
         ParameterStubMethod stub =
             generateParameterStub(member, renamedSelector, selector);
         if (stub != null) {
           stubs.add(stub);
         }
@@ skipping 15 matching lines @@
             generateParameterStub(member, selector, null);
         if (stub != null) {
           stubs.add(stub);
         }
       }
     }
 
     return stubs;
   }
 }