dartfmt pkg/compiler

pkg/compiler/lib/src/universe/call_structure.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.call_structure;
 
 import '../common.dart';
-import '../common/names.dart' show
-    Identifiers,
-    Names,
-    Selectors;
+import '../common/names.dart' show Identifiers, Names, Selectors;
 import '../elements/elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 
-import 'selector.dart' show
-    Selector;
+import 'selector.dart' show Selector;
 
 /// The structure of the arguments at a call-site.
 // TODO(johnniwinther): Should these be cached?
 // TODO(johnniwinther): Should isGetter/isSetter be part of the call structure
 // instead of the selector?
 class CallStructure {
   static const CallStructure NO_ARGS = const CallStructure.unnamed(0);
   static const CallStructure ONE_ARG = const CallStructure.unnamed(1);
   static const CallStructure TWO_ARGS = const CallStructure.unnamed(2);
 
@@ skipping 29 matching lines @@
 
   /// A description of the argument structure.
   String structureToString() => 'arity=$argumentCount';
 
   String toString() => 'CallStructure(${structureToString()})';
 
   Selector get callSelector => new Selector.call(Names.call, this);
 
   bool match(CallStructure other) {
     if (identical(this, other)) return true;
-    return this.argumentCount == other.argumentCount
-        && this.namedArgumentCount == other.namedArgumentCount
-        && sameNames(this.namedArguments, other.namedArguments);
+    return this.argumentCount == other.argumentCount &&
+        this.namedArgumentCount == other.namedArgumentCount &&
+        sameNames(this.namedArguments, other.namedArguments);
   }
 
   // TODO(johnniwinther): Cache hash code?
   int get hashCode {
     return Hashing.listHash(namedArguments,
         Hashing.objectHash(argumentCount, namedArguments.length));
   }
 
   bool operator ==(other) {
     if (other is! CallStructure) return false;
@@ skipping 93 matching lines @@
    *
    * [compileArgument] is a function that returns a compiled version
    * of a parameter of [callee].
    *
    * [compileConstant] is a function that returns a compiled constant
    * of an optional argument that is not in the parameters of [callee].
    *
    * Returns [:true:] if the signature of the [caller] matches the
    * signature of the [callee], [:false:] otherwise.
    */
-  static /*<T>*/ bool addForwardingElementArgumentsToList(
+  static/*<T>*/ bool addForwardingElementArgumentsToList(
       ConstructorElement caller,
       List/*<T>*/ list,
       ConstructorElement callee,
       /*T*/ compileArgument(ParameterElement element),
       /*T*/ compileConstant(ParameterElement element)) {
     assert(invariant(caller, !callee.isMalformed,
         message: "Cannot compute arguments to malformed constructor: "
-                 "$caller calling $callee."));
+            "$caller calling $callee."));
 
     FunctionSignature signature = caller.functionSignature;
     Map<Node, ParameterElement> mapping = <Node, ParameterElement>{};
 
     // TODO(ngeoffray): This is a hack that fakes up AST nodes, so
     // that we can call [addArgumentsToList].
     Link<Node> computeCallNodesFromParameters() {
       LinkBuilder<Node> builder = new LinkBuilder<Node>();
       signature.forEachRequiredParameter((ParameterElement element) {
         Node node = element.node;
@@ skipping 27 matching lines @@
     if (signature.optionalParametersAreNamed) {
       namedParameters =
           signature.optionalParameters.map((e) => e.name).toList();
     }
     CallStructure callStructure =
         new CallStructure(signature.parameterCount, namedParameters);
     if (!callStructure.signatureApplies(signature)) {
       return false;
     }
     list.addAll(callStructure.makeArgumentsList(
-        nodes,
-        callee,
-        internalCompileArgument,
-        compileConstant));
+        nodes, callee, internalCompileArgument, compileConstant));
 
     return true;
   }
 
   static bool sameNames(List<String> first, List<String> second) {
     for (int i = 0; i < first.length; i++) {
       if (first[i] != second[i]) return false;
     }
     return true;
   }
@@ skipping 30 matching lines @@
       return first.compareTo(second);
     });
     return _orderedNamedArguments;
   }
 
   @override
   String structureToString() {
     return 'arity=$argumentCount, named=[${namedArguments.join(', ')}]';
   }
 }