dartfmt pkg/compiler

pkg/compiler/lib/src/ssa/codegen_helpers.dart

 // Copyright (c) 2012, 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.
 
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart';
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
@@ skipping 49 matching lines @@
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitIs(HIs node) {
     if (node.kind == HIs.RAW_CHECK) {
       HInstruction interceptor = node.interceptor;
       if (interceptor != null) {
-        return new HIsViaInterceptor(node.typeExpression, interceptor,
-                                     backend.boolType);
+        return new HIsViaInterceptor(
+            node.typeExpression, interceptor, backend.boolType);
       }
     }
     return node;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     node.singleComparisonOp = simpleOp(node.left, node.right);
     return node;
   }
 
   String simpleOp(HInstruction left, HInstruction right) {
     // Returns the single identity comparison (== or ===) or null if a more
     // complex expression is required.
     TypeMask leftType = left.instructionType;
     TypeMask rightType = right.instructionType;
     if (leftType.isNullable && rightType.isNullable) {
       if (left.isConstantNull() ||
           right.isConstantNull() ||
-          (left.isPrimitive(compiler) &&
-           leftType == rightType)) {
+          (left.isPrimitive(compiler) && leftType == rightType)) {
         return '==';
       }
       return null;
     }
     return '===';
   }
 
   HInstruction visitInvokeDynamic(HInvokeDynamic node) {
     if (node.isInterceptedCall) {
       // Calls of the form
@@ skipping 84 matching lines @@
       HInstruction left = binary.left;
       HInstruction right = binary.right;
       if (isMatchingRead(left)) {
         if (left.usedBy.length == 1) {
           if (right is HConstant && right.constant.isOne) {
             HInstruction rmw = new HReadModifyWrite.preOp(
                 setter.element, incrementOp, receiver, op.instructionType);
             return replaceOp(rmw, left);
           } else {
             HInstruction rmw = new HReadModifyWrite.assignOp(
-                setter.element,
-                assignOp,
-                receiver, right, op.instructionType);
+                setter.element, assignOp, receiver, right, op.instructionType);
             return replaceOp(rmw, left);
           }
         } else if (op.usedBy.length == 1 &&
-                   right is HConstant &&
-                   right.constant.isOne) {
+            right is HConstant &&
+            right.constant.isOne) {
           HInstruction rmw = new HReadModifyWrite.postOp(
               setter.element, incrementOp, receiver, op.instructionType);
           block.addAfter(left, rmw);
           block.remove(setter);
           block.remove(op);
           block.rewrite(left, rmw);
           block.remove(left);
           return null;
         }
       }
       return noMatchingRead();
     }
 
-    HInstruction simple(String assignOp,
-                        HInstruction left, HInstruction right) {
+    HInstruction simple(
+        String assignOp, HInstruction left, HInstruction right) {
       if (isMatchingRead(left)) {
         if (left.usedBy.length == 1) {
           HInstruction rmw = new HReadModifyWrite.assignOp(
-              setter.element,
-              assignOp,
-              receiver, right, op.instructionType);
+              setter.element, assignOp, receiver, right, op.instructionType);
           return replaceOp(rmw, left);
         }
       }
       return noMatchingRead();
     }
 
     HInstruction simpleBinary(String assignOp) {
       HInvokeBinary binary = op;
       return simple(assignOp, binary.left, binary.right);
     }
