dartfmt pkg/compiler

pkg/compiler/lib/src/cps_ir/path_based_optimizer.dart

 // Copyright (c) 2016, 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.cps_ir.path_based_optimizer;
 
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import 'cps_fragment.dart';
 import '../js_backend/js_backend.dart';
 import 'type_mask_system.dart';
@@ skipping 41 matching lines @@
 /// refined type cannot always be represented exactly, and type propagation
 /// may therefore not see that `x` is a self-interceptor.
 //
 // TODO(asgerf): A kind of redundant join can arise where a branching condition
 // is known to be true/false on all but one predecessor for a branch. We could
 // try to reduce those.
 //
 // TODO(asgerf): Could be more precise if GVN shared expressions that are not
 // in direct scope of one another, e.g. by using phis pass the shared value.
 //
-class PathBasedOptimizer extends TrampolineRecursiveVisitor
-                         implements Pass {
+class PathBasedOptimizer extends TrampolineRecursiveVisitor implements Pass {
   String get passName => 'Path-based optimizations';
 
   // Classification of all values.
   static const int TRUE = 1 << 0;
   static const int SELF_INTERCEPTOR = 1 << 1;
   static const int INTERCEPTED_TRUTHY = 1 << 2;
   static const int FALSE = 1 << 3;
   static const int OTHER_FALSY = 1 << 4;
 
   static const int TRUTHY = TRUE | SELF_INTERCEPTOR | INTERCEPTED_TRUTHY;
@@ skipping 77 matching lines @@
       valuesAt[falseCont] = valueOf..[condition] = values & negativeValues;
     }
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     int receiverValue = valueOf[node.receiver] ?? ANY;
     if (!backend.isInterceptedSelector(node.selector)) {
       // Only self-interceptors can respond to a non-intercepted selector.
       valueOf[node.receiver] = receiverValue & SELF_INTERCEPTOR;
     } else if (receiverValue & ~SELF_INTERCEPTOR == 0 &&
-               node.callingConvention == CallingConvention.Intercepted) {
+        node.callingConvention == CallingConvention.Intercepted) {
       // This is an intercepted call whose receiver is definitely a
       // self-interceptor.
       // TODO(25646): If TypeMasks could represent "any self-interceptor" this
       //   optimization should be subsumed by type propagation.
       node.interceptorRef.changeTo(node.receiver);
 
       // Replace the extra receiver argument with a dummy value if the
       // target definitely does not use it.
-      if (typeSystem.targetIgnoresReceiverArgument(node.receiver.type,
-            node.selector)) {
+      if (typeSystem.targetIgnoresReceiverArgument(
+          node.receiver.type, node.selector)) {
         node.makeDummyIntercepted();
       }
     }
   }
 }