dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show Pass;
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../universe/selector.dart' show Selector;
 import '../../cps_ir/cps_fragment.dart';
@@ skipping 89 matching lines @@
     //     body;
     //
     // with
     //
     //     if (identical(arg, null))
     //       return false;
     //     else
     //       body;
     //
     CpsFragment cps = new CpsFragment();
-    Primitive isNull = cps.applyBuiltin(
-        BuiltinOperator.Identical,
+    Primitive isNull = cps.applyBuiltin(BuiltinOperator.Identical,
         <Primitive>[function.parameters.single, cps.makeNull()]);
     CpsFragment trueBranch = cps.ifTruthy(isNull);
-    trueBranch.invokeContinuation(function.returnContinuation,
-        <Primitive>[trueBranch.makeFalse()]);
+    trueBranch.invokeContinuation(
+        function.returnContinuation, <Primitive>[trueBranch.makeFalse()]);
     cps.insertAbove(function.body);
   }
 
   /// Insert a static call to [function] immediately above [node].
-  Primitive insertStaticCallAbove(FunctionElement function,
-      List<Primitive> arguments, Expression node) {
+  Primitive insertStaticCallAbove(
+      FunctionElement function, List<Primitive> arguments, Expression node) {
     // TODO(johnniwinther): Come up with an implementation of SourceInformation
     // for calls such as this one that don't appear in the original source.
     InvokeStatic invoke = new InvokeStatic(
         function, new Selector.fromElement(function), arguments, null);
     new LetPrim(invoke).insertAbove(node);
     return invoke;
   }
 
   @override
   Expression traverseLetHandler(LetHandler node) {
@@ skipping 13 matching lines @@
           [new Parameter(null)], // Dummy argument, see below.
           body);
       _exceptionParameter.replaceUsesWith(unwrapped);
 
       // Replace the dummy with the exception parameter.  It must be set after
       // replacing all uses of [_exceptionParameter].
       unwrapped.argumentRefs[0].changeTo(_exceptionParameter);
 
       if (stackTraceParameter.hasAtLeastOneUse) {
         InvokeStatic stackTraceValue = insertStaticCallAbove(
-            _glue.getTraceFromException(),
-            [_exceptionParameter],
-            body);
+            _glue.getTraceFromException(), [_exceptionParameter], body);
         stackTraceParameter.replaceUsesWith(stackTraceValue);
       }
     }
 
     assert(stackTraceParameter.hasNoUses);
     node.handler.parameters.removeLast();
 
     visit(node.handler);
     _exceptionParameter = previousExceptionParameter;
 
     return node.body;
   }
 
   processThrow(Throw node) {
     // The subexpression of throw is wrapped in the JavaScript output.
     Primitive wrappedException = insertStaticCallAbove(
-        _glue.getWrapExceptionHelper(),
-        [node.value],
-        node);
+        _glue.getWrapExceptionHelper(), [node.value], node);
     node.valueRef.changeTo(wrappedException);
   }
 
   processRethrow(Rethrow node) {
     // Rethrow can only appear in a catch block.  It throws that block's
     // (wrapped) caught exception.
     Throw replacement = new Throw(_exceptionParameter);
     InteriorNode parent = node.parent;
     parent.body = replacement;
     replacement.parent = parent;
     // The original rethrow does not have any references that we need to
     // worry about unlinking.
   }
 
   bool isNullConstant(Primitive prim) {
     return prim is Constant && prim.value.isNull;
   }
 
   processInvokeMethod(InvokeMethod node) {
     Selector selector = node.selector;
     if (!_glue.isInterceptedSelector(selector)) return;
 
     // Some platform libraries will compare non-interceptable objects against
     // null using the Dart == operator.  These must be translated directly.
     if (node.selector == Selectors.equals &&
         node.argumentRefs.length == 1 &&
         isNullConstant(node.argument(0))) {
-      node.replaceWith(new ApplyBuiltinOperator(
-          BuiltinOperator.Identical,
-          [node.receiver, node.argument(0)],
-          node.sourceInformation));
+      node.replaceWith(new ApplyBuiltinOperator(BuiltinOperator.Identical,
+          [node.receiver, node.argument(0)], node.sourceInformation));
       return;
     }
 
     Primitive receiver = node.receiver;
     Primitive interceptor;
 
     if (receiver == receiverParameter && receiverInterceptor != null) {
       // TODO(asgerf): This could be done by GVN.
       // If the receiver is 'this', we are calling a method in
       // the same interceptor:
@@ skipping 25 matching lines @@
       interceptor = new Interceptor(receiver, node.sourceInformation);
       if (receiver.hint != null) {
         interceptor.hint = new InterceptorEntity(receiver.hint);
       }
       new LetPrim(interceptor).insertAbove(node.parent);
     }
     assert(node.interceptorRef == null);
     node.makeIntercepted(interceptor);
   }
 }