@@ skipping 19 matching lines @@
 
     return noMatchingRead();
   }
 }
 
 /**
  * Remove [HTypeKnown] instructions from the graph, to make codegen
  * analysis easier.
  */
 class SsaTypeKnownRemover extends HBaseVisitor {
-
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction.accept(this);
       instruction = next;
     }
   }
 
   void visitTypeKnown(HTypeKnown instruction) {
     instruction.block.rewrite(instruction, instruction.checkedInput);
     instruction.block.remove(instruction);
   }
 }
 
 /**
  * Remove [HTypeConversion] instructions from the graph in '--trust-primitives'
  * mode.
  */
 class SsaTrustedCheckRemover extends HBaseVisitor {
-
   Compiler compiler;
   SsaTrustedCheckRemover(this.compiler);
 
   void visitGraph(HGraph graph) {
     if (!compiler.options.trustPrimitives) return;
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
@@ skipping 47 matching lines @@
   JavaScriptBackend get backend => compiler.backend;
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void analyzeInputs(HInstruction user, int start) {
     List<HInstruction> inputs = user.inputs;
     for (int i = start; i < inputs.length; i++) {
       HInstruction input = inputs[i];
-      if (!generateAtUseSite.contains(input)
-          && !input.isCodeMotionInvariant()
-          && input.usedBy.length == 1
-          && input is !HPhi
-          && input is !HLocalValue
-          && !input.isJsStatement()) {
+      if (!generateAtUseSite.contains(input) &&
+          !input.isCodeMotionInvariant() &&
+          input.usedBy.length == 1 &&
+          input is! HPhi &&
+          input is! HLocalValue &&
+          !input.isJsStatement()) {
         if (input.isPure()) {
           // Only consider a pure input if it is in the same loop.
           // Otherwise, we might move GVN'ed instruction back into the
           // loop.
           if (user.hasSameLoopHeaderAs(input)) {
             // Move it closer to [user], so that instructions in
             // between do not prevent making it generate at use site.
             input.moveBefore(user);
             pureInputs.add(input);
             // Previous computations done on [input] are now invalid
@@ skipping 61 matching lines @@
   // does not require an expression with multiple uses (because of null /
   // undefined).
   void visitIdentity(HIdentity instruction) {
     if (instruction.singleComparisonOp != null) {
       super.visitIdentity(instruction);
     }
     // Do nothing.
   }
 
   void visitTypeConversion(HTypeConversion instruction) {
-    if (!instruction.isArgumentTypeCheck
-        && !instruction.isReceiverTypeCheck) {
+    if (!instruction.isArgumentTypeCheck && !instruction.isReceiverTypeCheck) {
       assert(instruction.isCheckedModeCheck || instruction.isCastTypeCheck);
       // Checked mode checks and cast checks compile to code that
       // only use their input once, so we can safely visit them
       // and try to merge the input.
       visitInstruction(instruction);
     }
   }
 
   void visitTypeKnown(HTypeKnown instruction) {
     // [HTypeKnown] instructions are removed before code generation.
     assert(false);
   }
 
   void tryGenerateAtUseSite(HInstruction instruction) {
     if (instruction.isControlFlow()) return;
     markAsGenerateAtUseSite(instruction);
   }
 
   bool isBlockSinglePredecessor(HBasicBlock block) {
-    return block.successors.length == 1
-        && block.successors[0].predecessors.length == 1;
+    return block.successors.length == 1 &&
+        block.successors[0].predecessors.length == 1;
   }
 
   void visitBasicBlock(HBasicBlock block) {
     // Compensate from not merging blocks: if the block is the
     // single predecessor of its single successor, let the successor
     // visit it.
     if (isBlockSinglePredecessor(block)) return;
 
     tryMergingExpressions(block);
   }
@@ skipping 19 matching lines @@
         assert(nextInput.usedBy.length == 1);
         if (identical(nextInput, instruction)) {
           return true;
         }
       }
       return false;
     }
 
     block.last.accept(this);
     for (HInstruction instruction = block.last.previous;
-         instruction != null;
-         instruction = instruction.previous) {
+        instruction != null;
+        instruction = instruction.previous) {
       if (generateAtUseSite.contains(instruction)) {
         continue;
       }
       if (instruction.isCodeMotionInvariant()) {
         markAsGenerateAtUseSite(instruction);
         continue;
       }
       if (instruction.isPure()) {
         if (pureInputs.contains(instruction)) {
           tryGenerateAtUseSite(instruction);
@@ skipping 60 matching lines @@
           // The current instruction is the next non-trivial
           // expected input.
           tryGenerateAtUseSite(instruction);
         } else {
           assert(expectedInputs.isEmpty);
         }
         instruction.accept(this);
       }
     }
 
-    if (block.predecessors.length == 1
-        && isBlockSinglePredecessor(block.predecessors[0])) {
+    if (block.predecessors.length == 1 &&
+        isBlockSinglePredecessor(block.predecessors[0])) {
       assert(block.phis.isEmpty);
       tryMergingExpressions(block.predecessors[0]);
     } else {
       expectedInputs = null;
       pureInputs = null;
     }
   }
 }
 
 /**
@@ skipping 23 matching lines @@
   bool hasAnyStatement(HBasicBlock block, HInstruction instruction) {
     // If [instruction] is not in [block], then if the block is not
     // empty, we know there will be a statement to emit.
     if (!identical(instruction.block, block)) {
       return !identical(block.last, block.first);
     }
 
     // If [instruction] is not the last instruction of the block
     // before the control flow instruction, or the last instruction,
     // then we will have to emit a statement for that last instruction.
-    if (instruction != block.last
-        && !identical(instruction, block.last.previous)) return true;
+    if (instruction != block.last &&
+        !identical(instruction, block.last.previous)) return true;
 
     // If one of the instructions in the block until [instruction] is
     // not generated at use site, then we will have to emit a
     // statement for it.
     // TODO(ngeoffray): we could generate a comma separated
     // list of expressions.
     for (HInstruction temp = block.first;
-         !identical(temp, instruction);
-         temp = temp.next) {
+        !identical(temp, instruction);
+        temp = temp.next) {
       if (!generateAtUseSite.contains(temp)) return true;
     }
 
     return false;
   }
 
   bool isSafeToGenerateAtUseSite(HInstruction user, HInstruction input) {
     // HForeignNew evaluates arguments in order and passes them to a
     // constructor.
     if (user is HForeignNew) return true;
     // A [HForeign] instruction uses operators and if we generate
     // [input] at use site, the precedence might be wrong.
     if (user is HForeign) return false;
     // A [HCheck] instruction with control flow uses its input
     // multiple times, so we avoid generating it at use site.
     if (user is HCheck && user.isControlFlow()) return false;
     // A [HIs] instruction uses its input multiple times, so we
     // avoid generating it at use site.
     if (user is HIs) return false;
     return true;
   }
 
   void visitBasicBlock(HBasicBlock block) {
-    if (block.last is !HIf) return;
+    if (block.last is! HIf) return;
     HIf startIf = block.last;
     HBasicBlock end = startIf.joinBlock;
 
     // We check that the structure is the following:
     //         If
     //       /    \
     //      /      \
     //   1 expr    goto
     //    goto     /
     //      \     /
@@ skipping 69 matching lines @@
 
     // Find the next non-HGoto instruction following the phi.
     HInstruction nextInstruction = phi.block.first;
     while (nextInstruction is HGoto) {
       nextInstruction = nextInstruction.block.successors[0].first;
     }
 
     // If the operation is only used by the first instruction
     // of its block and is safe to be generated at use site, mark it
     // so.
-    if (phi.usedBy.length == 1
-        && phi.usedBy[0] == nextInstruction
-        && isSafeToGenerateAtUseSite(phi.usedBy[0], phi)) {
+    if (phi.usedBy.length == 1 &&
+        phi.usedBy[0] == nextInstruction &&
+        isSafeToGenerateAtUseSite(phi.usedBy[0], phi)) {
       markAsGenerateAtUseSite(phi);
     }
 
     if (identical(elseInput.block, elseBlock)) {
       assert(elseInput.usedBy.length == 1);
       markAsGenerateAtUseSite(elseInput);
     }
 
     // If [thenInput] is defined in the first predecessor, then it is only used
     // by [phi] and can be generated at use site.
     if (identical(thenInput.block, end.predecessors[0])) {
       assert(thenInput.usedBy.length == 1);
       markAsGenerateAtUseSite(thenInput);
     }
   }
 }