Fix warnings spotted by dart.

dart/sdk/lib/_internal/compiler/implementation/ssa/tracer.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.
 
 library tracer;
 
 import 'dart:io';
 import 'ssa.dart';
 import '../js_backend/js_backend.dart';
 import '../dart2jslib.dart';
@@ skipping 96 matching lines @@
         printProperty("dominator", "B${block.dominator.id}");
       }
       tag("states", () {
         tag("locals", () {
           printProperty("size", 0);
           printProperty("method", "None");
           block.forEachPhi((phi) {
             String phiId = stringifier.temporaryId(phi);
             StringBuffer inputIds = new StringBuffer();
             for (int i = 0; i < phi.inputs.length; i++) {
-              inputIds.add(stringifier.temporaryId(phi.inputs[i]));
-              inputIds.add(" ");
+              inputIds.write(stringifier.temporaryId(phi.inputs[i]));
+              inputIds.write(" ");
             }
             println("${phi.id} $phiId [ $inputIds]");
           });
         });
       });
       tag("HIR", () {
         addInstructions(stringifier, block.phis);
         addInstructions(stringifier, block);
       });
     });
@@ skipping 78 matching lines @@
         prefix = 'x';
       }
     }
     return "$prefix${instruction.id}";
   }
 
   String visitBailoutTarget(HBailoutTarget node) {
     StringBuffer envBuffer = new StringBuffer();
     List<HInstruction> inputs = node.inputs;
     for (int i = 0; i < inputs.length; i++) {
-      envBuffer.add(" ${temporaryId(inputs[i])}");
+      envBuffer.write(" ${temporaryId(inputs[i])}");
     }
     String on = node.isEnabled ? "enabled" : "disabled";
     return "BailoutTarget($on): id: ${node.state} env: $envBuffer";
   }
 
   String visitBoolify(HBoolify node) {
     return "Boolify: ${temporaryId(node.inputs[0])}";
   }
 
   String handleInvokeBinary(HInvokeBinary node, String op) {
@@ skipping 80 matching lines @@
     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 visitGenericInvoke(String invokeType, String functionName,
                             List<HInstruction> arguments) {
     StringBuffer argumentsString = new StringBuffer();
     for (int i = 0; i < arguments.length; i++) {
-      if (i != 0) argumentsString.add(", ");
-      argumentsString.add(temporaryId(arguments[i]));
+      if (i != 0) argumentsString.write(", ");
+      argumentsString.write(temporaryId(arguments[i]));
     }
     return "$invokeType: $functionName($argumentsString)";
   }
 
   String visitIndex(HIndex node) {
     String receiver = temporaryId(node.receiver);
     String index = temporaryId(node.index);
     return "Index: $receiver[$index]";
   }
 
@@ skipping 59 matching lines @@
                               "${node.element.name.slowToString()}",
                               node.inputs);
   }
 
   String visitLess(HLess node) => handleInvokeBinary(node, '<');
   String visitLessEqual(HLessEqual node) => handleInvokeBinary(node, '<=');
 
   String visitLiteralList(HLiteralList node) {
     StringBuffer elementsString = new StringBuffer();
     for (int i = 0; i < node.inputs.length; i++) {
-      if (i != 0) elementsString.add(", ");
-      elementsString.add(temporaryId(node.inputs[i]));
+      if (i != 0) elementsString.write(", ");
+      elementsString.write(temporaryId(node.inputs[i]));
     }
     return "Literal list: [$elementsString]";
   }
 
   String visitLoopBranch(HLoopBranch branch) {
     HBasicBlock bodyBlock = currentBlock.successors[0];
     HBasicBlock exitBlock = currentBlock.successors[1];
     String conditionId = temporaryId(branch.inputs[0]);
     return "While ($conditionId): (B${bodyBlock.id}) then (B${exitBlock.id})";
   }
