dartfmt pkg/compiler

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

 // Copyright (c) 2013, 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 ssa.tracer;
 
 import 'dart:async' show EventSink;
 
 import '../compiler.dart' show Compiler;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
@@ skipping 41 matching lines @@
     } else {
       addIndent();
       add("successors");
       for (HBasicBlock successor in block.successors) {
         add(' "B${successor.id}"');
       }
       add("\n");
     }
   }
 
-  void addInstructions(HInstructionStringifier stringifier,
-                       HInstructionList list) {
+  void addInstructions(
+      HInstructionStringifier stringifier, HInstructionList list) {
     for (HInstruction instruction = list.first;
-         instruction != null;
-         instruction = instruction.next) {
+        instruction != null;
+        instruction = instruction.next) {
       int bci = 0;
       int uses = instruction.usedBy.length;
       String changes = instruction.sideEffects.hasSideEffects() ? '!' : ' ';
       String depends = instruction.sideEffects.dependsOnSomething() ? '?' : '';
       addIndent();
       String temporaryId = stringifier.temporaryId(instruction);
       String instructionString = stringifier.visit(instruction);
       add("$bci $uses $temporaryId $instructionString $changes $depends <|@\n");
     }
   }
@@ skipping 78 matching lines @@
     }
     return "$prefix${instruction.id}";
   }
 
   String visitBoolify(HBoolify node) {
     return "Boolify: ${temporaryId(node.inputs[0])}";
   }
 
   String handleInvokeBinary(HInvokeBinary node, String opcode) {
     String left = temporaryId(node.left);
-    String right= temporaryId(node.right);
+    String right = temporaryId(node.right);
     return '$opcode: $left $right';
   }
 
   String visitAdd(HAdd node) => handleInvokeBinary(node, 'Add');
 
   String visitBitAnd(HBitAnd node) => handleInvokeBinary(node, 'BitAnd');
 
   String visitBitNot(HBitNot node) {
     String operand = temporaryId(node.operand);
     return "BitNot: $operand";
@@ skipping 72 matching lines @@
 
   String visitGoto(HGoto node) {
     HBasicBlock target = currentBlock.successors[0];
     return "Goto: (B${target.id})";
   }
 
   String visitGreater(HGreater node) => handleInvokeBinary(node, 'Greater');
   String visitGreaterEqual(HGreaterEqual node) {
     return handleInvokeBinary(node, 'GreaterEqual');
   }
+
   String visitIdentity(HIdentity node) => handleInvokeBinary(node, 'Identity');
 
   String visitIf(HIf node) {
     HBasicBlock thenBlock = currentBlock.successors[0];
     HBasicBlock elseBlock = currentBlock.successors[1];
     String conditionId = temporaryId(node.inputs[0]);
     return "If ($conditionId): (B${thenBlock.id}) else (B${elseBlock.id})";
   }
 
-  String handleGenericInvoke(String invokeType, String functionName,
-                             List<HInstruction> arguments) {
+  String handleGenericInvoke(
+      String invokeType, String functionName, List<HInstruction> arguments) {
     StringBuffer argumentsString = new StringBuffer();
     for (int i = 0; i < arguments.length; i++) {
       if (i != 0) argumentsString.write(", ");
       argumentsString.write(temporaryId(arguments[i]));
     }
     return "$invokeType: $functionName($argumentsString)";
   }
 
   String visitIndex(HIndex node) {
     String receiver = temporaryId(node.receiver);
@@ skipping 12 matching lines @@
     String value = temporaryId(node.inputs[0]);
     if (node.interceptedClasses != null) {
       JavaScriptBackend backend = compiler.backend;
       String cls =
           backend.namer.suffixForGetInterceptor(node.interceptedClasses);
       return "Interceptor ($cls): $value";
     }
     return "Interceptor: $value";
   }
 
-  String visitInvokeClosure(HInvokeClosure node)
-      => handleInvokeDynamic(node, "InvokeClosure");
+  String visitInvokeClosure(HInvokeClosure node) =>
+      handleInvokeDynamic(node, "InvokeClosure");
 
   String handleInvokeDynamic(HInvokeDynamic invoke, String kind) {
     String receiver = temporaryId(invoke.receiver);
     String name = invoke.selector.name;
     String target = "$receiver.$name";
     int offset = HInvoke.ARGUMENTS_OFFSET;
     List arguments = invoke.inputs.sublist(offset);
-    return handleGenericInvoke(kind, target, arguments) +
-        "(${invoke.mask})";
+    return handleGenericInvoke(kind, target, arguments) + "(${invoke.mask})";
   }
 
-  String visitInvokeDynamicMethod(HInvokeDynamicMethod node)
-      => handleInvokeDynamic(node, "InvokeDynamicMethod");
-  String visitInvokeDynamicGetter(HInvokeDynamicGetter node)
-      => handleInvokeDynamic(node, "InvokeDynamicGetter");
-  String visitInvokeDynamicSetter(HInvokeDynamicSetter node)
-      => handleInvokeDynamic(node, "InvokeDynamicSetter");
+  String visitInvokeDynamicMethod(HInvokeDynamicMethod node) =>
+      handleInvokeDynamic(node, "InvokeDynamicMethod");
+  String visitInvokeDynamicGetter(HInvokeDynamicGetter node) =>
+      handleInvokeDynamic(node, "InvokeDynamicGetter");
+  String visitInvokeDynamicSetter(HInvokeDynamicSetter node) =>
+      handleInvokeDynamic(node, "InvokeDynamicSetter");
 
   String visitInvokeStatic(HInvokeStatic invoke) {
     String target = invoke.element.name;
     return handleGenericInvoke("InvokeStatic", target, invoke.inputs);
   }
 
   String visitInvokeSuper(HInvokeSuper invoke) {
     String target = invoke.element.name;
     return handleGenericInvoke("InvokeSuper", target, invoke.inputs);
   }
 
   String visitInvokeConstructorBody(HInvokeConstructorBody invoke) {
     String target = invoke.element.name;
     return handleGenericInvoke("InvokeConstructorBody", target, invoke.inputs);
   }
 
   String visitForeignCode(HForeignCode foreign) {
-    return handleGenericInvoke("ForeignCode", "${foreign.codeTemplate.ast}",
-                              foreign.inputs);
+    return handleGenericInvoke(
+        "ForeignCode", "${foreign.codeTemplate.ast}", foreign.inputs);
   }
 
   String visitForeignNew(HForeignNew node) {
-    return handleGenericInvoke("ForeignNew",
-                              "${node.element.name}",
-                              node.inputs);
+    return handleGenericInvoke(
+        "ForeignNew", "${node.element.name}", node.inputs);
   }
 
   String visitLess(HLess node) => handleInvokeBinary(node, 'Less');
   String visitLessEqual(HLessEqual node) =>
       handleInvokeBinary(node, 'LessEqual');
 
   String visitLiteralList(HLiteralList node) {
     StringBuffer elementsString = new StringBuffer();
     for (int i = 0; i < node.inputs.length; i++) {
       if (i != 0) elementsString.write(", ");
       elementsString.write(temporaryId(node.inputs[i]));
     }
     return "LiteralList: [$elementsString]";
   }
 
   String visitLoopBranch(HLoopBranch branch) {
     HBasicBlock bodyBlock = currentBlock.successors[0];
     HBasicBlock exitBlock = currentBlock.successors[1];
     String conditionId = temporaryId(branch.inputs[0]);
-    return
-      "LoopBranch ($conditionId): (B${bodyBlock.id}) then (B${exitBlock.id})";
+    return "LoopBranch ($conditionId): (B${bodyBlock.id}) then (B${exitBlock.id})";
   }
 
   String visitMultiply(HMultiply node) => handleInvokeBinary(node, 'Multiply');
 
   String visitNegate(HNegate node) {
     String operand = temporaryId(node.operand);
     return "Negate: $operand";
   }
 
   String visitNot(HNot node) => "Not: ${temporaryId(node.inputs[0])}";
@@ skipping 20 matching lines @@
     return 'Ref: ${temporaryId(node.value)}';
   }
 
   String visitReturn(HReturn node) => "Return: ${temporaryId(node.inputs[0])}";
 
   String visitShiftLeft(HShiftLeft node) =>
       handleInvokeBinary(node, 'ShiftLeft');
   String visitShiftRight(HShiftRight node) =>
       handleInvokeBinary(node, 'ShiftRight');
 
-  String visitStatic(HStatic node)
-      => "Static: ${node.element.name}";
+  String visitStatic(HStatic node) => "Static: ${node.element.name}";
 
-  String visitLazyStatic(HLazyStatic node)
-      => "LazyStatic: ${node.element.name}";
+  String visitLazyStatic(HLazyStatic node) =>
+      "LazyStatic: ${node.element.name}";
 
-  String visitOneShotInterceptor(HOneShotInterceptor node)
-      => handleInvokeDynamic(node, "OneShotInterceptor");
+  String visitOneShotInterceptor(HOneShotInterceptor node) =>
+      handleInvokeDynamic(node, "OneShotInterceptor");
 
   String visitStaticStore(HStaticStore node) {
     String lhs = node.element.name;
     return "StaticStore: $lhs = ${temporaryId(node.inputs[0])}";
   }
 
   String visitStringConcat(HStringConcat node) {
     var leftId = temporaryId(node.left);
     var rightId = temporaryId(node.right);
     return "StringConcat: $leftId + $rightId";
@@ skipping 59 matching lines @@
     return "Is: ${temporaryId(node.expression)} is $type";
   }
 
   String visitIsViaInterceptor(HIsViaInterceptor node) {
     String type = node.typeExpression.toString();
     return "IsViaInterceptor: ${temporaryId(node.inputs[0])} is $type";
   }
 
   String visitTypeConversion(HTypeConversion node) {
     assert(node.inputs.length <= 2);
-    String otherInput = (node.inputs.length == 2)
-        ? temporaryId(node.inputs[1])
-        : '';
+    String otherInput =
+        (node.inputs.length == 2) ? temporaryId(node.inputs[1]) : '';
     return "TypeConversion: ${temporaryId(node.checkedInput)} to "
-      "${node.instructionType} $otherInput";
+        "${node.instructionType} $otherInput";
   }
 
   String visitTypeKnown(HTypeKnown node) {
     assert(node.inputs.length <= 2);
     String result =
         "TypeKnown: ${temporaryId(node.checkedInput)} is ${node.knownType}";
     if (node.witness != null) {
       result += " witnessed by ${temporaryId(node.witness)}";
     }
     return result;
@@ skipping 24 matching lines @@
   }
 
   String visitAwait(HAwait node) {
     return "Await: ${temporaryId(node.inputs[0])}";
   }
 
   String visitYield(HYield node) {
     return "Yield${node.hasStar ? "*" : ""}: ${temporaryId(node.inputs[0])}";
   }
 }