dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/cps_ir_nodes_sexpr.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.ir_nodes_sexpr;
 
 import '../constants/values.dart';
 import '../util/util.dart';
 import 'cps_ir_nodes.dart';
-import '../universe/call_structure.dart' show
-    CallStructure;
+import '../universe/call_structure.dart' show CallStructure;
 
 /// A [Decorator] is a function used by [SExpressionStringifier] to augment the
 /// output produced for a node or reference.  It can be provided to the
 /// constructor.
 typedef String Decorator(node, String s);
 
 /// Generate a Lisp-like S-expression representation of an IR node as a string.
 class SExpressionStringifier extends Indentation implements Visitor<String> {
   final _Namer namer = new _Namer();
 
@@ skipping 149 matching lines @@
     return '$indentation(LetHandler (($parameters)\n$handlerBody)\n$body)';
   }
 
   String visitLetMutable(LetMutable node) {
     String name = visit(node.variable);
     String value = access(node.valueRef);
     String body = indentBlock(() => visit(node.body));
     return '$indentation(LetMutable ($name $value)\n$body)';
   }
 
-  String formatArguments(CallStructure call,
-      List<Reference<Primitive>> arguments,
+  String formatArguments(
+      CallStructure call, List<Reference<Primitive>> arguments,
       [CallingConvention callingConvention = CallingConvention.Normal]) {
     int positionalArgumentCount = call.positionalArgumentCount;
     List<String> args =
         arguments.take(positionalArgumentCount).map(access).toList();
     List<String> argumentNames = call.getOrderedNamedArguments();
     for (int i = 0; i < argumentNames.length; ++i) {
       String name = argumentNames[i];
       String arg = access(arguments[positionalArgumentCount + i]);
       args.add("($name: $arg)");
     }
     // Constructors can have type parameter after the named arguments.
-    args.addAll(
-        arguments.skip(positionalArgumentCount + argumentNames.length)
-            .map(access));
+    args.addAll(arguments
+        .skip(positionalArgumentCount + argumentNames.length)
+        .map(access));
     return '(${args.join(' ')})';
   }
 
   String visitInvokeStatic(InvokeStatic node) {
     String name = node.target.name;
-    String args = formatArguments(node.selector.callStructure, node.argumentRefs);
+    String args =
+        formatArguments(node.selector.callStructure, node.argumentRefs);
     return '(InvokeStatic $name $args)';
   }
 
   String visitInvokeMethod(InvokeMethod node) {
     String name = node.selector.name;
     String interceptor = optionalAccess(node.interceptorRef);
     String receiver = access(node.receiverRef);
-    String arguments = formatArguments(node.selector.callStructure,
-        node.argumentRefs, node.callingConvention);
+    String arguments = formatArguments(
+        node.selector.callStructure, node.argumentRefs, node.callingConvention);
     return '(InvokeMethod $interceptor $receiver $name $arguments)';
   }
 
   String visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     String interceptor = optionalAccess(node.interceptorRef);
     String receiver = access(node.receiverRef);
     String name = node.selector.name;
-    String arguments = formatArguments(node.selector.callStructure,
-        node.argumentRefs, node.callingConvention);
+    String arguments = formatArguments(
+        node.selector.callStructure, node.argumentRefs, node.callingConvention);
     return '(InvokeMethodDirectly $interceptor $receiver $name $arguments)';
   }
 
   String visitInvokeConstructor(InvokeConstructor node) {
     // TODO(karlklose): for illegal nodes constructed for tests or unresolved
     // constructor calls in the DartBackend, we get an element with no enclosing
     // class.  Clean this up by introducing a name field to the node and
     // removing [ErroneousElement]s from the IR.
     String name = node.dartType != null
         ? node.dartType.toString()
         : node.target.enclosingClass.name;
     if (!node.target.name.isEmpty) {
       name = '${name}.${node.target.name}';
     }
-    String args = formatArguments(node.selector.callStructure, node.argumentRefs);
+    String args =
+        formatArguments(node.selector.callStructure, node.argumentRefs);
     return '(InvokeConstructor $name $args)';
   }
 
   String visitInvokeContinuation(InvokeContinuation node) {
     String name = access(node.continuationRef);
     if (node.isRecursive) name = 'rec $name';
     String args = node.argumentRefs == null
         ? '**** NULL ****'
-        : node.argumentRefs.map(access).join(' ');
+        : node.argumentRefs.map(access).join(' ');
     String escaping = node.isEscapingTry ? ' escape' : '';
     return '$indentation(InvokeContinuation $name ($args)$escaping)';
   }
 
   String visitThrow(Throw node) {
     String value = access(node.valueRef);
     return '$indentation(Throw $value)';
   }
 
   String visitRethrow(Rethrow node) {
     return '$indentation(Rethrow)';
   }
 
   String visitBranch(Branch node) {
     String condition = access(node.conditionRef);
     assert(isBranchTarget(node.trueContinuation));
     assert(isBranchTarget(node.falseContinuation));
-    String trueCont =
-        indentBlock(() => visit(node.trueContinuation));
-    String falseCont =
-        indentBlock(() => visit(node.falseContinuation));
+    String trueCont = indentBlock(() => visit(node.trueContinuation));
+    String falseCont = indentBlock(() => visit(node.falseContinuation));
     String strict = node.isStrictCheck ? 'Strict' : 'NonStrict';
     return '$indentation(Branch $strict $condition\n$trueCont\n$falseCont)';
   }
 
   String visitUnreachable(Unreachable node) {
     return '$indentation(Unreachable)';
   }
 
   String visitConstant(Constant node) {
     String value = node.value.accept(new ConstantStringifier(), null);
@@ skipping 211 matching lines @@
   String visitBool(BoolConstantValue constant, _) {
     return '(Bool ${constant.unparse()})';
   }
 
   String visitString(StringConstantValue constant, _) {
     return '(String ${constant.unparse()})';
   }
 
   String visitList(ListConstantValue constant, _) {
     String entries =
-      constant.entries.map((entry) => entry.accept(this, _)).join(' ');
+        constant.entries.map((entry) => entry.accept(this, _)).join(' ');
     return '(List $entries)';
   }
 
   String visitMap(MapConstantValue constant, _) {
     List<String> elements = <String>[];
     for (int i = 0; i < constant.keys.length; ++i) {
       ConstantValue key = constant.keys[i];
       ConstantValue value = constant.values[i];
       elements.add('(${key.accept(this, _)} . ${value.accept(this, _)})');
     }
@@ skipping 54 matching lines @@
   void setReturnContinuation(Continuation node) {
     assert(!_names.containsKey(node) || _names[node] == 'return');
     _names[node] = 'return';
   }
 
   String getName(Node node) {
     if (!_names.containsKey(node)) return 'MISSING_NAME';
     return _names[node];
   }
 }