@@ skipping 10 matching lines @@
   String visitParameterValue(HParameterValue node) {
     return "p${node.sourceElement.name.slowToString()}";
   }
 
   String visitLocalValue(HLocalValue node) {
     return "l${node.sourceElement.name.slowToString()}";
   }
 
   String visitPhi(HPhi phi) {
     StringBuffer buffer = new StringBuffer();
-    buffer.add("Phi(");
+    buffer.write("Phi(");
     for (int i = 0; i < phi.inputs.length; i++) {
-      if (i > 0) buffer.add(", ");
-      buffer.add(temporaryId(phi.inputs[i]));
+      if (i > 0) buffer.write(", ");
+      buffer.write(temporaryId(phi.inputs[i]));
     }
-    buffer.add(")");
+    buffer.write(")");
     return buffer.toString();
   }
 
   String visitReturn(HReturn node) => "Return ${temporaryId(node.inputs[0])}";
 
   String visitShiftLeft(HShiftLeft node) => handleInvokeBinary(node, '<<');
 
   String visitStatic(HStatic node)
       => "Static ${node.element.name.slowToString()}";
 
@@ skipping 11 matching lines @@
   String visitStringConcat(HStringConcat node) {
     var leftId = temporaryId(node.left);
     var rightId = temporaryId(node.right);
     return "StringConcat: $leftId + $rightId";
   }
 
   String visitSubtract(HSubtract node) => handleInvokeBinary(node, '-');
 
   String visitSwitch(HSwitch node) {
     StringBuffer buf = new StringBuffer();
-    buf.add("Switch: (");
-    buf.add(temporaryId(node.inputs[0]));
-    buf.add(") ");
+    buf.write("Switch: (");
+    buf.write(temporaryId(node.inputs[0]));
+    buf.write(") ");
     for (int i = 1; i < node.inputs.length; i++) {
-      buf.add(temporaryId(node.inputs[i]));
-      buf.add(": B");
-      buf.add(node.block.successors[i - 1].id);
-      buf.add(", ");
+      buf.write(temporaryId(node.inputs[i]));
+      buf.write(": B");
+      buf.write(node.block.successors[i - 1].id);
+      buf.write(", ");
     }
-    buf.add("default: B");
-    buf.add(node.block.successors.last.id);
+    buf.write("default: B");
+    buf.write(node.block.successors.last.id);
     return buf.toString();
   }
 
   String visitThis(HThis node) => "this";
 
   String visitThrow(HThrow node) => "Throw ${temporaryId(node.inputs[0])}";
 
   String visitExitTry(HExitTry node) {
     return "Exit try";
   }
@@ skipping 42 matching lines @@
       throw new CompilerCancelledException('Unexpected type guard: $type');
     }
     HInstruction guarded = node.guarded;
     HInstruction bailoutTarget = node.bailoutTarget;
     StringBuffer envBuffer = new StringBuffer();
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length >= 2);
     assert(inputs[0] == guarded);
     assert(inputs[1] == bailoutTarget);
     for (int i = 2; i < inputs.length; i++) {
-      envBuffer.add(" ${temporaryId(inputs[i])}");
+      envBuffer.write(" ${temporaryId(inputs[i])}");
     }
     String on = node.isEnabled ? "enabled" : "disabled";
     String guardedId = temporaryId(node.guarded);
     String bailoutId = temporaryId(node.bailoutTarget);
     return "TypeGuard($on): $guardedId is $type bailout: $bailoutId "
            "env: $envBuffer";
   }
 
   String visitIs(HIs node) {
     String type = node.typeExpression.toString();
     return "TypeTest: ${temporaryId(node.expression)} is $type";
   }
 
   String visitTypeConversion(HTypeConversion node) {
     return "TypeConversion: ${temporaryId(node.checkedInput)} to "
       "${node.instructionType}";
   }
 
   String visitRangeConversion(HRangeConversion node) {
     return "RangeConversion: ${node.checkedInput}";
   }
 }